hrtimer.c 35.1 KB
Newer Older
1 2 3
/*
 *  linux/kernel/hrtimer.c
 *
4
 *  Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
5
 *  Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
6
 *  Copyright(C) 2006-2007  Timesys Corp., Thomas Gleixner
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 *  High-resolution kernel timers
 *
 *  In contrast to the low-resolution timeout API implemented in
 *  kernel/timer.c, hrtimers provide finer resolution and accuracy
 *  depending on system configuration and capabilities.
 *
 *  These timers are currently used for:
 *   - itimers
 *   - POSIX timers
 *   - nanosleep
 *   - precise in-kernel timing
 *
 *  Started by: Thomas Gleixner and Ingo Molnar
 *
 *  Credits:
 *	based on kernel/timer.c
 *
25 26 27 28 29 30
 *	Help, testing, suggestions, bugfixes, improvements were
 *	provided by:
 *
 *	George Anzinger, Andrew Morton, Steven Rostedt, Roman Zippel
 *	et. al.
 *
31 32 33 34
 *  For licencing details see kernel-base/COPYING
 */

#include <linux/cpu.h>
35
#include <linux/irq.h>
36 37 38 39 40
#include <linux/module.h>
#include <linux/percpu.h>
#include <linux/hrtimer.h>
#include <linux/notifier.h>
#include <linux/syscalls.h>
41
#include <linux/kallsyms.h>
42
#include <linux/interrupt.h>
43
#include <linux/tick.h>
44 45
#include <linux/seq_file.h>
#include <linux/err.h>
46 47 48 49 50 51 52 53

#include <asm/uaccess.h>

/**
 * ktime_get - get the monotonic time in ktime_t format
 *
 * returns the time in ktime_t format
 */
54
ktime_t ktime_get(void)
55 56 57 58 59 60 61
{
	struct timespec now;

	ktime_get_ts(&now);

	return timespec_to_ktime(now);
}
62
EXPORT_SYMBOL_GPL(ktime_get);
63 64 65 66 67 68

/**
 * ktime_get_real - get the real (wall-) time in ktime_t format
 *
 * returns the time in ktime_t format
 */
69
ktime_t ktime_get_real(void)
70 71 72 73 74 75 76 77 78 79 80 81
{
	struct timespec now;

	getnstimeofday(&now);

	return timespec_to_ktime(now);
}

EXPORT_SYMBOL_GPL(ktime_get_real);

/*
 * The timer bases:
82 83 84 85 86 87
 *
 * Note: If we want to add new timer bases, we have to skip the two
 * clock ids captured by the cpu-timers. We do this by holding empty
 * entries rather than doing math adjustment of the clock ids.
 * This ensures that we capture erroneous accesses to these clock ids
 * rather than moving them into the range of valid clock id's.
88
 */
89
DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases) =
90
{
91 92

	.clock_base =
93
	{
94 95 96
		{
			.index = CLOCK_REALTIME,
			.get_time = &ktime_get_real,
97
			.resolution = KTIME_LOW_RES,
98 99 100 101
		},
		{
			.index = CLOCK_MONOTONIC,
			.get_time = &ktime_get,
102
			.resolution = KTIME_LOW_RES,
103 104
		},
	}
105 106 107 108 109 110 111 112
};

/**
 * ktime_get_ts - get the monotonic clock in timespec format
 * @ts:		pointer to timespec variable
 *
 * The function calculates the monotonic clock from the realtime
 * clock and the wall_to_monotonic offset and stores the result
113
 * in normalized timespec format in the variable pointed to by @ts.
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
 */
void ktime_get_ts(struct timespec *ts)
{
	struct timespec tomono;
	unsigned long seq;

	do {
		seq = read_seqbegin(&xtime_lock);
		getnstimeofday(ts);
		tomono = wall_to_monotonic;

	} while (read_seqretry(&xtime_lock, seq));

	set_normalized_timespec(ts, ts->tv_sec + tomono.tv_sec,
				ts->tv_nsec + tomono.tv_nsec);
}
M
Matt Helsley 已提交
130
EXPORT_SYMBOL_GPL(ktime_get_ts);
131

132 133 134 135
/*
 * Get the coarse grained time at the softirq based on xtime and
 * wall_to_monotonic.
 */
136
static void hrtimer_get_softirq_time(struct hrtimer_cpu_base *base)
137 138
{
	ktime_t xtim, tomono;
139
	struct timespec xts, tom;
140 141 142 143
	unsigned long seq;

	do {
		seq = read_seqbegin(&xtime_lock);
J
john stultz 已提交
144 145 146 147 148
#ifdef CONFIG_NO_HZ
		getnstimeofday(&xts);
#else
		xts = xtime;
#endif
149
		tom = wall_to_monotonic;
150 151
	} while (read_seqretry(&xtime_lock, seq));

J
john stultz 已提交
152
	xtim = timespec_to_ktime(xts);
153
	tomono = timespec_to_ktime(tom);
154 155 156
	base->clock_base[CLOCK_REALTIME].softirq_time = xtim;
	base->clock_base[CLOCK_MONOTONIC].softirq_time =
		ktime_add(xtim, tomono);
157 158
}

159 160 161 162 163 164 165 166 167
/*
 * Helper function to check, whether the timer is running the callback
 * function
 */
static inline int hrtimer_callback_running(struct hrtimer *timer)
{
	return timer->state & HRTIMER_STATE_CALLBACK;
}

168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
/*
 * Functions and macros which are different for UP/SMP systems are kept in a
 * single place
 */
#ifdef CONFIG_SMP

/*
 * We are using hashed locking: holding per_cpu(hrtimer_bases)[n].lock
 * means that all timers which are tied to this base via timer->base are
 * locked, and the base itself is locked too.
 *
 * So __run_timers/migrate_timers can safely modify all timers which could
 * be found on the lists/queues.
 *
 * When the timer's base is locked, and the timer removed from list, it is
 * possible to set timer->base = NULL and drop the lock: the timer remains
 * locked.
 */
