2007-02-16 02:28:02 -07:00
|
|
|
/*
|
|
|
|
* linux/kernel/time/tick-broadcast.c
|
|
|
|
*
|
|
|
|
* This file contains functions which emulate a local clock-event
|
|
|
|
* device via a broadcast event source.
|
|
|
|
*
|
|
|
|
* Copyright(C) 2005-2006, Thomas Gleixner <tglx@linutronix.de>
|
|
|
|
* Copyright(C) 2005-2007, Red Hat, Inc., Ingo Molnar
|
|
|
|
* Copyright(C) 2006-2007, Timesys Corp., Thomas Gleixner
|
|
|
|
*
|
|
|
|
* This code is licenced under the GPL version 2. For details see
|
|
|
|
* kernel-base/COPYING.
|
|
|
|
*/
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/hrtimer.h>
|
[S390] genirq/clockevents: move irq affinity prototypes/inlines to interrupt.h
> Generic code is not supposed to include irq.h. Replace this include
> by linux/hardirq.h instead and add/replace an include of linux/irq.h
> in asm header files where necessary.
> This change should only matter for architectures that make use of
> GENERIC_CLOCKEVENTS.
> Architectures in question are mips, x86, arm, sh, powerpc, uml and sparc64.
>
> I did some cross compile tests for mips, x86_64, arm, powerpc and sparc64.
> This patch fixes also build breakages caused by the include replacement in
> tick-common.h.
I generally dislike adding optional linux/* includes in asm/* includes -
I'm nervous about this causing include loops.
However, there's a separate point to be discussed here.
That is, what interfaces are expected of every architecture in the kernel.
If generic code wants to be able to set the affinity of interrupts, then
that needs to become part of the interfaces listed in linux/interrupt.h
rather than linux/irq.h.
So what I suggest is this approach instead (against Linus' tree of a
couple of days ago) - we move irq_set_affinity() and irq_can_set_affinity()
to linux/interrupt.h, change the linux/irq.h includes to linux/interrupt.h
and include asm/irq_regs.h where needed (asm/irq_regs.h is supposed to be
rarely used include since not much touches the stacked parent context
registers.)
Build tested on ARM PXA family kernels and ARM's Realview platform
kernels which both use genirq.
[ tglx@linutronix.de: add GENERIC_HARDIRQ dependencies ]
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
2008-04-16 23:46:24 -06:00
|
|
|
#include <linux/interrupt.h>
|
2007-02-16 02:28:02 -07:00
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/profile.h>
|
|
|
|
#include <linux/sched.h>
|
2013-01-14 10:05:22 -07:00
|
|
|
#include <linux/smp.h>
|
2013-04-25 14:31:49 -06:00
|
|
|
#include <linux/module.h>
|
2007-02-16 02:28:02 -07:00
|
|
|
|
|
|
|
#include "tick-internal.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Broadcast support for broken x86 hardware, where the local apic
|
|
|
|
* timer stops in C3 state.
|
|
|
|
*/
|
|
|
|
|
2009-05-01 14:10:21 -06:00
|
|
|
static struct tick_device tick_broadcast_device;
|
2013-03-05 06:25:32 -07:00
|
|
|
static cpumask_var_t tick_broadcast_mask;
|
2013-07-01 14:14:10 -06:00
|
|
|
static cpumask_var_t tick_broadcast_on;
|
2013-03-05 06:25:32 -07:00
|
|
|
static cpumask_var_t tmpmask;
|
2009-12-08 04:40:31 -07:00
|
|
|
static DEFINE_RAW_SPINLOCK(tick_broadcast_lock);
|
2008-06-09 11:15:00 -06:00
|
|
|
static int tick_broadcast_force;
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2007-07-21 05:37:35 -06:00
|
|
|
#ifdef CONFIG_TICK_ONESHOT
|
|
|
|
static void tick_broadcast_clear_oneshot(int cpu);
|
|
|
|
#else
|
|
|
|
static inline void tick_broadcast_clear_oneshot(int cpu) { }
|
|
|
|
#endif
|
|
|
|
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
/*
|
|
|
|
* Debugging: see timer_list.c
|
|
|
|
*/
|
|
|
|
struct tick_device *tick_get_broadcast_device(void)
|
|
|
|
{
|
|
|
|
return &tick_broadcast_device;
|
|
|
|
}
|
|
|
|
|
2008-12-31 16:42:25 -07:00
|
|
|
struct cpumask *tick_get_broadcast_mask(void)
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
{
|
2013-03-05 06:25:32 -07:00
|
|
|
return tick_broadcast_mask;
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
/*
|
|
|
|
* Start the device in periodic mode
|
|
|
|
*/
|
|
|
|
static void tick_broadcast_start_periodic(struct clock_event_device *bc)
|
|
|
|
{
|
2007-07-21 05:37:34 -06:00
|
|
|
if (bc)
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_setup_periodic(bc, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check, if the device can be utilized as broadcast device:
|
|
|
|
*/
|
2013-04-25 14:31:50 -06:00
|
|
|
static bool tick_check_broadcast_device(struct clock_event_device *curdev,
|
|
|
|
struct clock_event_device *newdev)
|
|
|
|
{
|
|
|
|
if ((newdev->features & CLOCK_EVT_FEAT_DUMMY) ||
|
2013-09-18 12:48:37 -06:00
|
|
|
(newdev->features & CLOCK_EVT_FEAT_PERCPU) ||
|
2013-04-25 14:31:50 -06:00
|
|
|
(newdev->features & CLOCK_EVT_FEAT_C3STOP))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT &&
|
|
|
|
!(newdev->features & CLOCK_EVT_FEAT_ONESHOT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return !curdev || newdev->rating > curdev->rating;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Conditionally install/replace broadcast device
|
|
|
|
*/
|
2013-04-25 14:31:47 -06:00
|
|
|
void tick_install_broadcast_device(struct clock_event_device *dev)
|
2007-02-16 02:28:02 -07:00
|
|
|
{
|
2013-04-25 03:45:53 -06:00
|
|
|
struct clock_event_device *cur = tick_broadcast_device.evtdev;
|
|
|
|
|
2013-04-25 14:31:50 -06:00
|
|
|
if (!tick_check_broadcast_device(cur, dev))
|
2013-04-25 14:31:47 -06:00
|
|
|
return;
|
2013-04-25 14:31:50 -06:00
|
|
|
|
2013-04-25 14:31:49 -06:00
|
|
|
if (!try_module_get(dev->owner))
|
|
|
|
return;
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2013-04-25 14:31:50 -06:00
|
|
|
clockevents_exchange_device(cur, dev);
|
2013-04-25 03:45:53 -06:00
|
|
|
if (cur)
|
|
|
|
cur->event_handler = clockevents_handle_noop;
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_broadcast_device.evtdev = dev;
|
2013-03-05 06:25:32 -07:00
|
|
|
if (!cpumask_empty(tick_broadcast_mask))
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_broadcast_start_periodic(dev);
|
2013-04-17 11:26:06 -06:00
|
|
|
/*
|
|
|
|
* Inform all cpus about this. We might be in a situation
|
|
|
|
* where we did not switch to oneshot mode because the per cpu
|
|
|
|
* devices are affected by CLOCK_EVT_FEAT_C3STOP and the lack
|
|
|
|
* of a oneshot capable broadcast device. Without that
|
|
|
|
* notification the systems stays stuck in periodic mode
|
|
|
|
* forever.
|
|
|
|
*/
|
|
|
|
if (dev->features & CLOCK_EVT_FEAT_ONESHOT)
|
|
|
|
tick_clock_notify();
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check, if the device is the broadcast device
|
|
|
|
*/
|
|
|
|
int tick_is_broadcast_device(struct clock_event_device *dev)
|
|
|
|
{
|
|
|
|
return (dev && tick_broadcast_device.evtdev == dev);
|
|
|
|
}
|
|
|
|
|
2013-01-14 10:05:22 -07:00
|
|
|
static void err_broadcast(const struct cpumask *mask)
|
|
|
|
{
|
|
|
|
pr_crit_once("Failed to broadcast timer tick. Some CPUs may be unresponsive.\n");
|
|
|
|
}
|
|
|
|
|
2013-02-08 08:24:07 -07:00
|
|
|
static void tick_device_setup_broadcast_func(struct clock_event_device *dev)
|
|
|
|
{
|
|
|
|
if (!dev->broadcast)
|
|
|
|
dev->broadcast = tick_broadcast;
|
|
|
|
if (!dev->broadcast) {
|
|
|
|
pr_warn_once("%s depends on broadcast, but no broadcast function available\n",
|
|
|
|
dev->name);
|
|
|
|
dev->broadcast = err_broadcast;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
/*
|
|
|
|
* Check, if the device is disfunctional and a place holder, which
|
|
|
|
* needs to be handled by the broadcast device.
|
|
|
|
*/
|
|
|
|
int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
|
|
|
|
{
|
2013-07-01 14:14:10 -06:00
|
|
|
struct clock_event_device *bc = tick_broadcast_device.evtdev;
|
2007-02-16 02:28:02 -07:00
|
|
|
unsigned long flags;
|
2013-07-01 14:14:10 -06:00
|
|
|
int ret;
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Devices might be registered with both periodic and oneshot
|
|
|
|
* mode disabled. This signals, that the device needs to be
|
|
|
|
* operated from the broadcast device and is a placeholder for
|
|
|
|
* the cpu local device.
|
|
|
|
*/
|
|
|
|
if (!tick_device_is_functional(dev)) {
|
|
|
|
dev->event_handler = tick_handle_periodic;
|
2013-02-08 08:24:07 -07:00
|
|
|
tick_device_setup_broadcast_func(dev);
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_set_cpu(cpu, tick_broadcast_mask);
|
2013-07-11 08:00:59 -06:00
|
|
|
if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
|
|
|
|
tick_broadcast_start_periodic(bc);
|
|
|
|
else
|
|
|
|
tick_broadcast_setup_oneshot(bc);
|
2007-02-16 02:28:02 -07:00
|
|
|
ret = 1;
|
2007-07-21 05:37:35 -06:00
|
|
|
} else {
|
|
|
|
/*
|
2013-07-01 14:14:10 -06:00
|
|
|
* Clear the broadcast bit for this cpu if the
|
|
|
|
* device is not power state affected.
|
2007-07-21 05:37:35 -06:00
|
|
|
*/
|
2013-07-01 14:14:10 -06:00
|
|
|
if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_mask);
|
2013-07-01 14:14:10 -06:00
|
|
|
else
|
2013-02-08 08:24:07 -07:00
|
|
|
tick_device_setup_broadcast_func(dev);
|
2013-07-01 14:14:10 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the broadcast bit if the CPU is not in
|
|
|
|
* periodic broadcast on state.
|
|
|
|
*/
|
|
|
|
if (!cpumask_test_cpu(cpu, tick_broadcast_on))
|
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_mask);
|
|
|
|
|
|
|
|
switch (tick_broadcast_device.mode) {
|
|
|
|
case TICKDEV_MODE_ONESHOT:
|
|
|
|
/*
|
|
|
|
* If the system is in oneshot mode we can
|
|
|
|
* unconditionally clear the oneshot mask bit,
|
|
|
|
* because the CPU is running and therefore
|
|
|
|
* not in an idle state which causes the power
|
|
|
|
* state affected device to stop. Let the
|
|
|
|
* caller initialize the device.
|
|
|
|
*/
|
|
|
|
tick_broadcast_clear_oneshot(cpu);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TICKDEV_MODE_PERIODIC:
|
|
|
|
/*
|
|
|
|
* If the system is in periodic mode, check
|
|
|
|
* whether the broadcast device can be
|
|
|
|
* switched off now.
|
|
|
|
*/
|
|
|
|
if (cpumask_empty(tick_broadcast_mask) && bc)
|
|
|
|
clockevents_shutdown(bc);
|
|
|
|
/*
|
|
|
|
* If we kept the cpu in the broadcast mask,
|
|
|
|
* tell the caller to leave the per cpu device
|
|
|
|
* in shutdown state. The periodic interrupt
|
|
|
|
* is delivered by the broadcast device.
|
|
|
|
*/
|
|
|
|
ret = cpumask_test_cpu(cpu, tick_broadcast_mask);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Nothing to do */
|
|
|
|
ret = 0;
|
|
|
|
break;
|
2007-07-21 05:37:35 -06:00
|
|
|
}
|
|
|
|
}
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-01-14 10:05:21 -07:00
|
|
|
#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
|
|
|
|
int tick_receive_broadcast(void)
|
|
|
|
{
|
|
|
|
struct tick_device *td = this_cpu_ptr(&tick_cpu_device);
|
|
|
|
struct clock_event_device *evt = td->evtdev;
|
|
|
|
|
|
|
|
if (!evt)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (!evt->event_handler)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
evt->event_handler(evt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
/*
|
2008-12-31 16:42:25 -07:00
|
|
|
* Broadcast the event to the cpus, which are set in the mask (mangled).
|
2007-02-16 02:28:02 -07:00
|
|
|
*/
|
2008-12-31 16:42:25 -07:00
|
|
|
static void tick_do_broadcast(struct cpumask *mask)
|
2007-02-16 02:28:02 -07:00
|
|
|
{
|
2008-01-30 05:30:01 -07:00
|
|
|
int cpu = smp_processor_id();
|
2007-02-16 02:28:02 -07:00
|
|
|
struct tick_device *td;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check, if the current cpu is in the mask
|
|
|
|
*/
|
2008-12-31 16:42:25 -07:00
|
|
|
if (cpumask_test_cpu(cpu, mask)) {
|
|
|
|
cpumask_clear_cpu(cpu, mask);
|
2007-02-16 02:28:02 -07:00
|
|
|
td = &per_cpu(tick_cpu_device, cpu);
|
|
|
|
td->evtdev->event_handler(td->evtdev);
|
|
|
|
}
|
|
|
|
|
2008-12-31 16:42:25 -07:00
|
|
|
if (!cpumask_empty(mask)) {
|
2007-02-16 02:28:02 -07:00
|
|
|
/*
|
|
|
|
* It might be necessary to actually check whether the devices
|
|
|
|
* have different broadcast functions. For now, just use the
|
|
|
|
* one of the first device. This works as long as we have this
|
|
|
|
* misfeature only on x86 (lapic)
|
|
|
|
*/
|
2008-12-31 16:42:25 -07:00
|
|
|
td = &per_cpu(tick_cpu_device, cpumask_first(mask));
|
|
|
|
td->evtdev->broadcast(mask);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Periodic broadcast:
|
|
|
|
* - invoke the broadcast handlers
|
|
|
|
*/
|
|
|
|
static void tick_do_periodic_broadcast(void)
|
|
|
|
{
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock(&tick_broadcast_lock);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_and(tmpmask, cpu_online_mask, tick_broadcast_mask);
|
|
|
|
tick_do_broadcast(tmpmask);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock(&tick_broadcast_lock);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Event handler for periodic broadcast ticks
|
|
|
|
*/
|
|
|
|
static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
|
|
|
|
{
|
2008-09-03 15:36:57 -06:00
|
|
|
ktime_t next;
|
|
|
|
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_do_periodic_broadcast();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The device is in periodic mode. No reprogramming necessary:
|
|
|
|
*/
|
|
|
|
if (dev->mode == CLOCK_EVT_MODE_PERIODIC)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup the next period for devices, which do not have
|
2008-09-03 15:36:57 -06:00
|
|
|
* periodic mode. We read dev->next_event first and add to it
|
2010-07-02 12:41:51 -06:00
|
|
|
* when the event already expired. clockevents_program_event()
|
2008-09-03 15:36:57 -06:00
|
|
|
* sets dev->next_event only when the event is really
|
|
|
|
* programmed to the device.
|
2007-02-16 02:28:02 -07:00
|
|
|
*/
|
2008-09-03 15:36:57 -06:00
|
|
|
for (next = dev->next_event; ;) {
|
|
|
|
next = ktime_add(next, tick_period);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2011-08-23 07:29:42 -06:00
|
|
|
if (!clockevents_program_event(dev, next, false))
|
2007-02-16 02:28:02 -07:00
|
|
|
return;
|
|
|
|
tick_do_periodic_broadcast();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Powerstate information: The system enters/leaves a state, where
|
|
|
|
* affected devices might stop
|
|
|
|
*/
|
2009-08-17 15:34:59 -06:00
|
|
|
static void tick_do_broadcast_on_off(unsigned long *reason)
|
2007-02-16 02:28:02 -07:00
|
|
|
{
|
|
|
|
struct clock_event_device *bc, *dev;
|
|
|
|
struct tick_device *td;
|
2009-08-17 15:34:59 -06:00
|
|
|
unsigned long flags;
|
2008-09-03 15:37:08 -06:00
|
|
|
int cpu, bc_stopped;
|
2007-02-16 02:28:02 -07:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
|
|
|
cpu = smp_processor_id();
|
|
|
|
td = &per_cpu(tick_cpu_device, cpu);
|
|
|
|
dev = td->evtdev;
|
|
|
|
bc = tick_broadcast_device.evtdev;
|
|
|
|
|
|
|
|
/*
|
2007-10-14 14:57:45 -06:00
|
|
|
* Is the device not affected by the powerstate ?
|
2007-02-16 02:28:02 -07:00
|
|
|
*/
|
2007-10-14 14:57:45 -06:00
|
|
|
if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))
|
2007-02-16 02:28:02 -07:00
|
|
|
goto out;
|
|
|
|
|
2007-10-17 10:04:32 -06:00
|
|
|
if (!tick_device_is_functional(dev))
|
|
|
|
goto out;
|
2007-10-14 14:57:45 -06:00
|
|
|
|
2013-03-05 06:25:32 -07:00
|
|
|
bc_stopped = cpumask_empty(tick_broadcast_mask);
|
2008-09-03 15:37:08 -06:00
|
|
|
|
2007-10-14 14:57:45 -06:00
|
|
|
switch (*reason) {
|
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_ON:
|
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
|
2013-07-01 14:14:10 -06:00
|
|
|
cpumask_set_cpu(cpu, tick_broadcast_on);
|
2013-03-05 06:25:32 -07:00
|
|
|
if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_mask)) {
|
2008-10-04 02:51:07 -06:00
|
|
|
if (tick_broadcast_device.mode ==
|
|
|
|
TICKDEV_MODE_PERIODIC)
|
2008-09-16 12:32:50 -06:00
|
|
|
clockevents_shutdown(dev);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
2007-10-17 10:04:32 -06:00
|
|
|
if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_FORCE)
|
2008-06-09 11:15:00 -06:00
|
|
|
tick_broadcast_force = 1;
|
2007-10-14 14:57:45 -06:00
|
|
|
break;
|
|
|
|
case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
|
2013-07-01 14:14:10 -06:00
|
|
|
if (tick_broadcast_force)
|
|
|
|
break;
|
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_on);
|
|
|
|
if (!tick_device_is_functional(dev))
|
|
|
|
break;
|
|
|
|
if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_mask)) {
|
2008-10-04 02:51:07 -06:00
|
|
|
if (tick_broadcast_device.mode ==
|
|
|
|
TICKDEV_MODE_PERIODIC)
|
2007-02-16 02:28:02 -07:00
|
|
|
tick_setup_periodic(dev, 0);
|
|
|
|
}
|
2007-10-14 14:57:45 -06:00
|
|
|
break;
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
|
2013-03-05 06:25:32 -07:00
|
|
|
if (cpumask_empty(tick_broadcast_mask)) {
|
2008-09-03 15:37:08 -06:00
|
|
|
if (!bc_stopped)
|
2008-09-16 12:32:50 -06:00
|
|
|
clockevents_shutdown(bc);
|
2008-09-03 15:37:08 -06:00
|
|
|
} else if (bc_stopped) {
|
2007-02-16 02:28:02 -07:00
|
|
|
if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
|
|
|
|
tick_broadcast_start_periodic(bc);
|
2007-02-16 02:28:03 -07:00
|
|
|
else
|
|
|
|
tick_broadcast_setup_oneshot(bc);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
out:
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Powerstate information: The system enters/leaves a state, where
|
|
|
|
* affected devices might stop.
|
|
|
|
*/
|
|
|
|
void tick_broadcast_on_off(unsigned long reason, int *oncpu)
|
|
|
|
{
|
2008-12-31 16:42:25 -07:00
|
|
|
if (!cpumask_test_cpu(*oncpu, cpu_online_mask))
|
2008-04-18 14:38:58 -06:00
|
|
|
printk(KERN_ERR "tick-broadcast: ignoring broadcast for "
|
2007-05-23 14:57:30 -06:00
|
|
|
"offline CPU #%d\n", *oncpu);
|
2007-10-17 00:26:24 -06:00
|
|
|
else
|
2009-08-17 15:34:59 -06:00
|
|
|
tick_do_broadcast_on_off(&reason);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the periodic handler depending on broadcast on/off
|
|
|
|
*/
|
|
|
|
void tick_set_periodic_handler(struct clock_event_device *dev, int broadcast)
|
|
|
|
{
|
|
|
|
if (!broadcast)
|
|
|
|
dev->event_handler = tick_handle_periodic;
|
|
|
|
else
|
|
|
|
dev->event_handler = tick_handle_periodic_broadcast;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a CPU from broadcasting
|
|
|
|
*/
|
|
|
|
void tick_shutdown_broadcast(unsigned int *cpup)
|
|
|
|
{
|
|
|
|
struct clock_event_device *bc;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int cpu = *cpup;
|
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
|
|
|
bc = tick_broadcast_device.evtdev;
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_mask);
|
2013-07-01 14:14:10 -06:00
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_on);
|
2007-02-16 02:28:02 -07:00
|
|
|
|
|
|
|
if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC) {
|
2013-03-05 06:25:32 -07:00
|
|
|
if (bc && cpumask_empty(tick_broadcast_mask))
|
2008-09-16 12:32:50 -06:00
|
|
|
clockevents_shutdown(bc);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:02 -07:00
|
|
|
}
|
2007-02-16 02:28:03 -07:00
|
|
|
|
2007-03-06 00:25:42 -07:00
|
|
|
void tick_suspend_broadcast(void)
|
|
|
|
{
|
|
|
|
struct clock_event_device *bc;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-03-06 00:25:42 -07:00
|
|
|
|
|
|
|
bc = tick_broadcast_device.evtdev;
|
2007-07-21 05:37:34 -06:00
|
|
|
if (bc)
|
2008-09-16 12:32:50 -06:00
|
|
|
clockevents_shutdown(bc);
|
2007-03-06 00:25:42 -07:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-03-06 00:25:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int tick_resume_broadcast(void)
|
|
|
|
{
|
|
|
|
struct clock_event_device *bc;
|
|
|
|
unsigned long flags;
|
|
|
|
int broadcast = 0;
|
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-03-06 00:25:42 -07:00
|
|
|
|
|
|
|
bc = tick_broadcast_device.evtdev;
|
|
|
|
|
2007-03-16 17:25:52 -06:00
|
|
|
if (bc) {
|
2007-07-21 05:37:34 -06:00
|
|
|
clockevents_set_mode(bc, CLOCK_EVT_MODE_RESUME);
|
|
|
|
|
2007-03-16 17:25:52 -06:00
|
|
|
switch (tick_broadcast_device.mode) {
|
|
|
|
case TICKDEV_MODE_PERIODIC:
|
2013-03-05 06:25:32 -07:00
|
|
|
if (!cpumask_empty(tick_broadcast_mask))
|
2007-03-16 17:25:52 -06:00
|
|
|
tick_broadcast_start_periodic(bc);
|
2008-12-31 16:42:25 -07:00
|
|
|
broadcast = cpumask_test_cpu(smp_processor_id(),
|
2013-03-05 06:25:32 -07:00
|
|
|
tick_broadcast_mask);
|
2007-03-16 17:25:52 -06:00
|
|
|
break;
|
|
|
|
case TICKDEV_MODE_ONESHOT:
|
2013-03-05 06:25:32 -07:00
|
|
|
if (!cpumask_empty(tick_broadcast_mask))
|
2012-04-18 20:27:39 -06:00
|
|
|
broadcast = tick_resume_broadcast_oneshot(bc);
|
2007-03-16 17:25:52 -06:00
|
|
|
break;
|
|
|
|
}
|
2007-03-06 00:25:42 -07:00
|
|
|
}
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-03-06 00:25:42 -07:00
|
|
|
|
|
|
|
return broadcast;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
#ifdef CONFIG_TICK_ONESHOT
|
|
|
|
|
2013-03-05 06:25:32 -07:00
|
|
|
static cpumask_var_t tick_broadcast_oneshot_mask;
|
2013-03-06 04:18:35 -07:00
|
|
|
static cpumask_var_t tick_broadcast_pending_mask;
|
2013-03-06 04:18:35 -07:00
|
|
|
static cpumask_var_t tick_broadcast_force_mask;
|
2007-02-16 02:28:03 -07:00
|
|
|
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
/*
|
2008-12-31 16:42:25 -07:00
|
|
|
* Exposed for debugging: see timer_list.c
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
*/
|
2008-12-31 16:42:25 -07:00
|
|
|
struct cpumask *tick_get_broadcast_oneshot_mask(void)
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
{
|
2013-03-05 06:25:32 -07:00
|
|
|
return tick_broadcast_oneshot_mask;
|
[PATCH] Add debugging feature /proc/timer_list
add /proc/timer_list, which prints all currently pending (high-res) timers,
all clock-event sources and their parameters in a human-readable form.
Sample output:
Timer List Version: v0.1
HRTIMER_MAX_CLOCK_BASES: 2
now at 4246046273872 nsecs
cpu: 0
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_stop_sched_tick, swapper/0
# expires at 4246432689566 nsecs [in 386415694 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, pcscd/2050
# expires at 4247018194689 nsecs [in 971920817 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, irqbalance/1909
# expires at 4247351358392 nsecs [in 1305084520 nsecs]
#3: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, crond/2157
# expires at 4249097614968 nsecs [in 3051341096 nsecs]
#4: <f5a90ec8>, it_real_fn, do_setitimer, syslogd/1888
# expires at 4251329900926 nsecs [in 5283627054 nsecs]
.expires_next : 4246432689566 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 31306
.idle_tick : 4246020791890 nsecs
.tick_stopped : 1
.idle_jiffies : 986504
.idle_calls : 40700
.idle_sleeps : 36014
.idle_entrytime : 4246019418883 nsecs
.idle_sleeptime : 4178181972709 nsecs
cpu: 1
clock 0:
.index: 0
.resolution: 1 nsecs
.get_time: ktime_get_real
.offset: 1273998312645738432 nsecs
active timers:
clock 1:
.index: 1
.resolution: 1 nsecs
.get_time: ktime_get
.offset: 0 nsecs
active timers:
#0: <f5a90ec8>, hrtimer_sched_tick, hrtimer_restart_sched_tick, swapper/0
# expires at 4246050084568 nsecs [in 3810696 nsecs]
#1: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, atd/2227
# expires at 4261010635003 nsecs [in 14964361131 nsecs]
#2: <f5a90ec8>, hrtimer_wakeup, do_nanosleep, smartd/2332
# expires at 5469485798970 nsecs [in 1223439525098 nsecs]
.expires_next : 4246050084568 nsecs
.hres_active : 1
.check_clocks : 0
.nr_events : 24043
.idle_tick : 4246046084568 nsecs
.tick_stopped : 0
.idle_jiffies : 986510
.idle_calls : 26360
.idle_sleeps : 22551
.idle_entrytime : 4246043874339 nsecs
.idle_sleeptime : 4170763761184 nsecs
tick_broadcast_mask: 00000003
event_broadcast_mask: 00000001
CPU#0's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246432689566 nsecs
CPU#1's local event device:
Clock Event Device: lapic
capabilities: 0000000e
max_delta_ns: 807385544
min_delta_ns: 1443
mult: 44624025
shift: 32
set_next_event: lapic_next_event
set_mode: lapic_timer_setup
event_handler: hrtimer_interrupt
.installed: 1
.expires: 4246050084568 nsecs
Clock Event Device: hpet
capabilities: 00000007
max_delta_ns: 2147483647
min_delta_ns: 3352
mult: 61496110
shift: 32
set_next_event: hpet_next_event
set_mode: hpet_set_mode
event_handler: handle_nextevt_broadcast
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-16 02:28:15 -07:00
|
|
|
}
|
|
|
|
|
2013-03-06 04:18:36 -07:00
|
|
|
/*
|
|
|
|
* Called before going idle with interrupts disabled. Checks whether a
|
|
|
|
* broadcast event from the other core is about to happen. We detected
|
|
|
|
* that in tick_broadcast_oneshot_control(). The callsite can use this
|
|
|
|
* to avoid a deep idle transition as we are about to get the
|
|
|
|
* broadcast IPI right away.
|
|
|
|
*/
|
|
|
|
int tick_check_broadcast_expired(void)
|
|
|
|
{
|
|
|
|
return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask);
|
|
|
|
}
|
|
|
|
|
2013-03-02 03:10:11 -07:00
|
|
|
/*
|
|
|
|
* Set broadcast interrupt affinity
|
|
|
|
*/
|
|
|
|
static void tick_broadcast_set_affinity(struct clock_event_device *bc,
|
|
|
|
const struct cpumask *cpumask)
|
|
|
|
{
|
|
|
|
if (!(bc->features & CLOCK_EVT_FEAT_DYNIRQ))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (cpumask_equal(bc->cpumask, cpumask))
|
|
|
|
return;
|
|
|
|
|
|
|
|
bc->cpumask = cpumask;
|
|
|
|
irq_set_affinity(bc->irq, bc->cpumask);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tick_broadcast_set_event(struct clock_event_device *bc, int cpu,
|
2013-03-02 03:10:10 -07:00
|
|
|
ktime_t expires, int force)
|
2007-02-16 02:28:03 -07:00
|
|
|
{
|
2013-03-02 03:10:11 -07:00
|
|
|
int ret;
|
|
|
|
|
tick: Ensure that the broadcast device is initialized
Santosh found another trap when we avoid to initialize the broadcast
device in the switch_to_oneshot code. The broadcast device might be
still in SHUTDOWN state when we actually need to use it. That
obviously breaks, as set_next_event() is called on a shutdown
device. This did not break on x86, but Suresh analyzed it:
From the review, most likely on Sven's system we are force enabling
the hpet using the pci quirk's method very late. And in this case,
hpet_clockevent (which will be global_clock_event) handler can be
null, specifically as this platform might not be using deeper c-states
and using the reliable APIC timer.
Prior to commit 'fa4da365bc7772c', that handler will be set to
'tick_handle_oneshot_broadcast' when we switch the broadcast timer to
oneshot mode, even though we don't use it. Post commit
'fa4da365bc7772c', we stopped switching the broadcast mode to oneshot
as this is not really needed and his platform's global_clock_event's
handler will remain null. While on my SNB laptop, same is set to
'clockevents_handle_noop' because hpet gets enabled very early. (noop
handler on my platform set when the early enabled hpet timer gets
replaced by the lapic timer).
But the commit 'fa4da365bc7772c' tracked the broadcast timer mode in
the SW as oneshot, even though it didn't touch the HW timer. During
resume however, tick_resume_broadcast() saw the SW broadcast mode as
oneshot and actually programmed the broadcast device also into oneshot
mode. So this triggered the null pointer de-reference after the hpet
wraps around and depending on what the hpet counter is set to. On the
normal platforms where hpet gets enabled early we should be seeing a
spurious interrupt (in my SNB laptop I see one spurious interrupt
after around 5 minutes ;) which is 32-bit hpet counter wraparound
time), but that's a separate issue.
Enforce the mode setting when trying to set an event.
Reported-and-tested-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: torvalds@linux-foundation.org
Cc: svenjoac@gmx.de
Cc: rjw@sisk.pl
Link: http://lkml.kernel.org/r/alpine.LFD.2.02.1204181723350.2542@ionos
2012-04-18 09:31:58 -06:00
|
|
|
if (bc->mode != CLOCK_EVT_MODE_ONESHOT)
|
|
|
|
clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
|
|
|
|
|
2013-03-02 03:10:11 -07:00
|
|
|
ret = clockevents_program_event(bc, expires, force);
|
|
|
|
if (!ret)
|
|
|
|
tick_broadcast_set_affinity(bc, cpumask_of(cpu));
|
|
|
|
return ret;
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
2007-03-16 17:25:52 -06:00
|
|
|
int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
|
|
|
|
{
|
|
|
|
clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
|
2007-09-22 16:29:06 -06:00
|
|
|
return 0;
|
2007-03-16 17:25:52 -06:00
|
|
|
}
|
|
|
|
|
2008-10-17 02:01:23 -06:00
|
|
|
/*
|
|
|
|
* Called from irq_enter() when idle was interrupted to reenable the
|
|
|
|
* per cpu device.
|
|
|
|
*/
|
|
|
|
void tick_check_oneshot_broadcast(int cpu)
|
|
|
|
{
|
2013-03-05 06:25:32 -07:00
|
|
|
if (cpumask_test_cpu(cpu, tick_broadcast_oneshot_mask)) {
|
2008-10-17 02:01:23 -06:00
|
|
|
struct tick_device *td = &per_cpu(tick_cpu_device, cpu);
|
|
|
|
|
tick: Prevent uncontrolled switch to oneshot mode
When the system switches from periodic to oneshot mode, the broadcast
logic causes a possibility that a CPU which has not yet switched to
oneshot mode puts its own clock event device into oneshot mode without
updating the state and the timer handler.
CPU0 CPU1
per cpu tickdev is in periodic mode
and switched to broadcast
Switch to oneshot mode
tick_broadcast_switch_to_oneshot()
cpumask_copy(tick_oneshot_broacast_mask,
tick_broadcast_mask);
broadcast device mode = oneshot
Timer interrupt
irq_enter()
tick_check_oneshot_broadcast()
dev->set_mode(ONESHOT);
tick_handle_periodic()
if (dev->mode == ONESHOT)
dev->next_event += period;
FAIL.
We fail, because dev->next_event contains KTIME_MAX, if the device was
in periodic mode before the uncontrolled switch to oneshot happened.
We must copy the broadcast bits over to the oneshot mask, because
otherwise a CPU which relies on the broadcast would not been woken up
anymore after the broadcast device switched to oneshot mode.
So we need to verify in tick_check_oneshot_broadcast() whether the CPU
has already switched to oneshot mode. If not, leave the device
untouched and let the CPU switch controlled into oneshot mode.
This is a long standing bug, which was never noticed, because the main
user of the broadcast x86 cannot run into that scenario, AFAICT. The
nonarchitected timer mess of ARM creates a gazillion of differently
broken abominations which trigger the shortcomings of that broadcast
code, which better had never been necessary in the first place.
Reported-and-tested-by: Stehle Vincent-B46079 <B46079@freescale.com>
Reviewed-by: Stephen Boyd <sboyd@codeaurora.org>
Cc: John Stultz <john.stultz@linaro.org>,
Cc: Mark Rutland <mark.rutland@arm.com>
Link: http://lkml.kernel.org/r/alpine.DEB.2.02.1307012153060.4013@ionos.tec.linutronix.de
Cc: stable@vger.kernel.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2013-07-01 14:14:10 -06:00
|
|
|
/*
|
|
|
|
* We might be in the middle of switching over from
|
|
|
|
* periodic to oneshot. If the CPU has not yet
|
|
|
|
* switched over, leave the device alone.
|
|
|
|
*/
|
|
|
|
if (td->mode == TICKDEV_MODE_ONESHOT) {
|
|
|
|
clockevents_set_mode(td->evtdev,
|
|
|
|
CLOCK_EVT_MODE_ONESHOT);
|
|
|
|
}
|
2008-10-17 02:01:23 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
/*
|
|
|
|
* Handle oneshot mode broadcasting
|
|
|
|
*/
|
|
|
|
static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
|
|
|
|
{
|
|
|
|
struct tick_device *td;
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
ktime_t now, next_event;
|
2013-03-02 03:10:11 -07:00
|
|
|
int cpu, next_cpu = 0;
|
2007-02-16 02:28:03 -07:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock(&tick_broadcast_lock);
|
2007-02-16 02:28:03 -07:00
|
|
|
again:
|
|
|
|
dev->next_event.tv64 = KTIME_MAX;
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
next_event.tv64 = KTIME_MAX;
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_clear(tmpmask);
|
2007-02-16 02:28:03 -07:00
|
|
|
now = ktime_get();
|
|
|
|
/* Find all expired events */
|
2013-03-05 06:25:32 -07:00
|
|
|
for_each_cpu(cpu, tick_broadcast_oneshot_mask) {
|
2007-02-16 02:28:03 -07:00
|
|
|
td = &per_cpu(tick_cpu_device, cpu);
|
2013-03-02 03:10:11 -07:00
|
|
|
if (td->evtdev->next_event.tv64 <= now.tv64) {
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_set_cpu(cpu, tmpmask);
|
2013-03-06 04:18:35 -07:00
|
|
|
/*
|
|
|
|
* Mark the remote cpu in the pending mask, so
|
|
|
|
* it can avoid reprogramming the cpu local
|
|
|
|
* timer in tick_broadcast_oneshot_control().
|
|
|
|
*/
|
|
|
|
cpumask_set_cpu(cpu, tick_broadcast_pending_mask);
|
2013-03-02 03:10:11 -07:00
|
|
|
} else if (td->evtdev->next_event.tv64 < next_event.tv64) {
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
next_event.tv64 = td->evtdev->next_event.tv64;
|
2013-03-02 03:10:11 -07:00
|
|
|
next_cpu = cpu;
|
|
|
|
}
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
2013-05-28 01:33:01 -06:00
|
|
|
/*
|
|
|
|
* Remove the current cpu from the pending mask. The event is
|
|
|
|
* delivered immediately in tick_do_broadcast() !
|
|
|
|
*/
|
|
|
|
cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask);
|
|
|
|
|
2013-03-06 04:18:35 -07:00
|
|
|
/* Take care of enforced broadcast requests */
|
|
|
|
cpumask_or(tmpmask, tmpmask, tick_broadcast_force_mask);
|
|
|
|
cpumask_clear(tick_broadcast_force_mask);
|
|
|
|
|
2013-06-26 04:17:32 -06:00
|
|
|
/*
|
|
|
|
* Sanity check. Catch the case where we try to broadcast to
|
|
|
|
* offline cpus.
|
|
|
|
*/
|
|
|
|
if (WARN_ON_ONCE(!cpumask_subset(tmpmask, cpu_online_mask)))
|
|
|
|
cpumask_and(tmpmask, tmpmask, cpu_online_mask);
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
/*
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
* Wakeup the cpus which have an expired event.
|
|
|
|
*/
|
2013-03-05 06:25:32 -07:00
|
|
|
tick_do_broadcast(tmpmask);
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Two reasons for reprogram:
|
|
|
|
*
|
|
|
|
* - The global event did not expire any CPU local
|
|
|
|
* events. This happens in dyntick mode, as the maximum PIT
|
|
|
|
* delta is quite small.
|
|
|
|
*
|
|
|
|
* - There are pending events on sleeping CPUs which were not
|
|
|
|
* in the event mask
|
2007-02-16 02:28:03 -07:00
|
|
|
*/
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
if (next_event.tv64 != KTIME_MAX) {
|
2007-02-16 02:28:03 -07:00
|
|
|
/*
|
clockevents: fix reprogramming decision in oneshot broadcast
Resolve the following regression of a choppy, almost unusable laptop:
http://lkml.org/lkml/2007/12/7/299
http://bugzilla.kernel.org/show_bug.cgi?id=9525
A previous version of the code did the reprogramming of the broadcast
device in the return from idle code. This was removed, but the logic in
tick_handle_oneshot_broadcast() was kept the same.
When a broadcast interrupt happens we signal the expiry to all CPUs
which have an expired event. If none of the CPUs has an expired event,
which can happen in dyntick mode, then we reprogram the broadcast
device. We do not reprogram otherwise, but this is only correct if all
CPUs, which are in the idle broadcast state have been woken up.
The code ignores, that there might be pending not yet expired events on
other CPUs, which are in the idle broadcast state. So the delivery of
those events can be delayed for quite a time.
Change the tick_handle_oneshot_broadcast() function to check for CPUs,
which are in broadcast state and are not woken up by the current event,
and enforce the rearming of the broadcast device for those CPUs.
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2007-12-18 10:05:58 -07:00
|
|
|
* Rearm the broadcast device. If event expired,
|
|
|
|
* repeat the above
|
2007-02-16 02:28:03 -07:00
|
|
|
*/
|
2013-03-02 03:10:11 -07:00
|
|
|
if (tick_broadcast_set_event(dev, next_cpu, next_event, 0))
|
2007-02-16 02:28:03 -07:00
|
|
|
goto again;
|
|
|
|
}
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock(&tick_broadcast_lock);
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Powerstate information: The system enters/leaves a state, where
|
|
|
|
* affected devices might stop
|
|
|
|
*/
|
|
|
|
void tick_broadcast_oneshot_control(unsigned long reason)
|
|
|
|
{
|
|
|
|
struct clock_event_device *bc, *dev;
|
|
|
|
struct tick_device *td;
|
|
|
|
unsigned long flags;
|
2013-03-06 04:18:35 -07:00
|
|
|
ktime_t now;
|
2007-02-16 02:28:03 -07:00
|
|
|
int cpu;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Periodic mode does not care about the enter/exit of power
|
|
|
|
* states
|
|
|
|
*/
|
|
|
|
if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
|
2011-05-04 16:09:27 -06:00
|
|
|
return;
|
2007-02-16 02:28:03 -07:00
|
|
|
|
2011-05-04 16:09:27 -06:00
|
|
|
/*
|
|
|
|
* We are called with preemtion disabled from the depth of the
|
|
|
|
* idle code, so we can't be moved away.
|
|
|
|
*/
|
2007-02-16 02:28:03 -07:00
|
|
|
cpu = smp_processor_id();
|
|
|
|
td = &per_cpu(tick_cpu_device, cpu);
|
|
|
|
dev = td->evtdev;
|
|
|
|
|
|
|
|
if (!(dev->features & CLOCK_EVT_FEAT_C3STOP))
|
2011-05-04 16:09:27 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
bc = tick_broadcast_device.evtdev;
|
2007-02-16 02:28:03 -07:00
|
|
|
|
2011-05-04 16:09:27 -06:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:03 -07:00
|
|
|
if (reason == CLOCK_EVT_NOTIFY_BROADCAST_ENTER) {
|
2013-03-05 06:25:32 -07:00
|
|
|
if (!cpumask_test_and_set_cpu(cpu, tick_broadcast_oneshot_mask)) {
|
2013-05-28 01:33:01 -06:00
|
|
|
WARN_ON_ONCE(cpumask_test_cpu(cpu, tick_broadcast_pending_mask));
|
2007-02-16 02:28:03 -07:00
|
|
|
clockevents_set_mode(dev, CLOCK_EVT_MODE_SHUTDOWN);
|
2013-03-06 04:18:35 -07:00
|
|
|
/*
|
|
|
|
* We only reprogram the broadcast timer if we
|
|
|
|
* did not mark ourself in the force mask and
|
|
|
|
* if the cpu local event is earlier than the
|
|
|
|
* broadcast event. If the current CPU is in
|
|
|
|
* the force mask, then we are going to be
|
|
|
|
* woken by the IPI right away.
|
|
|
|
*/
|
|
|
|
if (!cpumask_test_cpu(cpu, tick_broadcast_force_mask) &&
|
|
|
|
dev->next_event.tv64 < bc->next_event.tv64)
|
2013-03-02 03:10:11 -07:00
|
|
|
tick_broadcast_set_event(bc, cpu, dev->next_event, 1);
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
} else {
|
2013-03-05 06:25:32 -07:00
|
|
|
if (cpumask_test_and_clear_cpu(cpu, tick_broadcast_oneshot_mask)) {
|
2007-02-16 02:28:03 -07:00
|
|
|
clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);
|
2013-03-06 04:18:35 -07:00
|
|
|
/*
|
|
|
|
* The cpu which was handling the broadcast
|
|
|
|
* timer marked this cpu in the broadcast
|
|
|
|
* pending mask and fired the broadcast
|
|
|
|
* IPI. So we are going to handle the expired
|
|
|
|
* event anyway via the broadcast IPI
|
|
|
|
* handler. No need to reprogram the timer
|
|
|
|
* with an already expired event.
|
|
|
|
*/
|
|
|
|
if (cpumask_test_and_clear_cpu(cpu,
|
|
|
|
tick_broadcast_pending_mask))
|
|
|
|
goto out;
|
|
|
|
|
tick: Fix tick_broadcast_pending_mask not cleared
The recent modification in the cpuidle framework consolidated the
timer broadcast code across the different drivers by setting a new
flag in the idle state. It tells the cpuidle core code to enter/exit
the broadcast mode for the cpu when entering a deep idle state. The
broadcast timer enter/exit is no longer handled by the back-end
driver.
This change made the local interrupt to be enabled *before* calling
CLOCK_EVENT_NOTIFY_EXIT.
On a tegra114, a four cores system, when the flag has been introduced
in the driver, the following warning appeared:
WARNING: at kernel/time/tick-broadcast.c:578 tick_broadcast_oneshot_control
CPU: 2 PID: 0 Comm: swapper/2 Not tainted 3.10.0-rc3-next-20130529+ #15
[<c00667f8>] (tick_broadcast_oneshot_control+0x1a4/0x1d0) from [<c0065cd0>] (tick_notify+0x240/0x40c)
[<c0065cd0>] (tick_notify+0x240/0x40c) from [<c0044724>] (notifier_call_chain+0x44/0x84)
[<c0044724>] (notifier_call_chain+0x44/0x84) from [<c0044828>] (raw_notifier_call_chain+0x18/0x20)
[<c0044828>] (raw_notifier_call_chain+0x18/0x20) from [<c00650cc>] (clockevents_notify+0x28/0x170)
[<c00650cc>] (clockevents_notify+0x28/0x170) from [<c033f1f0>] (cpuidle_idle_call+0x11c/0x168)
[<c033f1f0>] (cpuidle_idle_call+0x11c/0x168) from [<c000ea94>] (arch_cpu_idle+0x8/0x38)
[<c000ea94>] (arch_cpu_idle+0x8/0x38) from [<c005ea80>] (cpu_startup_entry+0x60/0x134)
[<c005ea80>] (cpu_startup_entry+0x60/0x134) from [<804fe9a4>] (0x804fe9a4)
I don't have the hardware, so I wasn't able to reproduce the warning
but after looking a while at the code, I deduced the following:
1. the CPU2 enters a deep idle state and sets the broadcast timer
2. the timer expires, the tick_handle_oneshot_broadcast function is
called, setting the tick_broadcast_pending_mask and waking up the
idle cpu CPU2
3. the CPU2 exits idle handles the interrupt and then invokes
tick_broadcast_oneshot_control with CLOCK_EVENT_NOTIFY_EXIT which
runs the following code:
[...]
if (dev->next_event.tv64 == KTIME_MAX)
goto out;
if (cpumask_test_and_clear_cpu(cpu,
tick_broadcast_pending_mask))
goto out;
[...]
So if there is no next event scheduled for CPU2, we fulfil the
first condition and jump out without clearing the
tick_broadcast_pending_mask.
4. CPU2 goes to deep idle again and calls
tick_broadcast_oneshot_control with CLOCK_NOTIFY_EVENT_ENTER but
with the tick_broadcast_pending_mask set for CPU2, triggering the
warning.
The issue only surfaced due to the modifications of the cpuidle
framework, which resulted in interrupts being enabled before the call
to the clockevents code. If the call happens before interrupts have
been enabled, the warning cannot trigger, because there is still the
event pending which caused the broadcast timer expiry.
Move the check for the next event below the check for the pending bit,
so the pending bit gets cleared whether an event is scheduled on the
cpu or not.
[ tglx: Massaged changelog ]
Signed-off-by: Daniel Lezcano <daniel.lezcano@linaro.org>
Reported-and-tested-by: Joseph Lo <josephl@nvidia.com>
Cc: Stephen Warren <swarren@nvidia.com>
Cc: linux-arm-kernel@lists.infradead.org
Cc: linaro-kernel@lists.linaro.org
Link: http://lkml.kernel.org/r/1371485735-31249-1-git-send-email-daniel.lezcano@linaro.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2013-06-17 10:15:35 -06:00
|
|
|
/*
|
|
|
|
* Bail out if there is no next event.
|
|
|
|
*/
|
|
|
|
if (dev->next_event.tv64 == KTIME_MAX)
|
|
|
|
goto out;
|
2013-03-06 04:18:35 -07:00
|
|
|
/*
|
|
|
|
* If the pending bit is not set, then we are
|
|
|
|
* either the CPU handling the broadcast
|
|
|
|
* interrupt or we got woken by something else.
|
|
|
|
*
|
|
|
|
* We are not longer in the broadcast mask, so
|
|
|
|
* if the cpu local expiry time is already
|
|
|
|
* reached, we would reprogram the cpu local
|
|
|
|
* timer with an already expired event.
|
|
|
|
*
|
|
|
|
* This can lead to a ping-pong when we return
|
|
|
|
* to idle and therefor rearm the broadcast
|
|
|
|
* timer before the cpu local timer was able
|
|
|
|
* to fire. This happens because the forced
|
|
|
|
* reprogramming makes sure that the event
|
|
|
|
* will happen in the future and depending on
|
|
|
|
* the min_delta setting this might be far
|
|
|
|
* enough out that the ping-pong starts.
|
|
|
|
*
|
|
|
|
* If the cpu local next_event has expired
|
|
|
|
* then we know that the broadcast timer
|
|
|
|
* next_event has expired as well and
|
|
|
|
* broadcast is about to be handled. So we
|
|
|
|
* avoid reprogramming and enforce that the
|
|
|
|
* broadcast handler, which did not run yet,
|
|
|
|
* will invoke the cpu local handler.
|
|
|
|
*
|
|
|
|
* We cannot call the handler directly from
|
|
|
|
* here, because we might be in a NOHZ phase
|
|
|
|
* and we did not go through the irq_enter()
|
|
|
|
* nohz fixups.
|
|
|
|
*/
|
|
|
|
now = ktime_get();
|
|
|
|
if (dev->next_event.tv64 <= now.tv64) {
|
|
|
|
cpumask_set_cpu(cpu, tick_broadcast_force_mask);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We got woken by something else. Reprogram
|
|
|
|
* the cpu local timer device.
|
|
|
|
*/
|
2013-03-06 04:18:35 -07:00
|
|
|
tick_program_event(dev->next_event, 1);
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
}
|
2013-03-06 04:18:35 -07:00
|
|
|
out:
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
2007-07-21 05:37:35 -06:00
|
|
|
/*
|
|
|
|
* Reset the one shot broadcast for a cpu
|
|
|
|
*
|
|
|
|
* Called with tick_broadcast_lock held
|
|
|
|
*/
|
|
|
|
static void tick_broadcast_clear_oneshot(int cpu)
|
|
|
|
{
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_oneshot_mask);
|
2007-07-21 05:37:35 -06:00
|
|
|
}
|
|
|
|
|
2008-12-31 16:42:25 -07:00
|
|
|
static void tick_broadcast_init_next_event(struct cpumask *mask,
|
|
|
|
ktime_t expires)
|
2008-09-05 19:01:45 -06:00
|
|
|
{
|
|
|
|
struct tick_device *td;
|
|
|
|
int cpu;
|
|
|
|
|
2008-12-31 16:42:29 -07:00
|
|
|
for_each_cpu(cpu, mask) {
|
2008-09-05 19:01:45 -06:00
|
|
|
td = &per_cpu(tick_cpu_device, cpu);
|
|
|
|
if (td->evtdev)
|
|
|
|
td->evtdev->next_event = expires;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
/**
|
2007-11-05 15:51:10 -07:00
|
|
|
* tick_broadcast_setup_oneshot - setup the broadcast device
|
2007-02-16 02:28:03 -07:00
|
|
|
*/
|
|
|
|
void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
|
|
|
|
{
|
2011-05-16 03:07:48 -06:00
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
2008-09-03 15:37:08 -06:00
|
|
|
/* Set it up only once ! */
|
|
|
|
if (bc->event_handler != tick_handle_oneshot_broadcast) {
|
2008-09-05 19:01:45 -06:00
|
|
|
int was_periodic = bc->mode == CLOCK_EVT_MODE_PERIODIC;
|
|
|
|
|
2008-09-03 15:37:08 -06:00
|
|
|
bc->event_handler = tick_handle_oneshot_broadcast;
|
2008-09-05 19:01:45 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We must be careful here. There might be other CPUs
|
|
|
|
* waiting for periodic broadcast. We need to set the
|
|
|
|
* oneshot_mask bits for those and program the
|
|
|
|
* broadcast device to fire.
|
|
|
|
*/
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_copy(tmpmask, tick_broadcast_mask);
|
|
|
|
cpumask_clear_cpu(cpu, tmpmask);
|
|
|
|
cpumask_or(tick_broadcast_oneshot_mask,
|
|
|
|
tick_broadcast_oneshot_mask, tmpmask);
|
2008-12-31 16:42:25 -07:00
|
|
|
|
2013-03-05 06:25:32 -07:00
|
|
|
if (was_periodic && !cpumask_empty(tmpmask)) {
|
2012-04-18 04:08:23 -06:00
|
|
|
clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
|
2013-03-05 06:25:32 -07:00
|
|
|
tick_broadcast_init_next_event(tmpmask,
|
2008-12-31 16:42:25 -07:00
|
|
|
tick_next_period);
|
2013-03-02 03:10:11 -07:00
|
|
|
tick_broadcast_set_event(bc, cpu, tick_next_period, 1);
|
2008-09-05 19:01:45 -06:00
|
|
|
} else
|
|
|
|
bc->next_event.tv64 = KTIME_MAX;
|
2011-05-16 03:07:48 -06:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The first cpu which switches to oneshot mode sets
|
|
|
|
* the bit for all other cpus which are in the general
|
|
|
|
* (periodic) broadcast mask. So the bit is set and
|
|
|
|
* would prevent the first broadcast enter after this
|
|
|
|
* to program the bc device.
|
|
|
|
*/
|
|
|
|
tick_broadcast_clear_oneshot(cpu);
|
2008-09-03 15:37:08 -06:00
|
|
|
}
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Select oneshot operating mode for the broadcast device
|
|
|
|
*/
|
|
|
|
void tick_broadcast_switch_to_oneshot(void)
|
|
|
|
{
|
|
|
|
struct clock_event_device *bc;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2012-04-09 16:41:44 -06:00
|
|
|
|
|
|
|
tick_broadcast_device.mode = TICKDEV_MODE_ONESHOT;
|
2007-02-16 02:28:03 -07:00
|
|
|
bc = tick_broadcast_device.evtdev;
|
|
|
|
if (bc)
|
|
|
|
tick_broadcast_setup_oneshot(bc);
|
2011-11-04 18:18:21 -06:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove a dead CPU from broadcasting
|
|
|
|
*/
|
|
|
|
void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int cpu = *cpup;
|
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_lock_irqsave(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:03 -07:00
|
|
|
|
2007-09-16 07:36:43 -06:00
|
|
|
/*
|
2013-06-26 04:17:32 -06:00
|
|
|
* Clear the broadcast masks for the dead cpu, but do not stop
|
|
|
|
* the broadcast device!
|
2007-09-16 07:36:43 -06:00
|
|
|
*/
|
2013-03-05 06:25:32 -07:00
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_oneshot_mask);
|
2013-06-26 04:17:32 -06:00
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_pending_mask);
|
|
|
|
cpumask_clear_cpu(cpu, tick_broadcast_force_mask);
|
2007-02-16 02:28:03 -07:00
|
|
|
|
2009-12-08 04:40:31 -07:00
|
|
|
raw_spin_unlock_irqrestore(&tick_broadcast_lock, flags);
|
2007-02-16 02:28:03 -07:00
|
|
|
}
|
|
|
|
|
2008-09-22 11:04:02 -06:00
|
|
|
/*
|
|
|
|
* Check, whether the broadcast device is in one shot mode
|
|
|
|
*/
|
|
|
|
int tick_broadcast_oneshot_active(void)
|
|
|
|
{
|
|
|
|
return tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT;
|
|
|
|
}
|
|
|
|
|
2011-02-25 14:34:23 -07:00
|
|
|
/*
|
|
|
|
* Check whether the broadcast device supports oneshot.
|
|
|
|
*/
|
|
|
|
bool tick_broadcast_oneshot_available(void)
|
|
|
|
{
|
|
|
|
struct clock_event_device *bc = tick_broadcast_device.evtdev;
|
|
|
|
|
|
|
|
return bc ? bc->features & CLOCK_EVT_FEAT_ONESHOT : false;
|
|
|
|
}
|
|
|
|
|
2007-02-16 02:28:03 -07:00
|
|
|
#endif
|
2013-03-05 06:25:32 -07:00
|
|
|
|
|
|
|
void __init tick_broadcast_init(void)
|
|
|
|
{
|
2013-05-03 12:22:36 -06:00
|
|
|
zalloc_cpumask_var(&tick_broadcast_mask, GFP_NOWAIT);
|
2013-07-01 14:14:10 -06:00
|
|
|
zalloc_cpumask_var(&tick_broadcast_on, GFP_NOWAIT);
|
2013-05-03 12:22:36 -06:00
|
|
|
zalloc_cpumask_var(&tmpmask, GFP_NOWAIT);
|
2013-03-05 06:25:32 -07:00
|
|
|
#ifdef CONFIG_TICK_ONESHOT
|
2013-05-03 12:22:36 -06:00
|
|
|
zalloc_cpumask_var(&tick_broadcast_oneshot_mask, GFP_NOWAIT);
|
|
|
|
zalloc_cpumask_var(&tick_broadcast_pending_mask, GFP_NOWAIT);
|
|
|
|
zalloc_cpumask_var(&tick_broadcast_force_mask, GFP_NOWAIT);
|
2013-03-05 06:25:32 -07:00
|
|
|
#endif
|
|
|
|
}
|