自学教程：C++ timer_stats_account_hrtimer函数代码示例

static void __run_hrtimer(struct hrtimer *timer){	struct hrtimer_clock_base *base = timer->base;	struct hrtimer_cpu_base *cpu_base = base->cpu_base;	enum hrtimer_restart (*fn)(struct hrtimer *);	int restart;	WARN_ON(!irqs_disabled());	debug_hrtimer_deactivate(timer);	__remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);	timer_stats_account_hrtimer(timer);	fn = timer->function;	/*	 * 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.	 */	spin_unlock(&cpu_base->lock);	restart = fn(timer);	spin_lock(&cpu_base->lock);	/*	 * Note: We clear the CALLBACK bit after enqueue_hrtimer and	 * we do not reprogramm the event hardware. Happens either in	 * hrtimer_start_range_ns() or in hrtimer_interrupt()	 */	if (restart != HRTIMER_NORESTART) {		BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);		enqueue_hrtimer(timer, base);	}	timer->state &= ~HRTIMER_STATE_CALLBACK;}

static void run_hrtimer_pending(struct hrtimer_cpu_base *cpu_base){	spin_lock_irq(&cpu_base->lock);	while (!list_empty(&cpu_base->cb_pending)) {		enum hrtimer_restart (*fn)(struct hrtimer *);		struct hrtimer *timer;		int restart;		timer = list_entry(cpu_base->cb_pending.next,				   struct hrtimer, cb_entry);		debug_hrtimer_deactivate(timer);		timer_stats_account_hrtimer(timer);		fn = timer->function;		__remove_hrtimer(timer, timer->base, HRTIMER_STATE_CALLBACK, 0);		spin_unlock_irq(&cpu_base->lock);		restart = fn(timer);		spin_lock_irq(&cpu_base->lock);		timer->state &= ~HRTIMER_STATE_CALLBACK;		if (restart == HRTIMER_RESTART) {			BUG_ON(hrtimer_active(timer));			/*			 * Enqueue the timer, allow reprogramming of the event			 * device			 */			enqueue_hrtimer(timer, timer->base, 1);		} else if (hrtimer_active(timer)) {			/*			 * If the timer was rearmed on another CPU, reprogram			 * the event device.			 */			struct hrtimer_clock_base *base = timer->base;			if (base->first == &timer->node &&			    hrtimer_reprogram(timer, base)) {				/*				 * Timer is expired. Thus move it from tree to				 * pending list again.				 */				__remove_hrtimer(timer, base,						 HRTIMER_STATE_PENDING, 0);				list_add_tail(&timer->cb_entry,					      &base->cpu_base->cb_pending);			}		}	}	spin_unlock_irq(&cpu_base->lock);}

