Kernel

Kernel Git Source Tree

Root/kernel/timer.c

1	/*
2	* linux/kernel/timer.c
3	*
4	* Kernel internal timers, basic process system calls
5	*
6	* Copyright (C) 1991, 1992 Linus Torvalds
7	*
8	* 1997-01-28 Modified by Finn Arne Gangstad to make timers scale better.
9	*
10	* 1997-09-10 Updated NTP code according to technical memorandum Jan '96
11	* "A Kernel Model for Precision Timekeeping" by Dave Mills
12	* 1998-12-24 Fixed a xtime SMP race (we need the xtime_lock rw spinlock to
13	* serialize accesses to xtime/lost_ticks).
14	* Copyright (C) 1998 Andrea Arcangeli
15	* 1999-03-10 Improved NTP compatibility by Ulrich Windl
16	* 2002-05-31 Move sys_sysinfo here and make its locking sane, Robert Love
17	* 2000-10-05 Implemented scalable SMP per-CPU timer handling.
18	* Copyright (C) 2000, 2001, 2002 Ingo Molnar
19	* Designed by David S. Miller, Alexey Kuznetsov and Ingo Molnar
20	*/
21
22	#include <linux/kernel_stat.h>
23	#include <linux/module.h>
24	#include <linux/interrupt.h>
25	#include <linux/percpu.h>
26	#include <linux/init.h>
27	#include <linux/mm.h>
28	#include <linux/swap.h>
29	#include <linux/pid_namespace.h>
30	#include <linux/notifier.h>
31	#include <linux/thread_info.h>
32	#include <linux/time.h>
33	#include <linux/jiffies.h>
34	#include <linux/posix-timers.h>
35	#include <linux/cpu.h>
36	#include <linux/syscalls.h>
37	#include <linux/delay.h>
38	#include <linux/tick.h>
39	#include <linux/kallsyms.h>
40	#include <linux/irq_work.h>
41	#include <linux/sched.h>
42	#include <linux/slab.h>
43
44	#include <asm/uaccess.h>
45	#include <asm/unistd.h>
46	#include <asm/div64.h>
47	#include <asm/timex.h>
48	#include <asm/io.h>
49
50	#define CREATE_TRACE_POINTS
51	#include <trace/events/timer.h>
52
53	u64 jiffies_64 __cacheline_aligned_in_smp = INITIAL_JIFFIES;
54
55	EXPORT_SYMBOL(jiffies_64);
56
57	/*
58	* per-CPU timer vector definitions:
59	*/
60	#define TVN_BITS (CONFIG_BASE_SMALL ? 4 : 6)
61	#define TVR_BITS (CONFIG_BASE_SMALL ? 6 : 8)
62	#define TVN_SIZE (1 << TVN_BITS)
63	#define TVR_SIZE (1 << TVR_BITS)
64	#define TVN_MASK (TVN_SIZE - 1)
65	#define TVR_MASK (TVR_SIZE - 1)
66
67	struct tvec {
68	struct list_head vec[TVN_SIZE];
69	};
70
71	struct tvec_root {
72	struct list_head vec[TVR_SIZE];
73	};
74
75	struct tvec_base {
76	spinlock_t lock;
77	struct timer_list *running_timer;
78	unsigned long timer_jiffies;
79	unsigned long next_timer;
80	struct tvec_root tv1;
81	struct tvec tv2;
82	struct tvec tv3;
83	struct tvec tv4;
84	struct tvec tv5;
85	} ____cacheline_aligned;
86
87	struct tvec_base boot_tvec_bases;
88	EXPORT_SYMBOL(boot_tvec_bases);
89	static DEFINE_PER_CPU(struct tvec_base *, tvec_bases) = &boot_tvec_bases;
90
91	/* Functions below help us manage 'deferrable' flag */
92	static inline unsigned int tbase_get_deferrable(struct tvec_base *base)
93	{
94	return ((unsigned int)(unsigned long)base & TBASE_DEFERRABLE_FLAG);
95	}
96
97	static inline struct tvec_base tbase_get_base(struct tvec_base base)
98	{
99	return ((struct tvec_base *)((unsigned long)base & ~TBASE_DEFERRABLE_FLAG));
100	}
101
102	static inline void timer_set_deferrable(struct timer_list *timer)
103	{
104	timer->base = TBASE_MAKE_DEFERRED(timer->base);
105	}
106
107	static inline void
108	timer_set_base(struct timer_list timer, struct tvec_base new_base)
109	{
110	timer->base = (struct tvec_base *)((unsigned long)(new_base) \|
111	tbase_get_deferrable(timer->base));
112	}
113
114	static unsigned long round_jiffies_common(unsigned long j, int cpu,
115	bool force_up)
116	{
117	int rem;
118	unsigned long original = j;
119
120	/*
121	* We don't want all cpus firing their timers at once hitting the
122	* same lock or cachelines, so we skew each extra cpu with an extra
123	* 3 jiffies. This 3 jiffies came originally from the mm/ code which
124	* already did this.
125	* The skew is done by adding 3*cpunr, then round, then subtract this
126	* extra offset again.
127	*/
128	j += cpu * 3;
129
130	rem = j % HZ;
131
132	/*
133	* If the target jiffie is just after a whole second (which can happen
134	* due to delays of the timer irq, long irq off times etc etc) then
135	* we should round down to the whole second, not up. Use 1/4th second
136	* as cutoff for this rounding as an extreme upper bound for this.
137	* But never round down if @force_up is set.
138	*/
139	if (rem < HZ/4 && !force_up) /* round down */
140	j = j - rem;
141	else /* round up */
142	j = j - rem + HZ;
143
144	/* now that we have rounded, subtract the extra skew again */
145	j -= cpu * 3;
146
147	if (j <= jiffies) /* rounding ate our timeout entirely; */
148	return original;
149	return j;
150	}
151
152	/**
153	* __round_jiffies - function to round jiffies to a full second
154	* @j: the time in (absolute) jiffies that should be rounded
155	* @cpu: the processor number on which the timeout will happen
156	*
157	* __round_jiffies() rounds an absolute time in the future (in jiffies)
158	* up or down to (approximately) full seconds. This is useful for timers
159	* for which the exact time they fire does not matter too much, as long as
160	* they fire approximately every X seconds.
161	*
162	* By rounding these timers to whole seconds, all such timers will fire
163	* at the same time, rather than at various times spread out. The goal
164	* of this is to have the CPU wake up less, which saves power.
165	*
166	* The exact rounding is skewed for each processor to avoid all
167	* processors firing at the exact same time, which could lead
168	* to lock contention or spurious cache line bouncing.
169	*
170	* The return value is the rounded version of the @j parameter.
171	*/
172	unsigned long __round_jiffies(unsigned long j, int cpu)
173	{
174	return round_jiffies_common(j, cpu, false);
175	}
176	EXPORT_SYMBOL_GPL(__round_jiffies);
177
178	/**
179	* __round_jiffies_relative - function to round jiffies to a full second
180	* @j: the time in (relative) jiffies that should be rounded
181	* @cpu: the processor number on which the timeout will happen
182	*
183	* __round_jiffies_relative() rounds a time delta in the future (in jiffies)
184	* up or down to (approximately) full seconds. This is useful for timers
185	* for which the exact time they fire does not matter too much, as long as
186	* they fire approximately every X seconds.
187	*
188	* By rounding these timers to whole seconds, all such timers will fire
189	* at the same time, rather than at various times spread out. The goal
190	* of this is to have the CPU wake up less, which saves power.
191	*
192	* The exact rounding is skewed for each processor to avoid all
193	* processors firing at the exact same time, which could lead
194	* to lock contention or spurious cache line bouncing.
195	*
196	* The return value is the rounded version of the @j parameter.
197	*/
198	unsigned long __round_jiffies_relative(unsigned long j, int cpu)
199	{
200	unsigned long j0 = jiffies;
201
202	/* Use j0 because jiffies might change while we run */
203	return round_jiffies_common(j + j0, cpu, false) - j0;
204	}
205	EXPORT_SYMBOL_GPL(__round_jiffies_relative);
206
207	/**
208	* round_jiffies - function to round jiffies to a full second
209	* @j: the time in (absolute) jiffies that should be rounded
210	*
211	* round_jiffies() rounds an absolute time in the future (in jiffies)
212	* up or down to (approximately) full seconds. This is useful for timers
213	* for which the exact time they fire does not matter too much, as long as
214	* they fire approximately every X seconds.
215	*
216	* By rounding these timers to whole seconds, all such timers will fire
217	* at the same time, rather than at various times spread out. The goal
218	* of this is to have the CPU wake up less, which saves power.
219	*
220	* The return value is the rounded version of the @j parameter.
221	*/
222	unsigned long round_jiffies(unsigned long j)
223	{
224	return round_jiffies_common(j, raw_smp_processor_id(), false);
225	}
226	EXPORT_SYMBOL_GPL(round_jiffies);
227
228	/**
229	* round_jiffies_relative - function to round jiffies to a full second
230	* @j: the time in (relative) jiffies that should be rounded
231	*
232	* round_jiffies_relative() rounds a time delta in the future (in jiffies)
233	* up or down to (approximately) full seconds. This is useful for timers
234	* for which the exact time they fire does not matter too much, as long as
235	* they fire approximately every X seconds.
236	*
237	* By rounding these timers to whole seconds, all such timers will fire
238	* at the same time, rather than at various times spread out. The goal
239	* of this is to have the CPU wake up less, which saves power.
240	*
241	* The return value is the rounded version of the @j parameter.
242	*/
243	unsigned long round_jiffies_relative(unsigned long j)
244	{
245	return __round_jiffies_relative(j, raw_smp_processor_id());
246	}
247	EXPORT_SYMBOL_GPL(round_jiffies_relative);
248
249	/**
250	* __round_jiffies_up - function to round jiffies up to a full second
251	* @j: the time in (absolute) jiffies that should be rounded
252	* @cpu: the processor number on which the timeout will happen
253	*
254	* This is the same as __round_jiffies() except that it will never
255	* round down. This is useful for timeouts for which the exact time
256	* of firing does not matter too much, as long as they don't fire too
257	* early.
258	*/
259	unsigned long __round_jiffies_up(unsigned long j, int cpu)
260	{
261	return round_jiffies_common(j, cpu, true);
262	}
263	EXPORT_SYMBOL_GPL(__round_jiffies_up);
264
265	/**
266	* __round_jiffies_up_relative - function to round jiffies up to a full second
267	* @j: the time in (relative) jiffies that should be rounded
268	* @cpu: the processor number on which the timeout will happen
269	*
270	* This is the same as __round_jiffies_relative() except that it will never
271	* round down. This is useful for timeouts for which the exact time
272	* of firing does not matter too much, as long as they don't fire too
273	* early.
274	*/
275	unsigned long __round_jiffies_up_relative(unsigned long j, int cpu)
276	{
277	unsigned long j0 = jiffies;
278
279	/* Use j0 because jiffies might change while we run */
280	return round_jiffies_common(j + j0, cpu, true) - j0;
281	}
282	EXPORT_SYMBOL_GPL(__round_jiffies_up_relative);
283
284	/**
285	* round_jiffies_up - function to round jiffies up to a full second
286	* @j: the time in (absolute) jiffies that should be rounded
287	*
288	* This is the same as round_jiffies() except that it will never
289	* round down. This is useful for timeouts for which the exact time
290	* of firing does not matter too much, as long as they don't fire too
291	* early.
292	*/
293	unsigned long round_jiffies_up(unsigned long j)
294	{
295	return round_jiffies_common(j, raw_smp_processor_id(), true);
296	}
297	EXPORT_SYMBOL_GPL(round_jiffies_up);
298
299	/**
300	* round_jiffies_up_relative - function to round jiffies up to a full second
301	* @j: the time in (relative) jiffies that should be rounded
302	*
303	* This is the same as round_jiffies_relative() except that it will never
304	* round down. This is useful for timeouts for which the exact time
305	* of firing does not matter too much, as long as they don't fire too
306	* early.
307	*/
308	unsigned long round_jiffies_up_relative(unsigned long j)
309	{
310	return __round_jiffies_up_relative(j, raw_smp_processor_id());
311	}
312	EXPORT_SYMBOL_GPL(round_jiffies_up_relative);
313
314	/**
315	* set_timer_slack - set the allowed slack for a timer
316	* @timer: the timer to be modified
317	* @slack_hz: the amount of time (in jiffies) allowed for rounding
318	*
319	* Set the amount of time, in jiffies, that a certain timer has
320	* in terms of slack. By setting this value, the timer subsystem
321	* will schedule the actual timer somewhere between
322	* the time mod_timer() asks for, and that time plus the slack.
323	*
324	* By setting the slack to -1, a percentage of the delay is used
325	* instead.
326	*/
327	void set_timer_slack(struct timer_list *timer, int slack_hz)
328	{
329	timer->slack = slack_hz;
330	}
331	EXPORT_SYMBOL_GPL(set_timer_slack);
332
333	static void internal_add_timer(struct tvec_base base, struct timer_list timer)
334	{
335	unsigned long expires = timer->expires;
336	unsigned long idx = expires - base->timer_jiffies;
337	struct list_head *vec;
338
339	if (idx < TVR_SIZE) {
340	int i = expires & TVR_MASK;
341	vec = base->tv1.vec + i;
342	} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
343	int i = (expires >> TVR_BITS) & TVN_MASK;
344	vec = base->tv2.vec + i;
345	} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
346	int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
347	vec = base->tv3.vec + i;
348	} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
349	int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
350	vec = base->tv4.vec + i;
351	} else if ((signed long) idx < 0) {
352	/*
353	* Can happen if you add a timer with expires == jiffies,
354	* or you set a timer to go off in the past
355	*/
356	vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
357	} else {
358	int i;
359	/* If the timeout is larger than 0xffffffff on 64-bit
360	* architectures then we use the maximum timeout:
361	*/
362	if (idx > 0xffffffffUL) {
363	idx = 0xffffffffUL;
364	expires = idx + base->timer_jiffies;
365	}
366	i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
367	vec = base->tv5.vec + i;
368	}
369	/*
370	* Timers are FIFO:
371	*/
372	list_add_tail(&timer->entry, vec);
373	}
374
375	#ifdef CONFIG_TIMER_STATS
376	void __timer_stats_timer_set_start_info(struct timer_list timer, void addr)
377	{
378	if (timer->start_site)
379	return;
380
381	timer->start_site = addr;
382	memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
383	timer->start_pid = current->pid;
384	}
385
386	static void timer_stats_account_timer(struct timer_list *timer)
387	{
388	unsigned int flag = 0;
389
390	if (likely(!timer->start_site))
391	return;
392	if (unlikely(tbase_get_deferrable(timer->base)))
393	flag \|= TIMER_STATS_FLAG_DEFERRABLE;
394
395	timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
396	timer->function, timer->start_comm, flag);
397	}
398
399	#else
400	static void timer_stats_account_timer(struct timer_list *timer) {}
401	#endif
402
403	#ifdef CONFIG_DEBUG_OBJECTS_TIMERS
404
405	static struct debug_obj_descr timer_debug_descr;
406
407	/*
408	* fixup_init is called when:
409	* - an active object is initialized
410	*/
411	static int timer_fixup_init(void *addr, enum debug_obj_state state)
412	{
413	struct timer_list *timer = addr;
414
415	switch (state) {
416	case ODEBUG_STATE_ACTIVE:
417	del_timer_sync(timer);
418	debug_object_init(timer, &timer_debug_descr);
419	return 1;
420	default:
421	return 0;
422	}
423	}
424
425	/*
426	* fixup_activate is called when:
427	* - an active object is activated
428	* - an unknown object is activated (might be a statically initialized object)
429	*/
430	static int timer_fixup_activate(void *addr, enum debug_obj_state state)
431	{
432	struct timer_list *timer = addr;
433
434	switch (state) {
435
436	case ODEBUG_STATE_NOTAVAILABLE:
437	/*
438	* This is not really a fixup. The timer was
439	* statically initialized. We just make sure that it
440	* is tracked in the object tracker.
441	*/
442	if (timer->entry.next == NULL &&
443	timer->entry.prev == TIMER_ENTRY_STATIC) {
444	debug_object_init(timer, &timer_debug_descr);
445	debug_object_activate(timer, &timer_debug_descr);
446	return 0;
447	} else {
448	WARN_ON_ONCE(1);
449	}
450	return 0;
451
452	case ODEBUG_STATE_ACTIVE:
453	WARN_ON(1);
454
455	default:
456	return 0;
457	}
458	}
459
460	/*
461	* fixup_free is called when:
462	* - an active object is freed
463	*/
464	static int timer_fixup_free(void *addr, enum debug_obj_state state)
465	{
466	struct timer_list *timer = addr;
467
468	switch (state) {
469	case ODEBUG_STATE_ACTIVE:
470	del_timer_sync(timer);
471	debug_object_free(timer, &timer_debug_descr);
472	return 1;
473	default:
474	return 0;
475	}
476	}
477
478	static struct debug_obj_descr timer_debug_descr = {
479	.name = "timer_list",
480	.fixup_init = timer_fixup_init,
481	.fixup_activate = timer_fixup_activate,
482	.fixup_free = timer_fixup_free,
483	};
484
485	static inline void debug_timer_init(struct timer_list *timer)
486	{
487	debug_object_init(timer, &timer_debug_descr);
488	}
489
490	static inline void debug_timer_activate(struct timer_list *timer)
491	{
492	debug_object_activate(timer, &timer_debug_descr);
493	}
494
495	static inline void debug_timer_deactivate(struct timer_list *timer)
496	{
497	debug_object_deactivate(timer, &timer_debug_descr);
498	}
499
500	static inline void debug_timer_free(struct timer_list *timer)
501	{
502	debug_object_free(timer, &timer_debug_descr);
503	}
504
505	static void __init_timer(struct timer_list *timer,
506	const char *name,
507	struct lock_class_key *key);
508
509	void init_timer_on_stack_key(struct timer_list *timer,
510	const char *name,
511	struct lock_class_key *key)
512	{
513	debug_object_init_on_stack(timer, &timer_debug_descr);
514	__init_timer(timer, name, key);
515	}
516	EXPORT_SYMBOL_GPL(init_timer_on_stack_key);
517
518	void destroy_timer_on_stack(struct timer_list *timer)
519	{
520	debug_object_free(timer, &timer_debug_descr);
521	}
522	EXPORT_SYMBOL_GPL(destroy_timer_on_stack);
523
524	#else
525	static inline void debug_timer_init(struct timer_list *timer) { }
526	static inline void debug_timer_activate(struct timer_list *timer) { }
527	static inline void debug_timer_deactivate(struct timer_list *timer) { }
528	#endif
529
530	static inline void debug_init(struct timer_list *timer)
531	{
532	debug_timer_init(timer);
533	trace_timer_init(timer);
534	}
535
536	static inline void
537	debug_activate(struct timer_list *timer, unsigned long expires)
538	{
539	debug_timer_activate(timer);
540	trace_timer_start(timer, expires);
541	}
542
543	static inline void debug_deactivate(struct timer_list *timer)
544	{
545	debug_timer_deactivate(timer);
546	trace_timer_cancel(timer);
547	}
548
549	static void __init_timer(struct timer_list *timer,
550	const char *name,
551	struct lock_class_key *key)
552	{
553	timer->entry.next = NULL;
554	timer->base = __raw_get_cpu_var(tvec_bases);
555	timer->slack = -1;
556	#ifdef CONFIG_TIMER_STATS
557	timer->start_site = NULL;
558	timer->start_pid = -1;
559	memset(timer->start_comm, 0, TASK_COMM_LEN);
560	#endif
561	lockdep_init_map(&timer->lockdep_map, name, key, 0);
562	}
563
564	void setup_deferrable_timer_on_stack_key(struct timer_list *timer,
565	const char *name,
566	struct lock_class_key *key,
567	void (*function)(unsigned long),
568	unsigned long data)
569	{
570	timer->function = function;
571	timer->data = data;
572	init_timer_on_stack_key(timer, name, key);
573	timer_set_deferrable(timer);
574	}
575	EXPORT_SYMBOL_GPL(setup_deferrable_timer_on_stack_key);
576
577	/**
578	* init_timer_key - initialize a timer
579	* @timer: the timer to be initialized
580	* @name: name of the timer
581	* @key: lockdep class key of the fake lock used for tracking timer
582	* sync lock dependencies
583	*
584	* init_timer_key() must be done to a timer prior calling any of the
585	* other timer functions.
586	*/
587	void init_timer_key(struct timer_list *timer,
588	const char *name,
589	struct lock_class_key *key)
590	{
591	debug_init(timer);
592	__init_timer(timer, name, key);
593	}
594	EXPORT_SYMBOL(init_timer_key);
595
596	void init_timer_deferrable_key(struct timer_list *timer,
597	const char *name,
598	struct lock_class_key *key)
599	{
600	init_timer_key(timer, name, key);
601	timer_set_deferrable(timer);
602	}
603	EXPORT_SYMBOL(init_timer_deferrable_key);
604
605	static inline void detach_timer(struct timer_list *timer,
606	int clear_pending)
607	{
608	struct list_head *entry = &timer->entry;
609
610	debug_deactivate(timer);
611
612	__list_del(entry->prev, entry->next);
613	if (clear_pending)
614	entry->next = NULL;
615	entry->prev = LIST_POISON2;
616	}
617
618	/*
619	* We are using hashed locking: holding per_cpu(tvec_bases).lock
620	* means that all timers which are tied to this base via timer->base are
621	* locked, and the base itself is locked too.
622	*
623	* So __run_timers/migrate_timers can safely modify all timers which could
624	* be found on ->tvX lists.
625	*
626	* When the timer's base is locked, and the timer removed from list, it is
627	* possible to set timer->base = NULL and drop the lock: the timer remains
628	* locked.
629	*/
630	static struct tvec_base lock_timer_base(struct timer_list timer,
631	unsigned long *flags)
632	__acquires(timer->base->lock)
633	{
634	struct tvec_base *base;
635
636	for (;;) {
637	struct tvec_base *prelock_base = timer->base;
638	base = tbase_get_base(prelock_base);
639	if (likely(base != NULL)) {
640	spin_lock_irqsave(&base->lock, *flags);
641	if (likely(prelock_base == timer->base))
642	return base;
643	/* The timer has migrated to another CPU */
644	spin_unlock_irqrestore(&base->lock, *flags);
645	}
646	cpu_relax();
647	}
648	}
649
650	static inline int
651	__mod_timer(struct timer_list *timer, unsigned long expires,
652	bool pending_only, int pinned)
653	{
654	struct tvec_base base, new_base;
655	unsigned long flags;
656	int ret = 0 , cpu;
657
658	timer_stats_timer_set_start_info(timer);
659	BUG_ON(!timer->function);
660
661	base = lock_timer_base(timer, &flags);
662
663	if (timer_pending(timer)) {
664	detach_timer(timer, 0);
665	if (timer->expires == base->next_timer &&
666	!tbase_get_deferrable(timer->base))
667	base->next_timer = base->timer_jiffies;
668	ret = 1;
669	} else {
670	if (pending_only)
671	goto out_unlock;
672	}
673
674	debug_activate(timer, expires);
675
676	cpu = smp_processor_id();
677
678	#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
679	if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu))
680	cpu = get_nohz_timer_target();
681	#endif
682	new_base = per_cpu(tvec_bases, cpu);
683
684	if (base != new_base) {
685	/*
686	* We are trying to schedule the timer on the local CPU.
687	* However we can't change timer's base while it is running,
688	* otherwise del_timer_sync() can't detect that the timer's
689	* handler yet has not finished. This also guarantees that
690	* the timer is serialized wrt itself.
691	*/
692	if (likely(base->running_timer != timer)) {
693	/* See the comment in lock_timer_base() */
694	timer_set_base(timer, NULL);
695	spin_unlock(&base->lock);
696	base = new_base;
697	spin_lock(&base->lock);
698	timer_set_base(timer, base);
699	}
700	}
701
702	timer->expires = expires;
703	if (time_before(timer->expires, base->next_timer) &&
704	!tbase_get_deferrable(timer->base))
705	base->next_timer = timer->expires;
706	internal_add_timer(base, timer);
707
708	out_unlock:
709	spin_unlock_irqrestore(&base->lock, flags);
710
711	return ret;
712	}
713
714	/**
715	* mod_timer_pending - modify a pending timer's timeout
716	* @timer: the pending timer to be modified
717	* @expires: new timeout in jiffies
718	*
719	* mod_timer_pending() is the same for pending timers as mod_timer(),
720	* but will not re-activate and modify already deleted timers.
721	*
722	* It is useful for unserialized use of timers.
723	*/
724	int mod_timer_pending(struct timer_list *timer, unsigned long expires)
725	{
726	return __mod_timer(timer, expires, true, TIMER_NOT_PINNED);
727	}
728	EXPORT_SYMBOL(mod_timer_pending);
729
730	/*
731	* Decide where to put the timer while taking the slack into account
732	*
733	* Algorithm:
734	* 1) calculate the maximum (absolute) time
735	* 2) calculate the highest bit where the expires and new max are different
736	* 3) use this bit to make a mask
737	* 4) use the bitmask to round down the maximum time, so that all last
738	* bits are zeros
739	*/
740	static inline
741	unsigned long apply_slack(struct timer_list *timer, unsigned long expires)
742	{
743	unsigned long expires_limit, mask;
744	int bit;
745
746	expires_limit = expires;
747
748	if (timer->slack >= 0) {
749	expires_limit = expires + timer->slack;
750	} else {
751	unsigned long now = jiffies;
752
753	/* No slack, if already expired else auto slack 0.4% */
754	if (time_after(expires, now))
755	expires_limit = expires + (expires - now)/256;
756	}
757	mask = expires ^ expires_limit;
758	if (mask == 0)
759	return expires;
760
761	bit = find_last_bit(&mask, BITS_PER_LONG);
762
763	mask = (1 << bit) - 1;
764
765	expires_limit = expires_limit & ~(mask);
766
767	return expires_limit;
768	}
769
770	/**
771	* mod_timer - modify a timer's timeout
772	* @timer: the timer to be modified
773	* @expires: new timeout in jiffies
774	*
775	* mod_timer() is a more efficient way to update the expire field of an
776	* active timer (if the timer is inactive it will be activated)
777	*
778	* mod_timer(timer, expires) is equivalent to:
779	*
780	* del_timer(timer); timer->expires = expires; add_timer(timer);
781	*
782	* Note that if there are multiple unserialized concurrent users of the
783	* same timer, then mod_timer() is the only safe way to modify the timeout,
784	* since add_timer() cannot modify an already running timer.
785	*
786	* The function returns whether it has modified a pending timer or not.
787	* (ie. mod_timer() of an inactive timer returns 0, mod_timer() of an
788	* active timer returns 1.)
789	*/
790	int mod_timer(struct timer_list *timer, unsigned long expires)
791	{
792	/*
793	* This is a common optimization triggered by the
794	* networking code - if the timer is re-modified
795	* to be the same thing then just return:
796	*/
797	if (timer_pending(timer) && timer->expires == expires)
798	return 1;
799
800	expires = apply_slack(timer, expires);
801
802	return __mod_timer(timer, expires, false, TIMER_NOT_PINNED);
803	}
804	EXPORT_SYMBOL(mod_timer);
805
806	/**
807	* mod_timer_pinned - modify a timer's timeout
808	* @timer: the timer to be modified
809	* @expires: new timeout in jiffies
810	*
811	* mod_timer_pinned() is a way to update the expire field of an
812	* active timer (if the timer is inactive it will be activated)
813	* and not allow the timer to be migrated to a different CPU.
814	*
815	* mod_timer_pinned(timer, expires) is equivalent to:
816	*
817	* del_timer(timer); timer->expires = expires; add_timer(timer);
818	*/
819	int mod_timer_pinned(struct timer_list *timer, unsigned long expires)
820	{
821	if (timer->expires == expires && timer_pending(timer))
822	return 1;
823
824	return __mod_timer(timer, expires, false, TIMER_PINNED);
825	}
826	EXPORT_SYMBOL(mod_timer_pinned);
827
828	/**
829	* add_timer - start a timer
830	* @timer: the timer to be added
831	*
832	* The kernel will do a ->function(->data) callback from the
833	* timer interrupt at the ->expires point in the future. The
834	* current time is 'jiffies'.
835	*
836	* The timer's ->expires, ->function (and if the handler uses it, ->data)
837	* fields must be set prior calling this function.
838	*
839	* Timers with an ->expires field in the past will be executed in the next
840	* timer tick.
841	*/
842	void add_timer(struct timer_list *timer)
843	{
844	BUG_ON(timer_pending(timer));
845	mod_timer(timer, timer->expires);
846	}
847	EXPORT_SYMBOL(add_timer);
848
849	/**
850	* add_timer_on - start a timer on a particular CPU
851	* @timer: the timer to be added
852	* @cpu: the CPU to start it on
853	*
854	* This is not very scalable on SMP. Double adds are not possible.
855	*/
856	void add_timer_on(struct timer_list *timer, int cpu)
857	{
858	struct tvec_base *base = per_cpu(tvec_bases, cpu);
859	unsigned long flags;
860
861	timer_stats_timer_set_start_info(timer);
862	BUG_ON(timer_pending(timer) \|\| !timer->function);
863	spin_lock_irqsave(&base->lock, flags);
864	timer_set_base(timer, base);
865	debug_activate(timer, timer->expires);
866	if (time_before(timer->expires, base->next_timer) &&
867	!tbase_get_deferrable(timer->base))
868	base->next_timer = timer->expires;
869	internal_add_timer(base, timer);
870	/*
871	* Check whether the other CPU is idle and needs to be
872	* triggered to reevaluate the timer wheel when nohz is
873	* active. We are protected against the other CPU fiddling
874	* with the timer by holding the timer base lock. This also
875	* makes sure that a CPU on the way to idle can not evaluate
876	* the timer wheel.
877	*/
878	wake_up_idle_cpu(cpu);
879	spin_unlock_irqrestore(&base->lock, flags);
880	}
881	EXPORT_SYMBOL_GPL(add_timer_on);
882
883	/**
884	* del_timer - deactive a timer.
885	* @timer: the timer to be deactivated
886	*
887	* del_timer() deactivates a timer - this works on both active and inactive
888	* timers.
889	*
890	* The function returns whether it has deactivated a pending timer or not.
891	* (ie. del_timer() of an inactive timer returns 0, del_timer() of an
892	* active timer returns 1.)
893	*/
894	int del_timer(struct timer_list *timer)
895	{
896	struct tvec_base *base;
897	unsigned long flags;
898	int ret = 0;
899
900	timer_stats_timer_clear_start_info(timer);
901	if (timer_pending(timer)) {
902	base = lock_timer_base(timer, &flags);
903	if (timer_pending(timer)) {
904	detach_timer(timer, 1);
905	if (timer->expires == base->next_timer &&
906	!tbase_get_deferrable(timer->base))
907	base->next_timer = base->timer_jiffies;
908	ret = 1;
909	}
910	spin_unlock_irqrestore(&base->lock, flags);
911	}
912
913	return ret;
914	}
915	EXPORT_SYMBOL(del_timer);
916
917	/**
918	* try_to_del_timer_sync - Try to deactivate a timer
919	* @timer: timer do del
920	*
921	* This function tries to deactivate a timer. Upon successful (ret >= 0)
922	* exit the timer is not queued and the handler is not running on any CPU.
923	*/
924	int try_to_del_timer_sync(struct timer_list *timer)
925	{
926	struct tvec_base *base;
927	unsigned long flags;
928	int ret = -1;
929
930	base = lock_timer_base(timer, &flags);
931
932	if (base->running_timer == timer)
933	goto out;
934
935	timer_stats_timer_clear_start_info(timer);
936	ret = 0;
937	if (timer_pending(timer)) {
938	detach_timer(timer, 1);
939	if (timer->expires == base->next_timer &&
940	!tbase_get_deferrable(timer->base))
941	base->next_timer = base->timer_jiffies;
942	ret = 1;
943	}
944	out:
945	spin_unlock_irqrestore(&base->lock, flags);
946
947	return ret;
948	}
949	EXPORT_SYMBOL(try_to_del_timer_sync);
950
951	#ifdef CONFIG_SMP
952	/**
953	* del_timer_sync - deactivate a timer and wait for the handler to finish.
954	* @timer: the timer to be deactivated
955	*
956	* This function only differs from del_timer() on SMP: besides deactivating
957	* the timer it also makes sure the handler has finished executing on other
958	* CPUs.
959	*
960	* Synchronization rules: Callers must prevent restarting of the timer,
961	* otherwise this function is meaningless. It must not be called from
962	* interrupt contexts. The caller must not hold locks which would prevent
963	* completion of the timer's handler. The timer's handler must not call
964	* add_timer_on(). Upon exit the timer is not queued and the handler is
965	* not running on any CPU.
966	*
967	* The function returns whether it has deactivated a pending timer or not.
968	*/
969	int del_timer_sync(struct timer_list *timer)
970	{
971	#ifdef CONFIG_LOCKDEP
972	unsigned long flags;
973
974	local_irq_save(flags);
975	lock_map_acquire(&timer->lockdep_map);
976	lock_map_release(&timer->lockdep_map);
977	local_irq_restore(flags);
978	#endif
979	/*
980	* don't use it in hardirq context, because it
981	* could lead to deadlock.
982	*/
983	WARN_ON(in_irq());
984	for (;;) {
985	int ret = try_to_del_timer_sync(timer);
986	if (ret >= 0)
987	return ret;
988	cpu_relax();
989	}
990	}
991	EXPORT_SYMBOL(del_timer_sync);
992	#endif
993
994	static int cascade(struct tvec_base base, struct tvec tv, int index)
995	{
996	/* cascade all the timers from tv up one level */
997	struct timer_list timer, tmp;
998	struct list_head tv_list;
999
1000	list_replace_init(tv->vec + index, &tv_list);
1001
1002	/*
1003	* We are removing _all_ timers from the list, so we
1004	* don't have to detach them individually.
1005	*/
1006	list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
1007	BUG_ON(tbase_get_base(timer->base) != base);
1008	internal_add_timer(base, timer);
1009	}
1010
1011	return index;
1012	}
1013
1014	static void call_timer_fn(struct timer_list timer, void (fn)(unsigned long),
1015	unsigned long data)
1016	{
1017	int preempt_count = preempt_count();
1018
1019	#ifdef CONFIG_LOCKDEP
1020	/*
1021	* It is permissible to free the timer from inside the
1022	* function that is called from it, this we need to take into
1023	* account for lockdep too. To avoid bogus "held lock freed"
1024	* warnings as well as problems when looking into
1025	* timer->lockdep_map, make a copy and use that here.
1026	*/
1027	struct lockdep_map lockdep_map = timer->lockdep_map;
1028	#endif
1029	/*
1030	* Couple the lock chain with the lock chain at
1031	* del_timer_sync() by acquiring the lock_map around the fn()
1032	* call here and in del_timer_sync().
1033	*/
1034	lock_map_acquire(&lockdep_map);
1035
1036	trace_timer_expire_entry(timer);
1037	fn(data);
1038	trace_timer_expire_exit(timer);
1039
1040	lock_map_release(&lockdep_map);
1041
1042	if (preempt_count != preempt_count()) {
1043	WARN_ONCE(1, "timer: %pF preempt leak: %08x -> %08x\n",
1044	fn, preempt_count, preempt_count());
1045	/*
1046	* Restore the preempt count. That gives us a decent
1047	* chance to survive and extract information. If the
1048	* callback kept a lock held, bad luck, but not worse
1049	* than the BUG() we had.
1050	*/
1051	preempt_count() = preempt_count;
1052	}
1053	}
1054
1055	#define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
1056
1057	/**
1058	* __run_timers - run all expired timers (if any) on this CPU.
1059	* @base: the timer vector to be processed.
1060	*
1061	* This function cascades all vectors and executes all expired timer
1062	* vectors.
1063	*/
1064	static inline void __run_timers(struct tvec_base *base)
1065	{
1066	struct timer_list *timer;
1067
1068	spin_lock_irq(&base->lock);
1069	while (time_after_eq(jiffies, base->timer_jiffies)) {
1070	struct list_head work_list;
1071	struct list_head *head = &work_list;
1072	int index = base->timer_jiffies & TVR_MASK;
1073
1074	/*
1075	* Cascade timers:
1076	*/
1077	if (!index &&
1078	(!cascade(base, &base->tv2, INDEX(0))) &&
1079	(!cascade(base, &base->tv3, INDEX(1))) &&
1080	!cascade(base, &base->tv4, INDEX(2)))
1081	cascade(base, &base->tv5, INDEX(3));
1082	++base->timer_jiffies;
1083	list_replace_init(base->tv1.vec + index, &work_list);
1084	while (!list_empty(head)) {
1085	void (*fn)(unsigned long);
1086	unsigned long data;
1087
1088	timer = list_first_entry(head, struct timer_list,entry);
1089	fn = timer->function;
1090	data = timer->data;
1091
1092	timer_stats_account_timer(timer);
1093
1094	base->running_timer = timer;
1095	detach_timer(timer, 1);
1096
1097	spin_unlock_irq(&base->lock);
1098	call_timer_fn(timer, fn, data);
1099	spin_lock_irq(&base->lock);
1100	}
1101	}
1102	base->running_timer = NULL;
1103	spin_unlock_irq(&base->lock);
1104	}
1105
1106	#ifdef CONFIG_NO_HZ
1107	/*
1108	* Find out when the next timer event is due to happen. This
1109	* is used on S/390 to stop all activity when a CPU is idle.
1110	* This function needs to be called with interrupts disabled.
1111	*/
1112	static unsigned long __next_timer_interrupt(struct tvec_base *base)
1113	{
1114	unsigned long timer_jiffies = base->timer_jiffies;
1115	unsigned long expires = timer_jiffies + NEXT_TIMER_MAX_DELTA;
1116	int index, slot, array, found = 0;
1117	struct timer_list *nte;
1118	struct tvec *varray[4];
1119
1120	/* Look for timer events in tv1. */
1121	index = slot = timer_jiffies & TVR_MASK;
1122	do {
1123	list_for_each_entry(nte, base->tv1.vec + slot, entry) {
1124	if (tbase_get_deferrable(nte->base))
1125	continue;
1126
1127	found = 1;
1128	expires = nte->expires;
1129	/* Look at the cascade bucket(s)? */
1130	if (!index \|\| slot < index)
1131	goto cascade;
1132	return expires;
1133	}
1134	slot = (slot + 1) & TVR_MASK;
1135	} while (slot != index);
1136
1137	cascade:
1138	/* Calculate the next cascade event */
1139	if (index)
1140	timer_jiffies += TVR_SIZE - index;
1141	timer_jiffies >>= TVR_BITS;
1142
1143	/* Check tv2-tv5. */
1144	varray[0] = &base->tv2;
1145	varray[1] = &base->tv3;
1146	varray[2] = &base->tv4;
1147	varray[3] = &base->tv5;
1148
1149	for (array = 0; array < 4; array++) {
1150	struct tvec *varp = varray[array];
1151
1152	index = slot = timer_jiffies & TVN_MASK;
1153	do {
1154	list_for_each_entry(nte, varp->vec + slot, entry) {
1155	if (tbase_get_deferrable(nte->base))
1156	continue;
1157
1158	found = 1;
1159	if (time_before(nte->expires, expires))
1160	expires = nte->expires;
1161	}
1162	/*
1163	* Do we still search for the first timer or are
1164	* we looking up the cascade buckets ?
1165	*/
1166	if (found) {
1167	/* Look at the cascade bucket(s)? */
1168	if (!index \|\| slot < index)
1169	break;
1170	return expires;
1171	}
1172	slot = (slot + 1) & TVN_MASK;
1173	} while (slot != index);
1174
1175	if (index)
1176	timer_jiffies += TVN_SIZE - index;
1177	timer_jiffies >>= TVN_BITS;
1178	}
1179	return expires;
1180	}
1181
1182	/*
1183	* Check, if the next hrtimer event is before the next timer wheel
1184	* event:
1185	*/
1186	static unsigned long cmp_next_hrtimer_event(unsigned long now,
1187	unsigned long expires)
1188	{
1189	ktime_t hr_delta = hrtimer_get_next_event();
1190	struct timespec tsdelta;
1191	unsigned long delta;
1192
1193	if (hr_delta.tv64 == KTIME_MAX)
1194	return expires;
1195
1196	/*
1197	* Expired timer available, let it expire in the next tick
1198	*/
1199	if (hr_delta.tv64 <= 0)
1200	return now + 1;
1201
1202	tsdelta = ktime_to_timespec(hr_delta);
1203	delta = timespec_to_jiffies(&tsdelta);
1204
1205	/*
1206	* Limit the delta to the max value, which is checked in
1207	* tick_nohz_stop_sched_tick():
1208	*/
1209	if (delta > NEXT_TIMER_MAX_DELTA)
1210	delta = NEXT_TIMER_MAX_DELTA;
1211
1212	/*
1213	* Take rounding errors in to account and make sure, that it
1214	* expires in the next tick. Otherwise we go into an endless
1215	* ping pong due to tick_nohz_stop_sched_tick() retriggering
1216	* the timer softirq
1217	*/
1218	if (delta < 1)
1219	delta = 1;
1220	now += delta;
1221	if (time_before(now, expires))
1222	return now;
1223	return expires;
1224	}
1225
1226	/**
1227	* get_next_timer_interrupt - return the jiffy of the next pending timer
1228	* @now: current time (in jiffies)
1229	*/
1230	unsigned long get_next_timer_interrupt(unsigned long now)
1231	{
1232	struct tvec_base *base = __this_cpu_read(tvec_bases);
1233	unsigned long expires;
1234
1235	/*
1236	* Pretend that there is no timer pending if the cpu is offline.
1237	* Possible pending timers will be migrated later to an active cpu.
1238	*/
1239	if (cpu_is_offline(smp_processor_id()))
1240	return now + NEXT_TIMER_MAX_DELTA;
1241	spin_lock(&base->lock);
1242	if (time_before_eq(base->next_timer, base->timer_jiffies))
1243	base->next_timer = __next_timer_interrupt(base);
1244	expires = base->next_timer;
1245	spin_unlock(&base->lock);
1246
1247	if (time_before_eq(expires, now))
1248	return now;
1249
1250	return cmp_next_hrtimer_event(now, expires);
1251	}
1252	#endif
1253
1254	/*
1255	* Called from the timer interrupt handler to charge one tick to the current
1256	* process. user_tick is 1 if the tick is user time, 0 for system.
1257	*/
1258	void update_process_times(int user_tick)
1259	{
1260	struct task_struct *p = current;
1261	int cpu = smp_processor_id();
1262
1263	/* Note: this timer irq context must be accounted for as well. */
1264	account_process_tick(p, user_tick);
1265	run_local_timers();
1266	rcu_check_callbacks(cpu, user_tick);
1267	printk_tick();
1268	#ifdef CONFIG_IRQ_WORK
1269	if (in_irq())
1270	irq_work_run();
1271	#endif
1272	scheduler_tick();
1273	run_posix_cpu_timers(p);
1274	}
1275
1276	/*
1277	* This function runs timers and the timer-tq in bottom half context.
1278	*/
1279	static void run_timer_softirq(struct softirq_action *h)
1280	{
1281	struct tvec_base *base = __this_cpu_read(tvec_bases);
1282
1283	hrtimer_run_pending();
1284
1285	if (time_after_eq(jiffies, base->timer_jiffies))
1286	__run_timers(base);
1287	}
1288
1289	/*
1290	* Called by the local, per-CPU timer interrupt on SMP.
1291	*/
1292	void run_local_timers(void)
1293	{
1294	hrtimer_run_queues();
1295	raise_softirq(TIMER_SOFTIRQ);
1296	}
1297
1298	/*
1299	* The 64-bit jiffies value is not atomic - you MUST NOT read it
1300	* without sampling the sequence number in xtime_lock.
1301	* jiffies is defined in the linker script...
1302	*/
1303
1304	void do_timer(unsigned long ticks)
1305	{
1306	jiffies_64 += ticks;
1307	update_wall_time();
1308	calc_global_load(ticks);
1309	}
1310
1311	#ifdef __ARCH_WANT_SYS_ALARM
1312
1313	/*
1314	* For backwards compatibility? This can be done in libc so Alpha
1315	* and all newer ports shouldn't need it.
1316	*/
1317	SYSCALL_DEFINE1(alarm, unsigned int, seconds)
1318	{
1319	return alarm_setitimer(seconds);
1320	}
1321
1322	#endif
1323
1324	#ifndef __alpha__
1325
1326	/*
1327	* The Alpha uses getxpid, getxuid, and getxgid instead. Maybe this
1328	* should be moved into arch/i386 instead?
1329	*/
1330
1331	/**
1332	* sys_getpid - return the thread group id of the current process
1333	*
1334	* Note, despite the name, this returns the tgid not the pid. The tgid and
1335	* the pid are identical unless CLONE_THREAD was specified on clone() in
1336	* which case the tgid is the same in all threads of the same group.
1337	*
1338	* This is SMP safe as current->tgid does not change.
1339	*/
1340	SYSCALL_DEFINE0(getpid)
1341	{
1342	return task_tgid_vnr(current);
1343	}
1344
1345	/*
1346	* Accessing ->real_parent is not SMP-safe, it could
1347	* change from under us. However, we can use a stale
1348	* value of ->real_parent under rcu_read_lock(), see
1349	* release_task()->call_rcu(delayed_put_task_struct).
1350	*/
1351	SYSCALL_DEFINE0(getppid)
1352	{
1353	int pid;
1354
1355	rcu_read_lock();
1356	pid = task_tgid_vnr(current->real_parent);
1357	rcu_read_unlock();
1358
1359	return pid;
1360	}
1361
1362	SYSCALL_DEFINE0(getuid)
1363	{
1364	/* Only we change this so SMP safe */
1365	return current_uid();
1366	}
1367
1368	SYSCALL_DEFINE0(geteuid)
1369	{
1370	/* Only we change this so SMP safe */
1371	return current_euid();
1372	}
1373
1374	SYSCALL_DEFINE0(getgid)
1375	{
1376	/* Only we change this so SMP safe */
1377	return current_gid();
1378	}
1379
1380	SYSCALL_DEFINE0(getegid)
1381	{
1382	/* Only we change this so SMP safe */
1383	return current_egid();
1384	}
1385
1386	#endif
1387
1388	static void process_timeout(unsigned long __data)
1389	{
1390	wake_up_process((struct task_struct *)__data);
1391	}
1392
1393	/**
1394	* schedule_timeout - sleep until timeout
1395	* @timeout: timeout value in jiffies
1396	*
1397	* Make the current task sleep until @timeout jiffies have
1398	* elapsed. The routine will return immediately unless
1399	* the current task state has been set (see set_current_state()).
1400	*
1401	* You can set the task state as follows -
1402	*
1403	* %TASK_UNINTERRUPTIBLE - at least @timeout jiffies are guaranteed to
1404	* pass before the routine returns. The routine will return 0
1405	*
1406	* %TASK_INTERRUPTIBLE - the routine may return early if a signal is
1407	* delivered to the current task. In this case the remaining time
1408	* in jiffies will be returned, or 0 if the timer expired in time
1409	*
1410	* The current task state is guaranteed to be TASK_RUNNING when this
1411	* routine returns.
1412	*
1413	* Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT will schedule
1414	* the CPU away without a bound on the timeout. In this case the return
1415	* value will be %MAX_SCHEDULE_TIMEOUT.
1416	*
1417	* In all cases the return value is guaranteed to be non-negative.
1418	*/
1419	signed long __sched schedule_timeout(signed long timeout)
1420	{
1421	struct timer_list timer;
1422	unsigned long expire;
1423
1424	switch (timeout)
1425	{
1426	case MAX_SCHEDULE_TIMEOUT:
1427	/*
1428	* These two special cases are useful to be comfortable
1429	* in the caller. Nothing more. We could take
1430	* MAX_SCHEDULE_TIMEOUT from one of the negative value
1431	* but I' d like to return a valid offset (>=0) to allow
1432	* the caller to do everything it want with the retval.
1433	*/
1434	schedule();
1435	goto out;
1436	default:
1437	/*
1438	* Another bit of PARANOID. Note that the retval will be
1439	* 0 since no piece of kernel is supposed to do a check
1440	* for a negative retval of schedule_timeout() (since it
1441	* should never happens anyway). You just have the printk()
1442	* that will tell you if something is gone wrong and where.
1443	*/
1444	if (timeout < 0) {
1445	printk(KERN_ERR "schedule_timeout: wrong timeout "
1446	"value %lx\n", timeout);
1447	dump_stack();
1448	current->state = TASK_RUNNING;
1449	goto out;
1450	}
1451	}
1452
1453	expire = timeout + jiffies;
1454
1455	setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
1456	__mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
1457	schedule();
1458	del_singleshot_timer_sync(&timer);
1459
1460	/* Remove the timer from the object tracker */
1461	destroy_timer_on_stack(&timer);
1462
1463	timeout = expire - jiffies;
1464
1465	out:
1466	return timeout < 0 ? 0 : timeout;
1467	}
1468	EXPORT_SYMBOL(schedule_timeout);
1469
1470	/*
1471	* We can use __set_current_state() here because schedule_timeout() calls
1472	* schedule() unconditionally.
1473	*/
1474	signed long __sched schedule_timeout_interruptible(signed long timeout)
1475	{
1476	__set_current_state(TASK_INTERRUPTIBLE);
1477	return schedule_timeout(timeout);
1478	}
1479	EXPORT_SYMBOL(schedule_timeout_interruptible);
1480
1481	signed long __sched schedule_timeout_killable(signed long timeout)
1482	{
1483	__set_current_state(TASK_KILLABLE);
1484	return schedule_timeout(timeout);
1485	}
1486	EXPORT_SYMBOL(schedule_timeout_killable);
1487
1488	signed long __sched schedule_timeout_uninterruptible(signed long timeout)
1489	{
1490	__set_current_state(TASK_UNINTERRUPTIBLE);
1491	return schedule_timeout(timeout);
1492	}
1493	EXPORT_SYMBOL(schedule_timeout_uninterruptible);
1494
1495	/* Thread ID - the internal kernel "pid" */
1496	SYSCALL_DEFINE0(gettid)
1497	{
1498	return task_pid_vnr(current);
1499	}
1500
1501	/**
1502	* do_sysinfo - fill in sysinfo struct
1503	* @info: pointer to buffer to fill
1504	*/
1505	int do_sysinfo(struct sysinfo *info)
1506	{
1507	unsigned long mem_total, sav_total;
1508	unsigned int mem_unit, bitcount;
1509	struct timespec tp;
1510
1511	memset(info, 0, sizeof(struct sysinfo));
1512
1513	ktime_get_ts(&tp);
1514	monotonic_to_bootbased(&tp);
1515	info->uptime = tp.tv_sec + (tp.tv_nsec ? 1 : 0);
1516
1517	get_avenrun(info->loads, 0, SI_LOAD_SHIFT - FSHIFT);
1518
1519	info->procs = nr_threads;
1520
1521	si_meminfo(info);
1522	si_swapinfo(info);
1523
1524	/*
1525	* If the sum of all the available memory (i.e. ram + swap)
1526	* is less than can be stored in a 32 bit unsigned long then
1527	* we can be binary compatible with 2.2.x kernels. If not,
1528	* well, in that case 2.2.x was broken anyways...
1529	*
1530	* -Erik Andersen <andersee@debian.org>
1531	*/
1532
1533	mem_total = info->totalram + info->totalswap;
1534	if (mem_total < info->totalram \|\| mem_total < info->totalswap)
1535	goto out;
1536	bitcount = 0;
1537	mem_unit = info->mem_unit;
1538	while (mem_unit > 1) {
1539	bitcount++;
1540	mem_unit >>= 1;
1541	sav_total = mem_total;
1542	mem_total <<= 1;
1543	if (mem_total < sav_total)
1544	goto out;
1545	}
1546
1547	/*
1548	* If mem_total did not overflow, multiply all memory values by
1549	* info->mem_unit and set it to 1. This leaves things compatible
1550	* with 2.2.x, and also retains compatibility with earlier 2.4.x
1551	* kernels...
1552	*/
1553
1554	info->mem_unit = 1;
1555	info->totalram <<= bitcount;
1556	info->freeram <<= bitcount;
1557	info->sharedram <<= bitcount;
1558	info->bufferram <<= bitcount;
1559	info->totalswap <<= bitcount;
1560	info->freeswap <<= bitcount;
1561	info->totalhigh <<= bitcount;
1562	info->freehigh <<= bitcount;
1563
1564	out:
1565	return 0;
1566	}
1567
1568	SYSCALL_DEFINE1(sysinfo, struct sysinfo __user *, info)
1569	{
1570	struct sysinfo val;
1571
1572	do_sysinfo(&val);
1573
1574	if (copy_to_user(info, &val, sizeof(struct sysinfo)))
1575	return -EFAULT;
1576
1577	return 0;
1578	}
1579
1580	static int __cpuinit init_timers_cpu(int cpu)
1581	{
1582	int j;
1583	struct tvec_base *base;
1584	static char __cpuinitdata tvec_base_done[NR_CPUS];
1585
1586	if (!tvec_base_done[cpu]) {
1587	static char boot_done;
1588
1589	if (boot_done) {
1590	/*
1591	* The APs use this path later in boot
1592	*/
1593	base = kmalloc_node(sizeof(*base),
1594	GFP_KERNEL \| __GFP_ZERO,
1595	cpu_to_node(cpu));
1596	if (!base)
1597	return -ENOMEM;
1598
1599	/* Make sure that tvec_base is 2 byte aligned */
1600	if (tbase_get_deferrable(base)) {
1601	WARN_ON(1);
1602	kfree(base);
1603	return -ENOMEM;
1604	}
1605	per_cpu(tvec_bases, cpu) = base;
1606	} else {
1607	/*
1608	* This is for the boot CPU - we use compile-time
1609	* static initialisation because per-cpu memory isn't
1610	* ready yet and because the memory allocators are not
1611	* initialised either.
1612	*/
1613	boot_done = 1;
1614	base = &boot_tvec_bases;
1615	}
1616	tvec_base_done[cpu] = 1;
1617	} else {
1618	base = per_cpu(tvec_bases, cpu);
1619	}
1620
1621	spin_lock_init(&base->lock);
1622
1623	for (j = 0; j < TVN_SIZE; j++) {
1624	INIT_LIST_HEAD(base->tv5.vec + j);
1625	INIT_LIST_HEAD(base->tv4.vec + j);
1626	INIT_LIST_HEAD(base->tv3.vec + j);
1627	INIT_LIST_HEAD(base->tv2.vec + j);
1628	}
1629	for (j = 0; j < TVR_SIZE; j++)
1630	INIT_LIST_HEAD(base->tv1.vec + j);
1631
1632	base->timer_jiffies = jiffies;
1633	base->next_timer = base->timer_jiffies;
1634	return 0;
1635	}
1636
1637	#ifdef CONFIG_HOTPLUG_CPU
1638	static void migrate_timer_list(struct tvec_base new_base, struct list_head head)
1639	{
1640	struct timer_list *timer;
1641
1642	while (!list_empty(head)) {
1643	timer = list_first_entry(head, struct timer_list, entry);
1644	detach_timer(timer, 0);
1645	timer_set_base(timer, new_base);
1646	if (time_before(timer->expires, new_base->next_timer) &&
1647	!tbase_get_deferrable(timer->base))
1648	new_base->next_timer = timer->expires;
1649	internal_add_timer(new_base, timer);
1650	}
1651	}
1652
1653	static void __cpuinit migrate_timers(int cpu)
1654	{
1655	struct tvec_base *old_base;
1656	struct tvec_base *new_base;
1657	int i;
1658
1659	BUG_ON(cpu_online(cpu));
1660	old_base = per_cpu(tvec_bases, cpu);
1661	new_base = get_cpu_var(tvec_bases);
1662	/*
1663	* The caller is globally serialized and nobody else
1664	* takes two locks at once, deadlock is not possible.
1665	*/
1666	spin_lock_irq(&new_base->lock);
1667	spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
1668
1669	BUG_ON(old_base->running_timer);
1670
1671	for (i = 0; i < TVR_SIZE; i++)
1672	migrate_timer_list(new_base, old_base->tv1.vec + i);
1673	for (i = 0; i < TVN_SIZE; i++) {
1674	migrate_timer_list(new_base, old_base->tv2.vec + i);
1675	migrate_timer_list(new_base, old_base->tv3.vec + i);
1676	migrate_timer_list(new_base, old_base->tv4.vec + i);
1677	migrate_timer_list(new_base, old_base->tv5.vec + i);
1678	}
1679
1680	spin_unlock(&old_base->lock);
1681	spin_unlock_irq(&new_base->lock);
1682	put_cpu_var(tvec_bases);
1683	}
1684	#endif /* CONFIG_HOTPLUG_CPU */
1685
1686	static int __cpuinit timer_cpu_notify(struct notifier_block *self,
1687	unsigned long action, void *hcpu)
1688	{
1689	long cpu = (long)hcpu;
1690	int err;
1691
1692	switch(action) {
1693	case CPU_UP_PREPARE:
1694	case CPU_UP_PREPARE_FROZEN:
1695	err = init_timers_cpu(cpu);
1696	if (err < 0)
1697	return notifier_from_errno(err);
1698	break;
1699	#ifdef CONFIG_HOTPLUG_CPU
1700	case CPU_DEAD:
1701	case CPU_DEAD_FROZEN:
1702	migrate_timers(cpu);
1703	break;
1704	#endif
1705	default:
1706	break;
1707	}
1708	return NOTIFY_OK;
1709	}
1710
1711	static struct notifier_block __cpuinitdata timers_nb = {
1712	.notifier_call = timer_cpu_notify,
1713	};
1714
1715
1716	void __init init_timers(void)
1717	{
1718	int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,
1719	(void *)(long)smp_processor_id());
1720
1721	init_timer_stats();
1722
1723	BUG_ON(err != NOTIFY_OK);
1724	register_cpu_notifier(&timers_nb);
1725	open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
1726	}
1727
1728	/**
1729	* msleep - sleep safely even with waitqueue interruptions
1730	* @msecs: Time in milliseconds to sleep for
1731	*/
1732	void msleep(unsigned int msecs)
1733	{
1734	unsigned long timeout = msecs_to_jiffies(msecs) + 1;
1735
1736	while (timeout)
1737	timeout = schedule_timeout_uninterruptible(timeout);
1738	}
1739
1740	EXPORT_SYMBOL(msleep);
1741
1742	/**
1743	* msleep_interruptible - sleep waiting for signals
1744	* @msecs: Time in milliseconds to sleep for
1745	*/
1746	unsigned long msleep_interruptible(unsigned int msecs)
1747	{
1748	unsigned long timeout = msecs_to_jiffies(msecs) + 1;
1749
1750	while (timeout && !signal_pending(current))
1751	timeout = schedule_timeout_interruptible(timeout);
1752	return jiffies_to_msecs(timeout);
1753	}
1754
1755	EXPORT_SYMBOL(msleep_interruptible);
1756
1757	static int __sched do_usleep_range(unsigned long min, unsigned long max)
1758	{
1759	ktime_t kmin;
1760	unsigned long delta;
1761
1762	kmin = ktime_set(0, min * NSEC_PER_USEC);
1763	delta = (max - min) * NSEC_PER_USEC;
1764	return schedule_hrtimeout_range(&kmin, delta, HRTIMER_MODE_REL);
1765	}
1766
1767	/**
1768	* usleep_range - Drop in replacement for udelay where wakeup is flexible
1769	* @min: Minimum time in usecs to sleep
1770	* @max: Maximum time in usecs to sleep
1771	*/
1772	void usleep_range(unsigned long min, unsigned long max)
1773	{
1774	__set_current_state(TASK_UNINTERRUPTIBLE);
1775	do_usleep_range(min, max);
1776	}
1777	EXPORT_SYMBOL(usleep_range);
1778

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/timer.c

interactive