186 187 188
static
struct hrtimer_clock_base *lock_hrtimer_base(const struct hrtimer *timer,
					     unsigned long *flags)
189
{
190
	struct hrtimer_clock_base *base;
191 192 193 194

	for (;;) {
		base = timer->base;
		if (likely(base != NULL)) {
195
			spin_lock_irqsave(&base->cpu_base->lock, *flags);
196 197 198
			if (likely(base == timer->base))
				return base;
			/* The timer has migrated to another CPU: */
199
			spin_unlock_irqrestore(&base->cpu_base->lock, *flags);
200 201 202 203 204 205 206 207
		}
		cpu_relax();
	}
}

/*
 * Switch the timer base to the current CPU when possible.
 */
208 209
static inline struct hrtimer_clock_base *
switch_hrtimer_base(struct hrtimer *timer, struct hrtimer_clock_base *base)
210
{
211 212
	struct hrtimer_clock_base *new_base;
	struct hrtimer_cpu_base *new_cpu_base;
213

214 215
	new_cpu_base = &__get_cpu_var(hrtimer_bases);
	new_base = &new_cpu_base->clock_base[base->index];
216 217 218 219 220 221 222 223 224 225 226

	if (base != new_base) {
		/*
		 * We are trying to schedule the timer on the local CPU.
		 * However we can't change timer's base while it is running,
		 * so we keep it on the same CPU. No hassle vs. reprogramming
		 * the event source in the high resolution case. The softirq
		 * code will take care of this when the timer function has
		 * completed. There is no conflict as we hold the lock until
		 * the timer is enqueued.
		 */
227
		if (unlikely(hrtimer_callback_running(timer)))
228 229 230 231
			return base;

		/* See the comment in lock_timer_base() */
		timer->base = NULL;
232 233
		spin_unlock(&base->cpu_base->lock);
		spin_lock(&new_base->cpu_base->lock);
234 235 236 237 238 239 240
		timer->base = new_base;
	}
	return new_base;
}

#else /* CONFIG_SMP */

241
static inline struct hrtimer_clock_base *
242 243
lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
{
244
	struct hrtimer_clock_base *base = timer->base;
245

246
	spin_lock_irqsave(&base->cpu_base->lock, *flags);
247 248 249 250

	return base;
}

251
# define switch_hrtimer_base(t, b)	(b)
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281

#endif	/* !CONFIG_SMP */

/*
 * Functions for the union type storage format of ktime_t which are
 * too large for inlining:
 */
#if BITS_PER_LONG < 64
# ifndef CONFIG_KTIME_SCALAR
/**
 * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
 * @kt:		addend
 * @nsec:	the scalar nsec value to add
 *
 * Returns the sum of kt and nsec in ktime_t format
 */
ktime_t ktime_add_ns(const ktime_t kt, u64 nsec)
{
	ktime_t tmp;

	if (likely(nsec < NSEC_PER_SEC)) {
		tmp.tv64 = nsec;
	} else {
		unsigned long rem = do_div(nsec, NSEC_PER_SEC);

		tmp = ktime_set((long)nsec, rem);
	}

	return ktime_add(kt, tmp);
}
282 283

EXPORT_SYMBOL_GPL(ktime_add_ns);
284 285 286 287 288
# endif /* !CONFIG_KTIME_SCALAR */

/*
 * Divide a ktime value by a nanosecond value
 */
289
unsigned long ktime_divns(const ktime_t kt, s64 div)
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
{
	u64 dclc, inc, dns;
	int sft = 0;

	dclc = dns = ktime_to_ns(kt);
	inc = div;
	/* Make sure the divisor is less than 2^32: */
	while (div >> 32) {
		sft++;
		div >>= 1;
	}
	dclc >>= sft;
	do_div(dclc, (unsigned long) div);

	return (unsigned long) dclc;
}
#endif /* BITS_PER_LONG >= 64 */

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
/* High resolution timer related functions */
#ifdef CONFIG_HIGH_RES_TIMERS

/*
 * High resolution timer enabled ?
 */
static int hrtimer_hres_enabled __read_mostly  = 1;

/*
 * Enable / Disable high resolution mode
 */
static int __init setup_hrtimer_hres(char *str)
{
	if (!strcmp(str, "off"))
		hrtimer_hres_enabled = 0;
	else if (!strcmp(str, "on"))
		hrtimer_hres_enabled = 1;
	else
		return 0;
	return 1;
}

__setup("highres=", setup_hrtimer_hres);

/*
 * hrtimer_high_res_enabled - query, if the highres mode is enabled
 */
static inline int hrtimer_is_hres_enabled(void)
{
	return hrtimer_hres_enabled;
}

/*
 * Is the high resolution mode active ?
 */
static inline int hrtimer_hres_active(void)
{
	return __get_cpu_var(hrtimer_bases).hres_active;
}

/*
 * Reprogram the event source with checking both queues for the
 * next event
 * Called with interrupts disabled and base->lock held
 */
static void hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base)
{
	int i;
	struct hrtimer_clock_base *base = cpu_base->clock_base;
	ktime_t expires;

	cpu_base->expires_next.tv64 = KTIME_MAX;

	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {
		struct hrtimer *timer;

		if (!base->first)
			continue;
		timer = rb_entry(base->first, struct hrtimer, node);
		expires = ktime_sub(timer->expires, base->offset);
		if (expires.tv64 < cpu_base->expires_next.tv64)
			cpu_base->expires_next = expires;
	}

	if (cpu_base->expires_next.tv64 != KTIME_MAX)
		tick_program_event(cpu_base->expires_next, 1);
}

