tick-broadcast-hrtimer.c 3.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Emulate a local clock event device via a pseudo clock device.
  4. */
  5. #include <linux/cpu.h>
  6. #include <linux/err.h>
  7. #include <linux/hrtimer.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/percpu.h>
  10. #include <linux/profile.h>
  11. #include <linux/clockchips.h>
  12. #include <linux/sched.h>
  13. #include <linux/smp.h>
  14. #include <linux/module.h>
  15. #include "tick-internal.h"
  16. static struct hrtimer bctimer;
  17. static int bc_shutdown(struct clock_event_device *evt)
  18. {
  19. /*
  20. * Note, we cannot cancel the timer here as we might
  21. * run into the following live lock scenario:
  22. *
  23. * cpu 0 cpu1
  24. * lock(broadcast_lock);
  25. * hrtimer_interrupt()
  26. * bc_handler()
  27. * tick_handle_oneshot_broadcast();
  28. * lock(broadcast_lock);
  29. * hrtimer_cancel()
  30. * wait_for_callback()
  31. */
  32. hrtimer_try_to_cancel(&bctimer);
  33. return 0;
  34. }
  35. /*
  36. * This is called from the guts of the broadcast code when the cpu
  37. * which is about to enter idle has the earliest broadcast timer event.
  38. */
  39. static int bc_set_next(ktime_t expires, struct clock_event_device *bc)
  40. {
  41. /*
  42. * This is called either from enter/exit idle code or from the
  43. * broadcast handler. In all cases tick_broadcast_lock is held.
  44. *
  45. * hrtimer_cancel() cannot be called here neither from the
  46. * broadcast handler nor from the enter/exit idle code. The idle
  47. * code can run into the problem described in bc_shutdown() and the
  48. * broadcast handler cannot wait for itself to complete for obvious
  49. * reasons.
  50. *
  51. * Each caller tries to arm the hrtimer on its own CPU, but if the
  52. * hrtimer callbback function is currently running, then
  53. * hrtimer_start() cannot move it and the timer stays on the CPU on
  54. * which it is assigned at the moment.
  55. *
  56. * As this can be called from idle code, the hrtimer_start()
  57. * invocation has to be wrapped with RCU_NONIDLE() as
  58. * hrtimer_start() can call into tracing.
  59. */
  60. RCU_NONIDLE( {
  61. hrtimer_start(&bctimer, expires, HRTIMER_MODE_ABS_PINNED_HARD);
  62. /*
  63. * The core tick broadcast mode expects bc->bound_on to be set
  64. * correctly to prevent a CPU which has the broadcast hrtimer
  65. * armed from going deep idle.
  66. *
  67. * As tick_broadcast_lock is held, nothing can change the cpu
  68. * base which was just established in hrtimer_start() above. So
  69. * the below access is safe even without holding the hrtimer
  70. * base lock.
  71. */
  72. bc->bound_on = bctimer.base->cpu_base->cpu;
  73. } );
  74. return 0;
  75. }
  76. static struct clock_event_device ce_broadcast_hrtimer = {
  77. .name = "bc_hrtimer",
  78. .set_state_shutdown = bc_shutdown,
  79. .set_next_ktime = bc_set_next,
  80. .features = CLOCK_EVT_FEAT_ONESHOT |
  81. CLOCK_EVT_FEAT_KTIME |
  82. CLOCK_EVT_FEAT_HRTIMER,
  83. .rating = 0,
  84. .bound_on = -1,
  85. .min_delta_ns = 1,
  86. .max_delta_ns = KTIME_MAX,
  87. .min_delta_ticks = 1,
  88. .max_delta_ticks = ULONG_MAX,
  89. .mult = 1,
  90. .shift = 0,
  91. .cpumask = cpu_possible_mask,
  92. };
  93. static enum hrtimer_restart bc_handler(struct hrtimer *t)
  94. {
  95. ce_broadcast_hrtimer.event_handler(&ce_broadcast_hrtimer);
  96. return HRTIMER_NORESTART;
  97. }
  98. void tick_setup_hrtimer_broadcast(void)
  99. {
  100. hrtimer_init(&bctimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_HARD);
  101. bctimer.function = bc_handler;
  102. clockevents_register_device(&ce_broadcast_hrtimer);
  103. }