2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* SMP support for ppc.
|
|
|
|
|
*
|
|
|
|
|
* Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
|
|
|
|
|
* deal of code from the sparc and intel versions.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
|
|
|
|
|
*
|
|
|
|
|
* PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and
|
|
|
|
|
* Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
|
|
|
|
|
*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#undef DEBUG
|
|
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/smp.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <linux/cache.h>
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/sysdev.h>
|
|
|
|
|
#include <linux/cpu.h>
|
|
|
|
|
#include <linux/notifier.h>
|
2005-12-12 19:56:47 +00:00
|
|
|
#include <linux/topology.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
|
#include <asm/irq.h>
|
|
|
|
|
#include <asm/page.h>
|
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
|
#include <asm/prom.h>
|
|
|
|
|
#include <asm/smp.h>
|
|
|
|
|
#include <asm/time.h>
|
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
|
#include <asm/cputable.h>
|
|
|
|
|
#include <asm/system.h>
|
2005-09-27 03:51:59 +00:00
|
|
|
#include <asm/mpic.h>
|
2005-11-11 10:15:21 +00:00
|
|
|
#include <asm/vdso_datapage.h>
|
2005-11-04 23:33:55 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
|
#include <asm/paca.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef DEBUG
|
2005-11-15 04:16:38 +00:00
|
|
|
#include <asm/udbg.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#define DBG(fmt...) udbg_printf(fmt)
|
|
|
|
|
#else
|
|
|
|
|
#define DBG(fmt...)
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-11-15 04:16:38 +00:00
|
|
|
int smp_hw_index[NR_CPUS];
|
|
|
|
|
struct thread_info *secondary_ti;
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
cpumask_t cpu_possible_map = CPU_MASK_NONE;
|
|
|
|
|
cpumask_t cpu_online_map = CPU_MASK_NONE;
|
2007-10-16 08:24:05 +00:00
|
|
|
DEFINE_PER_CPU(cpumask_t, cpu_sibling_map) = CPU_MASK_NONE;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(cpu_online_map);
|
|
|
|
|
EXPORT_SYMBOL(cpu_possible_map);
|
2007-10-16 08:24:05 +00:00
|
|
|
EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-04 23:33:55 +00:00
|
|
|
/* SMP operations for this machine */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct smp_ops_t *smp_ops;
|
|
|
|
|
|
|
|
|
|
static volatile unsigned int cpu_callin_map[NR_CPUS];
|
|
|
|
|
|
|
|
|
|
void smp_call_function_interrupt(void);
|
|
|
|
|
|
|
|
|
|
int smt_enabled_at_boot = 1;
|
|
|
|
|
|
2007-12-28 04:11:09 +00:00
|
|
|
static int ipi_fail_ok;
|
|
|
|
|
|
2005-12-04 07:39:43 +00:00
|
|
|
static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL;
|
|
|
|
|
|
2005-11-04 23:33:55 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 22:20:36 +00:00
|
|
|
void __devinit smp_generic_kick_cpu(int nr)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(nr < 0 || nr >= NR_CPUS);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The processor is currently spinning, waiting for the
|
|
|
|
|
* cpu_start field to become non-zero After we set cpu_start,
|
|
|
|
|
* the processor will continue on to secondary_start
|
|
|
|
|
*/
|
|
|
|
|
paca[nr].cpu_start = 1;
|
2005-05-01 15:58:47 +00:00
|
|
|
smp_mb();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-11-04 23:33:55 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00: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 13:55:46 +00:00
|
|
|
void smp_message_recv(int msg)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
switch(msg) {
|
|
|
|
|
case PPC_MSG_CALL_FUNCTION:
|
|
|
|
|
smp_call_function_interrupt();
|
|
|
|
|
break;
|
2005-11-04 23:33:55 +00:00
|
|
|
case PPC_MSG_RESCHEDULE:
|
2005-04-16 22:20:36 +00:00
|
|
|
/* XXX Do we have to do this? */
|
|
|
|
|
set_need_resched();
|
|
|
|
|
break;
|
|
|
|
|
case PPC_MSG_DEBUGGER_BREAK:
|
2005-12-04 07:39:43 +00:00
|
|
|
if (crash_ipi_function_ptr) {
|
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 13:55:46 +00:00
|
|
|
crash_ipi_function_ptr(get_irq_regs());
|
2005-12-04 07:39:43 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#ifdef CONFIG_DEBUGGER
|
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 13:55:46 +00:00
|
|
|
debugger_ipi(get_irq_regs());
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2005-12-04 07:39:43 +00:00
|
|
|
#endif /* CONFIG_DEBUGGER */
|
|
|
|
|
/* FALLTHROUGH */
|
2005-04-16 22:20:36 +00:00
|
|
|
default:
|
|
|
|
|
printk("SMP %d: smp_message_recv(): unknown msg %d\n",
|
|
|
|
|
smp_processor_id(), msg);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void smp_send_reschedule(int cpu)
|
|
|
|
|
{
|
2006-07-04 04:09:36 +00:00
|
|
|
if (likely(smp_ops))
|
|
|
|
|
smp_ops->message_pass(cpu, PPC_MSG_RESCHEDULE);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUGGER
|
|
|
|
|
void smp_send_debugger_break(int cpu)
|
|
|
|
|
{
|
2006-07-04 04:09:36 +00:00
|
|
|
if (likely(smp_ops))
|
|
|
|
|
smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-12-04 07:39:43 +00:00
|
|
|
#ifdef CONFIG_KEXEC
|
|
|
|
|
void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
|
|
|
|
|
{
|
|
|
|
|
crash_ipi_function_ptr = crash_ipi_callback;
|
2006-07-04 04:09:36 +00:00
|
|
|
if (crash_ipi_callback && smp_ops) {
|
2005-12-04 07:39:43 +00:00
|
|
|
mb();
|
|
|
|
|
smp_ops->message_pass(MSG_ALL_BUT_SELF, PPC_MSG_DEBUGGER_BREAK);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void stop_this_cpu(void *dummy)
|
|
|
|
|
{
|
|
|
|
|
local_irq_disable();
|
|
|
|
|
while (1)
|
|
|
|
|
;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Structure and data for smp_call_function(). This is designed to minimise
|
|
|
|
|
* static memory requirements. It also looks cleaner.
|
|
|
|
|
* Stolen from the i386 version.
|
|
|
|
|
*/
|
|
|
|
|
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(call_lock);
|
|
|
|
|
|
|
|
|
|
static struct call_data_struct {
|
|
|
|
|
void (*func) (void *info);
|
|
|
|
|
void *info;
|
|
|
|
|
atomic_t started;
|
|
|
|
|
atomic_t finished;
|
|
|
|
|
int wait;
|
|
|
|
|
} *call_data;
|
|
|
|
|
|
2005-11-04 23:33:55 +00:00
|
|
|
/* delay of at least 8 seconds */
|
|
|
|
|
#define SMP_CALL_TIMEOUT 8
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/*
|
2007-05-02 17:12:34 +00:00
|
|
|
* These functions send a 'generic call function' IPI to other online
|
|
|
|
|
* CPUS in the system.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-05-02 17:12:34 +00:00
|
|
|
* [SUMMARY] Run a function on other CPUs.
|
2005-04-16 22:20:36 +00:00
|
|
|
* <func> The function to run. This must be fast and non-blocking.
|
|
|
|
|
* <info> An arbitrary pointer to pass to the function.
|
|
|
|
|
* <nonatomic> currently unused.
|
|
|
|
|
* <wait> If true, wait (atomically) until function has completed on other CPUs.
|
|
|
|
|
* [RETURNS] 0 on success, else a negative status code. Does not return until
|
|
|
|
|
* remote CPUs are nearly ready to execute <<func>> or are or have executed.
|
2007-12-28 04:08:36 +00:00
|
|
|
* <map> is a cpu map of the cpus to send IPI to.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
|
* You must not call this function with disabled interrupts or from a
|
|
|
|
|
* hardware interrupt handler or from a bottom half handler.
|
|
|
|
|
*/
|
2007-12-28 04:08:36 +00:00
|
|
|
static int __smp_call_function_map(void (*func) (void *info), void *info,
|
|
|
|
|
int nonatomic, int wait, cpumask_t map)
|
2007-05-02 17:12:34 +00:00
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
struct call_data_struct data;
|
2007-05-02 17:12:34 +00:00
|
|
|
int ret = -1, num_cpus;
|
|
|
|
|
int cpu;
|
2005-11-04 23:33:55 +00:00
|
|
|
u64 timeout;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-07-04 04:09:36 +00:00
|
|
|
if (unlikely(smp_ops == NULL))
|
2007-05-02 17:12:34 +00:00
|
|
|
return ret;
|
2006-07-04 04:09:36 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
data.func = func;
|
|
|
|
|
data.info = info;
|
|
|
|
|
atomic_set(&data.started, 0);
|
|
|
|
|
data.wait = wait;
|
|
|
|
|
if (wait)
|
|
|
|
|
atomic_set(&data.finished, 0);
|
|
|
|
|
|
2007-05-18 16:47:01 +00:00
|
|
|
/* remove 'self' from the map */
|
|
|
|
|
if (cpu_isset(smp_processor_id(), map))
|
|
|
|
|
cpu_clear(smp_processor_id(), map);
|
|
|
|
|
|
|
|
|
|
/* sanity check the map, remove any non-online processors. */
|
|
|
|
|
cpus_and(map, map, cpu_online_map);
|
2007-07-31 20:19:46 +00:00
|
|
|
|
|
|
|
|
num_cpus = cpus_weight(map);
|
|
|
|
|
if (!num_cpus)
|
2007-05-18 16:47:01 +00:00
|
|
|
goto done;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
call_data = &data;
|
2005-05-01 15:58:47 +00:00
|
|
|
smp_wmb();
|
2007-05-02 17:12:34 +00:00
|
|
|
/* Send a message to all CPUs in the map */
|
|
|
|
|
for_each_cpu_mask(cpu, map)
|
|
|
|
|
smp_ops->message_pass(cpu, PPC_MSG_CALL_FUNCTION);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-04 23:33:55 +00:00
|
|
|
timeout = get_tb() + (u64) SMP_CALL_TIMEOUT * tb_ticks_per_sec;
|
|
|
|
|
|
2007-05-02 17:12:34 +00:00
|
|
|
/* Wait for indication that they have received the message */
|
|
|
|
|
while (atomic_read(&data.started) != num_cpus) {
|
2005-04-16 22:20:36 +00:00
|
|
|
HMT_low();
|
2005-11-04 23:33:55 +00:00
|
|
|
if (get_tb() >= timeout) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("smp_call_function on cpu %d: other cpus not "
|
2007-05-02 17:12:34 +00:00
|
|
|
"responding (%d)\n", smp_processor_id(),
|
|
|
|
|
atomic_read(&data.started));
|
2007-12-28 04:11:09 +00:00
|
|
|
if (!ipi_fail_ok)
|
|
|
|
|
debugger(NULL);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:12:34 +00:00
|
|
|
/* optionally wait for the CPUs to complete */
|
2005-04-16 22:20:36 +00:00
|
|
|
if (wait) {
|
2007-05-02 17:12:34 +00:00
|
|
|
while (atomic_read(&data.finished) != num_cpus) {
|
2005-04-16 22:20:36 +00:00
|
|
|
HMT_low();
|
2005-11-04 23:33:55 +00:00
|
|
|
if (get_tb() >= timeout) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("smp_call_function on cpu %d: other "
|
2007-05-02 17:12:34 +00:00
|
|
|
"cpus not finishing (%d/%d)\n",
|
|
|
|
|
smp_processor_id(),
|
|
|
|
|
atomic_read(&data.finished),
|
|
|
|
|
atomic_read(&data.started));
|
2005-04-16 22:20:36 +00:00
|
|
|
debugger(NULL);
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-05-18 16:47:01 +00:00
|
|
|
done:
|
2005-04-16 22:20:36 +00:00
|
|
|
ret = 0;
|
|
|
|
|
|
2005-11-04 23:33:55 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
call_data = NULL;
|
|
|
|
|
HMT_medium();
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2007-09-17 23:43:40 +00:00
|
|
|
static int __smp_call_function(void (*func)(void *info), void *info,
|
|
|
|
|
int nonatomic, int wait)
|
|
|
|
|
{
|
2007-12-28 04:11:09 +00:00
|
|
|
int ret;
|
|
|
|
|
spin_lock(&call_lock);
|
|
|
|
|
ret =__smp_call_function_map(func, info, nonatomic, wait,
|
2007-12-28 04:08:36 +00:00
|
|
|
cpu_online_map);
|
2007-12-28 04:11:09 +00:00
|
|
|
spin_unlock(&call_lock);
|
|
|
|
|
return ret;
|
2007-09-17 23:43:40 +00:00
|
|
|
}
|
|
|
|
|
|
2007-05-02 17:12:34 +00:00
|
|
|
int smp_call_function(void (*func) (void *info), void *info, int nonatomic,
|
|
|
|
|
int wait)
|
|
|
|
|
{
|
2007-09-17 23:43:40 +00:00
|
|
|
/* Can deadlock when called with interrupts disabled */
|
|
|
|
|
WARN_ON(irqs_disabled());
|
|
|
|
|
|
|
|
|
|
return __smp_call_function(func, info, nonatomic, wait);
|
2007-05-02 17:12:34 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
EXPORT_SYMBOL(smp_call_function);
|
|
|
|
|
|
2007-12-28 04:08:36 +00:00
|
|
|
int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
|
|
|
|
|
int nonatomic, int wait)
|
2007-05-02 17:12:34 +00:00
|
|
|
{
|
2007-05-18 16:47:01 +00:00
|
|
|
cpumask_t map = CPU_MASK_NONE;
|
2007-07-19 15:33:48 +00:00
|
|
|
int ret = 0;
|
2007-05-02 17:12:34 +00:00
|
|
|
|
2007-09-17 23:43:40 +00:00
|
|
|
/* Can deadlock when called with interrupts disabled */
|
|
|
|
|
WARN_ON(irqs_disabled());
|
|
|
|
|
|
2007-05-02 17:12:34 +00:00
|
|
|
if (!cpu_online(cpu))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
cpu_set(cpu, map);
|
2007-12-28 04:11:09 +00:00
|
|
|
if (cpu != get_cpu()) {
|
|
|
|
|
spin_lock(&call_lock);
|
2007-12-28 04:08:36 +00:00
|
|
|
ret = __smp_call_function_map(func, info, nonatomic, wait, map);
|
2007-12-28 04:11:09 +00:00
|
|
|
spin_unlock(&call_lock);
|
|
|
|
|
} else {
|
2007-07-19 15:33:48 +00:00
|
|
|
local_irq_disable();
|
|
|
|
|
func(info);
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
}
|
2007-05-18 16:47:01 +00:00
|
|
|
put_cpu();
|
|
|
|
|
return ret;
|
2007-05-02 17:12:34 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(smp_call_function_single);
|
|
|
|
|
|
2007-09-17 23:43:40 +00:00
|
|
|
void smp_send_stop(void)
|
|
|
|
|
{
|
2007-12-28 04:11:09 +00:00
|
|
|
int nolock;
|
|
|
|
|
|
|
|
|
|
/* It's OK to fail sending the IPI, since the alternative is to
|
|
|
|
|
* be stuck forever waiting on the other CPU to take the interrupt.
|
|
|
|
|
*
|
|
|
|
|
* It's better to at least continue and go through reboot, since this
|
|
|
|
|
* function is usually called at panic or reboot time in the first
|
|
|
|
|
* place.
|
|
|
|
|
*/
|
|
|
|
|
ipi_fail_ok = 1;
|
|
|
|
|
|
|
|
|
|
/* Don't deadlock in case we got called through panic */
|
|
|
|
|
nolock = !spin_trylock(&call_lock);
|
|
|
|
|
__smp_call_function_map(stop_this_cpu, NULL, 1, 0, cpu_online_map);
|
|
|
|
|
if (!nolock)
|
|
|
|
|
spin_unlock(&call_lock);
|
2007-09-17 23:43:40 +00:00
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void smp_call_function_interrupt(void)
|
|
|
|
|
{
|
|
|
|
|
void (*func) (void *info);
|
|
|
|
|
void *info;
|
|
|
|
|
int wait;
|
|
|
|
|
|
|
|
|
|
/* call_data will be NULL if the sender timed out while
|
|
|
|
|
* waiting on us to receive the call.
|
|
|
|
|
*/
|
|
|
|
|
if (!call_data)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
func = call_data->func;
|
|
|
|
|
info = call_data->info;
|
|
|
|
|
wait = call_data->wait;
|
|
|
|
|
|
|
|
|
|
if (!wait)
|
|
|
|
|
smp_mb__before_atomic_inc();
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Notify initiating CPU that I've grabbed the data and am
|
|
|
|
|
* about to execute the function
|
|
|
|
|
*/
|
|
|
|
|
atomic_inc(&call_data->started);
|
|
|
|
|
/*
|
|
|
|
|
* At this point the info structure may be out of scope unless wait==1
|
|
|
|
|
*/
|
|
|
|
|
(*func)(info);
|
|
|
|
|
if (wait) {
|
|
|
|
|
smp_mb__before_atomic_inc();
|
|
|
|
|
atomic_inc(&call_data->finished);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern struct gettimeofday_struct do_gtod;
|
|
|
|
|
|
|
|
|
|
struct thread_info *current_set[NR_CPUS];
|
|
|
|
|
|
|
|
|
|
DECLARE_PER_CPU(unsigned int, pvr);
|
|
|
|
|
|
|
|
|
|
static void __devinit smp_store_cpu_info(int id)
|
|
|
|
|
{
|
|
|
|
|
per_cpu(pvr, id) = mfspr(SPRN_PVR);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void __init smp_create_idle(unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
struct task_struct *p;
|
|
|
|
|
|
|
|
|
|
/* create a process for the processor */
|
|
|
|
|
p = fork_idle(cpu);
|
|
|
|
|
if (IS_ERR(p))
|
|
|
|
|
panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
|
2005-11-04 23:33:55 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 22:20:36 +00:00
|
|
|
paca[cpu].__current = p;
|
[POWERPC] Bolt in SLB entry for kernel stack on secondary cpus
This fixes a regression reported by Kamalesh Bulabel where a POWER4
machine would crash because of an SLB miss at a point where the SLB
miss exception was unrecoverable. This regression is tracked at:
http://bugzilla.kernel.org/show_bug.cgi?id=10082
SLB misses at such points shouldn't happen because the kernel stack is
the only memory accessed other than things in the first segment of the
linear mapping (which is mapped at all times by entry 0 of the SLB).
The context switch code ensures that SLB entry 2 covers the kernel
stack, if it is not already covered by entry 0. None of entries 0
to 2 are ever replaced by the SLB miss handler.
Where this went wrong is that the context switch code assumes it
doesn't have to write to SLB entry 2 if the new kernel stack is in the
same segment as the old kernel stack, since entry 2 should already be
correct. However, when we start up a secondary cpu, it calls
slb_initialize, which doesn't set up entry 2. This is correct for
the boot cpu, where we will be using a stack in the kernel BSS at this
point (i.e. init_thread_union), but not necessarily for secondary
cpus, whose initial stack can be allocated anywhere. This doesn't
cause any immediate problem since the SLB miss handler will just
create an SLB entry somewhere else to cover the initial stack.
In fact it's possible for the cpu to go quite a long time without SLB
entry 2 being valid. Eventually, though, the entry created by the SLB
miss handler will get overwritten by some other entry, and if the next
access to the stack is at an unrecoverable point, we get the crash.
This fixes the problem by making slb_initialize create a suitable
entry for the kernel stack, if we are on a secondary cpu and the stack
isn't covered by SLB entry 0. This requires initializing the
get_paca()->kstack field earlier, so I do that in smp_create_idle
where the current field is initialized. This also abstracts a bit of
the computation that mk_esid_data in slb.c does so that it can be used
in slb_initialize.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-05-02 04:29:12 +00:00
|
|
|
paca[cpu].kstack = (unsigned long) task_thread_info(p)
|
|
|
|
|
+ THREAD_SIZE - STACK_FRAME_OVERHEAD;
|
2005-11-04 23:33:55 +00:00
|
|
|
#endif
|
2006-01-12 09:06:01 +00:00
|
|
|
current_set[cpu] = task_thread_info(p);
|
|
|
|
|
task_thread_info(p)->cpu = cpu;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void __init smp_prepare_cpus(unsigned int max_cpus)
|
|
|
|
|
{
|
|
|
|
|
unsigned int cpu;
|
|
|
|
|
|
|
|
|
|
DBG("smp_prepare_cpus\n");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* setup_cpu may need to be called on the boot cpu. We havent
|
|
|
|
|
* spun any cpus up but lets be paranoid.
|
|
|
|
|
*/
|
|
|
|
|
BUG_ON(boot_cpuid != smp_processor_id());
|
|
|
|
|
|
|
|
|
|
/* Fixup boot cpu */
|
|
|
|
|
smp_store_cpu_info(boot_cpuid);
|
|
|
|
|
cpu_callin_map[boot_cpuid] = 1;
|
|
|
|
|
|
2006-07-04 04:09:36 +00:00
|
|
|
if (smp_ops)
|
|
|
|
|
max_cpus = smp_ops->probe();
|
|
|
|
|
else
|
|
|
|
|
max_cpus = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
smp_space_timers(max_cpus);
|
|
|
|
|
|
2006-03-28 22:50:51 +00:00
|
|
|
for_each_possible_cpu(cpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
if (cpu != boot_cpuid)
|
|
|
|
|
smp_create_idle(cpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void __devinit smp_prepare_boot_cpu(void)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(smp_processor_id() != boot_cpuid);
|
|
|
|
|
|
|
|
|
|
cpu_set(boot_cpuid, cpu_online_map);
|
2005-11-04 23:33:55 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 22:20:36 +00:00
|
|
|
paca[boot_cpuid].__current = current;
|
2005-11-04 23:33:55 +00:00
|
|
|
#endif
|
2006-01-12 09:06:01 +00:00
|
|
|
current_set[boot_cpuid] = task_thread_info(current);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
|
/* State of each CPU during hotplug phases */
|
|
|
|
|
DEFINE_PER_CPU(int, cpu_state) = { 0 };
|
|
|
|
|
|
|
|
|
|
int generic_cpu_disable(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
|
|
if (cpu == boot_cpuid)
|
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
|
|
cpu_clear(cpu, cpu_online_map);
|
2005-11-10 02:37:51 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-11-11 10:15:21 +00:00
|
|
|
vdso_data->processorCount--;
|
2005-04-16 22:20:36 +00:00
|
|
|
fixup_irqs(cpu_online_map);
|
2005-11-10 03:26:12 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int generic_cpu_enable(unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
/* Do the normal bootup if we haven't
|
|
|
|
|
* already bootstrapped. */
|
|
|
|
|
if (system_state != SYSTEM_RUNNING)
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
|
|
|
|
|
/* get the target out of it's holding state */
|
|
|
|
|
per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
|
2005-05-01 15:58:47 +00:00
|
|
|
smp_wmb();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
while (!cpu_online(cpu))
|
|
|
|
|
cpu_relax();
|
|
|
|
|
|
2005-11-10 03:26:12 +00:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 22:20:36 +00:00
|
|
|
fixup_irqs(cpu_online_map);
|
|
|
|
|
/* counter the irq disable in fixup_irqs */
|
|
|
|
|
local_irq_enable();
|
2005-11-10 03:26:12 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void generic_cpu_die(unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 100; i++) {
|
2005-05-01 15:58:47 +00:00
|
|
|
smp_rmb();
|
2005-04-16 22:20:36 +00:00
|
|
|
if (per_cpu(cpu_state, cpu) == CPU_DEAD)
|
|
|
|
|
return;
|
|
|
|
|
msleep(100);
|
|
|
|
|
}
|
|
|
|
|
printk(KERN_ERR "CPU%d didn't die...\n", cpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void generic_mach_cpu_die(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned int cpu;
|
|
|
|
|
|
|
|
|
|
local_irq_disable();
|
|
|
|
|
cpu = smp_processor_id();
|
|
|
|
|
printk(KERN_DEBUG "CPU%d offline\n", cpu);
|
|
|
|
|
__get_cpu_var(cpu_state) = CPU_DEAD;
|
2005-05-01 15:58:47 +00:00
|
|
|
smp_wmb();
|
2005-04-16 22:20:36 +00:00
|
|
|
while (__get_cpu_var(cpu_state) != CPU_UP_PREPARE)
|
|
|
|
|
cpu_relax();
|
|
|
|
|
cpu_set(cpu, cpu_online_map);
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static int __devinit cpu_enable(unsigned int cpu)
|
|
|
|
|
{
|
2006-07-04 04:09:36 +00:00
|
|
|
if (smp_ops && smp_ops->cpu_enable)
|
2005-04-16 22:20:36 +00:00
|
|
|
return smp_ops->cpu_enable(cpu);
|
|
|
|
|
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
|
2007-01-11 07:15:34 +00:00
|
|
|
int __cpuinit __cpu_up(unsigned int cpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
|
int c;
|
|
|
|
|
|
2005-11-04 23:33:55 +00:00
|
|
|
secondary_ti = current_set[cpu];
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!cpu_enable(cpu))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2006-07-04 04:09:36 +00:00
|
|
|
if (smp_ops == NULL ||
|
|
|
|
|
(smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
/* Make sure callin-map entry is 0 (can be leftover a CPU
|
|
|
|
|
* hotplug
|
|
|
|
|
*/
|
|
|
|
|
cpu_callin_map[cpu] = 0;
|
|
|
|
|
|
|
|
|
|
/* The information for processor bringup must
|
|
|
|
|
* be written out to main store before we release
|
|
|
|
|
* the processor.
|
|
|
|
|
*/
|
2005-05-01 15:58:47 +00:00
|
|
|
smp_mb();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
/* wake up cpus */
|
|
|
|
|
DBG("smp: kicking cpu %d\n", cpu);
|
|
|
|
|
smp_ops->kick_cpu(cpu);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* wait to see if the cpu made a callin (is actually up).
|
|
|
|
|
* use this value that I found through experimentation.
|
|
|
|
|
* -- Cort
|
|
|
|
|
*/
|
|
|
|
|
if (system_state < SYSTEM_RUNNING)
|
2006-06-17 22:52:44 +00:00
|
|
|
for (c = 50000; c && !cpu_callin_map[cpu]; c--)
|
2005-04-16 22:20:36 +00:00
|
|
|
udelay(100);
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
|
else
|
|
|
|
|
/*
|
|
|
|
|
* CPUs can take much longer to come up in the
|
|
|
|
|
* hotplug case. Wait five seconds.
|
|
|
|
|
*/
|
|
|
|
|
for (c = 25; c && !cpu_callin_map[cpu]; c--) {
|
|
|
|
|
msleep(200);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (!cpu_callin_map[cpu]) {
|
|
|
|
|
printk("Processor %u is stuck.\n", cpu);
|
|
|
|
|
return -ENOENT;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
printk("Processor %u found.\n", cpu);
|
|
|
|
|
|
|
|
|
|
if (smp_ops->give_timebase)
|
|
|
|
|
smp_ops->give_timebase();
|
|
|
|
|
|
|
|
|
|
/* Wait until cpu puts itself in the online map */
|
|
|
|
|
while (!cpu_online(cpu))
|
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Activate a secondary processor. */
|
|
|
|
|
int __devinit start_secondary(void *unused)
|
|
|
|
|
{
|
|
|
|
|
unsigned int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
|
|
atomic_inc(&init_mm.mm_count);
|
|
|
|
|
current->active_mm = &init_mm;
|
|
|
|
|
|
|
|
|
|
smp_store_cpu_info(cpu);
|
2005-11-04 23:33:55 +00:00
|
|
|
set_dec(tb_ticks_per_jiffy);
|
2005-11-09 23:45:30 +00:00
|
|
|
preempt_disable();
|
2005-04-16 22:20:36 +00:00
|
|
|
cpu_callin_map[cpu] = 1;
|
|
|
|
|
|
|
|
|
|
smp_ops->setup_cpu(cpu);
|
|
|
|
|
if (smp_ops->take_timebase)
|
|
|
|
|
smp_ops->take_timebase();
|
|
|
|
|
|
2006-02-07 04:44:23 +00:00
|
|
|
if (system_state > SYSTEM_BOOTING)
|
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-23 23:06:59 +00:00
|
|
|
snapshot_timebase();
|
2006-02-07 04:44:23 +00:00
|
|
|
|
2007-09-21 03:26:03 +00:00
|
|
|
secondary_cpu_time_init();
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock(&call_lock);
|
|
|
|
|
cpu_set(cpu, cpu_online_map);
|
|
|
|
|
spin_unlock(&call_lock);
|
|
|
|
|
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
|
|
|
|
|
cpu_idle();
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int setup_profiling_timer(unsigned int multiplier)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void __init smp_cpus_done(unsigned int max_cpus)
|
|
|
|
|
{
|
|
|
|
|
cpumask_t old_mask;
|
|
|
|
|
|
|
|
|
|
/* We want the setup_cpu() here to be called from CPU 0, but our
|
|
|
|
|
* init thread may have been "borrowed" by another CPU in the meantime
|
|
|
|
|
* se we pin us down to CPU 0 for a short while
|
|
|
|
|
*/
|
|
|
|
|
old_mask = current->cpus_allowed;
|
|
|
|
|
set_cpus_allowed(current, cpumask_of_cpu(boot_cpuid));
|
|
|
|
|
|
2006-07-04 04:09:36 +00:00
|
|
|
if (smp_ops)
|
|
|
|
|
smp_ops->setup_cpu(boot_cpuid);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
set_cpus_allowed(current, old_mask);
|
2005-12-12 19:56:47 +00: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-23 23:06:59 +00:00
|
|
|
snapshot_timebases();
|
|
|
|
|
|
2005-12-12 19:56:47 +00:00
|
|
|
dump_numa_cpu_topology();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
|
int __cpu_disable(void)
|
|
|
|
|
{
|
|
|
|
|
if (smp_ops->cpu_disable)
|
|
|
|
|
return smp_ops->cpu_disable();
|
|
|
|
|
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void __cpu_die(unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
if (smp_ops->cpu_die)
|
|
|
|
|
smp_ops->cpu_die(cpu);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