static void __run_hrtimer(struct hrtimer *timer, ktime_t *now){	struct hrtimer_clock_base *base = timer->base;	struct hrtimer_cpu_base *cpu_base = base->cpu_base;	enum hrtimer_restart (*fn)(struct hrtimer *);	int restart;	WARN_ON(!irqs_disabled());	debug_deactivate(timer);	__remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);	timer_stats_account_hrtimer(timer);	fn = timer->function;	/*	 * 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);#ifdef CONFIG_SEC_DEBUG	secdbg_msg("hrtimer %pS entry", fn);#endif	restart = fn(timer);#ifdef CONFIG_SEC_DEBUG	secdbg_msg("hrtimer %pS exit", fn);#endif	trace_hrtimer_expire_exit(timer);	raw_spin_lock(&cpu_base->lock);	/*	 * Note: We clear the CALLBACK bit after enqueue_hrtimer and	 * we do not reprogramm 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);	WARN_ON_ONCE(!(timer->state & HRTIMER_STATE_CALLBACK));	timer->state &= ~HRTIMER_STATE_CALLBACK;}

/* * Expire the per base hrtimer-queue: */static inline void run_hrtimer_queue(struct hrtimer_cpu_base *cpu_base,				     int index){	struct rb_node *node;	struct hrtimer_clock_base *base = &cpu_base->clock_base[index];	if (!base->first)		return;	if (base->get_softirq_time)		base->softirq_time = base->get_softirq_time();	spin_lock_irq(&cpu_base->lock);	while ((node = base->first)) {		struct hrtimer *timer;		enum hrtimer_restart (*fn)(struct hrtimer *);		int restart;		timer = rb_entry(node, struct hrtimer, node);		if (base->softirq_time.tv64 <= timer->expires.tv64)			break;#ifdef CONFIG_HIGH_RES_TIMERS		WARN_ON_ONCE(timer->cb_mode == HRTIMER_CB_IRQSAFE_NO_SOFTIRQ);#endif		timer_stats_account_hrtimer(timer);		fn = timer->function;		__remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);		spin_unlock_irq(&cpu_base->lock);		restart = fn(timer);		spin_lock_irq(&cpu_base->lock);		timer->state &= ~HRTIMER_STATE_CALLBACK;		if (restart != HRTIMER_NORESTART) {			BUG_ON(hrtimer_active(timer));			enqueue_hrtimer(timer, base, 0);		}	}	spin_unlock_irq(&cpu_base->lock);}

static void run_hrtimer_softirq(struct softirq_action *h){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	spin_lock_irq(&cpu_base->lock);	while (!list_empty(&cpu_base->cb_pending)) {		enum hrtimer_restart (*fn)(struct hrtimer *);		struct hrtimer *timer;		int restart;		timer = list_entry(cpu_base->cb_pending.next,				   struct hrtimer, cb_entry);		timer_stats_account_hrtimer(timer);		fn = timer->function;		__remove_hrtimer(timer, timer->base, HRTIMER_STATE_CALLBACK, 0);		spin_unlock_irq(&cpu_base->lock);		restart = fn(timer);		spin_lock_irq(&cpu_base->lock);		timer->state &= ~HRTIMER_STATE_CALLBACK;		if (restart == HRTIMER_RESTART) {			BUG_ON(hrtimer_active(timer));			/*			 * Enqueue the timer, allow reprogramming of the event			 * device			 */			enqueue_hrtimer(timer, timer->base, 1);		} else if (hrtimer_active(timer)) {			/*			 * If the timer was rearmed on another CPU, reprogram			 * the event device.			 */			if (timer->base->first == &timer->node)				hrtimer_reprogram(timer, timer->base);		}	}	spin_unlock_irq(&cpu_base->lock);}

static void __run_hrtimer(struct hrtimer *timer){	struct hrtimer_clock_base *base = timer->base;	struct hrtimer_cpu_base *cpu_base = base->cpu_base;	enum hrtimer_restart (*fn)(struct hrtimer *);	int restart;	debug_hrtimer_deactivate(timer);	__remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);	timer_stats_account_hrtimer(timer);	fn = timer->function;	if (timer->cb_mode == HRTIMER_CB_IRQSAFE_PERCPU ||	    timer->cb_mode == HRTIMER_CB_IRQSAFE_UNLOCKED) {		/*		 * Used for scheduler timers, avoid lock inversion with		 * rq->lock and tasklist_lock.		 *		 * These timers are required to deal with enqueue expiry		 * themselves and are not allowed to migrate.		 */		spin_unlock(&cpu_base->lock);		restart = fn(timer);		spin_lock(&cpu_base->lock);	} else		restart = fn(timer);	/*	 * Note: We clear the CALLBACK bit after enqueue_hrtimer to avoid	 * reprogramming of the event hardware. This happens at the end of this	 * function anyway.	 */	if (restart != HRTIMER_NORESTART) {		BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);		enqueue_hrtimer(timer, base, 0);	}	timer->state &= ~HRTIMER_STATE_CALLBACK;}

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 reprogramm 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;}