/*
 * Shared reprogramming for clock_realtime and clock_monotonic
 *
 * When a timer is enqueued and expires earlier than the already enqueued
 * timers, we have to check, whether it expires earlier than the timer for
 * which the clock event device was armed.
 *
 * Called with interrupts disabled and base->cpu_base.lock held
 */
static int hrtimer_reprogram(struct hrtimer *timer,
			     struct hrtimer_clock_base *base)
{
	ktime_t *expires_next = &__get_cpu_var(hrtimer_bases).expires_next;
	ktime_t expires = ktime_sub(timer->expires, base->offset);
	int res;

	/*
	 * When the callback is running, we do not reprogram the clock event
	 * device. The timer callback is either running on a different CPU or
	 * the callback is executed in the hrtimer_interupt context. The
	 * reprogramming is handled either by the softirq, which called the
	 * callback or at the end of the hrtimer_interrupt.
	 */
	if (hrtimer_callback_running(timer))
		return 0;

	if (expires.tv64 >= expires_next->tv64)
		return 0;

	/*
	 * Clockevents returns -ETIME, when the event was in the past.
	 */
	res = tick_program_event(expires, 0);
	if (!IS_ERR_VALUE(res))
		*expires_next = expires;
	return res;
}


/*
 * Retrigger next event is called after clock was set
 *
 * Called with interrupts disabled via on_each_cpu()
 */
static void retrigger_next_event(void *arg)
{
	struct hrtimer_cpu_base *base;
	struct timespec realtime_offset;
	unsigned long seq;

	if (!hrtimer_hres_active())
		return;

	do {
		seq = read_seqbegin(&xtime_lock);
		set_normalized_timespec(&realtime_offset,
					-wall_to_monotonic.tv_sec,
					-wall_to_monotonic.tv_nsec);
	} while (read_seqretry(&xtime_lock, seq));

	base = &__get_cpu_var(hrtimer_bases);

	/* Adjust CLOCK_REALTIME offset */
	spin_lock(&base->lock);
	base->clock_base[CLOCK_REALTIME].offset =
		timespec_to_ktime(realtime_offset);

	hrtimer_force_reprogram(base);
	spin_unlock(&base->lock);
}

/*
 * Clock realtime was set
 *
 * Change the offset of the realtime clock vs. the monotonic
 * clock.
 *
 * We might have to reprogram the high resolution timer interrupt. On
 * SMP we call the architecture specific code to retrigger _all_ high
 * resolution timer interrupts. On UP we just disable interrupts and
 * call the high resolution interrupt code.
 */
void clock_was_set(void)
{
	/* Retrigger the CPU local events everywhere */
	on_each_cpu(retrigger_next_event, NULL, 0, 1);
}

464 465 466 467 468 469 470 471 472 473 474 475
/*
 * During resume we might have to reprogram the high resolution timer
 * interrupt (on the local CPU):
 */
void hres_timers_resume(void)
{
	WARN_ON_ONCE(num_online_cpus() > 1);

	/* Retrigger the CPU local events: */
	retrigger_next_event(NULL);
}

476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
/*
 * Check, whether the timer is on the callback pending list
 */
static inline int hrtimer_cb_pending(const struct hrtimer *timer)
{
	return timer->state & HRTIMER_STATE_PENDING;
}

/*
 * Remove a timer from the callback pending list
 */
static inline void hrtimer_remove_cb_pending(struct hrtimer *timer)
{
	list_del_init(&timer->cb_entry);
}

/*
 * Initialize the high resolution related parts of cpu_base
 */
static inline void hrtimer_init_hres(struct hrtimer_cpu_base *base)
{
	base->expires_next.tv64 = KTIME_MAX;
	base->hres_active = 0;
	INIT_LIST_HEAD(&base->cb_pending);
}

/*
 * Initialize the high resolution related parts of a hrtimer
 */
static inline void hrtimer_init_timer_hres(struct hrtimer *timer)
{
	INIT_LIST_HEAD(&timer->cb_entry);
}

/*
 * When High resolution timers are active, try to reprogram. Note, that in case
 * the state has HRTIMER_STATE_CALLBACK set, no reprogramming and no expiry
 * check happens. The timer gets enqueued into the rbtree. The reprogramming
 * and expiry check is done in the hrtimer_interrupt or in the softirq.
 */
static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
					    struct hrtimer_clock_base *base)
{
	if (base->cpu_base->hres_active && hrtimer_reprogram(timer, base)) {

		/* Timer is expired, act upon the callback mode */
		switch(timer->cb_mode) {
		case HRTIMER_CB_IRQSAFE_NO_RESTART:
			/*
			 * We can call the callback from here. No restart
			 * happens, so no danger of recursion
			 */
			BUG_ON(timer->function(timer) != HRTIMER_NORESTART);
			return 1;
		case HRTIMER_CB_IRQSAFE_NO_SOFTIRQ:
			/*
			 * This is solely for the sched tick emulation with
			 * dynamic tick support to ensure that we do not
			 * restart the tick right on the edge and end up with
			 * the tick timer in the softirq ! The calling site
			 * takes care of this.
			 */
			return 1;
		case HRTIMER_CB_IRQSAFE:
		case HRTIMER_CB_SOFTIRQ:
			/*
			 * Move everything else into the softirq pending list !
			 */
			list_add_tail(&timer->cb_entry,
				      &base->cpu_base->cb_pending);
			timer->state = HRTIMER_STATE_PENDING;
			raise_softirq(HRTIMER_SOFTIRQ);
			return 1;
		default:
			BUG();
		}
	}
	return 0;
}

/*
 * Switch to high resolution mode
 */
