Branch data     Line data    Source code

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