Linux 内核时钟之高精度处理

/* * Called from run_local_timers in hardirq context every jiffy */void hrtimer_run_queues(void){ struct hrtimer_cpu_base *cpu_base = this_cpu_ptr(&hrtimer_bases); ktime_t now;
 if (__hrtimer_hres_active(cpu_base))  return;
 /*  * This _is_ ugly: We have to check periodically, whether we  * can switch to highres and / or nohz mode. The clocksource  * switch happens with xtime_lock held. Notification from  * there only sets the check bit in the tick_oneshot code,  * otherwise we might deadlock vs. xtime_lock.  */ if (tick_check_oneshot_change(!hrtimer_is_hres_enabled())) {  hrtimer_switch_to_hres();  return; }
 raw_spin_lock(&cpu_base->lock); now = hrtimer_update_base(cpu_base); __hrtimer_run_queues(cpu_base, now); raw_spin_unlock(&cpu_base->lock);}
static void __hrtimer_run_queues(struct hrtimer_cpu_base *cpu_base, ktime_t now){ struct hrtimer_clock_base *base = cpu_base->clock_base; unsigned int active = cpu_base->active_bases;
 for (; active; base++, active >>= 1) {  struct timerqueue_node *node;  ktime_t basenow;
  if (!(active & 0x01))   continue;
  basenow = ktime_add(now, base->offset);
  while ((node = timerqueue_getnext(&base->active))) {   struct hrtimer *timer;
   timer = container_of(node, struct hrtimer, node);
   /*    * The immediate goal for using the softexpires is    * minimizing wakeups, not running timers at the    * earliest interrupt after their soft expiration.    * This allows us to avoid using a Priority Search    * Tree, which can answer a stabbing querry for    * overlapping intervals and instead use the simple    * BST we already have.    * We don't add extra wakeups by delaying timers that    * are right-of a not yet expired timer, because that    * timer will have to trigger a wakeup anyway.    */   if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer))    break;
   __run_hrtimer(cpu_base, base, timer, &basenow);  } }}
/* * The write_seqcount_barrier()s in __run_hrtimer() split the thing into 3 * distinct sections: * *  - queued: the timer is queued *  - callback: the timer is being ran *  - post: the timer is inactive or (re)queued * * On the read side we ensure we observe timer->state and cpu_base->running * from the same section, if anything changed while we looked at it, we retry. * This includes timer->base changing because sequence numbers alone are * insufficient for that. * * The sequence numbers are required because otherwise we could still observe * a false negative if the read side got smeared over multiple consequtive * __run_hrtimer() invocations. */
static void __run_hrtimer(struct hrtimer_cpu_base *cpu_base,     struct hrtimer_clock_base *base,     struct hrtimer *timer, ktime_t *now){ enum hrtimer_restart (*fn)(struct hrtimer *); int restart;
 lockdep_assert_held(&cpu_base->lock);
 debug_deactivate(timer); cpu_base->running = timer;
 /*  * Separate the ->running assignment from the ->state assignment.  *  * As with a regular write barrier, this ensures the read side in  * hrtimer_active() cannot observe cpu_base->running == NULL &&  * timer->state == INACTIVE.  */ raw_write_seqcount_barrier(&cpu_base->seq);
 __remove_hrtimer(timer, base, HRTIMER_STATE_INACTIVE, 0); timer_stats_account_hrtimer(timer); fn = timer->function;
 /*  * Clear the 'is relative' flag for the TIME_LOW_RES case. If the  * timer is restarted with a period then it becomes an absolute  * timer. If its not restarted it does not matter.  */ if (IS_ENABLED(CONFIG_TIME_LOW_RES))  timer->is_rel = false;
 /*  * Because we run timers from hardirq context, there is no chance  * they get migrated to another cpu, therefore its safe to unlock  * the timer base.  */ raw_spin_unlock(&cpu_base->lock); trace_hrtimer_expire_entry(timer, now); restart = fn(timer); trace_hrtimer_expire_exit(timer); raw_spin_lock(&cpu_base->lock);
 /*  * Note: We clear the running state after enqueue_hrtimer and  * we do not reprogram the event hardware. Happens either in  * hrtimer_start_range_ns() or in hrtimer_interrupt()  *  * Note: Because we dropped the cpu_base->lock above,  * hrtimer_start_range_ns() can have popped in and enqueued the timer  * for us already.  */ if (restart != HRTIMER_NORESTART &&     !(timer->state & HRTIMER_STATE_ENQUEUED))  enqueue_hrtimer(timer, base);
 /*  * Separate the ->running assignment from the ->state assignment.  *  * As with a regular write barrier, this ensures the read side in  * hrtimer_active() cannot observe cpu_base->running == NULL &&  * timer->state == INACTIVE.  */ raw_write_seqcount_barrier(&cpu_base->seq);
 WARN_ON_ONCE(cpu_base->running != timer); cpu_base->running = NULL;}