559
static int hrtimer_switch_to_hres(void)
560 561 562 563 564
{
	struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
	unsigned long flags;

	if (base->hres_active)
565
		return 1;
566 567 568 569 570

	local_irq_save(flags);

	if (tick_init_highres()) {
		local_irq_restore(flags);
571
		return 0;
572 573 574 575 576 577 578 579 580 581 582 583
	}
	base->hres_active = 1;
	base->clock_base[CLOCK_REALTIME].resolution = KTIME_HIGH_RES;
	base->clock_base[CLOCK_MONOTONIC].resolution = KTIME_HIGH_RES;

	tick_setup_sched_timer();

	/* "Retrigger" the interrupt to get things going */
	retrigger_next_event(NULL);
	local_irq_restore(flags);
	printk(KERN_INFO "Switched to high resolution mode on CPU %d\n",
	       smp_processor_id());
584
	return 1;
585 586 587 588 589 590
}

#else

static inline int hrtimer_hres_active(void) { return 0; }
static inline int hrtimer_is_hres_enabled(void) { return 0; }
591
static inline int hrtimer_switch_to_hres(void) { return 0; }
592 593 594 595 596 597 598 599 600 601 602 603 604
static inline void hrtimer_force_reprogram(struct hrtimer_cpu_base *base) { }
static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
					    struct hrtimer_clock_base *base)
{
	return 0;
}
static inline int hrtimer_cb_pending(struct hrtimer *timer) { return 0; }
static inline void hrtimer_remove_cb_pending(struct hrtimer *timer) { }
static inline void hrtimer_init_hres(struct hrtimer_cpu_base *base) { }
static inline void hrtimer_init_timer_hres(struct hrtimer *timer) { }

#endif /* CONFIG_HIGH_RES_TIMERS */

605 606 607 608 609 610 611 612 613 614 615 616
#ifdef CONFIG_TIMER_STATS
void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer, void *addr)
{
	if (timer->start_site)
		return;

	timer->start_site = addr;
	memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
	timer->start_pid = current->pid;
}
#endif

617 618 619 620 621 622
/*
 * Counterpart to lock_timer_base above:
 */
static inline
void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
{
623
	spin_unlock_irqrestore(&timer->base->cpu_base->lock, *flags);
624 625 626 627 628
}

/**
 * hrtimer_forward - forward the timer expiry
 * @timer:	hrtimer to forward
629
 * @now:	forward past this time
630 631 632
 * @interval:	the interval to forward
 *
 * Forward the timer expiry so it will expire in the future.
J
Jonathan Corbet 已提交
633
 * Returns the number of overruns.
634 635
 */
unsigned long
636
hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval)
637 638
{
	unsigned long orun = 1;
639
	ktime_t delta;
640 641 642 643 644 645

	delta = ktime_sub(now, timer->expires);

	if (delta.tv64 < 0)
		return 0;

646 647 648
	if (interval.tv64 < timer->base->resolution.tv64)
		interval.tv64 = timer->base->resolution.tv64;

649
	if (unlikely(delta.tv64 >= interval.tv64)) {
650
		s64 incr = ktime_to_ns(interval);
651 652 653 654 655 656 657 658 659 660 661 662

		orun = ktime_divns(delta, incr);
		timer->expires = ktime_add_ns(timer->expires, incr * orun);
		if (timer->expires.tv64 > now.tv64)
			return orun;
		/*
		 * This (and the ktime_add() below) is the
		 * correction for exact:
		 */
		orun++;
	}
	timer->expires = ktime_add(timer->expires, interval);
663 664 665 666 667 668
	/*
	 * Make sure, that the result did not wrap with a very large
	 * interval.
	 */
	if (timer->expires.tv64 < 0)
		timer->expires = ktime_set(KTIME_SEC_MAX, 0);
669 670 671 672 673 674 675 676 677 678

	return orun;
}

/*
 * enqueue_hrtimer - internal function to (re)start a timer
 *
 * The timer is inserted in expiry order. Insertion into the
 * red black tree is O(log(n)). Must hold the base lock.
 */
679
static void enqueue_hrtimer(struct hrtimer *timer,
680
			    struct hrtimer_clock_base *base, int reprogram)
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
{
	struct rb_node **link = &base->active.rb_node;
	struct rb_node *parent = NULL;
	struct hrtimer *entry;

	/*
	 * Find the right place in the rbtree:
	 */
	while (*link) {
		parent = *link;
		entry = rb_entry(parent, struct hrtimer, node);
		/*
		 * We dont care about collisions. Nodes with
		 * the same expiry time stay together.
		 */
		if (timer->expires.tv64 < entry->expires.tv64)
			link = &(*link)->rb_left;
698
		else
699 700 701 702
			link = &(*link)->rb_right;
	}

	/*
703 704
	 * Insert the timer to the rbtree and check whether it
	 * replaces the first pending timer
705
	 */
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
	if (!base->first || timer->expires.tv64 <
	    rb_entry(base->first, struct hrtimer, node)->expires.tv64) {
		/*
		 * Reprogram the clock event device. When the timer is already
		 * expired hrtimer_enqueue_reprogram has either called the
		 * callback or added it to the pending list and raised the
		 * softirq.
		 *
		 * This is a NOP for !HIGHRES
		 */
		if (reprogram && hrtimer_enqueue_reprogram(timer, base))
			return;

		base->first = &timer->node;
	}

722 723
	rb_link_node(&timer->node, parent, link);
	rb_insert_color(&timer->node, &base->active);
724 725 726 727 728
	/*
	 * HRTIMER_STATE_ENQUEUED is or'ed to the current state to preserve the
	 * state of a possibly running callback.
	 */
	timer->state |= HRTIMER_STATE_ENQUEUED;
729
}
730 731 732 733 734

/*
 * __remove_hrtimer - internal function to remove a timer
 *
 * Caller must hold the base lock.
735 736 737 738 739
 *
 * High resolution timer mode reprograms the clock event device when the
 * timer is the one which expires next. The caller can disable this by setting
 * reprogram to zero. This is useful, when the context does a reprogramming
 * anyway (e.g. timer interrupt)
740
 */
741
static void __remove_hrtimer(struct hrtimer *timer,
742
			     struct hrtimer_clock_base *base,
743
			     unsigned long newstate, int reprogram)
