kernel/time/tick-common.c

   1 /*
   2  * linux/kernel/time/tick-common.c
   3  *
   4  * This file contains the base functions to manage periodic tick
   5  * related events.
   6  *
   7  * Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
   8  * Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
   9  * Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
  10  *
  11  * This code is licenced under the GPL version 2. For details see
  12  * kernel-base/COPYING.
  13  */
  14 #include <linux/cpu.h>
  15 #include <linux/err.h>
  16 #include <linux/hrtimer.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/nmi.h>
  19 #include <linux/percpu.h>
  20 #include <linux/profile.h>
  21 #include <linux/sched.h>
  22 #include <linux/module.h>
  23 #include <trace/events/power.h>
  24
  25 #include <asm/irq_regs.h>
  26
  27 #include "tick-internal.h"
  28
  29 /*
  30  * Tick devices
  31  */
  32 DEFINE_PER_CPU(struct tick_device, tick_cpu_device);
  33 /*
  34  * Tick next event: keeps track of the tick time
  35  */
  36 ktime_t tick_next_period;
  37 ktime_t tick_period;
  38
  39 /*
  40  * tick_do_timer_cpu is a timer core internal variable which holds the CPU NR
  41  * which is responsible for calling do_timer(), i.e. the timekeeping stuff. This
  42  * variable has two functions:
  43  *
  44  * 1) Prevent a thundering herd issue of a gazillion of CPUs trying to grab the
  45  *    timekeeping lock all at once. Only the CPU which is assigned to do the
  46  *    update is handling it.
  47  *
  48  * 2) Hand off the duty in the NOHZ idle case by setting the value to
  49  *    TICK_DO_TIMER_NONE, i.e. a non existing CPU. So the next cpu which looks
  50  *    at it will take over and keep the time keeping alive.  The handover
  51  *    procedure also covers cpu hotplug.
  52  */
  53 int tick_do_timer_cpu __read_mostly = TICK_DO_TIMER_BOOT;
  54
  55 /*
  56  * Debugging: see timer_list.c
  57  */
  58 struct tick_device *tick_get_device(int cpu)
  59 {
  60         return &per_cpu(tick_cpu_device, cpu);
  61 }
  62
  63 /**
  64  * tick_is_oneshot_available - check for a oneshot capable event device
  65  */
  66 int tick_is_oneshot_available(void)
  67 {
  68         struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev);
  69
  70         if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT))
  71                 return 0;
  72         if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
  73                 return 1;
  74         return tick_broadcast_oneshot_available();
  75 }
  76
  77 /*
  78  * Periodic tick
  79  */
  80 static void tick_periodic(int cpu)
  81 {
  82         if (tick_do_timer_cpu == cpu) {
  83                 write_seqlock(&jiffies_lock);
  84
  85                 /* Keep track of the next tick event */
  86                 tick_next_period = ktime_add(tick_next_period, tick_period);
  87
  88                 do_timer(1);
  89                 write_sequnlock(&jiffies_lock);
  90                 update_wall_time();
  91         }
  92
  93         update_process_times(user_mode(get_irq_regs()));
  94         profile_tick(CPU_PROFILING);
  95 }
  96
  97 /*
  98  * Event handler for periodic ticks
  99  */
 100 void tick_handle_periodic(struct clock_event_device *dev)
 101 {
 102         int cpu = smp_processor_id();
 103         ktime_t next = dev->next_event;
 104
 105         tick_periodic(cpu);
 106
 107 #if defined(CONFIG_HIGH_RES_TIMERS) || defined(CONFIG_NO_HZ_COMMON)
 108         /*
 109          * The cpu might have transitioned to HIGHRES or NOHZ mode via
 110          * update_process_times() -> run_local_timers() ->
 111          * hrtimer_run_queues().
 112          */
 113         if (dev->event_handler != tick_handle_periodic)
 114                 return;
 115 #endif
 116
 117         if (!clockevent_state_oneshot(dev))
 118                 return;
 119         for (;;) {
 120                 /*
 121                  * Setup the next period for devices, which do not have
 122                  * periodic mode:
 123                  */
 124                 next = ktime_add(next, tick_period);
 125
 126                 if (!clockevents_program_event(dev, next, false))
 127                         return;
 128                 /*
 129                  * Have to be careful here. If we're in oneshot mode,
 130                  * before we call tick_periodic() in a loop, we need
 131                  * to be sure we're using a real hardware clocksource.
 132                  * Otherwise we could get trapped in an infinite
 133                  * loop, as the tick_periodic() increments jiffies,
 134                  * which then will increment time, possibly causing
 135                  * the loop to trigger again and again.
 136                  */
 137                 if (timekeeping_valid_for_hres())
 138                         tick_periodic(cpu);
 139         }
 140 }
 141
 142 /*
 143  * Setup the device for a periodic tick
 144  */
 145 void tick_setup_periodic(struct clock_event_device *dev, int broadcast)
 146 {
 147         tick_set_periodic_handler(dev, broadcast);
 148
 149         /* Broadcast setup ? */
 150         if (!tick_device_is_functional(dev))
 151                 return;
 152
 153         if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) &&
 154             !tick_broadcast_oneshot_active()) {
 155                 clockevents_switch_state(dev, CLOCK_EVT_STATE_PERIODIC);
 156         } else {
 157                 unsigned long seq;
 158                 ktime_t next;
 159
 160                 do {
 161                         seq = read_seqbegin(&jiffies_lock);
 162                         next = tick_next_period;
 163                 } while (read_seqretry(&jiffies_lock, seq));
 164
 165                 clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT);
 166
 167                 for (;;) {
 168                         if (!clockevents_program_event(dev, next, false))
 169                                 return;
 170                         next = ktime_add(next, tick_period);
 171                 }
 172         }
 173 }
 174
 175 /*
 176  * Setup the tick device
 177  */
 178 static void tick_setup_device(struct tick_device *td,
 179                               struct clock_event_device *newdev, int cpu,
 180                               const struct cpumask *cpumask)
 181 {
 182         void (*handler)(struct clock_event_device *) = NULL;
 183         ktime_t next_event = 0;
 184
 185         /*
 186          * First device setup ?
 187          */
 188         if (!td->evtdev) {
 189                 /*
 190                  * If no cpu took the do_timer update, assign it to
 191                  * this cpu:
 192                  */
 193                 if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {
 194                         if (!tick_nohz_full_cpu(cpu))
 195                                 tick_do_timer_cpu = cpu;
 196                         else
 197                                 tick_do_timer_cpu = TICK_DO_TIMER_NONE;
 198                         tick_next_period = ktime_get();
 199                         tick_period = NSEC_PER_SEC / HZ;
 200                 }
 201
 202                 /*
 203                  * Startup in periodic mode first.
 204                  */
 205                 td->mode = TICKDEV_MODE_PERIODIC;
 206         } else {
 207                 handler = td->evtdev->event_handler;
 208                 next_event = td->evtdev->next_event;
 209                 td->evtdev->event_handler = clockevents_handle_noop;
 210         }
 211
 212         td->evtdev = newdev;
 213
 214         /*
 215          * When the device is not per cpu, pin the interrupt to the
 216          * current cpu:
 217          */
 218         if (!cpumask_equal(newdev->cpumask, cpumask))
 219                 irq_set_affinity(newdev->irq, cpumask);
 220
 221         /*
 222          * When global broadcasting is active, check if the current
 223          * device is registered as a placeholder for broadcast mode.
 224          * This allows us to handle this x86 misfeature in a generic
 225          * way. This function also returns !=0 when we keep the
 226          * current active broadcast state for this CPU.
 227          */
 228         if (tick_device_uses_broadcast(newdev, cpu))
 229                 return;
 230
 231         if (td->mode == TICKDEV_MODE_PERIODIC)
 232                 tick_setup_periodic(newdev, 0);
 233         else
 234                 tick_setup_oneshot(newdev, handler, next_event);
 235 }
 236
 237 void tick_install_replacement(struct clock_event_device *newdev)
 238 {
 239         struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
 240         int cpu = smp_processor_id();
 241
 242         clockevents_exchange_device(td->evtdev, newdev);
 243         tick_setup_device(td, newdev, cpu, cpumask_of(cpu));
 244         if (newdev->features & CLOCK_EVT_FEAT_ONESHOT)
 245                 tick_oneshot_notify();
 246 }
 247
 248 static bool tick_check_percpu(struct clock_event_device *curdev,
 249                               struct clock_event_device *newdev, int cpu)
 250 {
 251         if (!cpumask_test_cpu(cpu, newdev->cpumask))
 252                 return false;
 253         if (cpumask_equal(newdev->cpumask, cpumask_of(cpu)))
 254                 return true;
 255         /* Check if irq affinity can be set */
 256         if (newdev->irq >= 0 && !irq_can_set_affinity(newdev->irq))
 257                 return false;
 258         /* Prefer an existing cpu local device */
 259         if (curdev && cpumask_equal(curdev->cpumask, cpumask_of(cpu)))
 260                 return false;
 261         return true;
 262 }
 263
 264 static bool tick_check_preferred(struct clock_event_device *curdev,
 265                                  struct clock_event_device *newdev)
 266 {
 267         /* Prefer oneshot capable device */
 268         if (!(newdev->features & CLOCK_EVT_FEAT_ONESHOT)) {
 269                 if (curdev && (curdev->features & CLOCK_EVT_FEAT_ONESHOT))
 270                         return false;
 271                 if (tick_oneshot_mode_active())
 272                         return false;
 273         }
 274
 275         /*
 276          * Use the higher rated one, but prefer a CPU local device with a lower
 277          * rating than a non-CPU local device
 278          */
 279         return !curdev ||
 280                 newdev->rating > curdev->rating ||
 281                !cpumask_equal(curdev->cpumask, newdev->cpumask);
 282 }
 283
 284 /*
 285  * Check whether the new device is a better fit than curdev. curdev
 286  * can be NULL !
 287  */
 288 bool tick_check_replacement(struct clock_event_device *curdev,
 289                             struct clock_event_device *newdev)
 290 {
 291         if (!tick_check_percpu(curdev, newdev, smp_processor_id()))
 292                 return false;
 293
 294         return tick_check_preferred(curdev, newdev);
 295 }
 296
 297 /*
 298  * Check, if the new registered device should be used. Called with
 299  * clockevents_lock held and interrupts disabled.
 300  */
 301 void tick_check_new_device(struct clock_event_device *newdev)
 302 {
 303         struct clock_event_device *curdev;
 304         struct tick_device *td;
 305         int cpu;
 306
 307         cpu = smp_processor_id();
 308         td = &per_cpu(tick_cpu_device, cpu);
 309         curdev = td->evtdev;
 310
 311         /* cpu local device ? */
 312         if (!tick_check_percpu(curdev, newdev, cpu))
 313                 goto out_bc;
 314
 315         /* Preference decision */
 316         if (!tick_check_preferred(curdev, newdev))
 317                 goto out_bc;
 318
 319         if (!try_module_get(newdev->owner))
 320                 return;
 321
 322         /*
 323          * Replace the eventually existing device by the new
 324          * device. If the current device is the broadcast device, do
 325          * not give it back to the clockevents layer !
 326          */
 327         if (tick_is_broadcast_device(curdev)) {
 328                 clockevents_shutdown(curdev);
 329                 curdev = NULL;
 330         }
 331         clockevents_exchange_device(curdev, newdev);
 332         tick_setup_device(td, newdev, cpu, cpumask_of(cpu));
 333         if (newdev->features & CLOCK_EVT_FEAT_ONESHOT)
 334                 tick_oneshot_notify();
 335         return;
 336
 337 out_bc:
 338         /*
 339          * Can the new device be used as a broadcast device ?
 340          */
 341         tick_install_broadcast_device(newdev);
 342 }
 343
 344 /**
 345  * tick_broadcast_oneshot_control - Enter/exit broadcast oneshot mode
 346  * @state:      The target state (enter/exit)
 347  *
 348  * The system enters/leaves a state, where affected devices might stop
 349  * Returns 0 on success, -EBUSY if the cpu is used to broadcast wakeups.
 350  *
 351  * Called with interrupts disabled, so clockevents_lock is not
 352  * required here because the local clock event device cannot go away
 353  * under us.
 354  */
 355 int tick_broadcast_oneshot_control(enum tick_broadcast_state state)
 356 {
 357         struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
 358
 359         if (!(td->evtdev->features & CLOCK_EVT_FEAT_C3STOP))
 360                 return 0;
 361
 362         return __tick_broadcast_oneshot_control(state);
 363 }
 364 EXPORT_SYMBOL_GPL(tick_broadcast_oneshot_control);
 365
 366 #ifdef CONFIG_HOTPLUG_CPU
 367 /*
 368  * Transfer the do_timer job away from a dying cpu.
 369  *
 370  * Called with interrupts disabled. Not locking required. If
 371  * tick_do_timer_cpu is owned by this cpu, nothing can change it.
 372  */
 373 void tick_handover_do_timer(void)
 374 {
 375         if (tick_do_timer_cpu == smp_processor_id()) {
 376                 int cpu = cpumask_first(cpu_online_mask);
 377
 378                 tick_do_timer_cpu = (cpu < nr_cpu_ids) ? cpu :
 379                         TICK_DO_TIMER_NONE;
 380         }
 381 }
 382
 383 /*
 384  * Shutdown an event device on a given cpu:
 385  *
 386  * This is called on a life CPU, when a CPU is dead. So we cannot
 387  * access the hardware device itself.
 388  * We just set the mode and remove it from the lists.
 389  */
 390 void tick_shutdown(unsigned int cpu)
 391 {
 392         struct tick_device *td = &per_cpu(tick_cpu_device, cpu);
 393         struct clock_event_device *dev = td->evtdev;
 394
 395         td->mode = TICKDEV_MODE_PERIODIC;
 396         if (dev) {
 397                 /*
 398                  * Prevent that the clock events layer tries to call
 399                  * the set mode function!
 400                  */
 401                 clockevent_set_state(dev, CLOCK_EVT_STATE_DETACHED);
 402                 clockevents_exchange_device(dev, NULL);
 403                 dev->event_handler = clockevents_handle_noop;
 404                 td->evtdev = NULL;
 405         }
 406 }
 407 #endif
 408
 409 /**
 410  * tick_suspend_local - Suspend the local tick device
 411  *
 412  * Called from the local cpu for freeze with interrupts disabled.
 413  *
 414  * No locks required. Nothing can change the per cpu device.
 415  */
 416 void tick_suspend_local(void)
 417 {
 418         struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
 419
 420         clockevents_shutdown(td->evtdev);
 421 }
 422
 423 /**
 424  * tick_resume_local - Resume the local tick device
 425  *
 426  * Called from the local CPU for unfreeze or XEN resume magic.
 427  *
 428  * No locks required. Nothing can change the per cpu device.
 429  */
 430 void tick_resume_local(void)
 431 {
 432         struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
 433         bool broadcast = tick_resume_check_broadcast();
 434
 435         clockevents_tick_resume(td->evtdev);
 436         if (!broadcast) {
 437                 if (td->mode == TICKDEV_MODE_PERIODIC)
 438                         tick_setup_periodic(td->evtdev, 0);
 439                 else
 440                         tick_resume_oneshot();
 441         }
 442 }
 443
 444 /**
 445  * tick_suspend - Suspend the tick and the broadcast device
 446  *
 447  * Called from syscore_suspend() via timekeeping_suspend with only one
 448  * CPU online and interrupts disabled or from tick_unfreeze() under
 449  * tick_freeze_lock.
 450  *
 451  * No locks required. Nothing can change the per cpu device.
 452  */
 453 void tick_suspend(void)
 454 {
 455         tick_suspend_local();
 456         tick_suspend_broadcast();
 457 }
 458
 459 /**
 460  * tick_resume - Resume the tick and the broadcast device
 461  *
 462  * Called from syscore_resume() via timekeeping_resume with only one
 463  * CPU online and interrupts disabled.
 464  *
 465  * No locks required. Nothing can change the per cpu device.
 466  */
 467 void tick_resume(void)
 468 {
 469         tick_resume_broadcast();
 470         tick_resume_local();
 471 }
 472
 473 #ifdef CONFIG_SUSPEND
 474 static DEFINE_RAW_SPINLOCK(tick_freeze_lock);
 475 static unsigned int tick_freeze_depth;
 476
 477 /**
 478  * tick_freeze - Suspend the local tick and (possibly) timekeeping.
 479  *
 480  * Check if this is the last online CPU executing the function and if so,
 481  * suspend timekeeping.  Otherwise suspend the local tick.
 482  *
 483  * Call with interrupts disabled.  Must be balanced with %tick_unfreeze().
 484  * Interrupts must not be enabled before the subsequent %tick_unfreeze().
 485  */
 486 void tick_freeze(void)
 487 {
 488         raw_spin_lock(&tick_freeze_lock);
 489
 490         tick_freeze_depth++;
 491         if (tick_freeze_depth == num_online_cpus()) {
 492                 trace_suspend_resume(TPS("timekeeping_freeze"),
 493                                      smp_processor_id(), true);
 494                 system_state = SYSTEM_SUSPEND;
 495                 sched_clock_suspend();
 496                 timekeeping_suspend();
 497         } else {
 498                 tick_suspend_local();
 499         }
 500
 501         raw_spin_unlock(&tick_freeze_lock);
 502 }
 503
 504 /**
 505  * tick_unfreeze - Resume the local tick and (possibly) timekeeping.
 506  *
 507  * Check if this is the first CPU executing the function and if so, resume
 508  * timekeeping.  Otherwise resume the local tick.
 509  *
 510  * Call with interrupts disabled.  Must be balanced with %tick_freeze().
 511  * Interrupts must not be enabled after the preceding %tick_freeze().
 512  */
 513 void tick_unfreeze(void)
 514 {
 515         raw_spin_lock(&tick_freeze_lock);
 516
 517         if (tick_freeze_depth == num_online_cpus()) {
 518                 timekeeping_resume();
 519                 sched_clock_resume();
 520                 system_state = SYSTEM_RUNNING;
 521                 trace_suspend_resume(TPS("timekeeping_freeze"),
 522                                      smp_processor_id(), false);
 523         } else {
 524                 touch_softlockup_watchdog();
 525                 tick_resume_local();
 526         }
 527
 528         tick_freeze_depth--;
 529
 530         raw_spin_unlock(&tick_freeze_lock);
 531 }
 532 #endif /* CONFIG_SUSPEND */
 533
 534 /**
 535  * tick_init - initialize the tick control
 536  */
 537 void __init tick_init(void)
 538 {
 539         tick_broadcast_init();
 540         tick_nohz_init();
 541 }