[PATCH] hrtimer: round up relative start time on low-res arches
[linux-3.10.git] / kernel / hrtimer.c
1 /*
2  *  linux/kernel/hrtimer.c
3  *
4  *  Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
5  *  Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
6  *
7  *  High-resolution kernel timers
8  *
9  *  In contrast to the low-resolution timeout API implemented in
10  *  kernel/timer.c, hrtimers provide finer resolution and accuracy
11  *  depending on system configuration and capabilities.
12  *
13  *  These timers are currently used for:
14  *   - itimers
15  *   - POSIX timers
16  *   - nanosleep
17  *   - precise in-kernel timing
18  *
19  *  Started by: Thomas Gleixner and Ingo Molnar
20  *
21  *  Credits:
22  *      based on kernel/timer.c
23  *
24  *      Help, testing, suggestions, bugfixes, improvements were
25  *      provided by:
26  *
27  *      George Anzinger, Andrew Morton, Steven Rostedt, Roman Zippel
28  *      et. al.
29  *
30  *  For licencing details see kernel-base/COPYING
31  */
32
33 #include <linux/cpu.h>
34 #include <linux/module.h>
35 #include <linux/percpu.h>
36 #include <linux/hrtimer.h>
37 #include <linux/notifier.h>
38 #include <linux/syscalls.h>
39 #include <linux/interrupt.h>
40
41 #include <asm/uaccess.h>
42
43 /**
44  * ktime_get - get the monotonic time in ktime_t format
45  *
46  * returns the time in ktime_t format
47  */
48 static ktime_t ktime_get(void)
49 {
50         struct timespec now;
51
52         ktime_get_ts(&now);
53
54         return timespec_to_ktime(now);
55 }
56
57 /**
58  * ktime_get_real - get the real (wall-) time in ktime_t format
59  *
60  * returns the time in ktime_t format
61  */
62 static ktime_t ktime_get_real(void)
63 {
64         struct timespec now;
65
66         getnstimeofday(&now);
67
68         return timespec_to_ktime(now);
69 }
70
71 EXPORT_SYMBOL_GPL(ktime_get_real);
72
73 /*
74  * The timer bases:
75  *
76  * Note: If we want to add new timer bases, we have to skip the two
77  * clock ids captured by the cpu-timers. We do this by holding empty
78  * entries rather than doing math adjustment of the clock ids.
79  * This ensures that we capture erroneous accesses to these clock ids
80  * rather than moving them into the range of valid clock id's.
81  */
82
83 #define MAX_HRTIMER_BASES 2
84
85 static DEFINE_PER_CPU(struct hrtimer_base, hrtimer_bases[MAX_HRTIMER_BASES]) =
86 {
87         {
88                 .index = CLOCK_REALTIME,
89                 .get_time = &ktime_get_real,
90                 .resolution = KTIME_REALTIME_RES,
91         },
92         {
93                 .index = CLOCK_MONOTONIC,
94                 .get_time = &ktime_get,
95                 .resolution = KTIME_MONOTONIC_RES,
96         },
97 };
98
99 /**
100  * ktime_get_ts - get the monotonic clock in timespec format
101  *
102  * @ts:         pointer to timespec variable
103  *
104  * The function calculates the monotonic clock from the realtime
105  * clock and the wall_to_monotonic offset and stores the result
106  * in normalized timespec format in the variable pointed to by ts.
107  */
108 void ktime_get_ts(struct timespec *ts)
109 {
110         struct timespec tomono;
111         unsigned long seq;
112
113         do {
114                 seq = read_seqbegin(&xtime_lock);
115                 getnstimeofday(ts);
116                 tomono = wall_to_monotonic;
117
118         } while (read_seqretry(&xtime_lock, seq));
119
120         set_normalized_timespec(ts, ts->tv_sec + tomono.tv_sec,
121                                 ts->tv_nsec + tomono.tv_nsec);
122 }
123 EXPORT_SYMBOL_GPL(ktime_get_ts);
124
125 /*
126  * Functions and macros which are different for UP/SMP systems are kept in a
127  * single place
128  */
129 #ifdef CONFIG_SMP
130
131 #define set_curr_timer(b, t)            do { (b)->curr_timer = (t); } while (0)
132
133 /*
134  * We are using hashed locking: holding per_cpu(hrtimer_bases)[n].lock
135  * means that all timers which are tied to this base via timer->base are
136  * locked, and the base itself is locked too.
137  *
138  * So __run_timers/migrate_timers can safely modify all timers which could
139  * be found on the lists/queues.
140  *
141  * When the timer's base is locked, and the timer removed from list, it is
142  * possible to set timer->base = NULL and drop the lock: the timer remains
143  * locked.
144  */
145 static struct hrtimer_base *lock_hrtimer_base(const struct hrtimer *timer,
146                                               unsigned long *flags)
147 {
148         struct hrtimer_base *base;
149
150         for (;;) {
151                 base = timer->base;
152                 if (likely(base != NULL)) {
153                         spin_lock_irqsave(&base->lock, *flags);
154                         if (likely(base == timer->base))
155                                 return base;
156                         /* The timer has migrated to another CPU: */
157                         spin_unlock_irqrestore(&base->lock, *flags);
158                 }
159                 cpu_relax();
160         }
161 }
162
163 /*
164  * Switch the timer base to the current CPU when possible.
165  */
166 static inline struct hrtimer_base *
167 switch_hrtimer_base(struct hrtimer *timer, struct hrtimer_base *base)
168 {
169         struct hrtimer_base *new_base;
170
171         new_base = &__get_cpu_var(hrtimer_bases[base->index]);
172
173         if (base != new_base) {
174                 /*
175                  * We are trying to schedule the timer on the local CPU.
176                  * However we can't change timer's base while it is running,
177                  * so we keep it on the same CPU. No hassle vs. reprogramming
178                  * the event source in the high resolution case. The softirq
179                  * code will take care of this when the timer function has
180                  * completed. There is no conflict as we hold the lock until
181                  * the timer is enqueued.
182                  */
183                 if (unlikely(base->curr_timer == timer))
184                         return base;
185
186                 /* See the comment in lock_timer_base() */
187                 timer->base = NULL;
188                 spin_unlock(&base->lock);
189                 spin_lock(&new_base->lock);
190                 timer->base = new_base;
191         }
192         return new_base;
193 }
194
195 #else /* CONFIG_SMP */
196
197 #define set_curr_timer(b, t)            do { } while (0)
198
199 static inline struct hrtimer_base *
200 lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
201 {
202         struct hrtimer_base *base = timer->base;
203
204         spin_lock_irqsave(&base->lock, *flags);
205
206         return base;
207 }
208
209 #define switch_hrtimer_base(t, b)       (b)
210
211 #endif  /* !CONFIG_SMP */
212
213 /*
214  * Functions for the union type storage format of ktime_t which are
215  * too large for inlining:
216  */
217 #if BITS_PER_LONG < 64
218 # ifndef CONFIG_KTIME_SCALAR
219 /**
220  * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
221  *
222  * @kt:         addend
223  * @nsec:       the scalar nsec value to add
224  *
225  * Returns the sum of kt and nsec in ktime_t format
226  */
227 ktime_t ktime_add_ns(const ktime_t kt, u64 nsec)
228 {
229         ktime_t tmp;
230
231         if (likely(nsec < NSEC_PER_SEC)) {
232                 tmp.tv64 = nsec;
233         } else {
234                 unsigned long rem = do_div(nsec, NSEC_PER_SEC);
235
236                 tmp = ktime_set((long)nsec, rem);
237         }
238
239         return ktime_add(kt, tmp);
240 }
241
242 #else /* CONFIG_KTIME_SCALAR */
243
244 # endif /* !CONFIG_KTIME_SCALAR */
245
246 /*
247  * Divide a ktime value by a nanosecond value
248  */
249 static unsigned long ktime_divns(const ktime_t kt, nsec_t div)
250 {
251         u64 dclc, inc, dns;
252         int sft = 0;
253
254         dclc = dns = ktime_to_ns(kt);
255         inc = div;
256         /* Make sure the divisor is less than 2^32: */
257         while (div >> 32) {
258                 sft++;
259                 div >>= 1;
260         }
261         dclc >>= sft;
262         do_div(dclc, (unsigned long) div);
263
264         return (unsigned long) dclc;
265 }
266
267 #else /* BITS_PER_LONG < 64 */
268 # define ktime_divns(kt, div)           (unsigned long)((kt).tv64 / (div))
269 #endif /* BITS_PER_LONG >= 64 */
270
271 /*
272  * Counterpart to lock_timer_base above:
273  */
274 static inline
275 void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
276 {
277         spin_unlock_irqrestore(&timer->base->lock, *flags);
278 }
279
280 /**
281  * hrtimer_forward - forward the timer expiry
282  *
283  * @timer:      hrtimer to forward
284  * @interval:   the interval to forward
285  *
286  * Forward the timer expiry so it will expire in the future.
287  * Returns the number of overruns.
288  */
289 unsigned long
290 hrtimer_forward(struct hrtimer *timer, ktime_t interval)
291 {
292         unsigned long orun = 1;
293         ktime_t delta, now;
294
295         now = timer->base->get_time();
296
297         delta = ktime_sub(now, timer->expires);
298
299         if (delta.tv64 < 0)
300                 return 0;
301
302         if (interval.tv64 < timer->base->resolution.tv64)
303                 interval.tv64 = timer->base->resolution.tv64;
304
305         if (unlikely(delta.tv64 >= interval.tv64)) {
306                 nsec_t incr = ktime_to_ns(interval);
307
308                 orun = ktime_divns(delta, incr);
309                 timer->expires = ktime_add_ns(timer->expires, incr * orun);
310                 if (timer->expires.tv64 > now.tv64)
311                         return orun;
312                 /*
313                  * This (and the ktime_add() below) is the
314                  * correction for exact:
315                  */
316                 orun++;
317         }
318         timer->expires = ktime_add(timer->expires, interval);
319
320         return orun;
321 }
322
323 /*
324  * enqueue_hrtimer - internal function to (re)start a timer
325  *
326  * The timer is inserted in expiry order. Insertion into the
327  * red black tree is O(log(n)). Must hold the base lock.
328  */
329 static void enqueue_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
330 {
331         struct rb_node **link = &base->active.rb_node;
332         struct rb_node *parent = NULL;
333         struct hrtimer *entry;
334
335         /*
336          * Find the right place in the rbtree:
337          */
338         while (*link) {
339                 parent = *link;
340                 entry = rb_entry(parent, struct hrtimer, node);
341                 /*
342                  * We dont care about collisions. Nodes with
343                  * the same expiry time stay together.
344                  */
345                 if (timer->expires.tv64 < entry->expires.tv64)
346                         link = &(*link)->rb_left;
347                 else
348                         link = &(*link)->rb_right;
349         }
350
351         /*
352          * Insert the timer to the rbtree and check whether it
353          * replaces the first pending timer
354          */
355         rb_link_node(&timer->node, parent, link);
356         rb_insert_color(&timer->node, &base->active);
357
358         timer->state = HRTIMER_PENDING;
359
360         if (!base->first || timer->expires.tv64 <
361             rb_entry(base->first, struct hrtimer, node)->expires.tv64)
362                 base->first = &timer->node;
363 }
364
365 /*
366  * __remove_hrtimer - internal function to remove a timer
367  *
368  * Caller must hold the base lock.
369  */
370 static void __remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
371 {
372         /*
373          * Remove the timer from the rbtree and replace the
374          * first entry pointer if necessary.
375          */
376         if (base->first == &timer->node)
377                 base->first = rb_next(&timer->node);
378         rb_erase(&timer->node, &base->active);
379 }
380
381 /*
382  * remove hrtimer, called with base lock held
383  */
384 static inline int
385 remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
386 {
387         if (hrtimer_active(timer)) {
388                 __remove_hrtimer(timer, base);
389                 timer->state = HRTIMER_INACTIVE;
390                 return 1;
391         }
392         return 0;
393 }
394
395 /**
396  * hrtimer_start - (re)start an relative timer on the current CPU
397  *
398  * @timer:      the timer to be added
399  * @tim:        expiry time
400  * @mode:       expiry mode: absolute (HRTIMER_ABS) or relative (HRTIMER_REL)
401  *
402  * Returns:
403  *  0 on success
404  *  1 when the timer was active
405  */
406 int
407 hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
408 {
409         struct hrtimer_base *base, *new_base;
410         unsigned long flags;
411         int ret;
412
413         base = lock_hrtimer_base(timer, &flags);
414
415         /* Remove an active timer from the queue: */
416         ret = remove_hrtimer(timer, base);
417
418         /* Switch the timer base, if necessary: */
419         new_base = switch_hrtimer_base(timer, base);
420
421         if (mode == HRTIMER_REL) {
422                 tim = ktime_add(tim, new_base->get_time());
423                 /*
424                  * CONFIG_TIME_LOW_RES is a temporary way for architectures
425                  * to signal that they simply return xtime in
426                  * do_gettimeoffset(). In this case we want to round up by
427                  * resolution when starting a relative timer, to avoid short
428                  * timeouts. This will go away with the GTOD framework.
429                  */
430 #ifdef CONFIG_TIME_LOW_RES
431                 tim = ktime_add(tim, base->resolution);
432 #endif
433         }
434         timer->expires = tim;
435
436         enqueue_hrtimer(timer, new_base);
437
438         unlock_hrtimer_base(timer, &flags);
439
440         return ret;
441 }
442
443 /**
444  * hrtimer_try_to_cancel - try to deactivate a timer
445  *
446  * @timer:      hrtimer to stop
447  *
448  * Returns:
449  *  0 when the timer was not active
450  *  1 when the timer was active
451  * -1 when the timer is currently excuting the callback function and
452  *    can not be stopped
453  */
454 int hrtimer_try_to_cancel(struct hrtimer *timer)
455 {
456         struct hrtimer_base *base;
457         unsigned long flags;
458         int ret = -1;
459
460         base = lock_hrtimer_base(timer, &flags);
461
462         if (base->curr_timer != timer)
463                 ret = remove_hrtimer(timer, base);
464
465         unlock_hrtimer_base(timer, &flags);
466
467         return ret;
468
469 }
470
471 /**
472  * hrtimer_cancel - cancel a timer and wait for the handler to finish.
473  *
474  * @timer:      the timer to be cancelled
475  *
476  * Returns:
477  *  0 when the timer was not active
478  *  1 when the timer was active
479  */
480 int hrtimer_cancel(struct hrtimer *timer)
481 {
482         for (;;) {
483                 int ret = hrtimer_try_to_cancel(timer);
484
485                 if (ret >= 0)
486                         return ret;
487         }
488 }
489
490 /**
491  * hrtimer_get_remaining - get remaining time for the timer
492  *
493  * @timer:      the timer to read
494  */
495 ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
496 {
497         struct hrtimer_base *base;
498         unsigned long flags;
499         ktime_t rem;
500
501         base = lock_hrtimer_base(timer, &flags);
502         rem = ktime_sub(timer->expires, timer->base->get_time());
503         unlock_hrtimer_base(timer, &flags);
504
505         return rem;
506 }
507
508 /**
509  * hrtimer_init - initialize a timer to the given clock
510  *
511  * @timer:      the timer to be initialized
512  * @clock_id:   the clock to be used
513  * @mode:       timer mode abs/rel
514  */
515 void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
516                   enum hrtimer_mode mode)
517 {
518         struct hrtimer_base *bases;
519
520         memset(timer, 0, sizeof(struct hrtimer));
521
522         bases = per_cpu(hrtimer_bases, raw_smp_processor_id());
523
524         if (clock_id == CLOCK_REALTIME && mode != HRTIMER_ABS)
525                 clock_id = CLOCK_MONOTONIC;
526
527         timer->base = &bases[clock_id];
528 }
529
530 /**
531  * hrtimer_get_res - get the timer resolution for a clock
532  *
533  * @which_clock: which clock to query
534  * @tp:          pointer to timespec variable to store the resolution
535  *
536  * Store the resolution of the clock selected by which_clock in the
537  * variable pointed to by tp.
538  */
539 int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
540 {
541         struct hrtimer_base *bases;
542
543         bases = per_cpu(hrtimer_bases, raw_smp_processor_id());
544         *tp = ktime_to_timespec(bases[which_clock].resolution);
545
546         return 0;
547 }
548
549 /*
550  * Expire the per base hrtimer-queue:
551  */
552 static inline void run_hrtimer_queue(struct hrtimer_base *base)
553 {
554         ktime_t now = base->get_time();
555         struct rb_node *node;
556
557         spin_lock_irq(&base->lock);
558
559         while ((node = base->first)) {
560                 struct hrtimer *timer;
561                 int (*fn)(void *);
562                 int restart;
563                 void *data;
564
565                 timer = rb_entry(node, struct hrtimer, node);
566                 if (now.tv64 <= timer->expires.tv64)
567                         break;
568
569                 fn = timer->function;
570                 data = timer->data;
571                 set_curr_timer(base, timer);
572                 timer->state = HRTIMER_RUNNING;
573                 __remove_hrtimer(timer, base);
574                 spin_unlock_irq(&base->lock);
575
576                 /*
577                  * fn == NULL is special case for the simplest timer
578                  * variant - wake up process and do not restart:
579                  */
580                 if (!fn) {
581                         wake_up_process(data);
582                         restart = HRTIMER_NORESTART;
583                 } else
584                         restart = fn(data);
585
586                 spin_lock_irq(&base->lock);
587
588                 /* Another CPU has added back the timer */
589                 if (timer->state != HRTIMER_RUNNING)
590                         continue;
591
592                 if (restart == HRTIMER_RESTART)
593                         enqueue_hrtimer(timer, base);
594                 else
595                         timer->state = HRTIMER_EXPIRED;
596         }
597         set_curr_timer(base, NULL);
598         spin_unlock_irq(&base->lock);
599 }
600
601 /*
602  * Called from timer softirq every jiffy, expire hrtimers:
603  */
604 void hrtimer_run_queues(void)
605 {
606         struct hrtimer_base *base = __get_cpu_var(hrtimer_bases);
607         int i;
608
609         for (i = 0; i < MAX_HRTIMER_BASES; i++)
610                 run_hrtimer_queue(&base[i]);
611 }
612
613 /*
614  * Sleep related functions:
615  */
616
617 /**
618  * schedule_hrtimer - sleep until timeout
619  *
620  * @timer:      hrtimer variable initialized with the correct clock base
621  * @mode:       timeout value is abs/rel
622  *
623  * Make the current task sleep until @timeout is
624  * elapsed.
625  *
626  * You can set the task state as follows -
627  *
628  * %TASK_UNINTERRUPTIBLE - at least @timeout is guaranteed to
629  * pass before the routine returns. The routine will return 0
630  *
631  * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
632  * delivered to the current task. In this case the remaining time
633  * will be returned
634  *
635  * The current task state is guaranteed to be TASK_RUNNING when this
636  * routine returns.
637  */
638 static ktime_t __sched
639 schedule_hrtimer(struct hrtimer *timer, const enum hrtimer_mode mode)
640 {
641         /* fn stays NULL, meaning single-shot wakeup: */
642         timer->data = current;
643
644         hrtimer_start(timer, timer->expires, mode);
645
646         schedule();
647         hrtimer_cancel(timer);
648
649         /* Return the remaining time: */
650         if (timer->state != HRTIMER_EXPIRED)
651                 return ktime_sub(timer->expires, timer->base->get_time());
652         else
653                 return (ktime_t) {.tv64 = 0 };
654 }
655
656 static inline ktime_t __sched
657 schedule_hrtimer_interruptible(struct hrtimer *timer,
658                                const enum hrtimer_mode mode)
659 {
660         set_current_state(TASK_INTERRUPTIBLE);
661
662         return schedule_hrtimer(timer, mode);
663 }
664
665 static long __sched nanosleep_restart(struct restart_block *restart)
666 {
667         struct timespec __user *rmtp;
668         struct timespec tu;
669         void *rfn_save = restart->fn;
670         struct hrtimer timer;
671         ktime_t rem;
672
673         restart->fn = do_no_restart_syscall;
674
675         hrtimer_init(&timer, (clockid_t) restart->arg3, HRTIMER_ABS);
676
677         timer.expires.tv64 = ((u64)restart->arg1 << 32) | (u64) restart->arg0;
678
679         rem = schedule_hrtimer_interruptible(&timer, HRTIMER_ABS);
680
681         if (rem.tv64 <= 0)
682                 return 0;
683
684         rmtp = (struct timespec __user *) restart->arg2;
685         tu = ktime_to_timespec(rem);
686         if (rmtp && copy_to_user(rmtp, &tu, sizeof(tu)))
687                 return -EFAULT;
688
689         restart->fn = rfn_save;
690
691         /* The other values in restart are already filled in */
692         return -ERESTART_RESTARTBLOCK;
693 }
694
695 long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
696                        const enum hrtimer_mode mode, const clockid_t clockid)
697 {
698         struct restart_block *restart;
699         struct hrtimer timer;
700         struct timespec tu;
701         ktime_t rem;
702
703         hrtimer_init(&timer, clockid, mode);
704
705         timer.expires = timespec_to_ktime(*rqtp);
706
707         rem = schedule_hrtimer_interruptible(&timer, mode);
708         if (rem.tv64 <= 0)
709                 return 0;
710
711         /* Absolute timers do not update the rmtp value and restart: */
712         if (mode == HRTIMER_ABS)
713                 return -ERESTARTNOHAND;
714
715         tu = ktime_to_timespec(rem);
716
717         if (rmtp && copy_to_user(rmtp, &tu, sizeof(tu)))
718                 return -EFAULT;
719
720         restart = &current_thread_info()->restart_block;
721         restart->fn = nanosleep_restart;
722         restart->arg0 = timer.expires.tv64 & 0xFFFFFFFF;
723         restart->arg1 = timer.expires.tv64 >> 32;
724         restart->arg2 = (unsigned long) rmtp;
725         restart->arg3 = (unsigned long) timer.base->index;
726
727         return -ERESTART_RESTARTBLOCK;
728 }
729
730 asmlinkage long
731 sys_nanosleep(struct timespec __user *rqtp, struct timespec __user *rmtp)
732 {
733         struct timespec tu;
734
735         if (copy_from_user(&tu, rqtp, sizeof(tu)))
736                 return -EFAULT;
737
738         if (!timespec_valid(&tu))
739                 return -EINVAL;
740
741         return hrtimer_nanosleep(&tu, rmtp, HRTIMER_REL, CLOCK_MONOTONIC);
742 }
743
744 /*
745  * Functions related to boot-time initialization:
746  */
747 static void __devinit init_hrtimers_cpu(int cpu)
748 {
749         struct hrtimer_base *base = per_cpu(hrtimer_bases, cpu);
750         int i;
751
752         for (i = 0; i < MAX_HRTIMER_BASES; i++, base++)
753                 spin_lock_init(&base->lock);
754 }
755
756 #ifdef CONFIG_HOTPLUG_CPU
757
758 static void migrate_hrtimer_list(struct hrtimer_base *old_base,
759                                 struct hrtimer_base *new_base)
760 {
761         struct hrtimer *timer;
762         struct rb_node *node;
763
764         while ((node = rb_first(&old_base->active))) {
765                 timer = rb_entry(node, struct hrtimer, node);
766                 __remove_hrtimer(timer, old_base);
767                 timer->base = new_base;
768                 enqueue_hrtimer(timer, new_base);
769         }
770 }
771
772 static void migrate_hrtimers(int cpu)
773 {
774         struct hrtimer_base *old_base, *new_base;
775         int i;
776
777         BUG_ON(cpu_online(cpu));
778         old_base = per_cpu(hrtimer_bases, cpu);
779         new_base = get_cpu_var(hrtimer_bases);
780
781         local_irq_disable();
782
783         for (i = 0; i < MAX_HRTIMER_BASES; i++) {
784
785                 spin_lock(&new_base->lock);
786                 spin_lock(&old_base->lock);
787
788                 BUG_ON(old_base->curr_timer);
789
790                 migrate_hrtimer_list(old_base, new_base);
791
792                 spin_unlock(&old_base->lock);
793                 spin_unlock(&new_base->lock);
794                 old_base++;
795                 new_base++;
796         }
797
798         local_irq_enable();
799         put_cpu_var(hrtimer_bases);
800 }
801 #endif /* CONFIG_HOTPLUG_CPU */
802
803 static int __devinit hrtimer_cpu_notify(struct notifier_block *self,
804                                         unsigned long action, void *hcpu)
805 {
806         long cpu = (long)hcpu;
807
808         switch (action) {
809
810         case CPU_UP_PREPARE:
811                 init_hrtimers_cpu(cpu);
812                 break;
813
814 #ifdef CONFIG_HOTPLUG_CPU
815         case CPU_DEAD:
816                 migrate_hrtimers(cpu);
817                 break;
818 #endif
819
820         default:
821                 break;
822         }
823
824         return NOTIFY_OK;
825 }
826
827 static struct notifier_block __devinitdata hrtimers_nb = {
828         .notifier_call = hrtimer_cpu_notify,
829 };
830
831 void __init hrtimers_init(void)
832 {
833         hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE,
834                           (void *)(long)smp_processor_id());
835         register_cpu_notifier(&hrtimers_nb);
836 }
837