744
{
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
	/* High res. callback list. NOP for !HIGHRES */
	if (hrtimer_cb_pending(timer))
		hrtimer_remove_cb_pending(timer);
	else {
		/*
		 * Remove the timer from the rbtree and replace the
		 * first entry pointer if necessary.
		 */
		if (base->first == &timer->node) {
			base->first = rb_next(&timer->node);
			/* Reprogram the clock event device. if enabled */
			if (reprogram && hrtimer_hres_active())
				hrtimer_force_reprogram(base->cpu_base);
		}
		rb_erase(&timer->node, &base->active);
	}
761
	timer->state = newstate;
762 763 764 765 766 767
}

/*
 * remove hrtimer, called with base lock held
 */
static inline int
768
remove_hrtimer(struct hrtimer *timer, struct hrtimer_clock_base *base)
769
{
770
	if (hrtimer_is_queued(timer)) {
771 772 773 774 775 776 777 778 779 780
		int reprogram;

		/*
		 * Remove the timer and force reprogramming when high
		 * resolution mode is active and the timer is on the current
		 * CPU. If we remove a timer on another CPU, reprogramming is
		 * skipped. The interrupt event on this CPU is fired and
		 * reprogramming happens in the interrupt handler. This is a
		 * rare case and less expensive than a smp call.
		 */
781
		timer_stats_hrtimer_clear_start_info(timer);
782 783 784
		reprogram = base->cpu_base == &__get_cpu_var(hrtimer_bases);
		__remove_hrtimer(timer, base, HRTIMER_STATE_INACTIVE,
				 reprogram);
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
		return 1;
	}
	return 0;
}

/**
 * hrtimer_start - (re)start an relative timer on the current CPU
 * @timer:	the timer to be added
 * @tim:	expiry time
 * @mode:	expiry mode: absolute (HRTIMER_ABS) or relative (HRTIMER_REL)
 *
 * Returns:
 *  0 on success
 *  1 when the timer was active
 */
int
hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
{
803
	struct hrtimer_clock_base *base, *new_base;
804 805 806 807 808 809 810 811 812 813 814
	unsigned long flags;
	int ret;

	base = lock_hrtimer_base(timer, &flags);

	/* Remove an active timer from the queue: */
	ret = remove_hrtimer(timer, base);

	/* Switch the timer base, if necessary: */
	new_base = switch_hrtimer_base(timer, base);

815
	if (mode == HRTIMER_MODE_REL) {
816
		tim = ktime_add(tim, new_base->get_time());
817 818 819 820 821 822 823 824 825 826 827
		/*
		 * CONFIG_TIME_LOW_RES is a temporary way for architectures
		 * to signal that they simply return xtime in
		 * do_gettimeoffset(). In this case we want to round up by
		 * resolution when starting a relative timer, to avoid short
		 * timeouts. This will go away with the GTOD framework.
		 */
#ifdef CONFIG_TIME_LOW_RES
		tim = ktime_add(tim, base->resolution);
#endif
	}
828 829
	timer->expires = tim;

830 831
	timer_stats_hrtimer_set_start_info(timer);

832 833 834 835 836 837
	/*
	 * Only allow reprogramming if the new base is on this CPU.
	 * (it might still be on another CPU if the timer was pending)
	 */
	enqueue_hrtimer(timer, new_base,
			new_base->cpu_base == &__get_cpu_var(hrtimer_bases));
838 839 840 841 842

	unlock_hrtimer_base(timer, &flags);

	return ret;
}
843
EXPORT_SYMBOL_GPL(hrtimer_start);
844 845 846 847 848 849 850 851 852

/**
 * hrtimer_try_to_cancel - try to deactivate a timer
 * @timer:	hrtimer to stop
 *
 * Returns:
 *  0 when the timer was not active
 *  1 when the timer was active
 * -1 when the timer is currently excuting the callback function and
853
 *    cannot be stopped
854 855 856
 */
int hrtimer_try_to_cancel(struct hrtimer *timer)
{
857
	struct hrtimer_clock_base *base;
858 859 860 861 862
	unsigned long flags;
	int ret = -1;

	base = lock_hrtimer_base(timer, &flags);

863
	if (!hrtimer_callback_running(timer))
864 865 866 867 868 869 870
		ret = remove_hrtimer(timer, base);

	unlock_hrtimer_base(timer, &flags);

	return ret;

}
871
EXPORT_SYMBOL_GPL(hrtimer_try_to_cancel);
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887

/**
 * hrtimer_cancel - cancel a timer and wait for the handler to finish.
 * @timer:	the timer to be cancelled
 *
 * Returns:
 *  0 when the timer was not active
 *  1 when the timer was active
 */
int hrtimer_cancel(struct hrtimer *timer)
{
	for (;;) {
		int ret = hrtimer_try_to_cancel(timer);

		if (ret >= 0)
			return ret;
888
		cpu_relax();
889 890
	}
}
891
EXPORT_SYMBOL_GPL(hrtimer_cancel);
892 893 894 895 896 897 898

/**
 * hrtimer_get_remaining - get remaining time for the timer
 * @timer:	the timer to read
 */
ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
{
899
	struct hrtimer_clock_base *base;
900 901 902 903
	unsigned long flags;
	ktime_t rem;

	base = lock_hrtimer_base(timer, &flags);
904
	rem = ktime_sub(timer->expires, base->get_time());
905 906 907 908
	unlock_hrtimer_base(timer, &flags);

	return rem;
}
909
EXPORT_SYMBOL_GPL(hrtimer_get_remaining);
910

911
#if defined(CONFIG_NO_IDLE_HZ) || defined(CONFIG_NO_HZ)
912 913 914 915 916 917 918 919
/**
 * hrtimer_get_next_event - get the time until next expiry event
 *
 * Returns the delta to the next expiry event or KTIME_MAX if no timer
 * is pending.
 */
