2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Common time routines among all ppc machines.
|
|
|
|
*
|
|
|
|
* Written by Cort Dougan (cort@cs.nmt.edu) to merge
|
|
|
|
* Paul Mackerras' version and mine for PReP and Pmac.
|
|
|
|
* MPC8xx/MBX changes by Dan Malek (dmalek@jlc.net).
|
|
|
|
* Converted for 64-bit by Mike Corrigan (mikejc@us.ibm.com)
|
|
|
|
*
|
|
|
|
* First round of bugfixes by Gabriel Paubert (paubert@iram.es)
|
|
|
|
* to make clock more stable (2.4.0-test5). The only thing
|
|
|
|
* that this code assumes is that the timebases have been synchronized
|
|
|
|
* by firmware on SMP and are never stopped (never do sleep
|
|
|
|
* on SMP then, nap and doze are OK).
|
|
|
|
*
|
|
|
|
* Speeded up do_gettimeofday by getting rid of references to
|
|
|
|
* xtime (which required locks for consistency). (mikejc@us.ibm.com)
|
|
|
|
*
|
|
|
|
* TODO (not necessarily in this file):
|
|
|
|
* - improve precision and reproducibility of timebase frequency
|
|
|
|
* measurement at boot time. (for iSeries, we calibrate the timebase
|
|
|
|
* against the Titan chip's clock.)
|
|
|
|
* - for astronomical applications: add a new function to get
|
|
|
|
* non ambiguous timestamps even around leap seconds. This needs
|
|
|
|
* a new timestamp format and a good name.
|
|
|
|
*
|
|
|
|
* 1997-09-10 Updated NTP code according to technical memorandum Jan '96
|
|
|
|
* "A Kernel Model for Precision Timekeeping" by Dave Mills
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/param.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/timex.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/profile.h>
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
#include <linux/security.h>
|
2005-10-20 01:23:26 +02:00
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/rtc.h>
|
2006-02-20 00:38:56 +01:00
|
|
|
#include <linux/jiffies.h>
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
#include <linux/posix-timers.h>
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
#include <linux/irq.h>
|
2009-06-09 23:12:00 +02:00
|
|
|
#include <linux/delay.h>
|
2010-10-14 08:01:34 +02:00
|
|
|
#include <linux/irq_work.h>
|
2009-10-26 19:49:14 +01:00
|
|
|
#include <asm/trace.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/nvram.h>
|
|
|
|
#include <asm/cache.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/time.h>
|
|
|
|
#include <asm/prom.h>
|
2005-10-20 01:23:26 +02:00
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/div64.h>
|
2005-11-07 03:18:13 +01:00
|
|
|
#include <asm/smp.h>
|
2005-11-11 11:15:21 +01:00
|
|
|
#include <asm/vdso_datapage.h>
|
2005-08-03 06:35:25 +02:00
|
|
|
#include <asm/firmware.h>
|
2008-02-06 10:36:12 +01:00
|
|
|
#include <asm/cputime.h>
|
2005-10-20 01:23:26 +02:00
|
|
|
#ifdef CONFIG_PPC_ISERIES
|
2005-11-02 04:13:34 +01:00
|
|
|
#include <asm/iseries/it_lp_queue.h>
|
2005-11-02 01:41:12 +01:00
|
|
|
#include <asm/iseries/hv_call_xm.h>
|
2005-10-20 01:23:26 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-09-21 23:35:52 +02:00
|
|
|
/* powerpc clocksource/clockevent code */
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
#include <linux/clockchips.h>
|
2007-09-21 23:35:52 +02:00
|
|
|
#include <linux/clocksource.h>
|
|
|
|
|
2009-04-21 21:24:00 +02:00
|
|
|
static cycle_t rtc_read(struct clocksource *);
|
2007-09-21 23:35:52 +02:00
|
|
|
static struct clocksource clocksource_rtc = {
|
|
|
|
.name = "rtc",
|
|
|
|
.rating = 400,
|
|
|
|
.flags = CLOCK_SOURCE_IS_CONTINUOUS,
|
|
|
|
.mask = CLOCKSOURCE_MASK(64),
|
|
|
|
.shift = 22,
|
|
|
|
.mult = 0, /* To be filled in */
|
|
|
|
.read = rtc_read,
|
|
|
|
};
|
|
|
|
|
2009-04-21 21:24:00 +02:00
|
|
|
static cycle_t timebase_read(struct clocksource *);
|
2007-09-21 23:35:52 +02:00
|
|
|
static struct clocksource clocksource_timebase = {
|
|
|
|
.name = "timebase",
|
|
|
|
.rating = 400,
|
|
|
|
.flags = CLOCK_SOURCE_IS_CONTINUOUS,
|
|
|
|
.mask = CLOCKSOURCE_MASK(64),
|
|
|
|
.shift = 22,
|
|
|
|
.mult = 0, /* To be filled in */
|
|
|
|
.read = timebase_read,
|
|
|
|
};
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
#define DECREMENTER_MAX 0x7fffffff
|
|
|
|
|
|
|
|
static int decrementer_set_next_event(unsigned long evt,
|
|
|
|
struct clock_event_device *dev);
|
|
|
|
static void decrementer_set_mode(enum clock_event_mode mode,
|
|
|
|
struct clock_event_device *dev);
|
|
|
|
|
|
|
|
static struct clock_event_device decrementer_clockevent = {
|
|
|
|
.name = "decrementer",
|
|
|
|
.rating = 200,
|
2009-05-10 15:37:36 +02:00
|
|
|
.shift = 0, /* To be filled in */
|
2007-09-21 05:26:03 +02:00
|
|
|
.mult = 0, /* To be filled in */
|
|
|
|
.irq = 0,
|
|
|
|
.set_next_event = decrementer_set_next_event,
|
|
|
|
.set_mode = decrementer_set_mode,
|
|
|
|
.features = CLOCK_EVT_FEAT_ONESHOT,
|
|
|
|
};
|
|
|
|
|
2007-12-14 05:52:15 +01:00
|
|
|
struct decrementer_clock {
|
|
|
|
struct clock_event_device event;
|
|
|
|
u64 next_tb;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_PER_CPU(struct decrementer_clock, decrementers);
|
2007-09-21 05:26:03 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_PPC_ISERIES
|
2007-06-22 08:54:30 +02:00
|
|
|
static unsigned long __initdata iSeries_recal_titan;
|
|
|
|
static signed long __initdata iSeries_recal_tb;
|
2007-09-21 23:35:52 +02:00
|
|
|
|
|
|
|
/* Forward declaration is only needed for iSereis compiles */
|
2008-05-08 06:27:19 +02:00
|
|
|
static void __init clocksource_init(void);
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#define XSEC_PER_SEC (1024*1024)
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#define SCALE_XSEC(xsec, max) (((xsec) * max) / XSEC_PER_SEC)
|
|
|
|
#else
|
|
|
|
/* compute ((xsec << 12) * max) >> 32 */
|
|
|
|
#define SCALE_XSEC(xsec, max) mulhwu((xsec) << 12, max)
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long tb_ticks_per_jiffy;
|
|
|
|
unsigned long tb_ticks_per_usec = 100; /* sane default */
|
|
|
|
EXPORT_SYMBOL(tb_ticks_per_usec);
|
|
|
|
unsigned long tb_ticks_per_sec;
|
2006-02-27 05:41:47 +01:00
|
|
|
EXPORT_SYMBOL(tb_ticks_per_sec); /* for cputime_t conversions */
|
2006-02-20 00:38:56 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
DEFINE_SPINLOCK(rtc_lock);
|
2005-06-27 23:36:35 +02:00
|
|
|
EXPORT_SYMBOL_GPL(rtc_lock);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-04 06:04:31 +02:00
|
|
|
static u64 tb_to_ns_scale __read_mostly;
|
|
|
|
static unsigned tb_to_ns_shift __read_mostly;
|
|
|
|
static unsigned long boot_tb __read_mostly;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
extern struct timezone sys_tz;
|
2005-10-20 01:23:26 +02:00
|
|
|
static long timezone_offset;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-23 01:43:07 +02:00
|
|
|
unsigned long ppc_proc_freq;
|
2010-09-20 18:23:41 +02:00
|
|
|
EXPORT_SYMBOL_GPL(ppc_proc_freq);
|
2005-06-23 01:43:07 +02:00
|
|
|
unsigned long ppc_tb_freq;
|
2010-09-20 18:23:41 +02:00
|
|
|
EXPORT_SYMBOL_GPL(ppc_tb_freq);
|
2005-10-23 09:14:56 +02:00
|
|
|
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
#ifdef CONFIG_VIRT_CPU_ACCOUNTING
|
|
|
|
/*
|
|
|
|
* Factors for converting from cputime_t (timebase ticks) to
|
|
|
|
* jiffies, milliseconds, seconds, and clock_t (1/USER_HZ seconds).
|
|
|
|
* These are all stored as 0.64 fixed-point binary fractions.
|
|
|
|
*/
|
|
|
|
u64 __cputime_jiffies_factor;
|
2006-02-27 05:41:47 +01:00
|
|
|
EXPORT_SYMBOL(__cputime_jiffies_factor);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
u64 __cputime_msec_factor;
|
2006-02-27 05:41:47 +01:00
|
|
|
EXPORT_SYMBOL(__cputime_msec_factor);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
u64 __cputime_sec_factor;
|
2006-02-27 05:41:47 +01:00
|
|
|
EXPORT_SYMBOL(__cputime_sec_factor);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
u64 __cputime_clockt_factor;
|
2006-02-27 05:41:47 +01:00
|
|
|
EXPORT_SYMBOL(__cputime_clockt_factor);
|
2008-02-06 10:36:12 +01:00
|
|
|
DEFINE_PER_CPU(unsigned long, cputime_last_delta);
|
|
|
|
DEFINE_PER_CPU(unsigned long, cputime_scaled_last_delta);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
|
2009-07-29 12:15:29 +02:00
|
|
|
cputime_t cputime_one_jiffy;
|
|
|
|
|
2010-08-31 03:59:53 +02:00
|
|
|
void (*dtl_consumer)(struct dtl_entry *, u64);
|
|
|
|
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
static void calc_cputime_factors(void)
|
|
|
|
{
|
|
|
|
struct div_result res;
|
|
|
|
|
|
|
|
div128_by_32(HZ, 0, tb_ticks_per_sec, &res);
|
|
|
|
__cputime_jiffies_factor = res.result_low;
|
|
|
|
div128_by_32(1000, 0, tb_ticks_per_sec, &res);
|
|
|
|
__cputime_msec_factor = res.result_low;
|
|
|
|
div128_by_32(1, 0, tb_ticks_per_sec, &res);
|
|
|
|
__cputime_sec_factor = res.result_low;
|
|
|
|
div128_by_32(USER_HZ, 0, tb_ticks_per_sec, &res);
|
|
|
|
__cputime_clockt_factor = res.result_low;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
* Read the SPURR on systems that have it, otherwise the PURR,
|
|
|
|
* or if that doesn't exist return the timebase value passed in.
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
*/
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
static u64 read_spurr(u64 tb)
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
{
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
if (cpu_has_feature(CPU_FTR_SPURR))
|
|
|
|
return mfspr(SPRN_SPURR);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
if (cpu_has_feature(CPU_FTR_PURR))
|
|
|
|
return mfspr(SPRN_PURR);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
return tb;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
}
|
|
|
|
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
#ifdef CONFIG_PPC_SPLPAR
|
|
|
|
|
2007-10-18 12:06:37 +02:00
|
|
|
/*
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
* Scan the dispatch trace log and count up the stolen time.
|
|
|
|
* Should be called with interrupts disabled.
|
2007-10-18 12:06:37 +02:00
|
|
|
*/
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
static u64 scan_dispatch_log(u64 stop_tb)
|
2007-10-18 12:06:37 +02:00
|
|
|
{
|
2010-08-31 03:59:53 +02:00
|
|
|
u64 i = local_paca->dtl_ridx;
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
struct dtl_entry *dtl = local_paca->dtl_curr;
|
|
|
|
struct dtl_entry *dtl_end = local_paca->dispatch_log_end;
|
|
|
|
struct lppaca *vpa = local_paca->lppaca_ptr;
|
|
|
|
u64 tb_delta;
|
|
|
|
u64 stolen = 0;
|
|
|
|
u64 dtb;
|
|
|
|
|
|
|
|
if (i == vpa->dtl_idx)
|
|
|
|
return 0;
|
|
|
|
while (i < vpa->dtl_idx) {
|
2010-08-31 03:59:53 +02:00
|
|
|
if (dtl_consumer)
|
|
|
|
dtl_consumer(dtl, i);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
dtb = dtl->timebase;
|
|
|
|
tb_delta = dtl->enqueue_to_dispatch_time +
|
|
|
|
dtl->ready_to_enqueue_time;
|
|
|
|
barrier();
|
|
|
|
if (i + N_DISPATCH_LOG < vpa->dtl_idx) {
|
|
|
|
/* buffer has overflowed */
|
|
|
|
i = vpa->dtl_idx - N_DISPATCH_LOG;
|
|
|
|
dtl = local_paca->dispatch_log + (i % N_DISPATCH_LOG);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (dtb > stop_tb)
|
|
|
|
break;
|
|
|
|
stolen += tb_delta;
|
|
|
|
++i;
|
|
|
|
++dtl;
|
|
|
|
if (dtl == dtl_end)
|
|
|
|
dtl = local_paca->dispatch_log;
|
|
|
|
}
|
|
|
|
local_paca->dtl_ridx = i;
|
|
|
|
local_paca->dtl_curr = dtl;
|
|
|
|
return stolen;
|
2007-10-18 12:06:37 +02:00
|
|
|
}
|
|
|
|
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
/*
|
|
|
|
* Accumulate stolen time by scanning the dispatch trace log.
|
|
|
|
* Called on entry from user mode.
|
|
|
|
*/
|
|
|
|
void accumulate_stolen_time(void)
|
|
|
|
{
|
|
|
|
u64 sst, ust;
|
|
|
|
|
|
|
|
sst = scan_dispatch_log(get_paca()->starttime_user);
|
|
|
|
ust = scan_dispatch_log(get_paca()->starttime);
|
|
|
|
get_paca()->system_time -= sst;
|
|
|
|
get_paca()->user_time -= ust;
|
|
|
|
get_paca()->stolen_time += ust + sst;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 calculate_stolen_time(u64 stop_tb)
|
|
|
|
{
|
|
|
|
u64 stolen = 0;
|
|
|
|
|
|
|
|
if (get_paca()->dtl_ridx != get_paca()->lppaca_ptr->dtl_idx) {
|
|
|
|
stolen = scan_dispatch_log(stop_tb);
|
|
|
|
get_paca()->system_time -= stolen;
|
|
|
|
}
|
|
|
|
|
|
|
|
stolen += get_paca()->stolen_time;
|
|
|
|
get_paca()->stolen_time = 0;
|
|
|
|
return stolen;
|
2007-10-18 12:06:37 +02:00
|
|
|
}
|
|
|
|
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
#else /* CONFIG_PPC_SPLPAR */
|
|
|
|
static inline u64 calculate_stolen_time(u64 stop_tb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PPC_SPLPAR */
|
|
|
|
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
/*
|
|
|
|
* Account time for a transition between system, hard irq
|
|
|
|
* or soft irq state.
|
|
|
|
*/
|
|
|
|
void account_system_vtime(struct task_struct *tsk)
|
|
|
|
{
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
u64 now, nowscaled, delta, deltascaled;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
unsigned long flags;
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
u64 stolen, udelta, sys_scaled, user_scaled;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
now = mftb();
|
2007-10-18 12:06:37 +02:00
|
|
|
nowscaled = read_spurr(now);
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
get_paca()->system_time += now - get_paca()->starttime;
|
|
|
|
get_paca()->starttime = now;
|
2007-10-18 12:06:37 +02:00
|
|
|
deltascaled = nowscaled - get_paca()->startspurr;
|
|
|
|
get_paca()->startspurr = nowscaled;
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
|
|
|
|
stolen = calculate_stolen_time(now);
|
|
|
|
|
|
|
|
delta = get_paca()->system_time;
|
|
|
|
get_paca()->system_time = 0;
|
|
|
|
udelta = get_paca()->user_time - get_paca()->utime_sspurr;
|
|
|
|
get_paca()->utime_sspurr = get_paca()->user_time;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Because we don't read the SPURR on every kernel entry/exit,
|
|
|
|
* deltascaled includes both user and system SPURR ticks.
|
|
|
|
* Apportion these ticks to system SPURR ticks and user
|
|
|
|
* SPURR ticks in the same ratio as the system time (delta)
|
|
|
|
* and user time (udelta) values obtained from the timebase
|
|
|
|
* over the same interval. The system ticks get accounted here;
|
|
|
|
* the user ticks get saved up in paca->user_time_scaled to be
|
|
|
|
* used by account_process_tick.
|
|
|
|
*/
|
|
|
|
sys_scaled = delta;
|
|
|
|
user_scaled = udelta;
|
|
|
|
if (deltascaled != delta + udelta) {
|
|
|
|
if (udelta) {
|
|
|
|
sys_scaled = deltascaled * delta / (delta + udelta);
|
|
|
|
user_scaled = deltascaled - sys_scaled;
|
|
|
|
} else {
|
|
|
|
sys_scaled = deltascaled;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
get_paca()->user_time_scaled += user_scaled;
|
|
|
|
|
|
|
|
if (in_irq() || idle_task(smp_processor_id()) != tsk) {
|
|
|
|
account_system_time(tsk, 0, delta, sys_scaled);
|
|
|
|
if (stolen)
|
|
|
|
account_steal_time(stolen);
|
|
|
|
} else {
|
|
|
|
account_idle_time(delta + stolen);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
2009-10-30 06:47:19 +01:00
|
|
|
EXPORT_SYMBOL_GPL(account_system_vtime);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Transfer the user and system times accumulated in the paca
|
|
|
|
* by the exception entry and exit code to the generic process
|
|
|
|
* user and system time records.
|
|
|
|
* Must be called with interrupts disabled.
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
* Assumes that account_system_vtime() has been called recently
|
|
|
|
* (i.e. since the last entry from usermode) so that
|
|
|
|
* get_paca()->user_time_scaled is up to date.
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
*/
|
2007-11-09 22:39:38 +01:00
|
|
|
void account_process_tick(struct task_struct *tsk, int user_tick)
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
{
|
2007-10-18 12:06:37 +02:00
|
|
|
cputime_t utime, utimescaled;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
|
|
|
|
utime = get_paca()->user_time;
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
utimescaled = get_paca()->user_time_scaled;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
get_paca()->user_time = 0;
|
powerpc: Account time using timebase rather than PURR
Currently, when CONFIG_VIRT_CPU_ACCOUNTING is enabled, we use the
PURR register for measuring the user and system time used by
processes, as well as other related times such as hardirq and
softirq times. This turns out to be quite confusing for users
because it means that a program will often be measured as taking
less time when run on a multi-threaded processor (SMT2 or SMT4 mode)
than it does when run on a single-threaded processor (ST mode), even
though the program takes longer to finish. The discrepancy is
accounted for as stolen time, which is also confusing, particularly
when there are no other partitions running.
This changes the accounting to use the timebase instead, meaning that
the reported user and system times are the actual number of real-time
seconds that the program was executing on the processor thread,
regardless of which SMT mode the processor is in. Thus a program will
generally show greater user and system times when run on a
multi-threaded processor than on a single-threaded processor.
On pSeries systems on POWER5 or later processors, we measure the
stolen time (time when this partition wasn't running) using the
hypervisor dispatch trace log. We check for new entries in the
log on every entry from user mode and on every transition from
kernel process context to soft or hard IRQ context (i.e. when
account_system_vtime() gets called). So that we can correctly
distinguish time stolen from user time and time stolen from system
time, without having to check the log on every exit to user mode,
we store separate timestamps for exit to user mode and entry from
user mode.
On systems that have a SPURR (POWER6 and POWER7), we read the SPURR
in account_system_vtime() (as before), and then apportion the SPURR
ticks since the last time we read it between scaled user time and
scaled system time according to the relative proportions of user
time and system time over the same interval. This avoids having to
read the SPURR on every kernel entry and exit. On systems that have
PURR but not SPURR (i.e., POWER5), we do the same using the PURR
rather than the SPURR.
This disables the DTL user interface in /sys/debug/kernel/powerpc/dtl
for now since it conflicts with the use of the dispatch trace log
by the time accounting code.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-08-26 21:56:43 +02:00
|
|
|
get_paca()->user_time_scaled = 0;
|
|
|
|
get_paca()->utime_sspurr = 0;
|
2008-12-31 15:11:37 +01:00
|
|
|
account_user_time(tsk, utime, utimescaled);
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* ! CONFIG_VIRT_CPU_ACCOUNTING */
|
|
|
|
#define calc_cputime_factors()
|
|
|
|
#endif
|
|
|
|
|
2005-11-18 03:44:17 +01:00
|
|
|
void __delay(unsigned long loops)
|
|
|
|
{
|
|
|
|
unsigned long start;
|
|
|
|
int diff;
|
|
|
|
|
|
|
|
if (__USE_RTC()) {
|
|
|
|
start = get_rtcl();
|
|
|
|
do {
|
|
|
|
/* the RTCL register wraps at 1000000000 */
|
|
|
|
diff = get_rtcl() - start;
|
|
|
|
if (diff < 0)
|
|
|
|
diff += 1000000000;
|
|
|
|
} while (diff < loops);
|
|
|
|
} else {
|
|
|
|
start = get_tbl();
|
|
|
|
while (get_tbl() - start < loops)
|
|
|
|
HMT_low();
|
|
|
|
HMT_medium();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__delay);
|
|
|
|
|
|
|
|
void udelay(unsigned long usecs)
|
|
|
|
{
|
|
|
|
__delay(tb_ticks_per_usec * usecs);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(udelay);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
unsigned long profile_pc(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned long pc = instruction_pointer(regs);
|
|
|
|
|
|
|
|
if (in_lock_functions(pc))
|
|
|
|
return regs->link;
|
|
|
|
|
|
|
|
return pc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(profile_pc);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_ISERIES
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function recalibrates the timebase based on the 49-bit time-of-day
|
|
|
|
* value in the Titan chip. The Titan is much more accurate than the value
|
|
|
|
* returned by the service processor for the timebase frequency.
|
|
|
|
*/
|
|
|
|
|
2007-06-22 08:54:30 +02:00
|
|
|
static int __init iSeries_tb_recal(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned long titan, tb;
|
2007-06-22 08:54:30 +02:00
|
|
|
|
|
|
|
/* Make sure we only run on iSeries */
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_ISERIES))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
tb = get_tb();
|
|
|
|
titan = HvCallXm_loadTod();
|
|
|
|
if ( iSeries_recal_titan ) {
|
|
|
|
unsigned long tb_ticks = tb - iSeries_recal_tb;
|
|
|
|
unsigned long titan_usec = (titan - iSeries_recal_titan) >> 12;
|
|
|
|
unsigned long new_tb_ticks_per_sec = (tb_ticks * USEC_PER_SEC)/titan_usec;
|
2009-08-02 00:48:27 +02:00
|
|
|
unsigned long new_tb_ticks_per_jiffy =
|
|
|
|
DIV_ROUND_CLOSEST(new_tb_ticks_per_sec, HZ);
|
2005-04-17 00:20:36 +02:00
|
|
|
long tick_diff = new_tb_ticks_per_jiffy - tb_ticks_per_jiffy;
|
|
|
|
char sign = '+';
|
|
|
|
/* make sure tb_ticks_per_sec and tb_ticks_per_jiffy are consistent */
|
|
|
|
new_tb_ticks_per_sec = new_tb_ticks_per_jiffy * HZ;
|
|
|
|
|
|
|
|
if ( tick_diff < 0 ) {
|
|
|
|
tick_diff = -tick_diff;
|
|
|
|
sign = '-';
|
|
|
|
}
|
|
|
|
if ( tick_diff ) {
|
|
|
|
if ( tick_diff < tb_ticks_per_jiffy/25 ) {
|
|
|
|
printk( "Titan recalibrate: new tb_ticks_per_jiffy = %lu (%c%ld)\n",
|
|
|
|
new_tb_ticks_per_jiffy, sign, tick_diff );
|
|
|
|
tb_ticks_per_jiffy = new_tb_ticks_per_jiffy;
|
|
|
|
tb_ticks_per_sec = new_tb_ticks_per_sec;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
calc_cputime_factors();
|
2005-11-11 11:15:21 +01:00
|
|
|
vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
|
2009-07-29 12:15:29 +02:00
|
|
|
setup_cputime_one_jiffy();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
printk( "Titan recalibrate: FAILED (difference > 4 percent)\n"
|
|
|
|
" new tb_ticks_per_jiffy = %lu\n"
|
|
|
|
" old tb_ticks_per_jiffy = %lu\n",
|
|
|
|
new_tb_ticks_per_jiffy, tb_ticks_per_jiffy );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
iSeries_recal_titan = titan;
|
|
|
|
iSeries_recal_tb = tb;
|
2007-06-22 08:54:30 +02:00
|
|
|
|
2007-09-21 23:35:52 +02:00
|
|
|
/* Called here as now we know accurate values for the timebase */
|
|
|
|
clocksource_init();
|
2007-06-22 08:54:30 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-06-22 08:54:30 +02:00
|
|
|
late_initcall(iSeries_tb_recal);
|
|
|
|
|
|
|
|
/* Called from platform early init */
|
|
|
|
void __init iSeries_time_init_early(void)
|
|
|
|
{
|
|
|
|
iSeries_recal_tb = get_tb();
|
|
|
|
iSeries_recal_titan = HvCallXm_loadTod();
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_PPC_ISERIES */
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
#ifdef CONFIG_IRQ_WORK
|
2009-06-17 13:50:04 +02:00
|
|
|
|
2010-04-13 22:46:04 +02:00
|
|
|
/*
|
|
|
|
* 64-bit uses a byte in the PACA, 32-bit uses a per-cpu variable...
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_PPC64
|
2010-10-14 08:01:34 +02:00
|
|
|
static inline unsigned long test_irq_work_pending(void)
|
2009-06-17 13:50:04 +02:00
|
|
|
{
|
2010-04-13 22:46:04 +02:00
|
|
|
unsigned long x;
|
|
|
|
|
|
|
|
asm volatile("lbz %0,%1(13)"
|
|
|
|
: "=r" (x)
|
2010-10-14 08:01:34 +02:00
|
|
|
: "i" (offsetof(struct paca_struct, irq_work_pending)));
|
2010-04-13 22:46:04 +02:00
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
static inline void set_irq_work_pending_flag(void)
|
2010-04-13 22:46:04 +02:00
|
|
|
{
|
|
|
|
asm volatile("stb %0,%1(13)" : :
|
|
|
|
"r" (1),
|
2010-10-14 08:01:34 +02:00
|
|
|
"i" (offsetof(struct paca_struct, irq_work_pending)));
|
2010-04-13 22:46:04 +02:00
|
|
|
}
|
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
static inline void clear_irq_work_pending(void)
|
2010-04-13 22:46:04 +02:00
|
|
|
{
|
|
|
|
asm volatile("stb %0,%1(13)" : :
|
|
|
|
"r" (0),
|
2010-10-14 08:01:34 +02:00
|
|
|
"i" (offsetof(struct paca_struct, irq_work_pending)));
|
2009-06-17 13:50:04 +02:00
|
|
|
}
|
|
|
|
|
2010-04-13 22:46:04 +02:00
|
|
|
#else /* 32-bit */
|
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
DEFINE_PER_CPU(u8, irq_work_pending);
|
2010-04-13 22:46:04 +02:00
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
#define set_irq_work_pending_flag() __get_cpu_var(irq_work_pending) = 1
|
|
|
|
#define test_irq_work_pending() __get_cpu_var(irq_work_pending)
|
|
|
|
#define clear_irq_work_pending() __get_cpu_var(irq_work_pending) = 0
|
2009-06-17 13:50:04 +02:00
|
|
|
|
2010-04-13 22:46:04 +02:00
|
|
|
#endif /* 32 vs 64 bit */
|
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
void set_irq_work_pending(void)
|
2010-04-13 22:46:04 +02:00
|
|
|
{
|
|
|
|
preempt_disable();
|
2010-10-14 08:01:34 +02:00
|
|
|
set_irq_work_pending_flag();
|
2010-04-13 22:46:04 +02:00
|
|
|
set_dec(1);
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
#else /* CONFIG_IRQ_WORK */
|
2009-06-17 13:50:04 +02:00
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
#define test_irq_work_pending() 0
|
|
|
|
#define clear_irq_work_pending()
|
2009-06-17 13:50:04 +02:00
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
#endif /* CONFIG_IRQ_WORK */
|
2009-06-17 13:50:04 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* For iSeries shared processors, we have to let the hypervisor
|
|
|
|
* set the hardware decrementer. We set a virtual decrementer
|
|
|
|
* in the lppaca and call the hypervisor if the virtual
|
|
|
|
* decrementer is less than the current value in the hardware
|
|
|
|
* decrementer. (almost always the new decrementer value will
|
|
|
|
* be greater than the current hardware decementer so the hypervisor
|
|
|
|
* call will not be needed)
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* timer_interrupt - gets called when the decrementer overflows,
|
|
|
|
* with interrupts disabled.
|
|
|
|
*/
|
2005-09-19 16:30:27 +02:00
|
|
|
void timer_interrupt(struct pt_regs * regs)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
struct pt_regs *old_regs;
|
2007-12-14 05:52:15 +01:00
|
|
|
struct decrementer_clock *decrementer = &__get_cpu_var(decrementers);
|
|
|
|
struct clock_event_device *evt = &decrementer->event;
|
2007-10-09 01:59:17 +02:00
|
|
|
u64 now;
|
2007-09-21 05:26:03 +02:00
|
|
|
|
2009-10-26 19:49:14 +01:00
|
|
|
trace_timer_interrupt_entry(regs);
|
|
|
|
|
2010-01-31 21:34:06 +01:00
|
|
|
__get_cpu_var(irq_stat).timer_irqs++;
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
/* Ensure a positive value is written to the decrementer, or else
|
|
|
|
* some CPUs will continuue to take decrementer exceptions */
|
|
|
|
set_dec(DECREMENTER_MAX);
|
2005-10-20 01:23:26 +02:00
|
|
|
|
2010-08-10 22:38:23 +02:00
|
|
|
#if defined(CONFIG_PPC32) && defined(CONFIG_PMAC)
|
2005-10-20 01:23:26 +02:00
|
|
|
if (atomic_read(&ppc_n_lost_interrupts) != 0)
|
|
|
|
do_IRQ(regs);
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
old_regs = set_irq_regs(regs);
|
2005-04-17 00:20:36 +02:00
|
|
|
irq_enter();
|
|
|
|
|
2010-10-14 08:01:34 +02:00
|
|
|
if (test_irq_work_pending()) {
|
|
|
|
clear_irq_work_pending();
|
|
|
|
irq_work_run();
|
2010-04-13 22:46:04 +02:00
|
|
|
}
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
#ifdef CONFIG_PPC_ISERIES
|
2006-11-21 05:10:20 +01:00
|
|
|
if (firmware_has_feature(FW_FEATURE_ISERIES))
|
|
|
|
get_lppaca()->int_dword.fields.decr_int = 0;
|
2005-10-20 01:23:26 +02:00
|
|
|
#endif
|
|
|
|
|
2010-08-10 22:38:23 +02:00
|
|
|
now = get_tb_or_rtc();
|
|
|
|
if (now >= decrementer->next_tb) {
|
|
|
|
decrementer->next_tb = ~(u64)0;
|
|
|
|
if (evt->event_handler)
|
|
|
|
evt->event_handler(evt);
|
|
|
|
} else {
|
|
|
|
now = decrementer->next_tb - now;
|
|
|
|
if (now <= DECREMENTER_MAX)
|
|
|
|
set_dec((int)now);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_ISERIES
|
2006-11-21 05:10:20 +01:00
|
|
|
if (firmware_has_feature(FW_FEATURE_ISERIES) && hvlpevent_is_pending())
|
2006-10-07 14:08:26 +02:00
|
|
|
process_hvlpevents();
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-08-03 06:40:16 +02:00
|
|
|
/* collect purr register values often, for accurate calculations */
|
2005-08-03 06:35:25 +02:00
|
|
|
if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
struct cpu_usage *cu = &__get_cpu_var(cpu_usage_array);
|
|
|
|
cu->current_tb = mfspr(SPRN_PURR);
|
|
|
|
}
|
2005-10-20 01:23:26 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
irq_exit();
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
set_irq_regs(old_regs);
|
2009-10-26 19:49:14 +01:00
|
|
|
|
|
|
|
trace_timer_interrupt_exit(regs);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-12-12 18:35:19 +01:00
|
|
|
#ifdef CONFIG_SUSPEND
|
2010-06-20 21:04:14 +02:00
|
|
|
static void generic_suspend_disable_irqs(void)
|
2007-12-12 18:35:19 +01:00
|
|
|
{
|
|
|
|
/* Disable the decrementer, so that it doesn't interfere
|
|
|
|
* with suspending.
|
|
|
|
*/
|
|
|
|
|
|
|
|
set_dec(0x7fffffff);
|
|
|
|
local_irq_disable();
|
|
|
|
set_dec(0x7fffffff);
|
|
|
|
}
|
|
|
|
|
2010-06-20 21:04:14 +02:00
|
|
|
static void generic_suspend_enable_irqs(void)
|
2007-12-12 18:35:19 +01:00
|
|
|
{
|
|
|
|
local_irq_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Overrides the weak version in kernel/power/main.c */
|
|
|
|
void arch_suspend_disable_irqs(void)
|
|
|
|
{
|
|
|
|
if (ppc_md.suspend_disable_irqs)
|
|
|
|
ppc_md.suspend_disable_irqs();
|
|
|
|
generic_suspend_disable_irqs();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Overrides the weak version in kernel/power/main.c */
|
|
|
|
void arch_suspend_enable_irqs(void)
|
|
|
|
{
|
|
|
|
generic_suspend_enable_irqs();
|
|
|
|
if (ppc_md.suspend_enable_irqs)
|
|
|
|
ppc_md.suspend_enable_irqs();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Scheduler clock - returns current time in nanosec units.
|
|
|
|
*
|
|
|
|
* Note: mulhdu(a, b) (multiply high double unsigned) returns
|
|
|
|
* the high 64 bits of a * b, i.e. (a * b) >> 64, where a and b
|
|
|
|
* are 64-bit unsigned numbers.
|
|
|
|
*/
|
|
|
|
unsigned long long sched_clock(void)
|
|
|
|
{
|
2005-10-23 09:14:56 +02:00
|
|
|
if (__USE_RTC())
|
|
|
|
return get_rtc();
|
2007-07-04 06:04:31 +02:00
|
|
|
return mulhdu(get_tb() - boot_tb, tb_to_ns_scale) << tb_to_ns_shift;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-20 10:47:26 +02:00
|
|
|
static int __init get_freq(char *name, int cells, unsigned long *val)
|
2005-06-23 01:43:07 +02:00
|
|
|
{
|
|
|
|
struct device_node *cpu;
|
2006-07-12 07:35:54 +02:00
|
|
|
const unsigned int *fp;
|
2006-06-20 10:47:26 +02:00
|
|
|
int found = 0;
|
2005-06-23 01:43:07 +02:00
|
|
|
|
2006-06-20 10:47:26 +02:00
|
|
|
/* The cpu node should have timebase and clock frequency properties */
|
2005-06-23 01:43:07 +02:00
|
|
|
cpu = of_find_node_by_type(NULL, "cpu");
|
|
|
|
|
2006-02-04 10:34:56 +01:00
|
|
|
if (cpu) {
|
2007-04-03 14:26:41 +02:00
|
|
|
fp = of_get_property(cpu, name, NULL);
|
2006-02-04 10:34:56 +01:00
|
|
|
if (fp) {
|
2006-06-20 10:47:26 +02:00
|
|
|
found = 1;
|
2006-09-19 06:06:27 +02:00
|
|
|
*val = of_read_ulong(fp, cells);
|
2005-06-23 01:43:07 +02:00
|
|
|
}
|
2006-06-20 10:47:26 +02:00
|
|
|
|
|
|
|
of_node_put(cpu);
|
2005-06-23 01:43:07 +02:00
|
|
|
}
|
2006-06-20 10:47:26 +02:00
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2009-08-28 06:25:04 +02:00
|
|
|
/* should become __cpuinit when secondary_cpu_time_init also is */
|
|
|
|
void start_cpu_decrementer(void)
|
|
|
|
{
|
|
|
|
#if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
|
|
|
|
/* Clear any pending timer interrupts */
|
|
|
|
mtspr(SPRN_TSR, TSR_ENW | TSR_WIS | TSR_DIS | TSR_FIS);
|
|
|
|
|
|
|
|
/* Enable decrementer interrupt */
|
|
|
|
mtspr(SPRN_TCR, TCR_DIE);
|
|
|
|
#endif /* defined(CONFIG_BOOKE) || defined(CONFIG_40x) */
|
|
|
|
}
|
|
|
|
|
2006-06-20 10:47:26 +02:00
|
|
|
void __init generic_calibrate_decr(void)
|
|
|
|
{
|
|
|
|
ppc_tb_freq = DEFAULT_TB_FREQ; /* hardcoded default */
|
|
|
|
|
|
|
|
if (!get_freq("ibm,extended-timebase-frequency", 2, &ppc_tb_freq) &&
|
|
|
|
!get_freq("timebase-frequency", 1, &ppc_tb_freq)) {
|
|
|
|
|
2005-06-23 01:43:07 +02:00
|
|
|
printk(KERN_ERR "WARNING: Estimating decrementer frequency "
|
|
|
|
"(not found)\n");
|
2006-06-20 10:47:26 +02:00
|
|
|
}
|
2005-06-23 01:43:07 +02:00
|
|
|
|
2006-06-20 10:47:26 +02:00
|
|
|
ppc_proc_freq = DEFAULT_PROC_FREQ; /* hardcoded default */
|
|
|
|
|
|
|
|
if (!get_freq("ibm,extended-clock-frequency", 2, &ppc_proc_freq) &&
|
|
|
|
!get_freq("clock-frequency", 1, &ppc_proc_freq)) {
|
|
|
|
|
|
|
|
printk(KERN_ERR "WARNING: Estimating processor frequency "
|
|
|
|
"(not found)\n");
|
2005-06-23 01:43:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-21 05:26:02 +02:00
|
|
|
int update_persistent_clock(struct timespec now)
|
2005-10-20 01:23:26 +02:00
|
|
|
{
|
|
|
|
struct rtc_time tm;
|
|
|
|
|
2007-09-21 05:26:02 +02:00
|
|
|
if (!ppc_md.set_rtc_time)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
to_tm(now.tv_sec + 1 + timezone_offset, &tm);
|
|
|
|
tm.tm_year -= 1900;
|
|
|
|
tm.tm_mon -= 1;
|
|
|
|
|
|
|
|
return ppc_md.set_rtc_time(&tm);
|
|
|
|
}
|
|
|
|
|
2009-11-01 20:11:03 +01:00
|
|
|
static void __read_persistent_clock(struct timespec *ts)
|
2007-09-21 05:26:02 +02:00
|
|
|
{
|
|
|
|
struct rtc_time tm;
|
|
|
|
static int first = 1;
|
|
|
|
|
2009-08-22 22:23:13 +02:00
|
|
|
ts->tv_nsec = 0;
|
2007-09-21 05:26:02 +02:00
|
|
|
/* XXX this is a litle fragile but will work okay in the short term */
|
|
|
|
if (first) {
|
|
|
|
first = 0;
|
|
|
|
if (ppc_md.time_init)
|
|
|
|
timezone_offset = ppc_md.time_init();
|
|
|
|
|
|
|
|
/* get_boot_time() isn't guaranteed to be safe to call late */
|
2009-08-22 22:23:13 +02:00
|
|
|
if (ppc_md.get_boot_time) {
|
|
|
|
ts->tv_sec = ppc_md.get_boot_time() - timezone_offset;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ppc_md.get_rtc_time) {
|
|
|
|
ts->tv_sec = 0;
|
|
|
|
return;
|
2007-09-21 05:26:02 +02:00
|
|
|
}
|
2005-10-20 01:23:26 +02:00
|
|
|
ppc_md.get_rtc_time(&tm);
|
2009-11-01 20:11:03 +01:00
|
|
|
|
2009-08-14 15:47:31 +02:00
|
|
|
ts->tv_sec = mktime(tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
|
|
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
2005-10-20 01:23:26 +02:00
|
|
|
}
|
|
|
|
|
2009-11-01 20:11:03 +01:00
|
|
|
void read_persistent_clock(struct timespec *ts)
|
|
|
|
{
|
|
|
|
__read_persistent_clock(ts);
|
|
|
|
|
|
|
|
/* Sanitize it in case real time clock is set below EPOCH */
|
|
|
|
if (ts->tv_sec < 0) {
|
|
|
|
ts->tv_sec = 0;
|
|
|
|
ts->tv_nsec = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2007-09-21 23:35:52 +02:00
|
|
|
/* clocksource code */
|
2009-04-21 21:24:00 +02:00
|
|
|
static cycle_t rtc_read(struct clocksource *cs)
|
2007-09-21 23:35:52 +02:00
|
|
|
{
|
|
|
|
return (cycle_t)get_rtc();
|
|
|
|
}
|
|
|
|
|
2009-04-21 21:24:00 +02:00
|
|
|
static cycle_t timebase_read(struct clocksource *cs)
|
2007-09-21 23:35:52 +02:00
|
|
|
{
|
|
|
|
return (cycle_t)get_tb();
|
|
|
|
}
|
|
|
|
|
2010-07-14 02:56:23 +02:00
|
|
|
void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
|
|
|
|
struct clocksource *clock, u32 mult)
|
2007-09-21 23:35:52 +02:00
|
|
|
{
|
2010-07-14 02:56:21 +02:00
|
|
|
u64 new_tb_to_xs, new_stamp_xsec;
|
2010-07-28 21:49:22 +02:00
|
|
|
u32 frac_sec;
|
2007-09-21 23:35:52 +02:00
|
|
|
|
|
|
|
if (clock != &clocksource_timebase)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Make userspace gettimeofday spin until we're done. */
|
|
|
|
++vdso_data->tb_update_count;
|
|
|
|
smp_mb();
|
|
|
|
|
|
|
|
/* XXX this assumes clock->shift == 22 */
|
|
|
|
/* 4611686018 ~= 2^(20+64-22) / 1e9 */
|
2010-07-14 02:56:21 +02:00
|
|
|
new_tb_to_xs = (u64) mult * 4611686018ULL;
|
2010-07-14 02:56:22 +02:00
|
|
|
new_stamp_xsec = (u64) wall_time->tv_nsec * XSEC_PER_SEC;
|
2010-07-14 02:56:21 +02:00
|
|
|
do_div(new_stamp_xsec, 1000000000);
|
2010-07-14 02:56:22 +02:00
|
|
|
new_stamp_xsec += (u64) wall_time->tv_sec * XSEC_PER_SEC;
|
2010-07-14 02:56:21 +02:00
|
|
|
|
2010-07-28 21:49:22 +02:00
|
|
|
BUG_ON(wall_time->tv_nsec >= NSEC_PER_SEC);
|
|
|
|
/* this is tv_nsec / 1e9 as a 0.32 fraction */
|
|
|
|
frac_sec = ((u64) wall_time->tv_nsec * 18446744073ULL) >> 32;
|
|
|
|
|
2010-07-14 02:56:21 +02:00
|
|
|
/*
|
|
|
|
* tb_update_count is used to allow the userspace gettimeofday code
|
|
|
|
* to assure itself that it sees a consistent view of the tb_to_xs and
|
|
|
|
* stamp_xsec variables. It reads the tb_update_count, then reads
|
|
|
|
* tb_to_xs and stamp_xsec and then reads tb_update_count again. If
|
|
|
|
* the two values of tb_update_count match and are even then the
|
|
|
|
* tb_to_xs and stamp_xsec values are consistent. If not, then it
|
|
|
|
* loops back and reads them again until this criteria is met.
|
|
|
|
* We expect the caller to have done the first increment of
|
|
|
|
* vdso_data->tb_update_count already.
|
|
|
|
*/
|
|
|
|
vdso_data->tb_orig_stamp = clock->cycle_last;
|
|
|
|
vdso_data->stamp_xsec = new_stamp_xsec;
|
|
|
|
vdso_data->tb_to_xs = new_tb_to_xs;
|
2010-07-14 02:56:23 +02:00
|
|
|
vdso_data->wtom_clock_sec = wtm->tv_sec;
|
|
|
|
vdso_data->wtom_clock_nsec = wtm->tv_nsec;
|
2010-07-14 02:56:22 +02:00
|
|
|
vdso_data->stamp_xtime = *wall_time;
|
powerpc: Rework VDSO gettimeofday to prevent time going backwards
Currently it is possible for userspace to see the result of
gettimeofday() going backwards by 1 microsecond, assuming that
userspace is using the gettimeofday() in the VDSO. The VDSO
gettimeofday() algorithm computes the time in "xsecs", which are
units of 2^-20 seconds, or approximately 0.954 microseconds,
using the algorithm
now = (timebase - tb_orig_stamp) * tb_to_xs + stamp_xsec
and then converts the time in xsecs to seconds and microseconds.
The kernel updates the tb_orig_stamp and stamp_xsec values every
tick in update_vsyscall(). If the length of the tick is not an
integer number of xsecs, then some precision is lost in converting
the current time to xsecs. For example, with CONFIG_HZ=1000, the
tick is 1ms long, which is 1048.576 xsecs. That means that
stamp_xsec will advance by either 1048 or 1049 on each tick.
With the right conditions, it is possible for userspace to get
(timebase - tb_orig_stamp) * tb_to_xs being 1049 if the kernel is
slightly late in updating the vdso_datapage, and then for stamp_xsec
to advance by 1048 when the kernel does update it, and for userspace
to then see (timebase - tb_orig_stamp) * tb_to_xs being zero due to
integer truncation. The result is that time appears to go backwards
by 1 microsecond.
To fix this we change the VDSO gettimeofday to use a new field in the
VDSO datapage which stores the nanoseconds part of the time as a
fractional number of seconds in a 0.32 binary fraction format.
(Or put another way, as a 32-bit number in units of 0.23283 ns.)
This is convenient because we can use the mulhwu instruction to
convert it to either microseconds or nanoseconds.
Since it turns out that computing the time of day using this new field
is simpler than either using stamp_xsec (as gettimeofday does) or
stamp_xtime.tv_nsec (as clock_gettime does), this converts both
gettimeofday and clock_gettime to use the new field. The existing
__do_get_tspec function is converted to use the new field and take
a parameter in r7 that indicates the desired resolution, 1,000,000
for microseconds or 1,000,000,000 for nanoseconds. The __do_get_xsec
function is then unused and is deleted.
The new algorithm is
now = ((timebase - tb_orig_stamp) << 12) * tb_to_xs
+ (stamp_xtime_seconds << 32) + stamp_sec_fraction
with 'now' in units of 2^-32 seconds. That is then converted to
seconds and either microseconds or nanoseconds with
seconds = now >> 32
partseconds = ((now & 0xffffffff) * resolution) >> 32
The 32-bit VDSO code also makes a further simplification: it ignores
the bottom 32 bits of the tb_to_xs value, which is a 0.64 format binary
fraction. Doing so gets rid of 4 multiply instructions. Assuming
a timebase frequency of 1GHz or less and an update interval of no
more than 10ms, the upper 32 bits of tb_to_xs will be at least
4503599, so the error from ignoring the low 32 bits will be at most
2.2ns, which is more than an order of magnitude less than the time
taken to do gettimeofday or clock_gettime on our fastest processors,
so there is no possibility of seeing inconsistent values due to this.
This also moves update_gtod() down next to its only caller, and makes
update_vsyscall use the time passed in via the wall_time argument rather
than accessing xtime directly. At present, wall_time always points to
xtime, but that could change in future.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2010-06-20 21:03:08 +02:00
|
|
|
vdso_data->stamp_sec_fraction = frac_sec;
|
2010-07-14 02:56:21 +02:00
|
|
|
smp_wmb();
|
|
|
|
++(vdso_data->tb_update_count);
|
2007-09-21 23:35:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void update_vsyscall_tz(void)
|
|
|
|
{
|
|
|
|
/* Make userspace gettimeofday spin until we're done. */
|
|
|
|
++vdso_data->tb_update_count;
|
|
|
|
smp_mb();
|
|
|
|
vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
|
|
|
|
vdso_data->tz_dsttime = sys_tz.tz_dsttime;
|
|
|
|
smp_mb();
|
|
|
|
++vdso_data->tb_update_count;
|
|
|
|
}
|
|
|
|
|
2008-05-08 06:27:19 +02:00
|
|
|
static void __init clocksource_init(void)
|
2007-09-21 23:35:52 +02:00
|
|
|
{
|
|
|
|
struct clocksource *clock;
|
|
|
|
|
|
|
|
if (__USE_RTC())
|
|
|
|
clock = &clocksource_rtc;
|
|
|
|
else
|
|
|
|
clock = &clocksource_timebase;
|
|
|
|
|
|
|
|
clock->mult = clocksource_hz2mult(tb_ticks_per_sec, clock->shift);
|
|
|
|
|
|
|
|
if (clocksource_register(clock)) {
|
|
|
|
printk(KERN_ERR "clocksource: %s is already registered\n",
|
|
|
|
clock->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO "clocksource: %s mult[%x] shift[%d] registered\n",
|
|
|
|
clock->name, clock->mult, clock->shift);
|
|
|
|
}
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
static int decrementer_set_next_event(unsigned long evt,
|
|
|
|
struct clock_event_device *dev)
|
|
|
|
{
|
2007-12-14 05:52:15 +01:00
|
|
|
__get_cpu_var(decrementers).next_tb = get_tb_or_rtc() + evt;
|
2007-09-21 05:26:03 +02:00
|
|
|
set_dec(evt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void decrementer_set_mode(enum clock_event_mode mode,
|
|
|
|
struct clock_event_device *dev)
|
|
|
|
{
|
|
|
|
if (mode != CLOCK_EVT_MODE_ONESHOT)
|
|
|
|
decrementer_set_next_event(DECREMENTER_MAX, dev);
|
|
|
|
}
|
|
|
|
|
2010-01-11 23:28:54 +01:00
|
|
|
static inline uint64_t div_sc64(unsigned long ticks, unsigned long nsec,
|
|
|
|
int shift)
|
|
|
|
{
|
|
|
|
uint64_t tmp = ((uint64_t)ticks) << shift;
|
|
|
|
|
|
|
|
do_div(tmp, nsec);
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2009-05-10 15:37:36 +02:00
|
|
|
static void __init setup_clockevent_multiplier(unsigned long hz)
|
|
|
|
{
|
|
|
|
u64 mult, shift = 32;
|
|
|
|
|
|
|
|
while (1) {
|
2010-01-11 23:28:54 +01:00
|
|
|
mult = div_sc64(hz, NSEC_PER_SEC, shift);
|
2009-05-10 15:37:36 +02:00
|
|
|
if (mult && (mult >> 32UL) == 0UL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
shift--;
|
|
|
|
}
|
|
|
|
|
|
|
|
decrementer_clockevent.shift = shift;
|
|
|
|
decrementer_clockevent.mult = mult;
|
|
|
|
}
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
static void register_decrementer_clockevent(int cpu)
|
|
|
|
{
|
2007-12-14 05:52:15 +01:00
|
|
|
struct clock_event_device *dec = &per_cpu(decrementers, cpu).event;
|
2007-09-21 05:26:03 +02:00
|
|
|
|
|
|
|
*dec = decrementer_clockevent;
|
2008-12-13 11:50:26 +01:00
|
|
|
dec->cpumask = cpumask_of(cpu);
|
2007-09-21 05:26:03 +02:00
|
|
|
|
2010-02-07 20:26:29 +01:00
|
|
|
printk_once(KERN_DEBUG "clockevent: %s mult[%x] shift[%d] cpu[%d]\n",
|
|
|
|
dec->name, dec->mult, dec->shift, cpu);
|
2007-09-21 05:26:03 +02:00
|
|
|
|
|
|
|
clockevents_register_device(dec);
|
|
|
|
}
|
|
|
|
|
2007-12-14 05:52:10 +01:00
|
|
|
static void __init init_decrementer_clockevent(void)
|
2007-09-21 05:26:03 +02:00
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
2009-05-10 15:37:36 +02:00
|
|
|
setup_clockevent_multiplier(ppc_tb_freq);
|
2007-09-21 05:26:03 +02:00
|
|
|
decrementer_clockevent.max_delta_ns =
|
|
|
|
clockevent_delta2ns(DECREMENTER_MAX, &decrementer_clockevent);
|
2007-10-31 12:25:35 +01:00
|
|
|
decrementer_clockevent.min_delta_ns =
|
|
|
|
clockevent_delta2ns(2, &decrementer_clockevent);
|
2007-09-21 05:26:03 +02:00
|
|
|
|
|
|
|
register_decrementer_clockevent(cpu);
|
|
|
|
}
|
|
|
|
|
|
|
|
void secondary_cpu_time_init(void)
|
|
|
|
{
|
2009-08-28 06:25:04 +02:00
|
|
|
/* Start the decrementer on CPUs that have manual control
|
|
|
|
* such as BookE
|
|
|
|
*/
|
|
|
|
start_cpu_decrementer();
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
/* FIME: Should make unrelatred change to move snapshot_timebase
|
|
|
|
* call here ! */
|
|
|
|
register_decrementer_clockevent(smp_processor_id());
|
|
|
|
}
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
/* This function is only called on the boot processor */
|
2005-04-17 00:20:36 +02:00
|
|
|
void __init time_init(void)
|
|
|
|
{
|
|
|
|
struct div_result res;
|
2010-06-20 21:04:14 +02:00
|
|
|
u64 scale;
|
2005-10-20 01:23:26 +02:00
|
|
|
unsigned shift;
|
|
|
|
|
2005-10-23 09:14:56 +02:00
|
|
|
if (__USE_RTC()) {
|
|
|
|
/* 601 processor: dec counts down by 128 every 128ns */
|
|
|
|
ppc_tb_freq = 1000000000;
|
|
|
|
} else {
|
|
|
|
/* Normal PowerPC with timebase register */
|
|
|
|
ppc_md.calibrate_decr();
|
2006-04-12 22:20:27 +02:00
|
|
|
printk(KERN_DEBUG "time_init: decrementer frequency = %lu.%.6lu MHz\n",
|
2005-10-23 09:14:56 +02:00
|
|
|
ppc_tb_freq / 1000000, ppc_tb_freq % 1000000);
|
2006-04-12 22:20:27 +02:00
|
|
|
printk(KERN_DEBUG "time_init: processor frequency = %lu.%.6lu MHz\n",
|
2005-10-23 09:14:56 +02:00
|
|
|
ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
|
|
|
|
}
|
2005-10-20 13:04:51 +02:00
|
|
|
|
|
|
|
tb_ticks_per_jiffy = ppc_tb_freq / HZ;
|
2006-02-20 00:38:56 +01:00
|
|
|
tb_ticks_per_sec = ppc_tb_freq;
|
2005-10-20 13:04:51 +02:00
|
|
|
tb_ticks_per_usec = ppc_tb_freq / 1000000;
|
powerpc: Implement accurate task and CPU time accounting
This implements accurate task and cpu time accounting for 64-bit
powerpc kernels. Instead of accounting a whole jiffy of time to a
task on a timer interrupt because that task happened to be running at
the time, we now account time in units of timebase ticks according to
the actual time spent by the task in user mode and kernel mode. We
also count the time spent processing hardware and software interrupts
accurately. This is conditional on CONFIG_VIRT_CPU_ACCOUNTING. If
that is not set, we do tick-based approximate accounting as before.
To get this accurate information, we read either the PURR (processor
utilization of resources register) on POWER5 machines, or the timebase
on other machines on
* each entry to the kernel from usermode
* each exit to usermode
* transitions between process context, hard irq context and soft irq
context in kernel mode
* context switches.
On POWER5 systems with shared-processor logical partitioning we also
read both the PURR and the timebase at each timer interrupt and
context switch in order to determine how much time has been taken by
the hypervisor to run other partitions ("steal" time). Unfortunately,
since we need values of the PURR on both threads at the same time to
accurately calculate the steal time, and since we can only calculate
steal time on a per-core basis, the apportioning of the steal time
between idle time (time which we ceded to the hypervisor in the idle
loop) and actual stolen time is somewhat approximate at the moment.
This is all based quite heavily on what s390 does, and it uses the
generic interfaces that were added by the s390 developers,
i.e. account_system_time(), account_user_time(), etc.
This patch doesn't add any new interfaces between the kernel and
userspace, and doesn't change the units in which time is reported to
userspace by things such as /proc/stat, /proc/<pid>/stat, getrusage(),
times(), etc. Internally the various task and cpu times are stored in
timebase units, but they are converted to USER_HZ units (1/100th of a
second) when reported to userspace. Some precision is therefore lost
but there should not be any accumulating error, since the internal
accumulation is at full precision.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-02-24 00:06:59 +01:00
|
|
|
calc_cputime_factors();
|
2009-07-29 12:15:29 +02:00
|
|
|
setup_cputime_one_jiffy();
|
2006-02-20 00:38:56 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Compute scale factor for sched_clock.
|
|
|
|
* The calibrate_decr() function has set tb_ticks_per_sec,
|
|
|
|
* which is the timebase frequency.
|
|
|
|
* We compute 1e9 * 2^64 / tb_ticks_per_sec and interpret
|
|
|
|
* the 128-bit result as a 64.64 fixed-point number.
|
|
|
|
* We then shift that number right until it is less than 1.0,
|
|
|
|
* giving us the scale factor and shift count to use in
|
|
|
|
* sched_clock().
|
|
|
|
*/
|
|
|
|
div128_by_32(1000000000, 0, tb_ticks_per_sec, &res);
|
|
|
|
scale = res.result_low;
|
|
|
|
for (shift = 0; res.result_high != 0; ++shift) {
|
|
|
|
scale = (scale >> 1) | (res.result_high << 63);
|
|
|
|
res.result_high >>= 1;
|
|
|
|
}
|
|
|
|
tb_to_ns_scale = scale;
|
|
|
|
tb_to_ns_shift = shift;
|
2007-07-04 06:04:31 +02:00
|
|
|
/* Save the current timebase to pretty up CONFIG_PRINTK_TIME */
|
2007-09-19 06:21:56 +02:00
|
|
|
boot_tb = get_tb_or_rtc();
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-02-20 00:38:56 +01:00
|
|
|
/* If platform provided a timezone (pmac), we correct the time */
|
|
|
|
if (timezone_offset) {
|
|
|
|
sys_tz.tz_minuteswest = -timezone_offset / 60;
|
|
|
|
sys_tz.tz_dsttime = 0;
|
|
|
|
}
|
|
|
|
|
2005-11-11 11:15:21 +01:00
|
|
|
vdso_data->tb_update_count = 0;
|
|
|
|
vdso_data->tb_ticks_per_sec = tb_ticks_per_sec;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-08-28 06:25:04 +02:00
|
|
|
/* Start the decrementer on CPUs that have manual control
|
|
|
|
* such as BookE
|
|
|
|
*/
|
|
|
|
start_cpu_decrementer();
|
|
|
|
|
2007-09-21 23:35:52 +02:00
|
|
|
/* Register the clocksource, if we're not running on iSeries */
|
|
|
|
if (!firmware_has_feature(FW_FEATURE_ISERIES))
|
|
|
|
clocksource_init();
|
|
|
|
|
2007-09-21 05:26:03 +02:00
|
|
|
init_decrementer_clockevent();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define FEBRUARY 2
|
|
|
|
#define STARTOFTIME 1970
|
|
|
|
#define SECDAY 86400L
|
|
|
|
#define SECYR (SECDAY * 365)
|
2005-10-20 01:23:26 +02:00
|
|
|
#define leapyear(year) ((year) % 4 == 0 && \
|
|
|
|
((year) % 100 != 0 || (year) % 400 == 0))
|
2005-04-17 00:20:36 +02:00
|
|
|
#define days_in_year(a) (leapyear(a) ? 366 : 365)
|
|
|
|
#define days_in_month(a) (month_days[(a) - 1])
|
|
|
|
|
|
|
|
static int month_days[12] = {
|
|
|
|
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This only works for the Gregorian calendar - i.e. after 1752 (in the UK)
|
|
|
|
*/
|
|
|
|
void GregorianDay(struct rtc_time * tm)
|
|
|
|
{
|
|
|
|
int leapsToDate;
|
|
|
|
int lastYear;
|
|
|
|
int day;
|
|
|
|
int MonthOffset[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
lastYear = tm->tm_year - 1;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Number of leap corrections to apply up to end of last year
|
|
|
|
*/
|
2005-10-20 01:23:26 +02:00
|
|
|
leapsToDate = lastYear / 4 - lastYear / 100 + lastYear / 400;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This year is a leap year if it is divisible by 4 except when it is
|
|
|
|
* divisible by 100 unless it is divisible by 400
|
|
|
|
*
|
2005-10-20 01:23:26 +02:00
|
|
|
* e.g. 1904 was a leap year, 1900 was not, 1996 is, and 2000 was
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2005-10-20 01:23:26 +02:00
|
|
|
day = tm->tm_mon > 2 && leapyear(tm->tm_year);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
day += lastYear*365 + leapsToDate + MonthOffset[tm->tm_mon-1] +
|
|
|
|
tm->tm_mday;
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
tm->tm_wday = day % 7;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void to_tm(int tim, struct rtc_time * tm)
|
|
|
|
{
|
|
|
|
register int i;
|
|
|
|
register long hms, day;
|
|
|
|
|
|
|
|
day = tim / SECDAY;
|
|
|
|
hms = tim % SECDAY;
|
|
|
|
|
|
|
|
/* Hours, minutes, seconds are easy */
|
|
|
|
tm->tm_hour = hms / 3600;
|
|
|
|
tm->tm_min = (hms % 3600) / 60;
|
|
|
|
tm->tm_sec = (hms % 3600) % 60;
|
|
|
|
|
|
|
|
/* Number of years in days */
|
|
|
|
for (i = STARTOFTIME; day >= days_in_year(i); i++)
|
|
|
|
day -= days_in_year(i);
|
|
|
|
tm->tm_year = i;
|
|
|
|
|
|
|
|
/* Number of months in days left */
|
|
|
|
if (leapyear(tm->tm_year))
|
|
|
|
days_in_month(FEBRUARY) = 29;
|
|
|
|
for (i = 1; day >= days_in_month(i); i++)
|
|
|
|
day -= days_in_month(i);
|
|
|
|
days_in_month(FEBRUARY) = 28;
|
|
|
|
tm->tm_mon = i;
|
|
|
|
|
|
|
|
/* Days are what is left over (+1) from all that. */
|
|
|
|
tm->tm_mday = day + 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine the day of week
|
|
|
|
*/
|
|
|
|
GregorianDay(tm);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Divide a 128-bit dividend by a 32-bit divisor, leaving a 128 bit
|
|
|
|
* result.
|
|
|
|
*/
|
2005-10-20 01:23:26 +02:00
|
|
|
void div128_by_32(u64 dividend_high, u64 dividend_low,
|
|
|
|
unsigned divisor, struct div_result *dr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-10-20 01:23:26 +02:00
|
|
|
unsigned long a, b, c, d;
|
|
|
|
unsigned long w, x, y, z;
|
|
|
|
u64 ra, rb, rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
a = dividend_high >> 32;
|
|
|
|
b = dividend_high & 0xffffffff;
|
|
|
|
c = dividend_low >> 32;
|
|
|
|
d = dividend_low & 0xffffffff;
|
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
w = a / divisor;
|
|
|
|
ra = ((u64)(a - (w * divisor)) << 32) + b;
|
|
|
|
|
|
|
|
rb = ((u64) do_div(ra, divisor) << 32) + c;
|
|
|
|
x = ra;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
rc = ((u64) do_div(rb, divisor) << 32) + d;
|
|
|
|
y = rb;
|
|
|
|
|
|
|
|
do_div(rc, divisor);
|
|
|
|
z = rc;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-20 01:23:26 +02:00
|
|
|
dr->result_high = ((u64)w << 32) + x;
|
|
|
|
dr->result_low = ((u64)y << 32) + z;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
}
|
2009-02-19 16:50:46 +01:00
|
|
|
|
2009-06-09 23:12:00 +02:00
|
|
|
/* We don't need to calibrate delay, we use the CPU timebase for that */
|
|
|
|
void calibrate_delay(void)
|
|
|
|
{
|
|
|
|
/* Some generic code (such as spinlock debug) use loops_per_jiffy
|
|
|
|
* as the number of __delay(1) in a jiffy, so make it so
|
|
|
|
*/
|
|
|
|
loops_per_jiffy = tb_ticks_per_jiffy;
|
|
|
|
}
|
|
|
|
|
2009-02-19 16:50:46 +01:00
|
|
|
static int __init rtc_init(void)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev;
|
|
|
|
|
|
|
|
if (!ppc_md.get_rtc_time)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
pdev = platform_device_register_simple("rtc-generic", -1, NULL, 0);
|
|
|
|
if (IS_ERR(pdev))
|
|
|
|
return PTR_ERR(pdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(rtc_init);
|