1861 lines · 46.4 KB · C
RawDownload
			t->task = NULL; 		if (likely(t->task))			schedule(); 		hrtimer_cancel(&t->timer);		mode = HRTIMER_MODE_ABS; 	} while (t->task && !signal_pending(current)); 	__set_current_state(TASK_RUNNING); 	return t->task == NULL;} static int update_rmtp(struct hrtimer *timer, struct timespec __user *rmtp){	struct timespec rmt;	ktime_t rem; 	rem = hrtimer_expires_remaining(timer);	if (rem.tv64 <= 0)		return 0;	rmt = ktime_to_timespec(rem); 	if (copy_to_user(rmtp, &rmt, sizeof(*rmtp)))		return -EFAULT; 	return 1;} long __sched hrtimer_nanosleep_restart(struct restart_block *restart){	struct hrtimer_sleeper t;	struct timespec __user  *rmtp;	int ret = 0; 	hrtimer_init_on_stack(&t.timer, restart->nanosleep.clockid,				HRTIMER_MODE_ABS);	hrtimer_set_expires_tv64(&t.timer, restart->nanosleep.expires); 	if (do_nanosleep(&t, HRTIMER_MODE_ABS))		goto out; 	rmtp = restart->nanosleep.rmtp;	if (rmtp) {		ret = update_rmtp(&t.timer, rmtp);		if (ret <= 0)			goto out;	} 	/* The other values in restart are already filled in */	ret = -ERESTART_RESTARTBLOCK;out:	destroy_hrtimer_on_stack(&t.timer);	return ret;} long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,		       const enum hrtimer_mode mode, const clockid_t clockid){	struct restart_block *restart;	struct hrtimer_sleeper t;	int ret = 0;	unsigned long slack; 	slack = current->timer_slack_ns;	if (rt_task(current))		slack = 0; 	hrtimer_init_on_stack(&t.timer, clockid, mode);	hrtimer_set_expires_range_ns(&t.timer, timespec_to_ktime(*rqtp), slack);	if (do_nanosleep(&t, mode))		goto out; 	/* Absolute timers do not update the rmtp value and restart: */	if (mode == HRTIMER_MODE_ABS) {		ret = -ERESTARTNOHAND;		goto out;	} 	if (rmtp) {		ret = update_rmtp(&t.timer, rmtp);		if (ret <= 0)			goto out;	} 	restart = &current_thread_info()->restart_block;	restart->fn = hrtimer_nanosleep_restart;	restart->nanosleep.clockid = t.timer.base->clockid;	restart->nanosleep.rmtp = rmtp;	restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer); 	ret = -ERESTART_RESTARTBLOCK;out:	destroy_hrtimer_on_stack(&t.timer);	return ret;} SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,		struct timespec __user *, rmtp){	struct timespec tu; 	if (copy_from_user(&tu, rqtp, sizeof(tu)))		return -EFAULT; 	if (!timespec_valid(&tu))		return -EINVAL; 	return hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);} /* * Functions related to boot-time initialization: */static void __cpuinit init_hrtimers_cpu(int cpu){	struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);	int i; 	raw_spin_lock_init(&cpu_base->lock); 	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		cpu_base->clock_base[i].cpu_base = cpu_base;		timerqueue_init_head(&cpu_base->clock_base[i].active);	} 	hrtimer_init_hres(cpu_base);} #ifdef CONFIG_HOTPLUG_CPU static void migrate_hrtimer_list(struct hrtimer_clock_base *old_base,				struct hrtimer_clock_base *new_base){	struct hrtimer *timer;	struct timerqueue_node *node; 	while ((node = timerqueue_getnext(&old_base->active))) {		timer = container_of(node, struct hrtimer, node);		BUG_ON(hrtimer_callback_running(timer));		debug_deactivate(timer); 		/*		 * Mark it as STATE_MIGRATE not INACTIVE otherwise the		 * timer could be seen as !active and just vanish away		 * under us on another CPU		 */		__remove_hrtimer(timer, old_base, HRTIMER_STATE_MIGRATE, 0);		timer->base = new_base;		/*		 * Enqueue the timers on the new cpu. This does not		 * reprogram the event device in case the timer		 * expires before the earliest on this CPU, but we run		 * hrtimer_interrupt after we migrated everything to		 * sort out already expired timers and reprogram the		 * event device.		 */		enqueue_hrtimer(timer, new_base); 		/* Clear the migration state bit */		timer->state &= ~HRTIMER_STATE_MIGRATE;	}} static void migrate_hrtimers(int scpu){	struct hrtimer_cpu_base *old_base, *new_base;	int i; 	BUG_ON(cpu_online(scpu));	tick_cancel_sched_timer(scpu); 	local_irq_disable();	old_base = &per_cpu(hrtimer_bases, scpu);	new_base = &__get_cpu_var(hrtimer_bases);	/*	 * The caller is globally serialized and nobody else	 * takes two locks at once, deadlock is not possible.	 */	raw_spin_lock(&new_base->lock);	raw_spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING); 	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {		migrate_hrtimer_list(&old_base->clock_base[i],				     &new_base->clock_base[i]);	} 	raw_spin_unlock(&old_base->lock);	raw_spin_unlock(&new_base->lock); 	/* Check, if we got expired work to do */	__hrtimer_peek_ahead_timers();	local_irq_enable();} #endif /* CONFIG_HOTPLUG_CPU */ static int __cpuinit hrtimer_cpu_notify(struct notifier_block *self,					unsigned long action, void *hcpu){	int scpu = (long)hcpu; 	switch (action) { 	case CPU_UP_PREPARE:	case CPU_UP_PREPARE_FROZEN:		init_hrtimers_cpu(scpu);		break; #ifdef CONFIG_HOTPLUG_CPU	case CPU_DYING:	case CPU_DYING_FROZEN:		clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DYING, &scpu);		break;	case CPU_DEAD:	case CPU_DEAD_FROZEN:	{		clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DEAD, &scpu);		migrate_hrtimers(scpu);		break;	}#endif 	default:		break;	} 	return NOTIFY_OK;} static struct notifier_block __cpuinitdata hrtimers_nb = {	.notifier_call = hrtimer_cpu_notify,}; void __init hrtimers_init(void){	hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE,			  (void *)(long)smp_processor_id());	register_cpu_notifier(&hrtimers_nb);#ifdef CONFIG_HIGH_RES_TIMERS	open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq);#endif} /** * schedule_hrtimeout_range_clock - sleep until timeout * @expires:	timeout value (ktime_t) * @delta:	slack in expires timeout (ktime_t) * @mode:	timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL * @clock:	timer clock, CLOCK_MONOTONIC or CLOCK_REALTIME */int __schedschedule_hrtimeout_range_clock(ktime_t *expires, unsigned long delta,			       const enum hrtimer_mode mode, int clock){	struct hrtimer_sleeper t; 	/*	 * Optimize when a zero timeout value is given. It does not	 * matter whether this is an absolute or a relative time.	 */	if (expires && !expires->tv64) {		__set_current_state(TASK_RUNNING);		return 0;	} 	/*	 * A NULL parameter means "infinite"	 */	if (!expires) {		schedule();		__set_current_state(TASK_RUNNING);		return -EINTR;	} 	hrtimer_init_on_stack(&t.timer, clock, mode);	hrtimer_set_expires_range_ns(&t.timer, *expires, delta); 	hrtimer_init_sleeper(&t, current); 	hrtimer_start_expires(&t.timer, mode);	if (!hrtimer_active(&t.timer))		t.task = NULL; 	if (likely(t.task))		schedule(); 	hrtimer_cancel(&t.timer);	destroy_hrtimer_on_stack(&t.timer); 	__set_current_state(TASK_RUNNING); 	return !t.task ? 0 : -EINTR;} /** * schedule_hrtimeout_range - sleep until timeout * @expires:	timeout value (ktime_t) * @delta:	slack in expires timeout (ktime_t) * @mode:	timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL * * Make the current task sleep until the given expiry time has * elapsed. The routine will return immediately unless * the current task state has been set (see set_current_state()). * * The @delta argument gives the kernel the freedom to schedule the * actual wakeup to a time that is both power and performance friendly. * The kernel give the normal best effort behavior for "@expires+@delta", * but may decide to fire the timer earlier, but no earlier than @expires. * * You can set the task state as follows - * * %TASK_UNINTERRUPTIBLE - at least @timeout time is guaranteed to * pass before the routine returns. * * %TASK_INTERRUPTIBLE - the routine may return early if a signal is * delivered to the current task. * * The current task state is guaranteed to be TASK_RUNNING when this * routine returns. * * Returns 0 when the timer has expired otherwise -EINTR */int __sched schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,				     const enum hrtimer_mode mode){	return schedule_hrtimeout_range_clock(expires, delta, mode,					      CLOCK_MONOTONIC);}EXPORT_SYMBOL_GPL(schedule_hrtimeout_range); /** * schedule_hrtimeout - sleep until timeout * @expires:	timeout value (ktime_t) * @mode:	timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL * * Make the current task sleep until the given expiry time has * elapsed. The routine will return immediately unless * the current task state has been set (see set_current_state()). * * You can set the task state as follows - * * %TASK_UNINTERRUPTIBLE - at least @timeout time is guaranteed to * pass before the routine returns. * * %TASK_INTERRUPTIBLE - the routine may return early if a signal is * delivered to the current task. * * The current task state is guaranteed to be TASK_RUNNING when this * routine returns. * * Returns 0 when the timer has expired otherwise -EINTR */int __sched schedule_hrtimeout(ktime_t *expires,			       const enum hrtimer_mode mode){	return schedule_hrtimeout_range(expires, 0, mode);}EXPORT_SYMBOL_GPL(schedule_hrtimeout);

Lines 1501–1861 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