ktime_t hrtimer_get_next_event(void)
{
920 921
	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
	struct hrtimer_clock_base *base = cpu_base->clock_base;
922 923 924 925
	ktime_t delta, mindelta = { .tv64 = KTIME_MAX };
	unsigned long flags;
	int i;

926 927
	spin_lock_irqsave(&cpu_base->lock, flags);

928 929 930
	if (!hrtimer_hres_active()) {
		for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {
			struct hrtimer *timer;
931

932 933
			if (!base->first)
				continue;
934

935 936 937 938 939 940
			timer = rb_entry(base->first, struct hrtimer, node);
			delta.tv64 = timer->expires.tv64;
			delta = ktime_sub(delta, base->get_time());
			if (delta.tv64 < mindelta.tv64)
				mindelta.tv64 = delta.tv64;
		}
941
	}
942 943 944

	spin_unlock_irqrestore(&cpu_base->lock, flags);

945 946 947 948 949 950
	if (mindelta.tv64 < 0)
		mindelta.tv64 = 0;
	return mindelta;
}
#endif

951
/**
952 953
 * hrtimer_init - initialize a timer to the given clock
 * @timer:	the timer to be initialized
954
 * @clock_id:	the clock to be used
955
 * @mode:	timer mode abs/rel
956
 */
957 958
void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
		  enum hrtimer_mode mode)
959
{
960
	struct hrtimer_cpu_base *cpu_base;
961

962 963
	memset(timer, 0, sizeof(struct hrtimer));

964
	cpu_base = &__raw_get_cpu_var(hrtimer_bases);
965

966
	if (clock_id == CLOCK_REALTIME && mode != HRTIMER_MODE_ABS)
967 968
		clock_id = CLOCK_MONOTONIC;

969
	timer->base = &cpu_base->clock_base[clock_id];
970
	hrtimer_init_timer_hres(timer);
971 972 973 974 975 976

#ifdef CONFIG_TIMER_STATS
	timer->start_site = NULL;
	timer->start_pid = -1;
	memset(timer->start_comm, 0, TASK_COMM_LEN);
#endif
977
}
978
EXPORT_SYMBOL_GPL(hrtimer_init);
979 980 981 982 983 984

/**
 * hrtimer_get_res - get the timer resolution for a clock
 * @which_clock: which clock to query
 * @tp:		 pointer to timespec variable to store the resolution
 *
985 986
 * Store the resolution of the clock selected by @which_clock in the
 * variable pointed to by @tp.
987 988 989
 */
int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
{
990
	struct hrtimer_cpu_base *cpu_base;
991

992 993
	cpu_base = &__raw_get_cpu_var(hrtimer_bases);
	*tp = ktime_to_timespec(cpu_base->clock_base[which_clock].resolution);
994 995 996

	return 0;
}
997
EXPORT_SYMBOL_GPL(hrtimer_get_res);
998

999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
#ifdef CONFIG_HIGH_RES_TIMERS

/*
 * High resolution timer interrupt
 * Called with interrupts disabled
 */
void hrtimer_interrupt(struct clock_event_device *dev)
{
	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
	struct hrtimer_clock_base *base;
	ktime_t expires_next, now;
	int i, raise = 0;

	BUG_ON(!cpu_base->hres_active);
	cpu_base->nr_events++;
	dev->next_event.tv64 = KTIME_MAX;

 retry:
	now = ktime_get();

	expires_next.tv64 = KTIME_MAX;

	base = cpu_base->clock_base;

	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
		ktime_t basenow;
		struct rb_node *node;

		spin_lock(&cpu_base->lock);

		basenow = ktime_add(now, base->offset);

		while ((node = base->first)) {
			struct hrtimer *timer;

			timer = rb_entry(node, struct hrtimer, node);

			if (basenow.tv64 < timer->expires.tv64) {
				ktime_t expires;

				expires = ktime_sub(timer->expires,
						    base->offset);
				if (expires.tv64 < expires_next.tv64)
					expires_next = expires;
				break;
			}

			/* Move softirq callbacks to the pending list */
			if (timer->cb_mode == HRTIMER_CB_SOFTIRQ) {
				__remove_hrtimer(timer, base,
						 HRTIMER_STATE_PENDING, 0);
				list_add_tail(&timer->cb_entry,
					      &base->cpu_base->cb_pending);
				raise = 1;
				continue;
			}

			__remove_hrtimer(timer, base,
					 HRTIMER_STATE_CALLBACK, 0);
1058
			timer_stats_account_hrtimer(timer);
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102

			/*
			 * Note: We clear the CALLBACK bit after
			 * enqueue_hrtimer to avoid reprogramming of
			 * the event hardware. This happens at the end
			 * of this function anyway.
			 */
			if (timer->function(timer) != HRTIMER_NORESTART) {
				BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
				enqueue_hrtimer(timer, base, 0);
			}
			timer->state &= ~HRTIMER_STATE_CALLBACK;
		}
		spin_unlock(&cpu_base->lock);
		base++;
	}

	cpu_base->expires_next = expires_next;

	/* Reprogramming necessary ? */
	if (expires_next.tv64 != KTIME_MAX) {
		if (tick_program_event(expires_next, 0))
			goto retry;
	}

	/* Raise softirq ? */
	if (raise)
		raise_softirq(HRTIMER_SOFTIRQ);
}