/* * High resolution timer interrupt * Called with interrupts disabled */void hrtimer_interrupt(struct clock_event_device *dev){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base;	ktime_t expires_next, now;	int i, raise = 0;	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX; retry:	now = ktime_get();	expires_next.tv64 = KTIME_MAX;	base = cpu_base->clock_base;	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		ktime_t basenow;		struct rb_node *node;		spin_lock(&cpu_base->lock);		basenow = ktime_add(now, base->offset);		while ((node = base->first)) {			struct hrtimer *timer;			timer = rb_entry(node, struct hrtimer, node);			if (basenow.tv64 < timer->expires.tv64) {				ktime_t expires;				expires = ktime_sub(timer->expires,						    base->offset);				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			}			/* Move softirq callbacks to the pending list */			if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {				__remove_hrtimer(timer, base,						 HRTIMER_STATE_PENDING, 0);				list_add_tail(&timer->cb_entry,					      &base->cpu_base->cb_pending);				raise = 1;				continue;			}			__remove_hrtimer(timer, base,					 HRTIMER_STATE_CALLBACK, 0);			timer_stats_account_hrtimer(timer);			/*			 * Note: We clear the CALLBACK bit after			 * enqueue_hrtimer to avoid reprogramming of			 * the event hardware. This happens at the end			 * of this function anyway.			 */			if (timer->function(timer) != HRTIMER_NORESTART) {				BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);				enqueue_hrtimer(timer, base, 0);			}			timer->state &= ~HRTIMER_STATE_CALLBACK;		}		spin_unlock(&cpu_base->lock);		base++;	}	cpu_base->expires_next = expires_next;	/* Reprogramming necessary ? */	if (expires_next.tv64 != KTIME_MAX) {		if (tick_program_event(expires_next, 0))			goto retry;	}	/* Raise softirq ? */	if (raise)		raise_softirq(HRTIMER_SOFTIRQ);}

static void run_hrtimer_pending(struct hrtimer_cpu_base *cpu_base){	spin_lock_irq(&cpu_base->lock);	while (!list_empty(&cpu_base->cb_pending)) {		enum hrtimer_restart (*fn)(struct hrtimer *);		struct hrtimer *timer;		int restart;		int emulate_hardirq_ctx = 0;		timer = list_entry(cpu_base->cb_pending.next,				   struct hrtimer, cb_entry);		debug_hrtimer_deactivate(timer);		timer_stats_account_hrtimer(timer);		fn = timer->function;		/*		 * A timer might have been added to the cb_pending list		 * when it was migrated during a cpu-offline operation.		 * Emulate hardirq context for such timers.		 */		if (timer->cb_mode == HRTIMER_CB_IRQSAFE_PERCPU ||		    timer->cb_mode == HRTIMER_CB_IRQSAFE_UNLOCKED)			emulate_hardirq_ctx = 1;		__remove_hrtimer(timer, timer->base, HRTIMER_STATE_CALLBACK, 0);		spin_unlock_irq(&cpu_base->lock);		if (unlikely(emulate_hardirq_ctx)) {			local_irq_disable();			restart = fn(timer);			local_irq_enable();		} else			restart = fn(timer);		spin_lock_irq(&cpu_base->lock);		timer->state &= ~HRTIMER_STATE_CALLBACK;		if (restart == HRTIMER_RESTART) {			BUG_ON(hrtimer_active(timer));			/*			 * Enqueue the timer, allow reprogramming of the event			 * device			 */			enqueue_hrtimer(timer, timer->base, 1);		} else if (hrtimer_active(timer)) {			/*			 * If the timer was rearmed on another CPU, reprogram			 * the event device.			 */			struct hrtimer_clock_base *base = timer->base;			if (base->first == &timer->node &&			    hrtimer_reprogram(timer, base)) {				/*				 * Timer is expired. Thus move it from tree to				 * pending list again.				 */				__remove_hrtimer(timer, base,						 HRTIMER_STATE_PENDING, 0);				list_add_tail(&timer->cb_entry,					      &base->cpu_base->cb_pending);			}		}	}	spin_unlock_irq(&cpu_base->lock);}