2 * linux/kernel/time/tick-broadcast.c
4 * This file contains functions which emulate a local clock-event
5 * device via a broadcast event source.
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
11 * This code is licenced under the GPL version 2. For details see
12 * kernel-base/COPYING.
14 #include <linux/cpu.h>
15 #include <linux/err.h>
16 #include <linux/hrtimer.h>
17 #include <linux/interrupt.h>
18 #include <linux/percpu.h>
19 #include <linux/profile.h>
20 #include <linux/sched.h>
21 #include <linux/smp.h>
22 #include <linux/module.h>
24 #include "tick-internal.h"
27 * Broadcast support for broken x86 hardware, where the local apic
28 * timer stops in C3 state.
31 static struct tick_device tick_broadcast_device
;
32 static cpumask_var_t tick_broadcast_mask
;
33 static cpumask_var_t tmpmask
;
34 static DEFINE_RAW_SPINLOCK(tick_broadcast_lock
);
35 static int tick_broadcast_force
;
37 #ifdef CONFIG_TICK_ONESHOT
38 static void tick_broadcast_clear_oneshot(int cpu
);
40 static inline void tick_broadcast_clear_oneshot(int cpu
) { }
44 * Debugging: see timer_list.c
46 struct tick_device
*tick_get_broadcast_device(void)
48 return &tick_broadcast_device
;
51 struct cpumask
*tick_get_broadcast_mask(void)
53 return tick_broadcast_mask
;
57 * Start the device in periodic mode
59 static void tick_broadcast_start_periodic(struct clock_event_device
*bc
)
62 tick_setup_periodic(bc
, 1);
66 * Check, if the device can be utilized as broadcast device:
68 static bool tick_check_broadcast_device(struct clock_event_device
*curdev
,
69 struct clock_event_device
*newdev
)
71 if ((newdev
->features
& CLOCK_EVT_FEAT_DUMMY
) ||
72 (newdev
->features
& CLOCK_EVT_FEAT_C3STOP
))
75 if (tick_broadcast_device
.mode
== TICKDEV_MODE_ONESHOT
&&
76 !(newdev
->features
& CLOCK_EVT_FEAT_ONESHOT
))
79 return !curdev
|| newdev
->rating
> curdev
->rating
;
83 * Conditionally install/replace broadcast device
85 void tick_install_broadcast_device(struct clock_event_device
*dev
)
87 struct clock_event_device
*cur
= tick_broadcast_device
.evtdev
;
89 if (!tick_check_broadcast_device(cur
, dev
))
92 if (!try_module_get(dev
->owner
))
95 clockevents_exchange_device(cur
, dev
);
97 cur
->event_handler
= clockevents_handle_noop
;
98 tick_broadcast_device
.evtdev
= dev
;
99 if (!cpumask_empty(tick_broadcast_mask
))
100 tick_broadcast_start_periodic(dev
);
102 * Inform all cpus about this. We might be in a situation
103 * where we did not switch to oneshot mode because the per cpu
104 * devices are affected by CLOCK_EVT_FEAT_C3STOP and the lack
105 * of a oneshot capable broadcast device. Without that
106 * notification the systems stays stuck in periodic mode
109 if (dev
->features
& CLOCK_EVT_FEAT_ONESHOT
)
114 * Check, if the device is the broadcast device
116 int tick_is_broadcast_device(struct clock_event_device
*dev
)
118 return (dev
&& tick_broadcast_device
.evtdev
== dev
);
121 static void err_broadcast(const struct cpumask
*mask
)
123 pr_crit_once("Failed to broadcast timer tick. Some CPUs may be unresponsive.\n");
126 static void tick_device_setup_broadcast_func(struct clock_event_device
*dev
)
129 dev
->broadcast
= tick_broadcast
;
130 if (!dev
->broadcast
) {
131 pr_warn_once("%s depends on broadcast, but no broadcast function available\n",
133 dev
->broadcast
= err_broadcast
;
138 * Check, if the device is disfunctional and a place holder, which
139 * needs to be handled by the broadcast device.
141 int tick_device_uses_broadcast(struct clock_event_device
*dev
, int cpu
)
146 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
149 * Devices might be registered with both periodic and oneshot
150 * mode disabled. This signals, that the device needs to be
151 * operated from the broadcast device and is a placeholder for
152 * the cpu local device.
154 if (!tick_device_is_functional(dev
)) {
155 dev
->event_handler
= tick_handle_periodic
;
156 tick_device_setup_broadcast_func(dev
);
157 cpumask_set_cpu(cpu
, tick_broadcast_mask
);
158 tick_broadcast_start_periodic(tick_broadcast_device
.evtdev
);
162 * When the new device is not affected by the stop
163 * feature and the cpu is marked in the broadcast mask
164 * then clear the broadcast bit.
166 if (!(dev
->features
& CLOCK_EVT_FEAT_C3STOP
)) {
167 int cpu
= smp_processor_id();
168 cpumask_clear_cpu(cpu
, tick_broadcast_mask
);
169 tick_broadcast_clear_oneshot(cpu
);
171 tick_device_setup_broadcast_func(dev
);
174 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
178 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
179 int tick_receive_broadcast(void)
181 struct tick_device
*td
= this_cpu_ptr(&tick_cpu_device
);
182 struct clock_event_device
*evt
= td
->evtdev
;
187 if (!evt
->event_handler
)
190 evt
->event_handler(evt
);
196 * Broadcast the event to the cpus, which are set in the mask (mangled).
198 static void tick_do_broadcast(struct cpumask
*mask
)
200 int cpu
= smp_processor_id();
201 struct tick_device
*td
;
204 * Check, if the current cpu is in the mask
206 if (cpumask_test_cpu(cpu
, mask
)) {
207 cpumask_clear_cpu(cpu
, mask
);
208 td
= &per_cpu(tick_cpu_device
, cpu
);
209 td
->evtdev
->event_handler(td
->evtdev
);
212 if (!cpumask_empty(mask
)) {
214 * It might be necessary to actually check whether the devices
215 * have different broadcast functions. For now, just use the
216 * one of the first device. This works as long as we have this
217 * misfeature only on x86 (lapic)
219 td
= &per_cpu(tick_cpu_device
, cpumask_first(mask
));
220 td
->evtdev
->broadcast(mask
);
225 * Periodic broadcast:
226 * - invoke the broadcast handlers
228 static void tick_do_periodic_broadcast(void)
230 raw_spin_lock(&tick_broadcast_lock
);
232 cpumask_and(tmpmask
, cpu_online_mask
, tick_broadcast_mask
);
233 tick_do_broadcast(tmpmask
);
235 raw_spin_unlock(&tick_broadcast_lock
);
239 * Event handler for periodic broadcast ticks
241 static void tick_handle_periodic_broadcast(struct clock_event_device
*dev
)
245 tick_do_periodic_broadcast();
248 * The device is in periodic mode. No reprogramming necessary:
250 if (dev
->mode
== CLOCK_EVT_MODE_PERIODIC
)
254 * Setup the next period for devices, which do not have
255 * periodic mode. We read dev->next_event first and add to it
256 * when the event already expired. clockevents_program_event()
257 * sets dev->next_event only when the event is really
258 * programmed to the device.
260 for (next
= dev
->next_event
; ;) {
261 next
= ktime_add(next
, tick_period
);
263 if (!clockevents_program_event(dev
, next
, false))
265 tick_do_periodic_broadcast();
270 * Powerstate information: The system enters/leaves a state, where
271 * affected devices might stop
273 static void tick_do_broadcast_on_off(unsigned long *reason
)
275 struct clock_event_device
*bc
, *dev
;
276 struct tick_device
*td
;
280 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
282 cpu
= smp_processor_id();
283 td
= &per_cpu(tick_cpu_device
, cpu
);
285 bc
= tick_broadcast_device
.evtdev
;
288 * Is the device not affected by the powerstate ?
290 if (!dev
|| !(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
293 if (!tick_device_is_functional(dev
))
296 bc_stopped
= cpumask_empty(tick_broadcast_mask
);
299 case CLOCK_EVT_NOTIFY_BROADCAST_ON
:
300 case CLOCK_EVT_NOTIFY_BROADCAST_FORCE
:
301 if (!cpumask_test_and_set_cpu(cpu
, tick_broadcast_mask
)) {
302 if (tick_broadcast_device
.mode
==
303 TICKDEV_MODE_PERIODIC
)
304 clockevents_shutdown(dev
);
306 if (*reason
== CLOCK_EVT_NOTIFY_BROADCAST_FORCE
)
307 tick_broadcast_force
= 1;
309 case CLOCK_EVT_NOTIFY_BROADCAST_OFF
:
310 if (!tick_broadcast_force
&&
311 cpumask_test_and_clear_cpu(cpu
, tick_broadcast_mask
)) {
312 if (tick_broadcast_device
.mode
==
313 TICKDEV_MODE_PERIODIC
)
314 tick_setup_periodic(dev
, 0);
319 if (cpumask_empty(tick_broadcast_mask
)) {
321 clockevents_shutdown(bc
);
322 } else if (bc_stopped
) {
323 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
324 tick_broadcast_start_periodic(bc
);
326 tick_broadcast_setup_oneshot(bc
);
329 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
333 * Powerstate information: The system enters/leaves a state, where
334 * affected devices might stop.
336 void tick_broadcast_on_off(unsigned long reason
, int *oncpu
)
338 if (!cpumask_test_cpu(*oncpu
, cpu_online_mask
))
339 printk(KERN_ERR
"tick-broadcast: ignoring broadcast for "
340 "offline CPU #%d\n", *oncpu
);
342 tick_do_broadcast_on_off(&reason
);
346 * Set the periodic handler depending on broadcast on/off
348 void tick_set_periodic_handler(struct clock_event_device
*dev
, int broadcast
)
351 dev
->event_handler
= tick_handle_periodic
;
353 dev
->event_handler
= tick_handle_periodic_broadcast
;
357 * Remove a CPU from broadcasting
359 void tick_shutdown_broadcast(unsigned int *cpup
)
361 struct clock_event_device
*bc
;
363 unsigned int cpu
= *cpup
;
365 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
367 bc
= tick_broadcast_device
.evtdev
;
368 cpumask_clear_cpu(cpu
, tick_broadcast_mask
);
370 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
) {
371 if (bc
&& cpumask_empty(tick_broadcast_mask
))
372 clockevents_shutdown(bc
);
375 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
378 void tick_suspend_broadcast(void)
380 struct clock_event_device
*bc
;
383 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
385 bc
= tick_broadcast_device
.evtdev
;
387 clockevents_shutdown(bc
);
389 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
392 int tick_resume_broadcast(void)
394 struct clock_event_device
*bc
;
398 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
400 bc
= tick_broadcast_device
.evtdev
;
403 clockevents_set_mode(bc
, CLOCK_EVT_MODE_RESUME
);
405 switch (tick_broadcast_device
.mode
) {
406 case TICKDEV_MODE_PERIODIC
:
407 if (!cpumask_empty(tick_broadcast_mask
))
408 tick_broadcast_start_periodic(bc
);
409 broadcast
= cpumask_test_cpu(smp_processor_id(),
410 tick_broadcast_mask
);
412 case TICKDEV_MODE_ONESHOT
:
413 if (!cpumask_empty(tick_broadcast_mask
))
414 broadcast
= tick_resume_broadcast_oneshot(bc
);
418 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
424 #ifdef CONFIG_TICK_ONESHOT
426 static cpumask_var_t tick_broadcast_oneshot_mask
;
427 static cpumask_var_t tick_broadcast_pending_mask
;
428 static cpumask_var_t tick_broadcast_force_mask
;
431 * Exposed for debugging: see timer_list.c
433 struct cpumask
*tick_get_broadcast_oneshot_mask(void)
435 return tick_broadcast_oneshot_mask
;
439 * Called before going idle with interrupts disabled. Checks whether a
440 * broadcast event from the other core is about to happen. We detected
441 * that in tick_broadcast_oneshot_control(). The callsite can use this
442 * to avoid a deep idle transition as we are about to get the
443 * broadcast IPI right away.
445 int tick_check_broadcast_expired(void)
447 return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask
);
451 * Set broadcast interrupt affinity
453 static void tick_broadcast_set_affinity(struct clock_event_device
*bc
,
454 const struct cpumask
*cpumask
)
456 if (!(bc
->features
& CLOCK_EVT_FEAT_DYNIRQ
))
459 if (cpumask_equal(bc
->cpumask
, cpumask
))
462 bc
->cpumask
= cpumask
;
463 irq_set_affinity(bc
->irq
, bc
->cpumask
);
466 static int tick_broadcast_set_event(struct clock_event_device
*bc
, int cpu
,
467 ktime_t expires
, int force
)
471 if (bc
->mode
!= CLOCK_EVT_MODE_ONESHOT
)
472 clockevents_set_mode(bc
, CLOCK_EVT_MODE_ONESHOT
);
474 ret
= clockevents_program_event(bc
, expires
, force
);
476 tick_broadcast_set_affinity(bc
, cpumask_of(cpu
));
480 int tick_resume_broadcast_oneshot(struct clock_event_device
*bc
)
482 clockevents_set_mode(bc
, CLOCK_EVT_MODE_ONESHOT
);
487 * Called from irq_enter() when idle was interrupted to reenable the
490 void tick_check_oneshot_broadcast(int cpu
)
492 if (cpumask_test_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
493 struct tick_device
*td
= &per_cpu(tick_cpu_device
, cpu
);
495 clockevents_set_mode(td
->evtdev
, CLOCK_EVT_MODE_ONESHOT
);
500 * Handle oneshot mode broadcasting
502 static void tick_handle_oneshot_broadcast(struct clock_event_device
*dev
)
504 struct tick_device
*td
;
505 ktime_t now
, next_event
;
506 int cpu
, next_cpu
= 0;
508 raw_spin_lock(&tick_broadcast_lock
);
510 dev
->next_event
.tv64
= KTIME_MAX
;
511 next_event
.tv64
= KTIME_MAX
;
512 cpumask_clear(tmpmask
);
514 /* Find all expired events */
515 for_each_cpu(cpu
, tick_broadcast_oneshot_mask
) {
516 td
= &per_cpu(tick_cpu_device
, cpu
);
517 if (td
->evtdev
->next_event
.tv64
<= now
.tv64
) {
518 cpumask_set_cpu(cpu
, tmpmask
);
520 * Mark the remote cpu in the pending mask, so
521 * it can avoid reprogramming the cpu local
522 * timer in tick_broadcast_oneshot_control().
524 cpumask_set_cpu(cpu
, tick_broadcast_pending_mask
);
525 } else if (td
->evtdev
->next_event
.tv64
< next_event
.tv64
) {
526 next_event
.tv64
= td
->evtdev
->next_event
.tv64
;
531 /* Take care of enforced broadcast requests */
532 cpumask_or(tmpmask
, tmpmask
, tick_broadcast_force_mask
);
533 cpumask_clear(tick_broadcast_force_mask
);
536 * Wakeup the cpus which have an expired event.
538 tick_do_broadcast(tmpmask
);
541 * Two reasons for reprogram:
543 * - The global event did not expire any CPU local
544 * events. This happens in dyntick mode, as the maximum PIT
545 * delta is quite small.
547 * - There are pending events on sleeping CPUs which were not
550 if (next_event
.tv64
!= KTIME_MAX
) {
552 * Rearm the broadcast device. If event expired,
555 if (tick_broadcast_set_event(dev
, next_cpu
, next_event
, 0))
558 raw_spin_unlock(&tick_broadcast_lock
);
562 * Powerstate information: The system enters/leaves a state, where
563 * affected devices might stop
565 void tick_broadcast_oneshot_control(unsigned long reason
)
567 struct clock_event_device
*bc
, *dev
;
568 struct tick_device
*td
;
574 * Periodic mode does not care about the enter/exit of power
577 if (tick_broadcast_device
.mode
== TICKDEV_MODE_PERIODIC
)
581 * We are called with preemtion disabled from the depth of the
582 * idle code, so we can't be moved away.
584 cpu
= smp_processor_id();
585 td
= &per_cpu(tick_cpu_device
, cpu
);
588 if (!(dev
->features
& CLOCK_EVT_FEAT_C3STOP
))
591 bc
= tick_broadcast_device
.evtdev
;
593 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
594 if (reason
== CLOCK_EVT_NOTIFY_BROADCAST_ENTER
) {
595 WARN_ON_ONCE(cpumask_test_cpu(cpu
, tick_broadcast_pending_mask
));
596 if (!cpumask_test_and_set_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
597 clockevents_set_mode(dev
, CLOCK_EVT_MODE_SHUTDOWN
);
599 * We only reprogram the broadcast timer if we
600 * did not mark ourself in the force mask and
601 * if the cpu local event is earlier than the
602 * broadcast event. If the current CPU is in
603 * the force mask, then we are going to be
604 * woken by the IPI right away.
606 if (!cpumask_test_cpu(cpu
, tick_broadcast_force_mask
) &&
607 dev
->next_event
.tv64
< bc
->next_event
.tv64
)
608 tick_broadcast_set_event(bc
, cpu
, dev
->next_event
, 1);
611 if (cpumask_test_and_clear_cpu(cpu
, tick_broadcast_oneshot_mask
)) {
612 clockevents_set_mode(dev
, CLOCK_EVT_MODE_ONESHOT
);
613 if (dev
->next_event
.tv64
== KTIME_MAX
)
616 * The cpu which was handling the broadcast
617 * timer marked this cpu in the broadcast
618 * pending mask and fired the broadcast
619 * IPI. So we are going to handle the expired
620 * event anyway via the broadcast IPI
621 * handler. No need to reprogram the timer
622 * with an already expired event.
624 if (cpumask_test_and_clear_cpu(cpu
,
625 tick_broadcast_pending_mask
))
629 * If the pending bit is not set, then we are
630 * either the CPU handling the broadcast
631 * interrupt or we got woken by something else.
633 * We are not longer in the broadcast mask, so
634 * if the cpu local expiry time is already
635 * reached, we would reprogram the cpu local
636 * timer with an already expired event.
638 * This can lead to a ping-pong when we return
639 * to idle and therefor rearm the broadcast
640 * timer before the cpu local timer was able
641 * to fire. This happens because the forced
642 * reprogramming makes sure that the event
643 * will happen in the future and depending on
644 * the min_delta setting this might be far
645 * enough out that the ping-pong starts.
647 * If the cpu local next_event has expired
648 * then we know that the broadcast timer
649 * next_event has expired as well and
650 * broadcast is about to be handled. So we
651 * avoid reprogramming and enforce that the
652 * broadcast handler, which did not run yet,
653 * will invoke the cpu local handler.
655 * We cannot call the handler directly from
656 * here, because we might be in a NOHZ phase
657 * and we did not go through the irq_enter()
661 if (dev
->next_event
.tv64
<= now
.tv64
) {
662 cpumask_set_cpu(cpu
, tick_broadcast_force_mask
);
666 * We got woken by something else. Reprogram
667 * the cpu local timer device.
669 tick_program_event(dev
->next_event
, 1);
673 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
677 * Reset the one shot broadcast for a cpu
679 * Called with tick_broadcast_lock held
681 static void tick_broadcast_clear_oneshot(int cpu
)
683 cpumask_clear_cpu(cpu
, tick_broadcast_oneshot_mask
);
686 static void tick_broadcast_init_next_event(struct cpumask
*mask
,
689 struct tick_device
*td
;
692 for_each_cpu(cpu
, mask
) {
693 td
= &per_cpu(tick_cpu_device
, cpu
);
695 td
->evtdev
->next_event
= expires
;
700 * tick_broadcast_setup_oneshot - setup the broadcast device
702 void tick_broadcast_setup_oneshot(struct clock_event_device
*bc
)
704 int cpu
= smp_processor_id();
706 /* Set it up only once ! */
707 if (bc
->event_handler
!= tick_handle_oneshot_broadcast
) {
708 int was_periodic
= bc
->mode
== CLOCK_EVT_MODE_PERIODIC
;
710 bc
->event_handler
= tick_handle_oneshot_broadcast
;
712 /* Take the do_timer update */
713 if (!tick_nohz_full_cpu(cpu
))
714 tick_do_timer_cpu
= cpu
;
717 * We must be careful here. There might be other CPUs
718 * waiting for periodic broadcast. We need to set the
719 * oneshot_mask bits for those and program the
720 * broadcast device to fire.
722 cpumask_copy(tmpmask
, tick_broadcast_mask
);
723 cpumask_clear_cpu(cpu
, tmpmask
);
724 cpumask_or(tick_broadcast_oneshot_mask
,
725 tick_broadcast_oneshot_mask
, tmpmask
);
727 if (was_periodic
&& !cpumask_empty(tmpmask
)) {
728 clockevents_set_mode(bc
, CLOCK_EVT_MODE_ONESHOT
);
729 tick_broadcast_init_next_event(tmpmask
,
731 tick_broadcast_set_event(bc
, cpu
, tick_next_period
, 1);
733 bc
->next_event
.tv64
= KTIME_MAX
;
736 * The first cpu which switches to oneshot mode sets
737 * the bit for all other cpus which are in the general
738 * (periodic) broadcast mask. So the bit is set and
739 * would prevent the first broadcast enter after this
740 * to program the bc device.
742 tick_broadcast_clear_oneshot(cpu
);
747 * Select oneshot operating mode for the broadcast device
749 void tick_broadcast_switch_to_oneshot(void)
751 struct clock_event_device
*bc
;
754 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
756 tick_broadcast_device
.mode
= TICKDEV_MODE_ONESHOT
;
757 bc
= tick_broadcast_device
.evtdev
;
759 tick_broadcast_setup_oneshot(bc
);
761 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
766 * Remove a dead CPU from broadcasting
768 void tick_shutdown_broadcast_oneshot(unsigned int *cpup
)
771 unsigned int cpu
= *cpup
;
773 raw_spin_lock_irqsave(&tick_broadcast_lock
, flags
);
776 * Clear the broadcast mask flag for the dead cpu, but do not
777 * stop the broadcast device!
779 cpumask_clear_cpu(cpu
, tick_broadcast_oneshot_mask
);
781 raw_spin_unlock_irqrestore(&tick_broadcast_lock
, flags
);
785 * Check, whether the broadcast device is in one shot mode
787 int tick_broadcast_oneshot_active(void)
789 return tick_broadcast_device
.mode
== TICKDEV_MODE_ONESHOT
;
793 * Check whether the broadcast device supports oneshot.
795 bool tick_broadcast_oneshot_available(void)
797 struct clock_event_device
*bc
= tick_broadcast_device
.evtdev
;
799 return bc
? bc
->features
& CLOCK_EVT_FEAT_ONESHOT
: false;
804 void __init
tick_broadcast_init(void)
806 zalloc_cpumask_var(&tick_broadcast_mask
, GFP_NOWAIT
);
807 zalloc_cpumask_var(&tmpmask
, GFP_NOWAIT
);
808 #ifdef CONFIG_TICK_ONESHOT
809 zalloc_cpumask_var(&tick_broadcast_oneshot_mask
, GFP_NOWAIT
);
810 zalloc_cpumask_var(&tick_broadcast_pending_mask
, GFP_NOWAIT
);
811 zalloc_cpumask_var(&tick_broadcast_force_mask
, GFP_NOWAIT
);