static void run_hrtimer_softirq(struct softirq_action *h)
{
	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);

	spin_lock_irq(&cpu_base->lock);

	while (!list_empty(&cpu_base->cb_pending)) {
		enum hrtimer_restart (*fn)(struct hrtimer *);
		struct hrtimer *timer;
		int restart;

		timer = list_entry(cpu_base->cb_pending.next,
				   struct hrtimer, cb_entry);

1103 1104
		timer_stats_account_hrtimer(timer);

1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
		fn = timer->function;
		__remove_hrtimer(timer, timer->base, HRTIMER_STATE_CALLBACK, 0);
		spin_unlock_irq(&cpu_base->lock);

		restart = fn(timer);

		spin_lock_irq(&cpu_base->lock);

		timer->state &= ~HRTIMER_STATE_CALLBACK;
		if (restart == HRTIMER_RESTART) {
			BUG_ON(hrtimer_active(timer));
			/*
			 * Enqueue the timer, allow reprogramming of the event
			 * device
			 */
			enqueue_hrtimer(timer, timer->base, 1);
		} else if (hrtimer_active(timer)) {
			/*
			 * If the timer was rearmed on another CPU, reprogram
			 * the event device.
			 */
			if (timer->base->first == &timer->node)
				hrtimer_reprogram(timer, timer->base);
		}
	}
	spin_unlock_irq(&cpu_base->lock);
}

#endif	/* CONFIG_HIGH_RES_TIMERS */

1135 1136 1137
/*
 * Expire the per base hrtimer-queue:
 */
1138 1139
static inline void run_hrtimer_queue(struct hrtimer_cpu_base *cpu_base,
				     int index)
1140
{
1141
	struct rb_node *node;
1142
	struct hrtimer_clock_base *base = &cpu_base->clock_base[index];
1143

1144 1145 1146
	if (!base->first)
		return;

1147 1148 1149
	if (base->get_softirq_time)
		base->softirq_time = base->get_softirq_time();

1150
	spin_lock_irq(&cpu_base->lock);
1151

1152
	while ((node = base->first)) {
1153
		struct hrtimer *timer;
1154
		enum hrtimer_restart (*fn)(struct hrtimer *);
1155 1156
		int restart;

1157
		timer = rb_entry(node, struct hrtimer, node);
1158
		if (base->softirq_time.tv64 <= timer->expires.tv64)
1159 1160
			break;

1161 1162 1163
#ifdef CONFIG_HIGH_RES_TIMERS
		WARN_ON_ONCE(timer->cb_mode == HRTIMER_CB_IRQSAFE_NO_SOFTIRQ);
#endif
1164 1165
		timer_stats_account_hrtimer(timer);

1166
		fn = timer->function;
1167
		__remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);
1168
		spin_unlock_irq(&cpu_base->lock);
1169

1170
		restart = fn(timer);
1171

1172
		spin_lock_irq(&cpu_base->lock);
1173

1174
		timer->state &= ~HRTIMER_STATE_CALLBACK;
1175 1176
		if (restart != HRTIMER_NORESTART) {
			BUG_ON(hrtimer_active(timer));
1177
			enqueue_hrtimer(timer, base, 0);
1178
		}
1179
	}
1180
	spin_unlock_irq(&cpu_base->lock);
1181 1182 1183 1184
}

/*
 * Called from timer softirq every jiffy, expire hrtimers:
1185 1186 1187 1188
 *
 * For HRT its the fall back code to run the softirq in the timer
 * softirq context in case the hrtimer initialization failed or has
 * not been done yet.
1189 1190 1191
 */
void hrtimer_run_queues(void)
{
1192
	struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
1193 1194
	int i;

1195 1196 1197
	if (hrtimer_hres_active())
		return;

1198 1199 1200 1201 1202 1203 1204 1205
	/*
	 * This _is_ ugly: We have to check in the softirq context,
	 * whether we can switch to highres and / or nohz mode. The
	 * clocksource switch happens in the timer interrupt with
	 * xtime_lock held. Notification from there only sets the
	 * check bit in the tick_oneshot code, otherwise we might
	 * deadlock vs. xtime_lock.
	 */
1206
	if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
1207 1208
		if (hrtimer_switch_to_hres())
			return;
1209

1210
	hrtimer_get_softirq_time(cpu_base);
1211

1212 1213
	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)
		run_hrtimer_queue(cpu_base, i);
1214 1215
}

1216 1217 1218
/*
 * Sleep related functions:
 */
1219
static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer)
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
{
	struct hrtimer_sleeper *t =
		container_of(timer, struct hrtimer_sleeper, timer);
	struct task_struct *task = t->task;

	t->task = NULL;
	if (task)
		wake_up_process(task);

	return HRTIMER_NORESTART;
}

1232
void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
1233 1234 1235
{
	sl->timer.function = hrtimer_wakeup;
	sl->task = task;
1236 1237 1238
#ifdef CONFIG_HIGH_RES_TIMERS
	sl->timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_RESTART;
#endif
1239 1240
}

1241
static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
1242
{
1243
	hrtimer_init_sleeper(t, current);
1244

1245 1246 1247 1248
	do {
		set_current_state(TASK_INTERRUPTIBLE);
		hrtimer_start(&t->timer, t->timer.expires, mode);

1249 1250
		if (likely(t->task))
			schedule();
1251

1252
		hrtimer_cancel(&t->timer);
1253
		mode = HRTIMER_MODE_ABS;
1254 1255

	} while (t->task && !signal_pending(current));
1256

1257
	return t->task == NULL;
1258 1259
}

1260
long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
1261
{
1262
	struct hrtimer_sleeper t;
1263 1264
	struct timespec __user *rmtp;
	struct timespec tu;
1265
	ktime_t time;
1266 1267 1268

	restart->fn = do_no_restart_syscall;

1269
	hrtimer_init(&t.timer, restart->arg0, HRTIMER_MODE_ABS);
1270
	t.timer.expires.tv64 = ((u64)restart->arg3 << 32) | (u64) restart->arg2;
1271

1272
	if (do_nanosleep(&t, HRTIMER_MODE_ABS))
1273 1274
		return 0;

1275
	rmtp = (struct timespec __user *) restart->arg1;
1276 1277 1278 1279 1280 1281 1282 1283
	if (rmtp) {
		time = ktime_sub(t.timer.expires, t.timer.base->get_time());
		if (time.tv64 <= 0)
			return 0;
		tu = ktime_to_timespec(time);
		if (copy_to_user(rmtp, &tu, sizeof(tu)))
			return -EFAULT;
	}
1284

1285
	restart->fn = hrtimer_nanosleep_restart;
1286 1287 1288 1289 1290 1291 1292 1293 1294

	/* The other values in restart are already filled in */
	return -ERESTART_RESTARTBLOCK;
}

