Kernel

Kernel Git Source Tree

Root/kernel/posix-cpu-timers.c

1	/*
2	* Implement CPU time clocks for the POSIX clock interface.
3	*/
4
5	#include <linux/sched.h>
6	#include <linux/posix-timers.h>
7	#include <linux/errno.h>
8	#include <linux/math64.h>
9	#include <asm/uaccess.h>
10	#include <linux/kernel_stat.h>
11	#include <trace/events/timer.h>
12
13	/*
14	* Called after updating RLIMIT_CPU to set timer expiration if necessary.
15	*/
16	void update_rlimit_cpu(unsigned long rlim_new)
17	{
18	cputime_t cputime = secs_to_cputime(rlim_new);
19	struct signal_struct *const sig = current->signal;
20
21	if (cputime_eq(sig->it[CPUCLOCK_PROF].expires, cputime_zero) \|\|
22	cputime_gt(sig->it[CPUCLOCK_PROF].expires, cputime)) {
23	spin_lock_irq(&current->sighand->siglock);
24	set_process_cpu_timer(current, CPUCLOCK_PROF, &cputime, NULL);
25	spin_unlock_irq(&current->sighand->siglock);
26	}
27	}
28
29	static int check_clock(const clockid_t which_clock)
30	{
31	int error = 0;
32	struct task_struct *p;
33	const pid_t pid = CPUCLOCK_PID(which_clock);
34
35	if (CPUCLOCK_WHICH(which_clock) >= CPUCLOCK_MAX)
36	return -EINVAL;
37
38	if (pid == 0)
39	return 0;
40
41	read_lock(&tasklist_lock);
42	p = find_task_by_vpid(pid);
43	if (!p \|\| !(CPUCLOCK_PERTHREAD(which_clock) ?
44	same_thread_group(p, current) : thread_group_leader(p))) {
45	error = -EINVAL;
46	}
47	read_unlock(&tasklist_lock);
48
49	return error;
50	}
51
52	static inline union cpu_time_count
53	timespec_to_sample(const clockid_t which_clock, const struct timespec *tp)
54	{
55	union cpu_time_count ret;
56	ret.sched = 0; /* high half always zero when .cpu used */
57	if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
58	ret.sched = (unsigned long long)tp->tv_sec * NSEC_PER_SEC + tp->tv_nsec;
59	} else {
60	ret.cpu = timespec_to_cputime(tp);
61	}
62	return ret;
63	}
64
65	static void sample_to_timespec(const clockid_t which_clock,
66	union cpu_time_count cpu,
67	struct timespec *tp)
68	{
69	if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED)
70	*tp = ns_to_timespec(cpu.sched);
71	else
72	cputime_to_timespec(cpu.cpu, tp);
73	}
74
75	static inline int cpu_time_before(const clockid_t which_clock,
76	union cpu_time_count now,
77	union cpu_time_count then)
78	{
79	if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
80	return now.sched < then.sched;
81	} else {
82	return cputime_lt(now.cpu, then.cpu);
83	}
84	}
85	static inline void cpu_time_add(const clockid_t which_clock,
86	union cpu_time_count *acc,
87	union cpu_time_count val)
88	{
89	if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
90	acc->sched += val.sched;
91	} else {
92	acc->cpu = cputime_add(acc->cpu, val.cpu);
93	}
94	}
95	static inline union cpu_time_count cpu_time_sub(const clockid_t which_clock,
96	union cpu_time_count a,
97	union cpu_time_count b)
98	{
99	if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
100	a.sched -= b.sched;
101	} else {
102	a.cpu = cputime_sub(a.cpu, b.cpu);
103	}
104	return a;
105	}
106
107	/*
108	* Divide and limit the result to res >= 1
109	*
110	* This is necessary to prevent signal delivery starvation, when the result of
111	* the division would be rounded down to 0.
112	*/
113	static inline cputime_t cputime_div_non_zero(cputime_t time, unsigned long div)
114	{
115	cputime_t res = cputime_div(time, div);
116
117	return max_t(cputime_t, res, 1);
118	}
119
120	/*
121	* Update expiry time from increment, and increase overrun count,
122	* given the current clock sample.
123	*/
124	static void bump_cpu_timer(struct k_itimer *timer,
125	union cpu_time_count now)
126	{
127	int i;
128
129	if (timer->it.cpu.incr.sched == 0)
130	return;
131
132	if (CPUCLOCK_WHICH(timer->it_clock) == CPUCLOCK_SCHED) {
133	unsigned long long delta, incr;
134
135	if (now.sched < timer->it.cpu.expires.sched)
136	return;
137	incr = timer->it.cpu.incr.sched;
138	delta = now.sched + incr - timer->it.cpu.expires.sched;
139	/* Don't use (incr2 < delta), incr2 might overflow. */
140	for (i = 0; incr < delta - incr; i++)
141	incr = incr << 1;
142	for (; i >= 0; incr >>= 1, i--) {
143	if (delta < incr)
144	continue;
145	timer->it.cpu.expires.sched += incr;
146	timer->it_overrun += 1 << i;
147	delta -= incr;
148	}
149	} else {
150	cputime_t delta, incr;
151
152	if (cputime_lt(now.cpu, timer->it.cpu.expires.cpu))
153	return;
154	incr = timer->it.cpu.incr.cpu;
155	delta = cputime_sub(cputime_add(now.cpu, incr),
156	timer->it.cpu.expires.cpu);
157	/* Don't use (incr2 < delta), incr2 might overflow. */
158	for (i = 0; cputime_lt(incr, cputime_sub(delta, incr)); i++)
159	incr = cputime_add(incr, incr);
160	for (; i >= 0; incr = cputime_halve(incr), i--) {
161	if (cputime_lt(delta, incr))
162	continue;
163	timer->it.cpu.expires.cpu =
164	cputime_add(timer->it.cpu.expires.cpu, incr);
165	timer->it_overrun += 1 << i;
166	delta = cputime_sub(delta, incr);
167	}
168	}
169	}
170
171	static inline cputime_t prof_ticks(struct task_struct *p)
172	{
173	return cputime_add(p->utime, p->stime);
174	}
175	static inline cputime_t virt_ticks(struct task_struct *p)
176	{
177	return p->utime;
178	}
179
180	int posix_cpu_clock_getres(const clockid_t which_clock, struct timespec *tp)
181	{
182	int error = check_clock(which_clock);
183	if (!error) {
184	tp->tv_sec = 0;
185	tp->tv_nsec = ((NSEC_PER_SEC + HZ - 1) / HZ);
186	if (CPUCLOCK_WHICH(which_clock) == CPUCLOCK_SCHED) {
187	/*
188	* If sched_clock is using a cycle counter, we
189	* don't have any idea of its true resolution
190	* exported, but it is much more than 1s/HZ.
191	*/
192	tp->tv_nsec = 1;
193	}
194	}
195	return error;
196	}
197
198	int posix_cpu_clock_set(const clockid_t which_clock, const struct timespec *tp)
199	{
200	/*
201	* You can never reset a CPU clock, but we check for other errors
202	* in the call before failing with EPERM.
203	*/
204	int error = check_clock(which_clock);
205	if (error == 0) {
206	error = -EPERM;
207	}
208	return error;
209	}
210
211
212	/*
213	* Sample a per-thread clock for the given task.
214	*/
215	static int cpu_clock_sample(const clockid_t which_clock, struct task_struct *p,
216	union cpu_time_count *cpu)
217	{
218	switch (CPUCLOCK_WHICH(which_clock)) {
219	default:
220	return -EINVAL;
221	case CPUCLOCK_PROF:
222	cpu->cpu = prof_ticks(p);
223	break;
224	case CPUCLOCK_VIRT:
225	cpu->cpu = virt_ticks(p);
226	break;
227	case CPUCLOCK_SCHED:
228	cpu->sched = task_sched_runtime(p);
229	break;
230	}
231	return 0;
232	}
233
234	void thread_group_cputime(struct task_struct tsk, struct task_cputime times)
235	{
236	struct sighand_struct *sighand;
237	struct signal_struct *sig;
238	struct task_struct *t;
239
240	*times = INIT_CPUTIME;
241
242	rcu_read_lock();
243	sighand = rcu_dereference(tsk->sighand);
244	if (!sighand)
245	goto out;
246
247	sig = tsk->signal;
248
249	t = tsk;
250	do {
251	times->utime = cputime_add(times->utime, t->utime);
252	times->stime = cputime_add(times->stime, t->stime);
253	times->sum_exec_runtime += t->se.sum_exec_runtime;
254
255	t = next_thread(t);
256	} while (t != tsk);
257
258	times->utime = cputime_add(times->utime, sig->utime);
259	times->stime = cputime_add(times->stime, sig->stime);
260	times->sum_exec_runtime += sig->sum_sched_runtime;
261	out:
262	rcu_read_unlock();
263	}
264
265	static void update_gt_cputime(struct task_cputime a, struct task_cputime b)
266	{
267	if (cputime_gt(b->utime, a->utime))
268	a->utime = b->utime;
269
270	if (cputime_gt(b->stime, a->stime))
271	a->stime = b->stime;
272
273	if (b->sum_exec_runtime > a->sum_exec_runtime)
274	a->sum_exec_runtime = b->sum_exec_runtime;
275	}
276
277	void thread_group_cputimer(struct task_struct tsk, struct task_cputime times)
278	{
279	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
280	struct task_cputime sum;
281	unsigned long flags;
282
283	spin_lock_irqsave(&cputimer->lock, flags);
284	if (!cputimer->running) {
285	cputimer->running = 1;
286	/*
287	* The POSIX timer interface allows for absolute time expiry
288	* values through the TIMER_ABSTIME flag, therefore we have
289	* to synchronize the timer to the clock every time we start
290	* it.
291	*/
292	thread_group_cputime(tsk, &sum);
293	update_gt_cputime(&cputimer->cputime, &sum);
294	}
295	*times = cputimer->cputime;
296	spin_unlock_irqrestore(&cputimer->lock, flags);
297	}
298
299	/*
300	* Sample a process (thread group) clock for the given group_leader task.
301	* Must be called with tasklist_lock held for reading.
302	*/
303	static int cpu_clock_sample_group(const clockid_t which_clock,
304	struct task_struct *p,
305	union cpu_time_count *cpu)
306	{
307	struct task_cputime cputime;
308
309	switch (CPUCLOCK_WHICH(which_clock)) {
310	default:
311	return -EINVAL;
312	case CPUCLOCK_PROF:
313	thread_group_cputime(p, &cputime);
314	cpu->cpu = cputime_add(cputime.utime, cputime.stime);
315	break;
316	case CPUCLOCK_VIRT:
317	thread_group_cputime(p, &cputime);
318	cpu->cpu = cputime.utime;
319	break;
320	case CPUCLOCK_SCHED:
321	cpu->sched = thread_group_sched_runtime(p);
322	break;
323	}
324	return 0;
325	}
326
327
328	int posix_cpu_clock_get(const clockid_t which_clock, struct timespec *tp)
329	{
330	const pid_t pid = CPUCLOCK_PID(which_clock);
331	int error = -EINVAL;
332	union cpu_time_count rtn;
333
334	if (pid == 0) {
335	/*
336	* Special case constant value for our own clocks.
337	* We don't have to do any lookup to find ourselves.
338	*/
339	if (CPUCLOCK_PERTHREAD(which_clock)) {
340	/*
341	* Sampling just ourselves we can do with no locking.
342	*/
343	error = cpu_clock_sample(which_clock,
344	current, &rtn);
345	} else {
346	read_lock(&tasklist_lock);
347	error = cpu_clock_sample_group(which_clock,
348	current, &rtn);
349	read_unlock(&tasklist_lock);
350	}
351	} else {
352	/*
353	* Find the given PID, and validate that the caller
354	* should be able to see it.
355	*/
356	struct task_struct *p;
357	rcu_read_lock();
358	p = find_task_by_vpid(pid);
359	if (p) {
360	if (CPUCLOCK_PERTHREAD(which_clock)) {
361	if (same_thread_group(p, current)) {
362	error = cpu_clock_sample(which_clock,
363	p, &rtn);
364	}
365	} else {
366	read_lock(&tasklist_lock);
367	if (thread_group_leader(p) && p->signal) {
368	error =
369	cpu_clock_sample_group(which_clock,
370	p, &rtn);
371	}
372	read_unlock(&tasklist_lock);
373	}
374	}
375	rcu_read_unlock();
376	}
377
378	if (error)
379	return error;
380	sample_to_timespec(which_clock, rtn, tp);
381	return 0;
382	}
383
384
385	/*
386	* Validate the clockid_t for a new CPU-clock timer, and initialize the timer.
387	* This is called from sys_timer_create with the new timer already locked.
388	*/
389	int posix_cpu_timer_create(struct k_itimer *new_timer)
390	{
391	int ret = 0;
392	const pid_t pid = CPUCLOCK_PID(new_timer->it_clock);
393	struct task_struct *p;
394
395	if (CPUCLOCK_WHICH(new_timer->it_clock) >= CPUCLOCK_MAX)
396	return -EINVAL;
397
398	INIT_LIST_HEAD(&new_timer->it.cpu.entry);
399	new_timer->it.cpu.incr.sched = 0;
400	new_timer->it.cpu.expires.sched = 0;
401
402	read_lock(&tasklist_lock);
403	if (CPUCLOCK_PERTHREAD(new_timer->it_clock)) {
404	if (pid == 0) {
405	p = current;
406	} else {
407	p = find_task_by_vpid(pid);
408	if (p && !same_thread_group(p, current))
409	p = NULL;
410	}
411	} else {
412	if (pid == 0) {
413	p = current->group_leader;
414	} else {
415	p = find_task_by_vpid(pid);
416	if (p && !thread_group_leader(p))
417	p = NULL;
418	}
419	}
420	new_timer->it.cpu.task = p;
421	if (p) {
422	get_task_struct(p);
423	} else {
424	ret = -EINVAL;
425	}
426	read_unlock(&tasklist_lock);
427
428	return ret;
429	}
430
431	/*
432	* Clean up a CPU-clock timer that is about to be destroyed.
433	* This is called from timer deletion with the timer already locked.
434	* If we return TIMER_RETRY, it's necessary to release the timer's lock
435	* and try again. (This happens when the timer is in the middle of firing.)
436	*/
437	int posix_cpu_timer_del(struct k_itimer *timer)
438	{
439	struct task_struct *p = timer->it.cpu.task;
440	int ret = 0;
441
442	if (likely(p != NULL)) {
443	read_lock(&tasklist_lock);
444	if (unlikely(p->signal == NULL)) {
445	/*
446	* We raced with the reaping of the task.
447	* The deletion should have cleared us off the list.
448	*/
449	BUG_ON(!list_empty(&timer->it.cpu.entry));
450	} else {
451	spin_lock(&p->sighand->siglock);
452	if (timer->it.cpu.firing)
453	ret = TIMER_RETRY;
454	else
455	list_del(&timer->it.cpu.entry);
456	spin_unlock(&p->sighand->siglock);
457	}
458	read_unlock(&tasklist_lock);
459
460	if (!ret)
461	put_task_struct(p);
462	}
463
464	return ret;
465	}
466
467	/*
468	* Clean out CPU timers still ticking when a thread exited. The task
469	* pointer is cleared, and the expiry time is replaced with the residual
470	* time for later timer_gettime calls to return.
471	* This must be called with the siglock held.
472	*/
473	static void cleanup_timers(struct list_head *head,
474	cputime_t utime, cputime_t stime,
475	unsigned long long sum_exec_runtime)
476	{
477	struct cpu_timer_list timer, next;
478	cputime_t ptime = cputime_add(utime, stime);
479
480	list_for_each_entry_safe(timer, next, head, entry) {
481	list_del_init(&timer->entry);
482	if (cputime_lt(timer->expires.cpu, ptime)) {
483	timer->expires.cpu = cputime_zero;
484	} else {
485	timer->expires.cpu = cputime_sub(timer->expires.cpu,
486	ptime);
487	}
488	}
489
490	++head;
491	list_for_each_entry_safe(timer, next, head, entry) {
492	list_del_init(&timer->entry);
493	if (cputime_lt(timer->expires.cpu, utime)) {
494	timer->expires.cpu = cputime_zero;
495	} else {
496	timer->expires.cpu = cputime_sub(timer->expires.cpu,
497	utime);
498	}
499	}
500
501	++head;
502	list_for_each_entry_safe(timer, next, head, entry) {
503	list_del_init(&timer->entry);
504	if (timer->expires.sched < sum_exec_runtime) {
505	timer->expires.sched = 0;
506	} else {
507	timer->expires.sched -= sum_exec_runtime;
508	}
509	}
510	}
511
512	/*
513	* These are both called with the siglock held, when the current thread
514	* is being reaped. When the final (leader) thread in the group is reaped,
515	* posix_cpu_timers_exit_group will be called after posix_cpu_timers_exit.
516	*/
517	void posix_cpu_timers_exit(struct task_struct *tsk)
518	{
519	cleanup_timers(tsk->cpu_timers,
520	tsk->utime, tsk->stime, tsk->se.sum_exec_runtime);
521
522	}
523	void posix_cpu_timers_exit_group(struct task_struct *tsk)
524	{
525	struct signal_struct *const sig = tsk->signal;
526
527	cleanup_timers(tsk->signal->cpu_timers,
528	cputime_add(tsk->utime, sig->utime),
529	cputime_add(tsk->stime, sig->stime),
530	tsk->se.sum_exec_runtime + sig->sum_sched_runtime);
531	}
532
533	static void clear_dead_task(struct k_itimer *timer, union cpu_time_count now)
534	{
535	/*
536	* That's all for this thread or process.
537	* We leave our residual in expires to be reported.
538	*/
539	put_task_struct(timer->it.cpu.task);
540	timer->it.cpu.task = NULL;
541	timer->it.cpu.expires = cpu_time_sub(timer->it_clock,
542	timer->it.cpu.expires,
543	now);
544	}
545
546	static inline int expires_gt(cputime_t expires, cputime_t new_exp)
547	{
548	return cputime_eq(expires, cputime_zero) \|\|
549	cputime_gt(expires, new_exp);
550	}
551
552	static inline int expires_le(cputime_t expires, cputime_t new_exp)
553	{
554	return !cputime_eq(expires, cputime_zero) &&
555	cputime_le(expires, new_exp);
556	}
557	/*
558	* Insert the timer on the appropriate list before any timers that
559	* expire later. This must be called with the tasklist_lock held
560	* for reading, and interrupts disabled.
561	*/
562	static void arm_timer(struct k_itimer *timer, union cpu_time_count now)
563	{
564	struct task_struct *p = timer->it.cpu.task;
565	struct list_head head, listpos;
566	struct cpu_timer_list *const nt = &timer->it.cpu;
567	struct cpu_timer_list *next;
568	unsigned long i;
569
570	head = (CPUCLOCK_PERTHREAD(timer->it_clock) ?
571	p->cpu_timers : p->signal->cpu_timers);
572	head += CPUCLOCK_WHICH(timer->it_clock);
573
574	BUG_ON(!irqs_disabled());
575	spin_lock(&p->sighand->siglock);
576
577	listpos = head;
578	if (CPUCLOCK_WHICH(timer->it_clock) == CPUCLOCK_SCHED) {
579	list_for_each_entry(next, head, entry) {
580	if (next->expires.sched > nt->expires.sched)
581	break;
582	listpos = &next->entry;
583	}
584	} else {
585	list_for_each_entry(next, head, entry) {
586	if (cputime_gt(next->expires.cpu, nt->expires.cpu))
587	break;
588	listpos = &next->entry;
589	}
590	}
591	list_add(&nt->entry, listpos);
592
593	if (listpos == head) {
594	/*
595	* We are the new earliest-expiring timer.
596	* If we are a thread timer, there can always
597	* be a process timer telling us to stop earlier.
598	*/
599
600	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
601	union cpu_time_count *exp = &nt->expires;
602
603	switch (CPUCLOCK_WHICH(timer->it_clock)) {
604	default:
605	BUG();
606	case CPUCLOCK_PROF:
607	if (expires_gt(p->cputime_expires.prof_exp,
608	exp->cpu))
609	p->cputime_expires.prof_exp = exp->cpu;
610	break;
611	case CPUCLOCK_VIRT:
612	if (expires_gt(p->cputime_expires.virt_exp,
613	exp->cpu))
614	p->cputime_expires.virt_exp = exp->cpu;
615	break;
616	case CPUCLOCK_SCHED:
617	if (p->cputime_expires.sched_exp == 0 \|\|
618	p->cputime_expires.sched_exp > exp->sched)
619	p->cputime_expires.sched_exp =
620	exp->sched;
621	break;
622	}
623	} else {
624	struct signal_struct *const sig = p->signal;
625	union cpu_time_count *exp = &timer->it.cpu.expires;
626
627	/*
628	* For a process timer, set the cached expiration time.
629	*/
630	switch (CPUCLOCK_WHICH(timer->it_clock)) {
631	default:
632	BUG();
633	case CPUCLOCK_VIRT:
634	if (expires_le(sig->it[CPUCLOCK_VIRT].expires,
635	exp->cpu))
636	break;
637	sig->cputime_expires.virt_exp = exp->cpu;
638	break;
639	case CPUCLOCK_PROF:
640	if (expires_le(sig->it[CPUCLOCK_PROF].expires,
641	exp->cpu))
642	break;
643	i = sig->rlim[RLIMIT_CPU].rlim_cur;
644	if (i != RLIM_INFINITY &&
645	i <= cputime_to_secs(exp->cpu))
646	break;
647	sig->cputime_expires.prof_exp = exp->cpu;
648	break;
649	case CPUCLOCK_SCHED:
650	sig->cputime_expires.sched_exp = exp->sched;
651	break;
652	}
653	}
654	}
655
656	spin_unlock(&p->sighand->siglock);
657	}
658
659	/*
660	* The timer is locked, fire it and arrange for its reload.
661	*/
662	static void cpu_timer_fire(struct k_itimer *timer)
663	{
664	if (unlikely(timer->sigq == NULL)) {
665	/*
666	* This a special case for clock_nanosleep,
667	* not a normal timer from sys_timer_create.
668	*/
669	wake_up_process(timer->it_process);
670	timer->it.cpu.expires.sched = 0;
671	} else if (timer->it.cpu.incr.sched == 0) {
672	/*
673	* One-shot timer. Clear it as soon as it's fired.
674	*/
675	posix_timer_event(timer, 0);
676	timer->it.cpu.expires.sched = 0;
677	} else if (posix_timer_event(timer, ++timer->it_requeue_pending)) {
678	/*
679	* The signal did not get queued because the signal
680	* was ignored, so we won't get any callback to
681	* reload the timer. But we need to keep it
682	* ticking in case the signal is deliverable next time.
683	*/
684	posix_cpu_timer_schedule(timer);
685	}
686	}
687
688	/*
689	* Sample a process (thread group) timer for the given group_leader task.
690	* Must be called with tasklist_lock held for reading.
691	*/
692	static int cpu_timer_sample_group(const clockid_t which_clock,
693	struct task_struct *p,
694	union cpu_time_count *cpu)
695	{
696	struct task_cputime cputime;
697
698	thread_group_cputimer(p, &cputime);
699	switch (CPUCLOCK_WHICH(which_clock)) {
700	default:
701	return -EINVAL;
702	case CPUCLOCK_PROF:
703	cpu->cpu = cputime_add(cputime.utime, cputime.stime);
704	break;
705	case CPUCLOCK_VIRT:
706	cpu->cpu = cputime.utime;
707	break;
708	case CPUCLOCK_SCHED:
709	cpu->sched = cputime.sum_exec_runtime + task_delta_exec(p);
710	break;
711	}
712	return 0;
713	}
714
715	/*
716	* Guts of sys_timer_settime for CPU timers.
717	* This is called with the timer locked and interrupts disabled.
718	* If we return TIMER_RETRY, it's necessary to release the timer's lock
719	* and try again. (This happens when the timer is in the middle of firing.)
720	*/
721	int posix_cpu_timer_set(struct k_itimer *timer, int flags,
722	struct itimerspec new, struct itimerspec old)
723	{
724	struct task_struct *p = timer->it.cpu.task;
725	union cpu_time_count old_expires, new_expires, val;
726	int ret;
727
728	if (unlikely(p == NULL)) {
729	/*
730	* Timer refers to a dead task's clock.
731	*/
732	return -ESRCH;
733	}
734
735	new_expires = timespec_to_sample(timer->it_clock, &new->it_value);
736
737	read_lock(&tasklist_lock);
738	/*
739	* We need the tasklist_lock to protect against reaping that
740	* clears p->signal. If p has just been reaped, we can no
741	* longer get any information about it at all.
742	*/
743	if (unlikely(p->signal == NULL)) {
744	read_unlock(&tasklist_lock);
745	put_task_struct(p);
746	timer->it.cpu.task = NULL;
747	return -ESRCH;
748	}
749
750	/*
751	* Disarm any old timer after extracting its expiry time.
752	*/
753	BUG_ON(!irqs_disabled());
754
755	ret = 0;
756	spin_lock(&p->sighand->siglock);
757	old_expires = timer->it.cpu.expires;
758	if (unlikely(timer->it.cpu.firing)) {
759	timer->it.cpu.firing = -1;
760	ret = TIMER_RETRY;
761	} else
762	list_del_init(&timer->it.cpu.entry);
763	spin_unlock(&p->sighand->siglock);
764
765	/*
766	* We need to sample the current value to convert the new
767	* value from to relative and absolute, and to convert the
768	* old value from absolute to relative. To set a process
769	* timer, we need a sample to balance the thread expiry
770	* times (in arm_timer). With an absolute time, we must
771	* check if it's already passed. In short, we need a sample.
772	*/
773	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
774	cpu_clock_sample(timer->it_clock, p, &val);
775	} else {
776	cpu_timer_sample_group(timer->it_clock, p, &val);
777	}
778
779	if (old) {
780	if (old_expires.sched == 0) {
781	old->it_value.tv_sec = 0;
782	old->it_value.tv_nsec = 0;
783	} else {
784	/*
785	* Update the timer in case it has
786	* overrun already. If it has,
787	* we'll report it as having overrun
788	* and with the next reloaded timer
789	* already ticking, though we are
790	* swallowing that pending
791	* notification here to install the
792	* new setting.
793	*/
794	bump_cpu_timer(timer, val);
795	if (cpu_time_before(timer->it_clock, val,
796	timer->it.cpu.expires)) {
797	old_expires = cpu_time_sub(
798	timer->it_clock,
799	timer->it.cpu.expires, val);
800	sample_to_timespec(timer->it_clock,
801	old_expires,
802	&old->it_value);
803	} else {
804	old->it_value.tv_nsec = 1;
805	old->it_value.tv_sec = 0;
806	}
807	}
808	}
809
810	if (unlikely(ret)) {
811	/*
812	* We are colliding with the timer actually firing.
813	* Punt after filling in the timer's old value, and
814	* disable this firing since we are already reporting
815	* it as an overrun (thanks to bump_cpu_timer above).
816	*/
817	read_unlock(&tasklist_lock);
818	goto out;
819	}
820
821	if (new_expires.sched != 0 && !(flags & TIMER_ABSTIME)) {
822	cpu_time_add(timer->it_clock, &new_expires, val);
823	}
824
825	/*
826	* Install the new expiry time (or zero).
827	* For a timer with no notification action, we don't actually
828	* arm the timer (we'll just fake it for timer_gettime).
829	*/
830	timer->it.cpu.expires = new_expires;
831	if (new_expires.sched != 0 &&
832	(timer->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE &&
833	cpu_time_before(timer->it_clock, val, new_expires)) {
834	arm_timer(timer, val);
835	}
836
837	read_unlock(&tasklist_lock);
838
839	/*
840	* Install the new reload setting, and
841	* set up the signal and overrun bookkeeping.
842	*/
843	timer->it.cpu.incr = timespec_to_sample(timer->it_clock,
844	&new->it_interval);
845
846	/*
847	* This acts as a modification timestamp for the timer,
848	* so any automatic reload attempt will punt on seeing
849	* that we have reset the timer manually.
850	*/
851	timer->it_requeue_pending = (timer->it_requeue_pending + 2) &
852	~REQUEUE_PENDING;
853	timer->it_overrun_last = 0;
854	timer->it_overrun = -1;
855
856	if (new_expires.sched != 0 &&
857	(timer->it_sigev_notify & ~SIGEV_THREAD_ID) != SIGEV_NONE &&
858	!cpu_time_before(timer->it_clock, val, new_expires)) {
859	/*
860	* The designated time already passed, so we notify
861	* immediately, even if the thread never runs to
862	* accumulate more time on this clock.
863	*/
864	cpu_timer_fire(timer);
865	}
866
867	ret = 0;
868	out:
869	if (old) {
870	sample_to_timespec(timer->it_clock,
871	timer->it.cpu.incr, &old->it_interval);
872	}
873	return ret;
874	}
875
876	void posix_cpu_timer_get(struct k_itimer timer, struct itimerspec itp)
877	{
878	union cpu_time_count now;
879	struct task_struct *p = timer->it.cpu.task;
880	int clear_dead;
881
882	/*
883	* Easy part: convert the reload time.
884	*/
885	sample_to_timespec(timer->it_clock,
886	timer->it.cpu.incr, &itp->it_interval);
887
888	if (timer->it.cpu.expires.sched == 0) { /* Timer not armed at all. */
889	itp->it_value.tv_sec = itp->it_value.tv_nsec = 0;
890	return;
891	}
892
893	if (unlikely(p == NULL)) {
894	/*
895	* This task already died and the timer will never fire.
896	* In this case, expires is actually the dead value.
897	*/
898	dead:
899	sample_to_timespec(timer->it_clock, timer->it.cpu.expires,
900	&itp->it_value);
901	return;
902	}
903
904	/*
905	* Sample the clock to take the difference with the expiry time.
906	*/
907	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
908	cpu_clock_sample(timer->it_clock, p, &now);
909	clear_dead = p->exit_state;
910	} else {
911	read_lock(&tasklist_lock);
912	if (unlikely(p->signal == NULL)) {
913	/*
914	* The process has been reaped.
915	* We can't even collect a sample any more.
916	* Call the timer disarmed, nothing else to do.
917	*/
918	put_task_struct(p);
919	timer->it.cpu.task = NULL;
920	timer->it.cpu.expires.sched = 0;
921	read_unlock(&tasklist_lock);
922	goto dead;
923	} else {
924	cpu_timer_sample_group(timer->it_clock, p, &now);
925	clear_dead = (unlikely(p->exit_state) &&
926	thread_group_empty(p));
927	}
928	read_unlock(&tasklist_lock);
929	}
930
931	if ((timer->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
932	if (timer->it.cpu.incr.sched == 0 &&
933	cpu_time_before(timer->it_clock,
934	timer->it.cpu.expires, now)) {
935	/*
936	* Do-nothing timer expired and has no reload,
937	* so it's as if it was never set.
938	*/
939	timer->it.cpu.expires.sched = 0;
940	itp->it_value.tv_sec = itp->it_value.tv_nsec = 0;
941	return;
942	}
943	/*
944	* Account for any expirations and reloads that should
945	* have happened.
946	*/
947	bump_cpu_timer(timer, now);
948	}
949
950	if (unlikely(clear_dead)) {
951	/*
952	* We've noticed that the thread is dead, but
953	* not yet reaped. Take this opportunity to
954	* drop our task ref.
955	*/
956	clear_dead_task(timer, now);
957	goto dead;
958	}
959
960	if (cpu_time_before(timer->it_clock, now, timer->it.cpu.expires)) {
961	sample_to_timespec(timer->it_clock,
962	cpu_time_sub(timer->it_clock,
963	timer->it.cpu.expires, now),
964	&itp->it_value);
965	} else {
966	/*
967	* The timer should have expired already, but the firing
968	* hasn't taken place yet. Say it's just about to expire.
969	*/
970	itp->it_value.tv_nsec = 1;
971	itp->it_value.tv_sec = 0;
972	}
973	}
974
975	/*
976	* Check for any per-thread CPU timers that have fired and move them off
977	* the tsk->cpu_timers[N] list onto the firing list. Here we update the
978	* tsk->it_*_expires values to reflect the remaining thread CPU timers.
979	*/
980	static void check_thread_timers(struct task_struct *tsk,
981	struct list_head *firing)
982	{
983	int maxfire;
984	struct list_head *timers = tsk->cpu_timers;
985	struct signal_struct *const sig = tsk->signal;
986
987	maxfire = 20;
988	tsk->cputime_expires.prof_exp = cputime_zero;
989	while (!list_empty(timers)) {
990	struct cpu_timer_list *t = list_first_entry(timers,
991	struct cpu_timer_list,
992	entry);
993	if (!--maxfire \|\| cputime_lt(prof_ticks(tsk), t->expires.cpu)) {
994	tsk->cputime_expires.prof_exp = t->expires.cpu;
995	break;
996	}
997	t->firing = 1;
998	list_move_tail(&t->entry, firing);
999	}
1000
1001	++timers;
1002	maxfire = 20;
1003	tsk->cputime_expires.virt_exp = cputime_zero;
1004	while (!list_empty(timers)) {
1005	struct cpu_timer_list *t = list_first_entry(timers,
1006	struct cpu_timer_list,
1007	entry);
1008	if (!--maxfire \|\| cputime_lt(virt_ticks(tsk), t->expires.cpu)) {
1009	tsk->cputime_expires.virt_exp = t->expires.cpu;
1010	break;
1011	}
1012	t->firing = 1;
1013	list_move_tail(&t->entry, firing);
1014	}
1015
1016	++timers;
1017	maxfire = 20;
1018	tsk->cputime_expires.sched_exp = 0;
1019	while (!list_empty(timers)) {
1020	struct cpu_timer_list *t = list_first_entry(timers,
1021	struct cpu_timer_list,
1022	entry);
1023	if (!--maxfire \|\| tsk->se.sum_exec_runtime < t->expires.sched) {
1024	tsk->cputime_expires.sched_exp = t->expires.sched;
1025	break;
1026	}
1027	t->firing = 1;
1028	list_move_tail(&t->entry, firing);
1029	}
1030
1031	/*
1032	* Check for the special case thread timers.
1033	*/
1034	if (sig->rlim[RLIMIT_RTTIME].rlim_cur != RLIM_INFINITY) {
1035	unsigned long hard = sig->rlim[RLIMIT_RTTIME].rlim_max;
1036	unsigned long *soft = &sig->rlim[RLIMIT_RTTIME].rlim_cur;
1037
1038	if (hard != RLIM_INFINITY &&
1039	tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) {
1040	/*
1041	* At the hard limit, we just die.
1042	* No need to calculate anything else now.
1043	*/
1044	__group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
1045	return;
1046	}
1047	if (tsk->rt.timeout > DIV_ROUND_UP(*soft, USEC_PER_SEC/HZ)) {
1048	/*
1049	* At the soft limit, send a SIGXCPU every second.
1050	*/
1051	if (sig->rlim[RLIMIT_RTTIME].rlim_cur
1052	< sig->rlim[RLIMIT_RTTIME].rlim_max) {
1053	sig->rlim[RLIMIT_RTTIME].rlim_cur +=
1054	USEC_PER_SEC;
1055	}
1056	printk(KERN_INFO
1057	"RT Watchdog Timeout: %s[%d]\n",
1058	tsk->comm, task_pid_nr(tsk));
1059	__group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
1060	}
1061	}
1062	}
1063
1064	static void stop_process_timers(struct task_struct *tsk)
1065	{
1066	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
1067	unsigned long flags;
1068
1069	if (!cputimer->running)
1070	return;
1071
1072	spin_lock_irqsave(&cputimer->lock, flags);
1073	cputimer->running = 0;
1074	spin_unlock_irqrestore(&cputimer->lock, flags);
1075	}
1076
1077	static u32 onecputick;
1078
1079	static void check_cpu_itimer(struct task_struct tsk, struct cpu_itimer it,
1080	cputime_t *expires, cputime_t cur_time, int signo)
1081	{
1082	if (cputime_eq(it->expires, cputime_zero))
1083	return;
1084
1085	if (cputime_ge(cur_time, it->expires)) {
1086	if (!cputime_eq(it->incr, cputime_zero)) {
1087	it->expires = cputime_add(it->expires, it->incr);
1088	it->error += it->incr_error;
1089	if (it->error >= onecputick) {
1090	it->expires = cputime_sub(it->expires,
1091	cputime_one_jiffy);
1092	it->error -= onecputick;
1093	}
1094	} else {
1095	it->expires = cputime_zero;
1096	}
1097
1098	trace_itimer_expire(signo == SIGPROF ?
1099	ITIMER_PROF : ITIMER_VIRTUAL,
1100	tsk->signal->leader_pid, cur_time);
1101	__group_send_sig_info(signo, SEND_SIG_PRIV, tsk);
1102	}
1103
1104	if (!cputime_eq(it->expires, cputime_zero) &&
1105	(cputime_eq(*expires, cputime_zero) \|\|
1106	cputime_lt(it->expires, *expires))) {
1107	*expires = it->expires;
1108	}
1109	}
1110
1111	/*
1112	* Check for any per-thread CPU timers that have fired and move them
1113	* off the tsk->*_timers list onto the firing list. Per-thread timers
1114	* have already been taken off.
1115	*/
1116	static void check_process_timers(struct task_struct *tsk,
1117	struct list_head *firing)
1118	{
1119	int maxfire;
1120	struct signal_struct *const sig = tsk->signal;
1121	cputime_t utime, ptime, virt_expires, prof_expires;
1122	unsigned long long sum_sched_runtime, sched_expires;
1123	struct list_head *timers = sig->cpu_timers;
1124	struct task_cputime cputime;
1125
1126	/*
1127	* Don't sample the current process CPU clocks if there are no timers.
1128	*/
1129	if (list_empty(&timers[CPUCLOCK_PROF]) &&
1130	cputime_eq(sig->it[CPUCLOCK_PROF].expires, cputime_zero) &&
1131	sig->rlim[RLIMIT_CPU].rlim_cur == RLIM_INFINITY &&
1132	list_empty(&timers[CPUCLOCK_VIRT]) &&
1133	cputime_eq(sig->it[CPUCLOCK_VIRT].expires, cputime_zero) &&
1134	list_empty(&timers[CPUCLOCK_SCHED])) {
1135	stop_process_timers(tsk);
1136	return;
1137	}
1138
1139	/*
1140	* Collect the current process totals.
1141	*/
1142	thread_group_cputimer(tsk, &cputime);
1143	utime = cputime.utime;
1144	ptime = cputime_add(utime, cputime.stime);
1145	sum_sched_runtime = cputime.sum_exec_runtime;
1146	maxfire = 20;
1147	prof_expires = cputime_zero;
1148	while (!list_empty(timers)) {
1149	struct cpu_timer_list *tl = list_first_entry(timers,
1150	struct cpu_timer_list,
1151	entry);
1152	if (!--maxfire \|\| cputime_lt(ptime, tl->expires.cpu)) {
1153	prof_expires = tl->expires.cpu;
1154	break;
1155	}
1156	tl->firing = 1;
1157	list_move_tail(&tl->entry, firing);
1158	}
1159
1160	++timers;
1161	maxfire = 20;
1162	virt_expires = cputime_zero;
1163	while (!list_empty(timers)) {
1164	struct cpu_timer_list *tl = list_first_entry(timers,
1165	struct cpu_timer_list,
1166	entry);
1167	if (!--maxfire \|\| cputime_lt(utime, tl->expires.cpu)) {
1168	virt_expires = tl->expires.cpu;
1169	break;
1170	}
1171	tl->firing = 1;
1172	list_move_tail(&tl->entry, firing);
1173	}
1174
1175	++timers;
1176	maxfire = 20;
1177	sched_expires = 0;
1178	while (!list_empty(timers)) {
1179	struct cpu_timer_list *tl = list_first_entry(timers,
1180	struct cpu_timer_list,
1181	entry);
1182	if (!--maxfire \|\| sum_sched_runtime < tl->expires.sched) {
1183	sched_expires = tl->expires.sched;
1184	break;
1185	}
1186	tl->firing = 1;
1187	list_move_tail(&tl->entry, firing);
1188	}
1189
1190	/*
1191	* Check for the special case process timers.
1192	*/
1193	check_cpu_itimer(tsk, &sig->it[CPUCLOCK_PROF], &prof_expires, ptime,
1194	SIGPROF);
1195	check_cpu_itimer(tsk, &sig->it[CPUCLOCK_VIRT], &virt_expires, utime,
1196	SIGVTALRM);
1197
1198	if (sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
1199	unsigned long psecs = cputime_to_secs(ptime);
1200	cputime_t x;
1201	if (psecs >= sig->rlim[RLIMIT_CPU].rlim_max) {
1202	/*
1203	* At the hard limit, we just die.
1204	* No need to calculate anything else now.
1205	*/
1206	__group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
1207	return;
1208	}
1209	if (psecs >= sig->rlim[RLIMIT_CPU].rlim_cur) {
1210	/*
1211	* At the soft limit, send a SIGXCPU every second.
1212	*/
1213	__group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
1214	if (sig->rlim[RLIMIT_CPU].rlim_cur
1215	< sig->rlim[RLIMIT_CPU].rlim_max) {
1216	sig->rlim[RLIMIT_CPU].rlim_cur++;
1217	}
1218	}
1219	x = secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
1220	if (cputime_eq(prof_expires, cputime_zero) \|\|
1221	cputime_lt(x, prof_expires)) {
1222	prof_expires = x;
1223	}
1224	}
1225
1226	if (!cputime_eq(prof_expires, cputime_zero) &&
1227	(cputime_eq(sig->cputime_expires.prof_exp, cputime_zero) \|\|
1228	cputime_gt(sig->cputime_expires.prof_exp, prof_expires)))
1229	sig->cputime_expires.prof_exp = prof_expires;
1230	if (!cputime_eq(virt_expires, cputime_zero) &&
1231	(cputime_eq(sig->cputime_expires.virt_exp, cputime_zero) \|\|
1232	cputime_gt(sig->cputime_expires.virt_exp, virt_expires)))
1233	sig->cputime_expires.virt_exp = virt_expires;
1234	if (sched_expires != 0 &&
1235	(sig->cputime_expires.sched_exp == 0 \|\|
1236	sig->cputime_expires.sched_exp > sched_expires))
1237	sig->cputime_expires.sched_exp = sched_expires;
1238	}
1239
1240	/*
1241	* This is called from the signal code (via do_schedule_next_timer)
1242	* when the last timer signal was delivered and we have to reload the timer.
1243	*/
1244	void posix_cpu_timer_schedule(struct k_itimer *timer)
1245	{
1246	struct task_struct *p = timer->it.cpu.task;
1247	union cpu_time_count now;
1248
1249	if (unlikely(p == NULL))
1250	/*
1251	* The task was cleaned up already, no future firings.
1252	*/
1253	goto out;
1254
1255	/*
1256	* Fetch the current sample and update the timer's expiry time.
1257	*/
1258	if (CPUCLOCK_PERTHREAD(timer->it_clock)) {
1259	cpu_clock_sample(timer->it_clock, p, &now);
1260	bump_cpu_timer(timer, now);
1261	if (unlikely(p->exit_state)) {
1262	clear_dead_task(timer, now);
1263	goto out;
1264	}
1265	read_lock(&tasklist_lock); /* arm_timer needs it. */
1266	} else {
1267	read_lock(&tasklist_lock);
1268	if (unlikely(p->signal == NULL)) {
1269	/*
1270	* The process has been reaped.
1271	* We can't even collect a sample any more.
1272	*/
1273	put_task_struct(p);
1274	timer->it.cpu.task = p = NULL;
1275	timer->it.cpu.expires.sched = 0;
1276	goto out_unlock;
1277	} else if (unlikely(p->exit_state) && thread_group_empty(p)) {
1278	/*
1279	* We've noticed that the thread is dead, but
1280	* not yet reaped. Take this opportunity to
1281	* drop our task ref.
1282	*/
1283	clear_dead_task(timer, now);
1284	goto out_unlock;
1285	}
1286	cpu_timer_sample_group(timer->it_clock, p, &now);
1287	bump_cpu_timer(timer, now);
1288	/* Leave the tasklist_lock locked for the call below. */
1289	}
1290
1291	/*
1292	* Now re-arm for the new expiry time.
1293	*/
1294	arm_timer(timer, now);
1295
1296	out_unlock:
1297	read_unlock(&tasklist_lock);
1298
1299	out:
1300	timer->it_overrun_last = timer->it_overrun;
1301	timer->it_overrun = -1;
1302	++timer->it_requeue_pending;
1303	}
1304
1305	/**
1306	* task_cputime_zero - Check a task_cputime struct for all zero fields.
1307	*
1308	* @cputime: The struct to compare.
1309	*
1310	* Checks @cputime to see if all fields are zero. Returns true if all fields
1311	* are zero, false if any field is nonzero.
1312	*/
1313	static inline int task_cputime_zero(const struct task_cputime *cputime)
1314	{
1315	if (cputime_eq(cputime->utime, cputime_zero) &&
1316	cputime_eq(cputime->stime, cputime_zero) &&
1317	cputime->sum_exec_runtime == 0)
1318	return 1;
1319	return 0;
1320	}
1321
1322	/**
1323	* task_cputime_expired - Compare two task_cputime entities.
1324	*
1325	* @sample: The task_cputime structure to be checked for expiration.
1326	* @expires: Expiration times, against which @sample will be checked.
1327	*
1328	* Checks @sample against @expires to see if any field of @sample has expired.
1329	* Returns true if any field of the former is greater than the corresponding
1330	* field of the latter if the latter field is set. Otherwise returns false.
1331	*/
1332	static inline int task_cputime_expired(const struct task_cputime *sample,
1333	const struct task_cputime *expires)
1334	{
1335	if (!cputime_eq(expires->utime, cputime_zero) &&
1336	cputime_ge(sample->utime, expires->utime))
1337	return 1;
1338	if (!cputime_eq(expires->stime, cputime_zero) &&
1339	cputime_ge(cputime_add(sample->utime, sample->stime),
1340	expires->stime))
1341	return 1;
1342	if (expires->sum_exec_runtime != 0 &&
1343	sample->sum_exec_runtime >= expires->sum_exec_runtime)
1344	return 1;
1345	return 0;
1346	}
1347
1348	/**
1349	* fastpath_timer_check - POSIX CPU timers fast path.
1350	*
1351	* @tsk: The task (thread) being checked.
1352	*
1353	* Check the task and thread group timers. If both are zero (there are no
1354	* timers set) return false. Otherwise snapshot the task and thread group
1355	* timers and compare them with the corresponding expiration times. Return
1356	* true if a timer has expired, else return false.
1357	*/
1358	static inline int fastpath_timer_check(struct task_struct *tsk)
1359	{
1360	struct signal_struct *sig;
1361
1362	/* tsk == current, ensure it is safe to use ->signal/sighand */
1363	if (unlikely(tsk->exit_state))
1364	return 0;
1365
1366	if (!task_cputime_zero(&tsk->cputime_expires)) {
1367	struct task_cputime task_sample = {
1368	.utime = tsk->utime,
1369	.stime = tsk->stime,
1370	.sum_exec_runtime = tsk->se.sum_exec_runtime
1371	};
1372
1373	if (task_cputime_expired(&task_sample, &tsk->cputime_expires))
1374	return 1;
1375	}
1376
1377	sig = tsk->signal;
1378	if (!task_cputime_zero(&sig->cputime_expires)) {
1379	struct task_cputime group_sample;
1380
1381	thread_group_cputimer(tsk, &group_sample);
1382	if (task_cputime_expired(&group_sample, &sig->cputime_expires))
1383	return 1;
1384	}
1385
1386	return sig->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY;
1387	}
1388
1389	/*
1390	* This is called from the timer interrupt handler. The irq handler has
1391	* already updated our counts. We need to check if any timers fire now.
1392	* Interrupts are disabled.
1393	*/
1394	void run_posix_cpu_timers(struct task_struct *tsk)
1395	{
1396	LIST_HEAD(firing);
1397	struct k_itimer timer, next;
1398
1399	BUG_ON(!irqs_disabled());
1400
1401	/*
1402	* The fast path checks that there are no expired thread or thread
1403	* group timers. If that's so, just return.
1404	*/
1405	if (!fastpath_timer_check(tsk))
1406	return;
1407
1408	spin_lock(&tsk->sighand->siglock);
1409	/*
1410	* Here we take off tsk->signal->cpu_timers[N] and
1411	* tsk->cpu_timers[N] all the timers that are firing, and
1412	* put them on the firing list.
1413	*/
1414	check_thread_timers(tsk, &firing);
1415	check_process_timers(tsk, &firing);
1416
1417	/*
1418	* We must release these locks before taking any timer's lock.
1419	* There is a potential race with timer deletion here, as the
1420	* siglock now protects our private firing list. We have set
1421	* the firing flag in each timer, so that a deletion attempt
1422	* that gets the timer lock before we do will give it up and
1423	* spin until we've taken care of that timer below.
1424	*/
1425	spin_unlock(&tsk->sighand->siglock);
1426
1427	/*
1428	* Now that all the timers on our list have the firing flag,
1429	* noone will touch their list entries but us. We'll take
1430	* each timer's lock before clearing its firing flag, so no
1431	* timer call will interfere.
1432	*/
1433	list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) {
1434	int cpu_firing;
1435
1436	spin_lock(&timer->it_lock);
1437	list_del_init(&timer->it.cpu.entry);
1438	cpu_firing = timer->it.cpu.firing;
1439	timer->it.cpu.firing = 0;
1440	/*
1441	* The firing flag is -1 if we collided with a reset
1442	* of the timer, which already reported this
1443	* almost-firing as an overrun. So don't generate an event.
1444	*/
1445	if (likely(cpu_firing >= 0))
1446	cpu_timer_fire(timer);
1447	spin_unlock(&timer->it_lock);
1448	}
1449	}
1450
1451	/*
1452	* Set one of the process-wide special case CPU timers.
1453	* The tsk->sighand->siglock must be held by the caller.
1454	* The newval argument is relative and we update it to be absolute, oldval
1455	* is absolute and we update it to be relative.
1456	*/
1457	void set_process_cpu_timer(struct task_struct *tsk, unsigned int clock_idx,
1458	cputime_t newval, cputime_t oldval)
1459	{
1460	union cpu_time_count now;
1461	struct list_head *head;
1462
1463	BUG_ON(clock_idx == CPUCLOCK_SCHED);
1464	cpu_timer_sample_group(clock_idx, tsk, &now);
1465
1466	if (oldval) {
1467	if (!cputime_eq(*oldval, cputime_zero)) {
1468	if (cputime_le(*oldval, now.cpu)) {
1469	/* Just about to fire. */
1470	*oldval = cputime_one_jiffy;
1471	} else {
1472	oldval = cputime_sub(oldval, now.cpu);
1473	}
1474	}
1475
1476	if (cputime_eq(*newval, cputime_zero))
1477	return;
1478	newval = cputime_add(newval, now.cpu);
1479
1480	/*
1481	* If the RLIMIT_CPU timer will expire before the
1482	* ITIMER_PROF timer, we have nothing else to do.
1483	*/
1484	if (tsk->signal->rlim[RLIMIT_CPU].rlim_cur
1485	< cputime_to_secs(*newval))
1486	return;
1487	}
1488
1489	/*
1490	* Check whether there are any process timers already set to fire
1491	* before this one. If so, we don't have anything more to do.
1492	*/
1493	head = &tsk->signal->cpu_timers[clock_idx];
1494	if (list_empty(head) \|\|
1495	cputime_ge(list_first_entry(head,
1496	struct cpu_timer_list, entry)->expires.cpu,
1497	*newval)) {
1498	switch (clock_idx) {
1499	case CPUCLOCK_PROF:
1500	tsk->signal->cputime_expires.prof_exp = *newval;
1501	break;
1502	case CPUCLOCK_VIRT:
1503	tsk->signal->cputime_expires.virt_exp = *newval;
1504	break;
1505	}
1506	}
1507	}
1508
1509	static int do_cpu_nanosleep(const clockid_t which_clock, int flags,
1510	struct timespec rqtp, struct itimerspec it)
1511	{
1512	struct k_itimer timer;
1513	int error;
1514
1515	/*
1516	* Set up a temporary timer and then wait for it to go off.
1517	*/
1518	memset(&timer, 0, sizeof timer);
1519	spin_lock_init(&timer.it_lock);
1520	timer.it_clock = which_clock;
1521	timer.it_overrun = -1;
1522	error = posix_cpu_timer_create(&timer);
1523	timer.it_process = current;
1524	if (!error) {
1525	static struct itimerspec zero_it;
1526
1527	memset(it, 0, sizeof *it);
1528	it->it_value = *rqtp;
1529
1530	spin_lock_irq(&timer.it_lock);
1531	error = posix_cpu_timer_set(&timer, flags, it, NULL);
1532	if (error) {
1533	spin_unlock_irq(&timer.it_lock);
1534	return error;
1535	}
1536
1537	while (!signal_pending(current)) {
1538	if (timer.it.cpu.expires.sched == 0) {
1539	/*
1540	* Our timer fired and was reset.
1541	*/
1542	spin_unlock_irq(&timer.it_lock);
1543	return 0;
1544	}
1545
1546	/*
1547	* Block until cpu_timer_fire (or a signal) wakes us.
1548	*/
1549	__set_current_state(TASK_INTERRUPTIBLE);
1550	spin_unlock_irq(&timer.it_lock);
1551	schedule();
1552	spin_lock_irq(&timer.it_lock);
1553	}
1554
1555	/*
1556	* We were interrupted by a signal.
1557	*/
1558	sample_to_timespec(which_clock, timer.it.cpu.expires, rqtp);
1559	posix_cpu_timer_set(&timer, 0, &zero_it, it);
1560	spin_unlock_irq(&timer.it_lock);
1561
1562	if ((it->it_value.tv_sec \| it->it_value.tv_nsec) == 0) {
1563	/*
1564	* It actually did fire already.
1565	*/
1566	return 0;
1567	}
1568
1569	error = -ERESTART_RESTARTBLOCK;
1570	}
1571
1572	return error;
1573	}
1574
1575	int posix_cpu_nsleep(const clockid_t which_clock, int flags,
1576	struct timespec rqtp, struct timespec __user rmtp)
1577	{
1578	struct restart_block *restart_block =
1579	&current_thread_info()->restart_block;
1580	struct itimerspec it;
1581	int error;
1582
1583	/*
1584	* Diagnose required errors first.
1585	*/
1586	if (CPUCLOCK_PERTHREAD(which_clock) &&
1587	(CPUCLOCK_PID(which_clock) == 0 \|\|
1588	CPUCLOCK_PID(which_clock) == current->pid))
1589	return -EINVAL;
1590
1591	error = do_cpu_nanosleep(which_clock, flags, rqtp, &it);
1592
1593	if (error == -ERESTART_RESTARTBLOCK) {
1594
1595	if (flags & TIMER_ABSTIME)
1596	return -ERESTARTNOHAND;
1597	/*
1598	* Report back to the user the time still remaining.
1599	*/
1600	if (rmtp != NULL && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
1601	return -EFAULT;
1602
1603	restart_block->fn = posix_cpu_nsleep_restart;
1604	restart_block->arg0 = which_clock;
1605	restart_block->arg1 = (unsigned long) rmtp;
1606	restart_block->arg2 = rqtp->tv_sec;
1607	restart_block->arg3 = rqtp->tv_nsec;
1608	}
1609	return error;
1610	}
1611
1612	long posix_cpu_nsleep_restart(struct restart_block *restart_block)
1613	{
1614	clockid_t which_clock = restart_block->arg0;
1615	struct timespec __user *rmtp;
1616	struct timespec t;
1617	struct itimerspec it;
1618	int error;
1619
1620	rmtp = (struct timespec __user *) restart_block->arg1;
1621	t.tv_sec = restart_block->arg2;
1622	t.tv_nsec = restart_block->arg3;
1623
1624	restart_block->fn = do_no_restart_syscall;
1625	error = do_cpu_nanosleep(which_clock, TIMER_ABSTIME, &t, &it);
1626
1627	if (error == -ERESTART_RESTARTBLOCK) {
1628	/*
1629	* Report back to the user the time still remaining.
1630	*/
1631	if (rmtp != NULL && copy_to_user(rmtp, &it.it_value, sizeof *rmtp))
1632	return -EFAULT;
1633
1634	restart_block->fn = posix_cpu_nsleep_restart;
1635	restart_block->arg0 = which_clock;
1636	restart_block->arg1 = (unsigned long) rmtp;
1637	restart_block->arg2 = t.tv_sec;
1638	restart_block->arg3 = t.tv_nsec;
1639	}
1640	return error;
1641
1642	}
1643
1644
1645	#define PROCESS_CLOCK MAKE_PROCESS_CPUCLOCK(0, CPUCLOCK_SCHED)
1646	#define THREAD_CLOCK MAKE_THREAD_CPUCLOCK(0, CPUCLOCK_SCHED)
1647
1648	static int process_cpu_clock_getres(const clockid_t which_clock,
1649	struct timespec *tp)
1650	{
1651	return posix_cpu_clock_getres(PROCESS_CLOCK, tp);
1652	}
1653	static int process_cpu_clock_get(const clockid_t which_clock,
1654	struct timespec *tp)
1655	{
1656	return posix_cpu_clock_get(PROCESS_CLOCK, tp);
1657	}
1658	static int process_cpu_timer_create(struct k_itimer *timer)
1659	{
1660	timer->it_clock = PROCESS_CLOCK;
1661	return posix_cpu_timer_create(timer);
1662	}
1663	static int process_cpu_nsleep(const clockid_t which_clock, int flags,
1664	struct timespec *rqtp,
1665	struct timespec __user *rmtp)
1666	{
1667	return posix_cpu_nsleep(PROCESS_CLOCK, flags, rqtp, rmtp);
1668	}
1669	static long process_cpu_nsleep_restart(struct restart_block *restart_block)
1670	{
1671	return -EINVAL;
1672	}
1673	static int thread_cpu_clock_getres(const clockid_t which_clock,
1674	struct timespec *tp)
1675	{
1676	return posix_cpu_clock_getres(THREAD_CLOCK, tp);
1677	}
1678	static int thread_cpu_clock_get(const clockid_t which_clock,
1679	struct timespec *tp)
1680	{
1681	return posix_cpu_clock_get(THREAD_CLOCK, tp);
1682	}
1683	static int thread_cpu_timer_create(struct k_itimer *timer)
1684	{
1685	timer->it_clock = THREAD_CLOCK;
1686	return posix_cpu_timer_create(timer);
1687	}
1688	static int thread_cpu_nsleep(const clockid_t which_clock, int flags,
1689	struct timespec rqtp, struct timespec __user rmtp)
1690	{
1691	return -EINVAL;
1692	}
1693	static long thread_cpu_nsleep_restart(struct restart_block *restart_block)
1694	{
1695	return -EINVAL;
1696	}
1697
1698	static __init int init_posix_cpu_timers(void)
1699	{
1700	struct k_clock process = {
1701	.clock_getres = process_cpu_clock_getres,
1702	.clock_get = process_cpu_clock_get,
1703	.clock_set = do_posix_clock_nosettime,
1704	.timer_create = process_cpu_timer_create,
1705	.nsleep = process_cpu_nsleep,
1706	.nsleep_restart = process_cpu_nsleep_restart,
1707	};
1708	struct k_clock thread = {
1709	.clock_getres = thread_cpu_clock_getres,
1710	.clock_get = thread_cpu_clock_get,
1711	.clock_set = do_posix_clock_nosettime,
1712	.timer_create = thread_cpu_timer_create,
1713	.nsleep = thread_cpu_nsleep,
1714	.nsleep_restart = thread_cpu_nsleep_restart,
1715	};
1716	struct timespec ts;
1717
1718	register_posix_clock(CLOCK_PROCESS_CPUTIME_ID, &process);
1719	register_posix_clock(CLOCK_THREAD_CPUTIME_ID, &thread);
1720
1721	cputime_to_timespec(cputime_one_jiffy, &ts);
1722	onecputick = ts.tv_nsec;
1723	WARN_ON(ts.tv_sec != 0);
1724
1725	return 0;
1726	}
1727	__initcall(init_posix_cpu_timers);
1728

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/kernel/posix-cpu-timers.c

interactive