1861 lines · 46.4 KB · C
RawDownload
 * @mode:	expiry mode: absolute (HRTIMER_ABS) or relative (HRTIMER_REL) * * Returns: *  0 on success *  1 when the timer was active */int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,		unsigned long delta_ns, const enum hrtimer_mode mode){	return __hrtimer_start_range_ns(timer, tim, delta_ns, mode, 1);}EXPORT_SYMBOL_GPL(hrtimer_start_range_ns); /** * hrtimer_start - (re)start an hrtimer on the current CPU * @timer:	the timer to be added * @tim:	expiry time * @mode:	expiry mode: absolute (HRTIMER_ABS) or relative (HRTIMER_REL) * * Returns: *  0 on success *  1 when the timer was active */inthrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode){	return __hrtimer_start_range_ns(timer, tim, 0, mode, 1);}EXPORT_SYMBOL_GPL(hrtimer_start);  /** * hrtimer_try_to_cancel - try to deactivate a timer * @timer:	hrtimer to stop * * Returns: *  0 when the timer was not active *  1 when the timer was active * -1 when the timer is currently excuting the callback function and *    cannot be stopped */int hrtimer_try_to_cancel(struct hrtimer *timer){	struct hrtimer_clock_base *base;	unsigned long flags;	int ret = -1; 	base = lock_hrtimer_base(timer, &flags); 	if (!hrtimer_callback_running(timer))		ret = remove_hrtimer(timer, base); 	unlock_hrtimer_base(timer, &flags); 	return ret; }EXPORT_SYMBOL_GPL(hrtimer_try_to_cancel); /** * hrtimer_cancel - cancel a timer and wait for the handler to finish. * @timer:	the timer to be cancelled * * Returns: *  0 when the timer was not active *  1 when the timer was active */int hrtimer_cancel(struct hrtimer *timer){	for (;;) {		int ret = hrtimer_try_to_cancel(timer); 		if (ret >= 0)			return ret;		cpu_relax();	}}EXPORT_SYMBOL_GPL(hrtimer_cancel); /** * hrtimer_get_remaining - get remaining time for the timer * @timer:	the timer to read */ktime_t hrtimer_get_remaining(const struct hrtimer *timer){	unsigned long flags;	ktime_t rem; 	lock_hrtimer_base(timer, &flags);	rem = hrtimer_expires_remaining(timer);	unlock_hrtimer_base(timer, &flags); 	return rem;}EXPORT_SYMBOL_GPL(hrtimer_get_remaining); #ifdef CONFIG_NO_HZ/** * hrtimer_get_next_event - get the time until next expiry event * * Returns the delta to the next expiry event or KTIME_MAX if no timer * is pending. */ktime_t hrtimer_get_next_event(void){	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base = cpu_base->clock_base;	ktime_t delta, mindelta = { .tv64 = KTIME_MAX };	unsigned long flags;	int i; 	raw_spin_lock_irqsave(&cpu_base->lock, flags); 	if (!hrtimer_hres_active()) {		for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {			struct hrtimer *timer;			struct timerqueue_node *next; 			next = timerqueue_getnext(&base->active);			if (!next)				continue; 			timer = container_of(next, struct hrtimer, node);			delta.tv64 = hrtimer_get_expires_tv64(timer);			delta = ktime_sub(delta, base->get_time());			if (delta.tv64 < mindelta.tv64)				mindelta.tv64 = delta.tv64;		}	} 	raw_spin_unlock_irqrestore(&cpu_base->lock, flags); 	if (mindelta.tv64 < 0)		mindelta.tv64 = 0;	return mindelta;}#endif static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id,			   enum hrtimer_mode mode){	struct hrtimer_cpu_base *cpu_base;	int base; 	memset(timer, 0, sizeof(struct hrtimer)); 	cpu_base = &__raw_get_cpu_var(hrtimer_bases); 	if (clock_id == CLOCK_REALTIME && mode != HRTIMER_MODE_ABS)		clock_id = CLOCK_MONOTONIC; 	base = hrtimer_clockid_to_base(clock_id);	timer->base = &cpu_base->clock_base[base];	timerqueue_init(&timer->node); #ifdef CONFIG_TIMER_STATS	timer->start_site = NULL;	timer->start_pid = -1;	memset(timer->start_comm, 0, TASK_COMM_LEN);#endif} /** * hrtimer_init - initialize a timer to the given clock * @timer:	the timer to be initialized * @clock_id:	the clock to be used * @mode:	timer mode abs/rel */void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,		  enum hrtimer_mode mode){	debug_init(timer, clock_id, mode);	__hrtimer_init(timer, clock_id, mode);}EXPORT_SYMBOL_GPL(hrtimer_init); /** * hrtimer_get_res - get the timer resolution for a clock * @which_clock: which clock to query * @tp:		 pointer to timespec variable to store the resolution * * Store the resolution of the clock selected by @which_clock in the * variable pointed to by @tp. */int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp){	struct hrtimer_cpu_base *cpu_base;	int base = hrtimer_clockid_to_base(which_clock); 	cpu_base = &__raw_get_cpu_var(hrtimer_bases);	*tp = ktime_to_timespec(cpu_base->clock_base[base].resolution); 	return 0;}EXPORT_SYMBOL_GPL(hrtimer_get_res); 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);	restart = fn(timer);	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()	 */	if (restart != HRTIMER_NORESTART) {		BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);		enqueue_hrtimer(timer, base);	} 	WARN_ON_ONCE(!(timer->state & HRTIMER_STATE_CALLBACK)); 	timer->state &= ~HRTIMER_STATE_CALLBACK;} #ifdef CONFIG_HIGH_RES_TIMERS /* * 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);	ktime_t expires_next, now, entry_time, delta;	int i, retries = 0; 	BUG_ON(!cpu_base->hres_active);	cpu_base->nr_events++;	dev->next_event.tv64 = KTIME_MAX; 	entry_time = now = ktime_get();retry:	expires_next.tv64 = KTIME_MAX; 	raw_spin_lock(&cpu_base->lock);	/*	 * We set expires_next to KTIME_MAX here with cpu_base->lock	 * held to prevent that a timer is enqueued in our queue via	 * the migration code. This does not affect enqueueing of	 * timers which run their callback and need to be requeued on	 * this CPU.	 */	cpu_base->expires_next.tv64 = KTIME_MAX; 	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		struct hrtimer_clock_base *base;		struct timerqueue_node *node;		ktime_t basenow; 		if (!(cpu_base->active_bases & (1 << i)))			continue; 		base = cpu_base->clock_base + i;		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)) {				ktime_t expires; 				expires = ktime_sub(hrtimer_get_expires(timer),						    base->offset);				if (expires.tv64 < expires_next.tv64)					expires_next = expires;				break;			} 			__run_hrtimer(timer, &basenow);		}	} 	/*	 * Store the new expiry value so the migration code can verify	 * against it.	 */	cpu_base->expires_next = expires_next;	raw_spin_unlock(&cpu_base->lock); 	/* Reprogramming necessary ? */	if (expires_next.tv64 == KTIME_MAX ||	    !tick_program_event(expires_next, 0)) {		cpu_base->hang_detected = 0;		return;	} 	/*	 * The next timer was already expired due to:	 * - tracing	 * - long lasting callbacks	 * - being scheduled away when running in a VM	 *	 * We need to prevent that we loop forever in the hrtimer	 * interrupt routine. We give it 3 attempts to avoid	 * overreacting on some spurious event.	 */	now = ktime_get();	cpu_base->nr_retries++;	if (++retries < 3)		goto retry;	/*	 * Give the system a chance to do something else than looping	 * here. We stored the entry time, so we know exactly how long	 * we spent here. We schedule the next event this amount of	 * time away.	 */	cpu_base->nr_hangs++;	cpu_base->hang_detected = 1;	delta = ktime_sub(now, entry_time);	if (delta.tv64 > cpu_base->max_hang_time.tv64)		cpu_base->max_hang_time = delta;	/*	 * Limit it to a sensible value as we enforce a longer	 * delay. Give the CPU at least 100ms to catch up.	 */	if (delta.tv64 > 100 * NSEC_PER_MSEC)		expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);	else		expires_next = ktime_add(now, delta);	tick_program_event(expires_next, 1);	printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns\n",		    ktime_to_ns(delta));} /* * local version of hrtimer_peek_ahead_timers() called with interrupts * disabled. */static void __hrtimer_peek_ahead_timers(void){	struct tick_device *td; 	if (!hrtimer_hres_active())		return; 	td = &__get_cpu_var(tick_cpu_device);	if (td && td->evtdev)		hrtimer_interrupt(td->evtdev);} /** * hrtimer_peek_ahead_timers -- run soft-expired timers now * * hrtimer_peek_ahead_timers will peek at the timer queue of * the current cpu and check if there are any timers for which * the soft expires time has passed. If any such timers exist, * they are run immediately and then removed from the timer queue. * */void hrtimer_peek_ahead_timers(void){	unsigned long flags; 	local_irq_save(flags);	__hrtimer_peek_ahead_timers();	local_irq_restore(flags);} static void run_hrtimer_softirq(struct softirq_action *h){	hrtimer_peek_ahead_timers();} #else /* CONFIG_HIGH_RES_TIMERS */ static inline void __hrtimer_peek_ahead_timers(void) { } #endif	/* !CONFIG_HIGH_RES_TIMERS */ /* * Called from timer softirq every jiffy, expire hrtimers: * * For HRT its the fall back code to run the softirq in the timer * softirq context in case the hrtimer initialization failed or has * not been done yet. */void hrtimer_run_pending(void){	if (hrtimer_hres_active())		return; 	/*	 * This _is_ ugly: We have to check in the softirq context,	 * whether we can switch to highres and / or nohz mode. The	 * clocksource switch happens in the timer interrupt 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();} /* * Called from hardirq context every jiffy */void hrtimer_run_queues(void){	struct timerqueue_node *node;	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);	struct hrtimer_clock_base *base;	int index, gettime = 1; 	if (hrtimer_hres_active())		return; 	for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {		base = &cpu_base->clock_base[index];		if (!timerqueue_getnext(&base->active))			continue; 		if (gettime) {			hrtimer_get_softirq_time(cpu_base);			gettime = 0;		} 		raw_spin_lock(&cpu_base->lock); 		while ((node = timerqueue_getnext(&base->active))) {			struct hrtimer *timer; 			timer = container_of(node, struct hrtimer, node);			if (base->softirq_time.tv64 <=					hrtimer_get_expires_tv64(timer))				break; 			__run_hrtimer(timer, &base->softirq_time);		}		raw_spin_unlock(&cpu_base->lock);	}} /* * Sleep related functions: */static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer){	struct hrtimer_sleeper *t =		container_of(timer, struct hrtimer_sleeper, timer);	struct task_struct *task = t->task; 	t->task = NULL;	if (task)		wake_up_process(task); 	return HRTIMER_NORESTART;} void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task){	sl->timer.function = hrtimer_wakeup;	sl->task = task;}EXPORT_SYMBOL_GPL(hrtimer_init_sleeper); static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode){	hrtimer_init_sleeper(t, current); 	do {		set_current_state(TASK_INTERRUPTIBLE);		hrtimer_start_expires(&t->timer, mode);		if (!hrtimer_active(&t->timer))

Lines 1001–1500 of 1861. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t