long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
		       const enum hrtimer_mode mode, const clockid_t clockid)
{
	struct restart_block *restart;
1295
	struct hrtimer_sleeper t;
1296 1297 1298
	struct timespec tu;
	ktime_t rem;

1299 1300 1301
	hrtimer_init(&t.timer, clockid, mode);
	t.timer.expires = timespec_to_ktime(*rqtp);
	if (do_nanosleep(&t, mode))
1302 1303
		return 0;

1304
	/* Absolute timers do not update the rmtp value and restart: */
1305
	if (mode == HRTIMER_MODE_ABS)
1306 1307
		return -ERESTARTNOHAND;

1308 1309 1310 1311 1312 1313 1314 1315
	if (rmtp) {
		rem = ktime_sub(t.timer.expires, t.timer.base->get_time());
		if (rem.tv64 <= 0)
			return 0;
		tu = ktime_to_timespec(rem);
		if (copy_to_user(rmtp, &tu, sizeof(tu)))
			return -EFAULT;
	}
1316 1317

	restart = &current_thread_info()->restart_block;
1318 1319 1320 1321 1322
	restart->fn = hrtimer_nanosleep_restart;
	restart->arg0 = (unsigned long) t.timer.base->index;
	restart->arg1 = (unsigned long) rmtp;
	restart->arg2 = t.timer.expires.tv64 & 0xFFFFFFFF;
	restart->arg3 = t.timer.expires.tv64 >> 32;
1323 1324 1325 1326

	return -ERESTART_RESTARTBLOCK;
}

1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
asmlinkage long
sys_nanosleep(struct timespec __user *rqtp, struct timespec __user *rmtp)
{
	struct timespec tu;

	if (copy_from_user(&tu, rqtp, sizeof(tu)))
		return -EFAULT;

	if (!timespec_valid(&tu))
		return -EINVAL;

1338
	return hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
1339 1340
}

1341 1342 1343 1344 1345
/*
 * Functions related to boot-time initialization:
 */
static void __devinit init_hrtimers_cpu(int cpu)
{
1346
	struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);
1347 1348
	int i;

1349 1350 1351 1352 1353 1354
	spin_lock_init(&cpu_base->lock);
	lockdep_set_class(&cpu_base->lock, &cpu_base->lock_key);

	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)
		cpu_base->clock_base[i].cpu_base = cpu_base;

1355
	hrtimer_init_hres(cpu_base);
1356 1357 1358 1359
}

#ifdef CONFIG_HOTPLUG_CPU

1360 1361
static void migrate_hrtimer_list(struct hrtimer_clock_base *old_base,
				struct hrtimer_clock_base *new_base)
1362 1363 1364 1365 1366 1367
{
	struct hrtimer *timer;
	struct rb_node *node;

	while ((node = rb_first(&old_base->active))) {
		timer = rb_entry(node, struct hrtimer, node);
1368 1369
		BUG_ON(hrtimer_callback_running(timer));
		__remove_hrtimer(timer, old_base, HRTIMER_STATE_INACTIVE, 0);
1370
		timer->base = new_base;
1371 1372 1373 1374
		/*
		 * Enqueue the timer. Allow reprogramming of the event device
		 */
		enqueue_hrtimer(timer, new_base, 1);
1375 1376 1377 1378 1379
	}
}

static void migrate_hrtimers(int cpu)
{
1380
	struct hrtimer_cpu_base *old_base, *new_base;
1381 1382 1383
	int i;

	BUG_ON(cpu_online(cpu));
1384 1385
	old_base = &per_cpu(hrtimer_bases, cpu);
	new_base = &get_cpu_var(hrtimer_bases);
1386

1387 1388
	tick_cancel_sched_timer(cpu);

1389
	local_irq_disable();
1390 1391
	double_spin_lock(&new_base->lock, &old_base->lock,
			 smp_processor_id() < cpu);
1392

1393 1394 1395
	for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
		migrate_hrtimer_list(&old_base->clock_base[i],
				     &new_base->clock_base[i]);
1396 1397
	}

1398 1399
	double_spin_unlock(&new_base->lock, &old_base->lock,
			   smp_processor_id() < cpu);
1400 1401 1402 1403 1404
	local_irq_enable();
	put_cpu_var(hrtimer_bases);
}
#endif /* CONFIG_HOTPLUG_CPU */

1405
static int __cpuinit hrtimer_cpu_notify(struct notifier_block *self,
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
					unsigned long action, void *hcpu)
{
	long cpu = (long)hcpu;

	switch (action) {

	case CPU_UP_PREPARE:
		init_hrtimers_cpu(cpu);
		break;

#ifdef CONFIG_HOTPLUG_CPU
	case CPU_DEAD:
1418
		clockevents_notify(CLOCK_EVT_NOTIFY_CPU_DEAD, &cpu);
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
		migrate_hrtimers(cpu);
		break;
#endif

	default:
		break;
	}

	return NOTIFY_OK;
}

1430
static struct notifier_block __cpuinitdata hrtimers_nb = {
1431 1432 1433 1434 1435 1436 1437 1438
	.notifier_call = hrtimer_cpu_notify,
};

void __init hrtimers_init(void)
{
	hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE,
			  (void *)(long)smp_processor_id());
	register_cpu_notifier(&hrtimers_nb);
1439 1440 1441
#ifdef CONFIG_HIGH_RES_TIMERS
	open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq, NULL);
#endif
1442 1443
}