2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* arch/s390/kernel/smp.c
|
|
|
|
*
|
2007-04-27 10:02:00 -04:00
|
|
|
* Copyright IBM Corp. 1999,2007
|
2005-04-16 18:20:36 -04:00
|
|
|
* Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
|
2007-04-27 10:02:00 -04:00
|
|
|
* Martin Schwidefsky (schwidefsky@de.ibm.com)
|
|
|
|
* Heiko Carstens (heiko.carstens@de.ibm.com)
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
2007-04-27 10:02:00 -04:00
|
|
|
* based on other smp stuff by
|
2005-04-16 18:20:36 -04:00
|
|
|
* (c) 1995 Alan Cox, CymruNET Ltd <alan@cymru.net>
|
|
|
|
* (c) 1998 Ingo Molnar
|
|
|
|
*
|
|
|
|
* We work with logical cpu numbering everywhere we can. The only
|
|
|
|
* functions using the real cpu address (got from STAP) are the sigp
|
|
|
|
* functions. For all other functions we use the identity mapping.
|
|
|
|
* That means that cpu_number_map[i] == i for every cpu. cpu_number_map is
|
|
|
|
* used e.g. to find the idle task belonging to a logical cpu. Every array
|
|
|
|
* in the kernel is sorted by the logical cpu number and not by the physical
|
|
|
|
* one which is causing all the confusion with __cpu_logical_map and
|
|
|
|
* cpu_number_map in other architectures.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/mm.h>
|
2007-07-29 18:36:13 -04:00
|
|
|
#include <linux/err.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/cpu.h>
|
2007-02-05 15:16:47 -05:00
|
|
|
#include <linux/timex.h>
|
2007-04-27 10:01:49 -04:00
|
|
|
#include <linux/bootmem.h>
|
2007-02-21 04:55:21 -05:00
|
|
|
#include <asm/ipl.h>
|
2007-02-05 15:16:47 -05:00
|
|
|
#include <asm/setup.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <asm/sigp.h>
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/s390_ext.h>
|
|
|
|
#include <asm/cpcmd.h>
|
|
|
|
#include <asm/tlbflush.h>
|
2007-02-05 15:16:47 -05:00
|
|
|
#include <asm/timer.h>
|
2007-04-27 10:01:49 -04:00
|
|
|
#include <asm/lowcore.h>
|
2008-01-26 08:10:56 -05:00
|
|
|
#include <asm/sclp.h>
|
2007-10-22 06:52:39 -04:00
|
|
|
#include <asm/cpu.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* An array with a pointer the lowcore of every CPU.
|
|
|
|
*/
|
|
|
|
struct _lowcore *lowcore_ptr[NR_CPUS];
|
2007-04-27 10:02:00 -04:00
|
|
|
EXPORT_SYMBOL(lowcore_ptr);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-02-17 16:52:46 -05:00
|
|
|
cpumask_t cpu_online_map = CPU_MASK_NONE;
|
2007-04-27 10:02:00 -04:00
|
|
|
EXPORT_SYMBOL(cpu_online_map);
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
cpumask_t cpu_possible_map = CPU_MASK_ALL;
|
2007-04-27 10:02:00 -04:00
|
|
|
EXPORT_SYMBOL(cpu_possible_map);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static struct task_struct *current_set[NR_CPUS];
|
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
static u8 smp_cpu_type;
|
|
|
|
static int smp_use_sigp_detection;
|
|
|
|
|
|
|
|
enum s390_cpu_state {
|
|
|
|
CPU_STATE_STANDBY,
|
|
|
|
CPU_STATE_CONFIGURED,
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
static DEFINE_MUTEX(smp_cpu_state_mutex);
|
|
|
|
#endif
|
|
|
|
static int smp_cpu_state[NR_CPUS];
|
|
|
|
|
|
|
|
static DEFINE_PER_CPU(struct cpu, cpu_devices);
|
|
|
|
DEFINE_PER_CPU(struct s390_idle_data, s390_idle);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static void smp_ext_bitcall(int, ec_bit_sig);
|
|
|
|
|
|
|
|
/*
|
2007-02-21 04:55:06 -05:00
|
|
|
* Structure and data for __smp_call_function_map(). This is designed to
|
|
|
|
* minimise static memory requirements. It also looks cleaner.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(call_lock);
|
|
|
|
|
|
|
|
struct call_data_struct {
|
|
|
|
void (*func) (void *info);
|
|
|
|
void *info;
|
2007-02-21 04:55:06 -05:00
|
|
|
cpumask_t started;
|
|
|
|
cpumask_t finished;
|
2005-04-16 18:20:36 -04:00
|
|
|
int wait;
|
|
|
|
};
|
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
static struct call_data_struct *call_data;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 'Call function' interrupt callback
|
|
|
|
*/
|
|
|
|
static void do_call_function(void)
|
|
|
|
{
|
|
|
|
void (*func) (void *info) = call_data->func;
|
|
|
|
void *info = call_data->info;
|
|
|
|
int wait = call_data->wait;
|
|
|
|
|
2007-02-21 04:55:06 -05:00
|
|
|
cpu_set(smp_processor_id(), call_data->started);
|
2005-04-16 18:20:36 -04:00
|
|
|
(*func)(info);
|
|
|
|
if (wait)
|
2007-02-21 04:55:06 -05:00
|
|
|
cpu_set(smp_processor_id(), call_data->finished);;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-02-21 04:55:06 -05:00
|
|
|
static void __smp_call_function_map(void (*func) (void *info), void *info,
|
|
|
|
int nonatomic, int wait, cpumask_t map)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct call_data_struct data;
|
2007-02-21 04:55:06 -05:00
|
|
|
int cpu, local = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-02-21 04:55:06 -05:00
|
|
|
/*
|
2007-03-05 17:35:41 -05:00
|
|
|
* Can deadlock when interrupts are disabled or if in wrong context.
|
2007-02-21 04:55:06 -05:00
|
|
|
*/
|
2007-03-05 17:35:41 -05:00
|
|
|
WARN_ON(irqs_disabled() || in_irq());
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-02-21 04:55:06 -05:00
|
|
|
/*
|
|
|
|
* Check for local function call. We have to have the same call order
|
|
|
|
* as in on_each_cpu() because of machine_restart_smp().
|
|
|
|
*/
|
|
|
|
if (cpu_isset(smp_processor_id(), map)) {
|
|
|
|
local = 1;
|
|
|
|
cpu_clear(smp_processor_id(), map);
|
|
|
|
}
|
|
|
|
|
|
|
|
cpus_and(map, map, cpu_online_map);
|
|
|
|
if (cpus_empty(map))
|
|
|
|
goto out;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
data.func = func;
|
|
|
|
data.info = info;
|
2007-02-21 04:55:06 -05:00
|
|
|
data.started = CPU_MASK_NONE;
|
2005-04-16 18:20:36 -04:00
|
|
|
data.wait = wait;
|
|
|
|
if (wait)
|
2007-02-21 04:55:06 -05:00
|
|
|
data.finished = CPU_MASK_NONE;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-07-27 06:29:09 -04:00
|
|
|
spin_lock(&call_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
call_data = &data;
|
2007-02-21 04:55:06 -05:00
|
|
|
|
|
|
|
for_each_cpu_mask(cpu, map)
|
|
|
|
smp_ext_bitcall(cpu, ec_call_function);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Wait for response */
|
2007-02-21 04:55:06 -05:00
|
|
|
while (!cpus_equal(map, data.started))
|
2005-04-16 18:20:36 -04:00
|
|
|
cpu_relax();
|
|
|
|
if (wait)
|
2007-02-21 04:55:06 -05:00
|
|
|
while (!cpus_equal(map, data.finished))
|
2005-04-16 18:20:36 -04:00
|
|
|
cpu_relax();
|
2007-07-27 06:29:09 -04:00
|
|
|
spin_unlock(&call_lock);
|
2007-02-21 04:55:06 -05:00
|
|
|
out:
|
2007-07-27 06:29:09 -04:00
|
|
|
if (local) {
|
|
|
|
local_irq_disable();
|
2007-02-21 04:55:06 -05:00
|
|
|
func(info);
|
2007-07-27 06:29:09 -04:00
|
|
|
local_irq_enable();
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-02-21 04:55:06 -05:00
|
|
|
* smp_call_function:
|
|
|
|
* @func: the function to run; this must be fast and non-blocking
|
|
|
|
* @info: an arbitrary pointer to pass to the function
|
|
|
|
* @nonatomic: unused
|
|
|
|
* @wait: if true, wait (atomically) until function has completed on other CPUs
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
2007-02-21 04:55:06 -05:00
|
|
|
* Run a function on all other CPUs.
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
2007-04-27 10:02:00 -04:00
|
|
|
* You must not call this function with disabled interrupts, from a
|
|
|
|
* hardware interrupt handler or from a bottom half.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
2007-02-21 04:55:06 -05:00
|
|
|
int smp_call_function(void (*func) (void *info), void *info, int nonatomic,
|
|
|
|
int wait)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-02-21 04:55:06 -05:00
|
|
|
cpumask_t map;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-03-05 17:35:41 -05:00
|
|
|
preempt_disable();
|
2007-02-21 04:55:06 -05:00
|
|
|
map = cpu_online_map;
|
|
|
|
cpu_clear(smp_processor_id(), map);
|
|
|
|
__smp_call_function_map(func, info, nonatomic, wait, map);
|
2007-03-05 17:35:41 -05:00
|
|
|
preempt_enable();
|
2007-02-21 04:55:06 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(smp_call_function);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-02-21 04:55:06 -05:00
|
|
|
/*
|
2007-07-27 06:29:08 -04:00
|
|
|
* smp_call_function_single:
|
|
|
|
* @cpu: the CPU where func should run
|
2007-02-21 04:55:06 -05:00
|
|
|
* @func: the function to run; this must be fast and non-blocking
|
|
|
|
* @info: an arbitrary pointer to pass to the function
|
|
|
|
* @nonatomic: unused
|
|
|
|
* @wait: if true, wait (atomically) until function has completed on other CPUs
|
|
|
|
*
|
|
|
|
* Run a function on one processor.
|
|
|
|
*
|
2007-04-27 10:02:00 -04:00
|
|
|
* You must not call this function with disabled interrupts, from a
|
|
|
|
* hardware interrupt handler or from a bottom half.
|
2007-02-21 04:55:06 -05:00
|
|
|
*/
|
2007-07-27 06:29:08 -04:00
|
|
|
int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
|
|
|
|
int nonatomic, int wait)
|
2007-02-21 04:55:06 -05:00
|
|
|
{
|
2007-03-05 17:35:41 -05:00
|
|
|
preempt_disable();
|
2007-07-27 06:29:08 -04:00
|
|
|
__smp_call_function_map(func, info, nonatomic, wait,
|
|
|
|
cpumask_of_cpu(cpu));
|
2007-03-05 17:35:41 -05:00
|
|
|
preempt_enable();
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
2007-07-27 06:29:08 -04:00
|
|
|
EXPORT_SYMBOL(smp_call_function_single);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-26 08:11:27 -05:00
|
|
|
/**
|
|
|
|
* smp_call_function_mask(): Run a function on a set of other CPUs.
|
|
|
|
* @mask: The set of cpus to run on. Must not include the current cpu.
|
|
|
|
* @func: The function to run. This must be fast and non-blocking.
|
|
|
|
* @info: An arbitrary pointer to pass to the function.
|
|
|
|
* @wait: If true, wait (atomically) until function has completed on other CPUs.
|
|
|
|
*
|
|
|
|
* Returns 0 on success, else a negative status code.
|
|
|
|
*
|
|
|
|
* If @wait is true, then returns once @func has returned; otherwise
|
|
|
|
* it returns just before the target cpu calls @func.
|
|
|
|
*
|
|
|
|
* You must not call this function with disabled interrupts or from a
|
|
|
|
* hardware interrupt handler or from a bottom half handler.
|
|
|
|
*/
|
2008-02-05 10:50:39 -05:00
|
|
|
int smp_call_function_mask(cpumask_t mask, void (*func)(void *), void *info,
|
|
|
|
int wait)
|
2008-01-26 08:11:27 -05:00
|
|
|
{
|
|
|
|
preempt_disable();
|
2008-02-05 10:50:39 -05:00
|
|
|
cpu_clear(smp_processor_id(), mask);
|
2008-01-26 08:11:27 -05:00
|
|
|
__smp_call_function_map(func, info, 0, wait, mask);
|
|
|
|
preempt_enable();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(smp_call_function_mask);
|
|
|
|
|
2007-11-20 05:13:37 -05:00
|
|
|
void smp_send_stop(void)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
int cpu, rc;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-11-20 05:13:37 -05:00
|
|
|
/* Disable all interrupts/machine checks */
|
|
|
|
__load_psw_mask(psw_kernel_bits & ~PSW_MASK_MCHECK);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-11-20 05:13:37 -05:00
|
|
|
/* write magic number to zero page (absolute 0) */
|
|
|
|
lowcore_ptr[smp_processor_id()]->panic_magic = __PANIC_MAGIC;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-11-20 05:13:37 -05:00
|
|
|
/* stop all processors */
|
2005-04-16 18:20:36 -04:00
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
if (cpu == smp_processor_id())
|
|
|
|
continue;
|
|
|
|
do {
|
2007-11-20 05:13:37 -05:00
|
|
|
rc = signal_processor(cpu, sigp_stop);
|
2007-04-27 10:02:00 -04:00
|
|
|
} while (rc == sigp_busy);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
while (!smp_cpu_not_running(cpu))
|
2006-12-04 09:40:33 -05:00
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* This is the main routine where commands issued by other
|
|
|
|
* cpus are handled.
|
|
|
|
*/
|
|
|
|
|
2007-02-05 15:16:47 -05:00
|
|
|
static void do_ext_call_interrupt(__u16 code)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
unsigned long bits;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
/*
|
|
|
|
* handle bit signal external calls
|
|
|
|
*
|
|
|
|
* For the ec_schedule signal we have to do nothing. All the work
|
|
|
|
* is done automatically when we return from the interrupt.
|
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
bits = xchg(&S390_lowcore.ext_call_fast, 0);
|
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
if (test_bit(ec_call_function, &bits))
|
2005-04-16 18:20:36 -04:00
|
|
|
do_call_function();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send an external call sigp to another cpu and return without waiting
|
|
|
|
* for its completion.
|
|
|
|
*/
|
|
|
|
static void smp_ext_bitcall(int cpu, ec_bit_sig sig)
|
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
/*
|
|
|
|
* Set signaling bit in lowcore of target cpu and kick it
|
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
set_bit(sig, (unsigned long *) &lowcore_ptr[cpu]->ext_call_fast);
|
2007-04-27 10:02:00 -04:00
|
|
|
while (signal_processor(cpu, sigp_emergency_signal) == sigp_busy)
|
2005-04-16 18:20:36 -04:00
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
|
2006-01-06 03:19:28 -05:00
|
|
|
#ifndef CONFIG_64BIT
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* this function sends a 'purge tlb' signal to another CPU.
|
|
|
|
*/
|
|
|
|
void smp_ptlb_callback(void *info)
|
|
|
|
{
|
[S390] tlb flush fix.
The current tlb flushing code for page table entries violates the
s390 architecture in a small detail. The relevant section from the
principles of operation (SA22-7832-02 page 3-47):
"A valid table entry must not be changed while it is attached
to any CPU and may be used for translation by that CPU except to
(1) invalidate the entry by using INVALIDATE PAGE TABLE ENTRY or
INVALIDATE DAT TABLE ENTRY, (2) alter bits 56-63 of a page-table
entry, or (3) make a change by means of a COMPARE AND SWAP AND
PURGE instruction that purges the TLB."
That means if one thread of a multithreaded applciation uses a vma
while another thread does an unmap on it, the page table entries of
that vma needs to get removed with IPTE, IDTE or CSP. In some strange
and rare situations a cpu could check-stop (die) because a entry has
been pushed out of the TLB that is still needed to complete a
(milli-coded) instruction. I've never seen it happen with the current
code on any of the supported machines, so right now this is a
theoretical problem. But I want to fix it nevertheless, to avoid
headaches in the futures.
To get this implemented correctly without changing common code the
primitives ptep_get_and_clear, ptep_get_and_clear_full and
ptep_set_wrprotect need to use the IPTE instruction to invalidate the
pte before the new pte value gets stored. If IPTE is always used for
the three primitives three important operations will have a performace
hit: fork, mprotect and exit_mmap. Time for some workarounds:
* 1: ptep_get_and_clear_full is used in unmap_vmas to remove page
tables entries in a batched tlb gather operation. If the mmu_gather
context passed to unmap_vmas has been started with full_mm_flush==1
or if only one cpu is online or if the only user of a mm_struct is the
current process then the fullmm indication in the mmu_gather context is
set to one. All TLBs for mm_struct are flushed by the tlb_gather_mmu
call. No new TLBs can be created while the unmap is in progress. In
this case ptep_get_and_clear_full clears the ptes with a simple store.
* 2: ptep_get_and_clear is used in change_protection to clear the
ptes from the page tables before they are reentered with the new
access flags. At the end of the update flush_tlb_range clears the
remaining TLBs. In general the ptep_get_and_clear has to issue IPTE
for each pte and flush_tlb_range is a nop. But if there is only one
user of the mm_struct then ptep_get_and_clear uses simple stores
to do the update and flush_tlb_range will flush the TLBs.
* 3: Similar to 2, ptep_set_wrprotect is used in copy_page_range
for a fork to make all ptes of a cow mapping read-only. At the end of
of copy_page_range dup_mmap will flush the TLBs with a call to
flush_tlb_mm. Check for mm->mm_users and if there is only one user
avoid using IPTE in ptep_set_wrprotect and let flush_tlb_mm clear the
TLBs.
Overall for single threaded programs the tlb flush code now performs
better, for multi threaded programs it is slightly worse. In particular
exit_mmap() now does a single IDTE for the mm and then just frees every
page cache reference and every page table page directly without a delay
over the mmu_gather structure.
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
2007-10-22 06:52:44 -04:00
|
|
|
__tlb_flush_local();
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void smp_ptlb_all(void)
|
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
on_each_cpu(smp_ptlb_callback, NULL, 0, 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(smp_ptlb_all);
|
2006-01-06 03:19:28 -05:00
|
|
|
#endif /* ! CONFIG_64BIT */
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* this function sends a 'reschedule' IPI to another CPU.
|
|
|
|
* it goes straight through and wastes no time serializing
|
|
|
|
* anything. Worst case is that we lose a reschedule ...
|
|
|
|
*/
|
|
|
|
void smp_send_reschedule(int cpu)
|
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
smp_ext_bitcall(cpu, ec_schedule);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* parameter area for the set/clear control bit callbacks
|
|
|
|
*/
|
2006-09-28 10:56:43 -04:00
|
|
|
struct ec_creg_mask_parms {
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long orvals[16];
|
|
|
|
unsigned long andvals[16];
|
2006-09-28 10:56:43 -04:00
|
|
|
};
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* callback for setting/clearing control bits
|
|
|
|
*/
|
2007-04-27 10:02:00 -04:00
|
|
|
static void smp_ctl_bit_callback(void *info)
|
|
|
|
{
|
2006-09-28 10:56:43 -04:00
|
|
|
struct ec_creg_mask_parms *pp = info;
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long cregs[16];
|
|
|
|
int i;
|
2007-04-27 10:02:00 -04:00
|
|
|
|
2006-09-28 10:56:43 -04:00
|
|
|
__ctl_store(cregs, 0, 15);
|
|
|
|
for (i = 0; i <= 15; i++)
|
2005-04-16 18:20:36 -04:00
|
|
|
cregs[i] = (cregs[i] & pp->andvals[i]) | pp->orvals[i];
|
2006-09-28 10:56:43 -04:00
|
|
|
__ctl_load(cregs, 0, 15);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set a bit in a control register of all cpus
|
|
|
|
*/
|
2006-09-28 10:56:43 -04:00
|
|
|
void smp_ctl_set_bit(int cr, int bit)
|
|
|
|
{
|
|
|
|
struct ec_creg_mask_parms parms;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-09-28 10:56:43 -04:00
|
|
|
memset(&parms.orvals, 0, sizeof(parms.orvals));
|
|
|
|
memset(&parms.andvals, 0xff, sizeof(parms.andvals));
|
2005-04-16 18:20:36 -04:00
|
|
|
parms.orvals[cr] = 1 << bit;
|
2006-09-28 10:56:43 -04:00
|
|
|
on_each_cpu(smp_ctl_bit_callback, &parms, 0, 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2007-04-27 10:02:00 -04:00
|
|
|
EXPORT_SYMBOL(smp_ctl_set_bit);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear a bit in a control register of all cpus
|
|
|
|
*/
|
2006-09-28 10:56:43 -04:00
|
|
|
void smp_ctl_clear_bit(int cr, int bit)
|
|
|
|
{
|
|
|
|
struct ec_creg_mask_parms parms;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-09-28 10:56:43 -04:00
|
|
|
memset(&parms.orvals, 0, sizeof(parms.orvals));
|
|
|
|
memset(&parms.andvals, 0xff, sizeof(parms.andvals));
|
2005-04-16 18:20:36 -04:00
|
|
|
parms.andvals[cr] = ~(1L << bit);
|
2006-09-28 10:56:43 -04:00
|
|
|
on_each_cpu(smp_ctl_bit_callback, &parms, 0, 1);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2007-04-27 10:02:00 -04:00
|
|
|
EXPORT_SYMBOL(smp_ctl_clear_bit);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
/*
|
|
|
|
* In early ipl state a temp. logically cpu number is needed, so the sigp
|
|
|
|
* functions can be used to sense other cpus. Since NR_CPUS is >= 2 on
|
|
|
|
* CONFIG_SMP and the ipl cpu is logical cpu 0, it must be 1.
|
|
|
|
*/
|
|
|
|
#define CPU_INIT_NO 1
|
|
|
|
|
2007-04-27 10:01:49 -04:00
|
|
|
#if defined(CONFIG_ZFCPDUMP) || defined(CONFIG_ZFCPDUMP_MODULE)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* zfcpdump_prefix_array holds prefix registers for the following scenario:
|
|
|
|
* 64 bit zfcpdump kernel and 31 bit kernel which is to be dumped. We have to
|
|
|
|
* save its prefix registers, since they get lost, when switching from 31 bit
|
|
|
|
* to 64 bit.
|
|
|
|
*/
|
|
|
|
unsigned int zfcpdump_prefix_array[NR_CPUS + 1] \
|
|
|
|
__attribute__((__section__(".data")));
|
|
|
|
|
2007-07-10 05:24:13 -04:00
|
|
|
static void __init smp_get_save_area(unsigned int cpu, unsigned int phy_cpu)
|
2007-04-27 10:01:49 -04:00
|
|
|
{
|
|
|
|
if (ipl_info.type != IPL_TYPE_FCP_DUMP)
|
|
|
|
return;
|
2007-07-10 05:24:13 -04:00
|
|
|
if (cpu >= NR_CPUS) {
|
|
|
|
printk(KERN_WARNING "Registers for cpu %i not saved since dump "
|
|
|
|
"kernel was compiled with NR_CPUS=%i\n", cpu, NR_CPUS);
|
|
|
|
return;
|
2007-04-27 10:01:49 -04:00
|
|
|
}
|
2008-01-26 08:11:05 -05:00
|
|
|
zfcpdump_save_areas[cpu] = kmalloc(sizeof(union save_area), GFP_KERNEL);
|
2008-01-26 08:10:56 -05:00
|
|
|
__cpu_logical_map[CPU_INIT_NO] = (__u16) phy_cpu;
|
|
|
|
while (signal_processor(CPU_INIT_NO, sigp_stop_and_store_status) ==
|
|
|
|
sigp_busy)
|
2007-07-10 05:24:13 -04:00
|
|
|
cpu_relax();
|
|
|
|
memcpy(zfcpdump_save_areas[cpu],
|
|
|
|
(void *)(unsigned long) store_prefix() + SAVE_AREA_BASE,
|
|
|
|
SAVE_AREA_SIZE);
|
|
|
|
#ifdef CONFIG_64BIT
|
|
|
|
/* copy original prefix register */
|
|
|
|
zfcpdump_save_areas[cpu]->s390x.pref_reg = zfcpdump_prefix_array[cpu];
|
|
|
|
#endif
|
2007-04-27 10:01:49 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
union save_area *zfcpdump_save_areas[NR_CPUS + 1];
|
|
|
|
EXPORT_SYMBOL_GPL(zfcpdump_save_areas);
|
|
|
|
|
|
|
|
#else
|
2007-07-10 05:24:13 -04:00
|
|
|
|
|
|
|
static inline void smp_get_save_area(unsigned int cpu, unsigned int phy_cpu) { }
|
|
|
|
|
|
|
|
#endif /* CONFIG_ZFCPDUMP || CONFIG_ZFCPDUMP_MODULE */
|
2007-04-27 10:01:49 -04:00
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
static int cpu_stopped(int cpu)
|
|
|
|
{
|
|
|
|
__u32 status;
|
|
|
|
|
|
|
|
/* Check for stopped state */
|
|
|
|
if (signal_processor_ps(&status, 0, cpu, sigp_sense) ==
|
|
|
|
sigp_status_stored) {
|
|
|
|
if (status & 0x40)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cpu_known(int cpu_id)
|
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
for_each_present_cpu(cpu) {
|
|
|
|
if (__cpu_logical_map[cpu] == cpu_id)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int smp_rescan_cpus_sigp(cpumask_t avail)
|
|
|
|
{
|
|
|
|
int cpu_id, logical_cpu;
|
|
|
|
|
|
|
|
logical_cpu = first_cpu(avail);
|
|
|
|
if (logical_cpu == NR_CPUS)
|
|
|
|
return 0;
|
|
|
|
for (cpu_id = 0; cpu_id <= 65535; cpu_id++) {
|
|
|
|
if (cpu_known(cpu_id))
|
|
|
|
continue;
|
|
|
|
__cpu_logical_map[logical_cpu] = cpu_id;
|
|
|
|
if (!cpu_stopped(logical_cpu))
|
|
|
|
continue;
|
|
|
|
cpu_set(logical_cpu, cpu_present_map);
|
|
|
|
smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED;
|
|
|
|
logical_cpu = next_cpu(logical_cpu, avail);
|
|
|
|
if (logical_cpu == NR_CPUS)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
static int smp_rescan_cpus_sclp(cpumask_t avail)
|
2008-01-26 08:10:56 -05:00
|
|
|
{
|
|
|
|
struct sclp_cpu_info *info;
|
|
|
|
int cpu_id, logical_cpu, cpu;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
logical_cpu = first_cpu(avail);
|
|
|
|
if (logical_cpu == NR_CPUS)
|
|
|
|
return 0;
|
2008-01-26 08:11:05 -05:00
|
|
|
info = kmalloc(sizeof(*info), GFP_KERNEL);
|
2008-01-26 08:10:56 -05:00
|
|
|
if (!info)
|
|
|
|
return -ENOMEM;
|
|
|
|
rc = sclp_get_cpu_info(info);
|
|
|
|
if (rc)
|
|
|
|
goto out;
|
|
|
|
for (cpu = 0; cpu < info->combined; cpu++) {
|
|
|
|
if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type)
|
|
|
|
continue;
|
|
|
|
cpu_id = info->cpu[cpu].address;
|
|
|
|
if (cpu_known(cpu_id))
|
|
|
|
continue;
|
|
|
|
__cpu_logical_map[logical_cpu] = cpu_id;
|
|
|
|
cpu_set(logical_cpu, cpu_present_map);
|
|
|
|
if (cpu >= info->configured)
|
|
|
|
smp_cpu_state[logical_cpu] = CPU_STATE_STANDBY;
|
|
|
|
else
|
|
|
|
smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED;
|
|
|
|
logical_cpu = next_cpu(logical_cpu, avail);
|
|
|
|
if (logical_cpu == NR_CPUS)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
2008-01-26 08:11:05 -05:00
|
|
|
kfree(info);
|
2008-01-26 08:10:56 -05:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int smp_rescan_cpus(void)
|
|
|
|
{
|
|
|
|
cpumask_t avail;
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
cpus_xor(avail, cpu_possible_map, cpu_present_map);
|
2008-01-26 08:10:56 -05:00
|
|
|
if (smp_use_sigp_detection)
|
|
|
|
return smp_rescan_cpus_sigp(avail);
|
|
|
|
else
|
|
|
|
return smp_rescan_cpus_sclp(avail);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
static void __init smp_detect_cpus(void)
|
|
|
|
{
|
|
|
|
unsigned int cpu, c_cpus, s_cpus;
|
|
|
|
struct sclp_cpu_info *info;
|
|
|
|
u16 boot_cpu_addr, cpu_addr;
|
|
|
|
|
|
|
|
c_cpus = 1;
|
|
|
|
s_cpus = 0;
|
|
|
|
boot_cpu_addr = S390_lowcore.cpu_data.cpu_addr;
|
|
|
|
info = kmalloc(sizeof(*info), GFP_KERNEL);
|
|
|
|
if (!info)
|
|
|
|
panic("smp_detect_cpus failed to allocate memory\n");
|
|
|
|
/* Use sigp detection algorithm if sclp doesn't work. */
|
|
|
|
if (sclp_get_cpu_info(info)) {
|
|
|
|
smp_use_sigp_detection = 1;
|
|
|
|
for (cpu = 0; cpu <= 65535; cpu++) {
|
|
|
|
if (cpu == boot_cpu_addr)
|
|
|
|
continue;
|
|
|
|
__cpu_logical_map[CPU_INIT_NO] = cpu;
|
|
|
|
if (!cpu_stopped(CPU_INIT_NO))
|
|
|
|
continue;
|
|
|
|
smp_get_save_area(c_cpus, cpu);
|
|
|
|
c_cpus++;
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->has_cpu_type) {
|
|
|
|
for (cpu = 0; cpu < info->combined; cpu++) {
|
|
|
|
if (info->cpu[cpu].address == boot_cpu_addr) {
|
|
|
|
smp_cpu_type = info->cpu[cpu].type;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (cpu = 0; cpu < info->combined; cpu++) {
|
|
|
|
if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type)
|
|
|
|
continue;
|
|
|
|
cpu_addr = info->cpu[cpu].address;
|
|
|
|
if (cpu_addr == boot_cpu_addr)
|
|
|
|
continue;
|
|
|
|
__cpu_logical_map[CPU_INIT_NO] = cpu_addr;
|
|
|
|
if (!cpu_stopped(CPU_INIT_NO)) {
|
|
|
|
s_cpus++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
smp_get_save_area(c_cpus, cpu_addr);
|
|
|
|
c_cpus++;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
kfree(info);
|
|
|
|
printk(KERN_INFO "CPUs: %d configured, %d standby\n", c_cpus, s_cpus);
|
2008-01-26 08:11:31 -05:00
|
|
|
get_online_cpus();
|
2008-01-26 08:11:05 -05:00
|
|
|
smp_rescan_cpus();
|
2008-01-26 08:11:31 -05:00
|
|
|
put_online_cpus();
|
2008-01-26 08:11:05 -05:00
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
2007-04-27 10:02:00 -04:00
|
|
|
* Activate a secondary processor.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
2007-05-31 11:38:05 -04:00
|
|
|
int __cpuinit start_secondary(void *cpuvoid)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
/* Setup the cpu */
|
|
|
|
cpu_init();
|
2005-11-09 00:39:01 -05:00
|
|
|
preempt_disable();
|
2007-02-05 15:18:19 -05:00
|
|
|
/* Enable TOD clock interrupts on the secondary cpu. */
|
2007-04-27 10:02:00 -04:00
|
|
|
init_cpu_timer();
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef CONFIG_VIRT_TIMER
|
2007-02-05 15:18:19 -05:00
|
|
|
/* Enable cpu timer interrupts on the secondary cpu. */
|
2007-04-27 10:02:00 -04:00
|
|
|
init_cpu_vtimer();
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
|
|
|
/* Enable pfault pseudo page faults on this cpu. */
|
2006-12-04 09:40:40 -05:00
|
|
|
pfault_init();
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Mark this cpu as online */
|
|
|
|
cpu_set(smp_processor_id(), cpu_online_map);
|
|
|
|
/* Switch on interrupts */
|
|
|
|
local_irq_enable();
|
2007-04-27 10:02:00 -04:00
|
|
|
/* Print info about this processor */
|
|
|
|
print_cpu_info(&S390_lowcore.cpu_data);
|
|
|
|
/* cpu_idle will call schedule for us */
|
|
|
|
cpu_idle();
|
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init smp_create_idle(unsigned int cpu)
|
|
|
|
{
|
|
|
|
struct task_struct *p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* don't care about the psw and regs settings since we'll never
|
|
|
|
* reschedule the forked task.
|
|
|
|
*/
|
|
|
|
p = fork_idle(cpu);
|
|
|
|
if (IS_ERR(p))
|
|
|
|
panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
|
|
|
|
current_set[cpu] = p;
|
2007-10-22 06:52:39 -04:00
|
|
|
spin_lock_init(&(&per_cpu(s390_idle, cpu))->lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-01-26 08:11:14 -05:00
|
|
|
static int __cpuinit smp_alloc_lowcore(int cpu)
|
|
|
|
{
|
|
|
|
unsigned long async_stack, panic_stack;
|
|
|
|
struct _lowcore *lowcore;
|
|
|
|
int lc_order;
|
|
|
|
|
|
|
|
lc_order = sizeof(long) == 8 ? 1 : 0;
|
|
|
|
lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, lc_order);
|
|
|
|
if (!lowcore)
|
|
|
|
return -ENOMEM;
|
|
|
|
async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
|
|
|
|
panic_stack = __get_free_page(GFP_KERNEL);
|
2008-02-19 09:29:29 -05:00
|
|
|
if (!panic_stack || !async_stack)
|
|
|
|
goto out;
|
2008-03-05 06:37:09 -05:00
|
|
|
memcpy(lowcore, &S390_lowcore, 512);
|
|
|
|
memset((char *)lowcore + 512, 0, sizeof(*lowcore) - 512);
|
2008-01-26 08:11:14 -05:00
|
|
|
lowcore->async_stack = async_stack + ASYNC_SIZE;
|
|
|
|
lowcore->panic_stack = panic_stack + PAGE_SIZE;
|
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
if (MACHINE_HAS_IEEE) {
|
|
|
|
unsigned long save_area;
|
|
|
|
|
|
|
|
save_area = get_zeroed_page(GFP_KERNEL);
|
|
|
|
if (!save_area)
|
|
|
|
goto out_save_area;
|
|
|
|
lowcore->extended_save_area_addr = (u32) save_area;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
lowcore_ptr[cpu] = lowcore;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
out_save_area:
|
|
|
|
free_page(panic_stack);
|
|
|
|
#endif
|
2008-02-19 09:29:29 -05:00
|
|
|
out:
|
2008-01-26 08:11:14 -05:00
|
|
|
free_pages(async_stack, ASYNC_ORDER);
|
|
|
|
free_pages((unsigned long) lowcore, lc_order);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
static void smp_free_lowcore(int cpu)
|
|
|
|
{
|
|
|
|
struct _lowcore *lowcore;
|
|
|
|
int lc_order;
|
|
|
|
|
|
|
|
lc_order = sizeof(long) == 8 ? 1 : 0;
|
|
|
|
lowcore = lowcore_ptr[cpu];
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
if (MACHINE_HAS_IEEE)
|
|
|
|
free_page((unsigned long) lowcore->extended_save_area_addr);
|
|
|
|
#endif
|
|
|
|
free_page(lowcore->panic_stack - PAGE_SIZE);
|
|
|
|
free_pages(lowcore->async_stack - ASYNC_SIZE, ASYNC_ORDER);
|
|
|
|
free_pages((unsigned long) lowcore, lc_order);
|
|
|
|
lowcore_ptr[cpu] = NULL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_HOTPLUG_CPU */
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Upping and downing of CPUs */
|
2008-01-26 08:11:14 -05:00
|
|
|
int __cpuinit __cpu_up(unsigned int cpu)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct task_struct *idle;
|
2007-04-27 10:02:00 -04:00
|
|
|
struct _lowcore *cpu_lowcore;
|
2005-04-16 18:20:36 -04:00
|
|
|
struct stack_frame *sf;
|
2007-04-27 10:02:00 -04:00
|
|
|
sigp_ccode ccode;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
if (smp_cpu_state[cpu] != CPU_STATE_CONFIGURED)
|
|
|
|
return -EIO;
|
2008-01-26 08:11:14 -05:00
|
|
|
if (smp_alloc_lowcore(cpu))
|
|
|
|
return -ENOMEM;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
ccode = signal_processor_p((__u32)(unsigned long)(lowcore_ptr[cpu]),
|
|
|
|
cpu, sigp_set_prefix);
|
2007-04-27 10:02:00 -04:00
|
|
|
if (ccode) {
|
2005-04-16 18:20:36 -04:00
|
|
|
printk("sigp_set_prefix failed for cpu %d "
|
|
|
|
"with condition code %d\n",
|
|
|
|
(int) cpu, (int) ccode);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
idle = current_set[cpu];
|
2007-04-27 10:02:00 -04:00
|
|
|
cpu_lowcore = lowcore_ptr[cpu];
|
2005-04-16 18:20:36 -04:00
|
|
|
cpu_lowcore->kernel_stack = (unsigned long)
|
2007-04-27 10:02:00 -04:00
|
|
|
task_stack_page(idle) + THREAD_SIZE;
|
2008-01-26 08:11:14 -05:00
|
|
|
cpu_lowcore->thread_info = (unsigned long) task_thread_info(idle);
|
2005-04-16 18:20:36 -04:00
|
|
|
sf = (struct stack_frame *) (cpu_lowcore->kernel_stack
|
|
|
|
- sizeof(struct pt_regs)
|
|
|
|
- sizeof(struct stack_frame));
|
|
|
|
memset(sf, 0, sizeof(struct stack_frame));
|
|
|
|
sf->gprs[9] = (unsigned long) sf;
|
|
|
|
cpu_lowcore->save_area[15] = (unsigned long) sf;
|
|
|
|
__ctl_store(cpu_lowcore->cregs_save_area[0], 0, 15);
|
2006-09-28 10:56:43 -04:00
|
|
|
asm volatile(
|
|
|
|
" stam 0,15,0(%0)"
|
|
|
|
: : "a" (&cpu_lowcore->access_regs_save_area) : "memory");
|
2005-04-16 18:20:36 -04:00
|
|
|
cpu_lowcore->percpu_offset = __per_cpu_offset[cpu];
|
2007-04-27 10:02:00 -04:00
|
|
|
cpu_lowcore->current_task = (unsigned long) idle;
|
|
|
|
cpu_lowcore->cpu_data.cpu_nr = cpu;
|
2008-02-19 09:29:29 -05:00
|
|
|
cpu_lowcore->kernel_asce = S390_lowcore.kernel_asce;
|
|
|
|
cpu_lowcore->ipl_device = S390_lowcore.ipl_device;
|
2005-04-16 18:20:36 -04:00
|
|
|
eieio();
|
2006-03-24 06:15:17 -05:00
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
while (signal_processor(cpu, sigp_restart) == sigp_busy)
|
2006-03-24 06:15:17 -05:00
|
|
|
udelay(10);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
while (!cpu_online(cpu))
|
|
|
|
cpu_relax();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
static int __init setup_possible_cpus(char *s)
|
2006-02-17 16:52:46 -05:00
|
|
|
{
|
2008-01-26 08:11:05 -05:00
|
|
|
int pcpus, cpu;
|
2006-02-17 16:52:46 -05:00
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
pcpus = simple_strtoul(s, NULL, 0);
|
|
|
|
cpu_possible_map = cpumask_of_cpu(0);
|
|
|
|
for (cpu = 1; cpu < pcpus && cpu < NR_CPUS; cpu++)
|
2006-02-17 16:52:46 -05:00
|
|
|
cpu_set(cpu, cpu_possible_map);
|
2006-02-17 16:52:47 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("possible_cpus", setup_possible_cpus);
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
int __cpu_disable(void)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2006-09-28 10:56:43 -04:00
|
|
|
struct ec_creg_mask_parms cr_parms;
|
2005-06-25 17:54:50 -04:00
|
|
|
int cpu = smp_processor_id();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-06-25 17:54:50 -04:00
|
|
|
cpu_clear(cpu, cpu_online_map);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Disable pfault pseudo page faults on this cpu. */
|
2006-12-04 09:40:40 -05:00
|
|
|
pfault_fini();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-09-28 10:56:43 -04:00
|
|
|
memset(&cr_parms.orvals, 0, sizeof(cr_parms.orvals));
|
|
|
|
memset(&cr_parms.andvals, 0xff, sizeof(cr_parms.andvals));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-09-28 10:56:43 -04:00
|
|
|
/* disable all external interrupts */
|
2005-04-16 18:20:36 -04:00
|
|
|
cr_parms.orvals[0] = 0;
|
2007-04-27 10:02:00 -04:00
|
|
|
cr_parms.andvals[0] = ~(1 << 15 | 1 << 14 | 1 << 13 | 1 << 12 |
|
|
|
|
1 << 11 | 1 << 10 | 1 << 6 | 1 << 4);
|
2005-04-16 18:20:36 -04:00
|
|
|
/* disable all I/O interrupts */
|
|
|
|
cr_parms.orvals[6] = 0;
|
2007-04-27 10:02:00 -04:00
|
|
|
cr_parms.andvals[6] = ~(1 << 31 | 1 << 30 | 1 << 29 | 1 << 28 |
|
|
|
|
1 << 27 | 1 << 26 | 1 << 25 | 1 << 24);
|
2005-04-16 18:20:36 -04:00
|
|
|
/* disable most machine checks */
|
|
|
|
cr_parms.orvals[14] = 0;
|
2007-04-27 10:02:00 -04:00
|
|
|
cr_parms.andvals[14] = ~(1 << 28 | 1 << 27 | 1 << 26 |
|
|
|
|
1 << 25 | 1 << 24);
|
2006-09-28 10:56:43 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
smp_ctl_bit_callback(&cr_parms);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
void __cpu_die(unsigned int cpu)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
/* Wait until target cpu is down */
|
|
|
|
while (!smp_cpu_not_running(cpu))
|
|
|
|
cpu_relax();
|
2008-01-26 08:11:14 -05:00
|
|
|
smp_free_lowcore(cpu);
|
2008-01-26 08:10:56 -05:00
|
|
|
printk(KERN_INFO "Processor %d spun down\n", cpu);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
void cpu_die(void)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
idle_task_exit();
|
|
|
|
signal_processor(smp_processor_id(), sigp_stop);
|
|
|
|
BUG();
|
2007-04-27 10:02:00 -04:00
|
|
|
for (;;);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2006-02-17 16:52:46 -05:00
|
|
|
#endif /* CONFIG_HOTPLUG_CPU */
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
void __init smp_prepare_cpus(unsigned int max_cpus)
|
|
|
|
{
|
2008-02-19 09:29:29 -05:00
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
unsigned long save_area = 0;
|
|
|
|
#endif
|
|
|
|
unsigned long async_stack, panic_stack;
|
|
|
|
struct _lowcore *lowcore;
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned int cpu;
|
2008-02-19 09:29:29 -05:00
|
|
|
int lc_order;
|
2007-04-27 10:02:00 -04:00
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
smp_detect_cpus();
|
|
|
|
|
2007-04-27 10:02:00 -04:00
|
|
|
/* request the 0x1201 emergency signal external interrupt */
|
|
|
|
if (register_external_interrupt(0x1201, do_ext_call_interrupt) != 0)
|
|
|
|
panic("Couldn't request external interrupt 0x1201");
|
2005-04-16 18:20:36 -04:00
|
|
|
print_cpu_info(&S390_lowcore.cpu_data);
|
|
|
|
|
2008-02-19 09:29:29 -05:00
|
|
|
/* Reallocate current lowcore, but keep its contents. */
|
|
|
|
lc_order = sizeof(long) == 8 ? 1 : 0;
|
|
|
|
lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, lc_order);
|
|
|
|
panic_stack = __get_free_page(GFP_KERNEL);
|
|
|
|
async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
|
2006-01-06 03:19:28 -05:00
|
|
|
#ifndef CONFIG_64BIT
|
2005-06-25 17:55:30 -04:00
|
|
|
if (MACHINE_HAS_IEEE)
|
2008-02-19 09:29:29 -05:00
|
|
|
save_area = get_zeroed_page(GFP_KERNEL);
|
2005-06-25 17:55:30 -04:00
|
|
|
#endif
|
2008-02-19 09:29:29 -05:00
|
|
|
local_irq_disable();
|
|
|
|
local_mcck_disable();
|
|
|
|
lowcore_ptr[smp_processor_id()] = lowcore;
|
|
|
|
*lowcore = S390_lowcore;
|
|
|
|
lowcore->panic_stack = panic_stack + PAGE_SIZE;
|
|
|
|
lowcore->async_stack = async_stack + ASYNC_SIZE;
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
if (MACHINE_HAS_IEEE)
|
|
|
|
lowcore->extended_save_area_addr = (u32) save_area;
|
|
|
|
#endif
|
|
|
|
set_prefix((u32)(unsigned long) lowcore);
|
|
|
|
local_mcck_enable();
|
|
|
|
local_irq_enable();
|
2006-03-31 05:30:26 -05:00
|
|
|
for_each_possible_cpu(cpu)
|
2005-04-16 18:20:36 -04:00
|
|
|
if (cpu != smp_processor_id())
|
|
|
|
smp_create_idle(cpu);
|
|
|
|
}
|
|
|
|
|
2007-05-31 11:38:05 -04:00
|
|
|
void __init smp_prepare_boot_cpu(void)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
BUG_ON(smp_processor_id() != 0);
|
|
|
|
|
2008-01-26 08:11:05 -05:00
|
|
|
current_thread_info()->cpu = 0;
|
|
|
|
cpu_set(0, cpu_present_map);
|
2005-04-16 18:20:36 -04:00
|
|
|
cpu_set(0, cpu_online_map);
|
|
|
|
S390_lowcore.percpu_offset = __per_cpu_offset[0];
|
|
|
|
current_set[0] = current;
|
2008-01-26 08:10:56 -05:00
|
|
|
smp_cpu_state[0] = CPU_STATE_CONFIGURED;
|
2007-10-22 06:52:39 -04:00
|
|
|
spin_lock_init(&(&__get_cpu_var(s390_idle))->lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-05-31 11:38:05 -04:00
|
|
|
void __init smp_cpus_done(unsigned int max_cpus)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* the frequency of the profiling timer can be changed
|
|
|
|
* by writing a multiplier value into /proc/profile.
|
|
|
|
*
|
|
|
|
* usually you want to run this on all CPUs ;)
|
|
|
|
*/
|
|
|
|
int setup_profiling_timer(unsigned int multiplier)
|
|
|
|
{
|
2007-04-27 10:02:00 -04:00
|
|
|
return 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
static ssize_t cpu_configure_show(struct sys_device *dev, char *buf)
|
|
|
|
{
|
|
|
|
ssize_t count;
|
|
|
|
|
|
|
|
mutex_lock(&smp_cpu_state_mutex);
|
|
|
|
count = sprintf(buf, "%d\n", smp_cpu_state[dev->id]);
|
|
|
|
mutex_unlock(&smp_cpu_state_mutex);
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t cpu_configure_store(struct sys_device *dev, const char *buf,
|
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
int cpu = dev->id;
|
|
|
|
int val, rc;
|
|
|
|
char delim;
|
|
|
|
|
|
|
|
if (sscanf(buf, "%d %c", &val, &delim) != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
if (val != 0 && val != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&smp_cpu_state_mutex);
|
2008-01-26 08:11:31 -05:00
|
|
|
get_online_cpus();
|
2008-01-26 08:10:56 -05:00
|
|
|
rc = -EBUSY;
|
|
|
|
if (cpu_online(cpu))
|
|
|
|
goto out;
|
|
|
|
rc = 0;
|
|
|
|
switch (val) {
|
|
|
|
case 0:
|
|
|
|
if (smp_cpu_state[cpu] == CPU_STATE_CONFIGURED) {
|
|
|
|
rc = sclp_cpu_deconfigure(__cpu_logical_map[cpu]);
|
|
|
|
if (!rc)
|
|
|
|
smp_cpu_state[cpu] = CPU_STATE_STANDBY;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if (smp_cpu_state[cpu] == CPU_STATE_STANDBY) {
|
|
|
|
rc = sclp_cpu_configure(__cpu_logical_map[cpu]);
|
|
|
|
if (!rc)
|
|
|
|
smp_cpu_state[cpu] = CPU_STATE_CONFIGURED;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
2008-01-26 08:11:31 -05:00
|
|
|
put_online_cpus();
|
2008-01-26 08:10:56 -05:00
|
|
|
mutex_unlock(&smp_cpu_state_mutex);
|
|
|
|
return rc ? rc : count;
|
|
|
|
}
|
|
|
|
static SYSDEV_ATTR(configure, 0644, cpu_configure_show, cpu_configure_store);
|
|
|
|
#endif /* CONFIG_HOTPLUG_CPU */
|
|
|
|
|
|
|
|
static ssize_t show_cpu_address(struct sys_device *dev, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%d\n", __cpu_logical_map[dev->id]);
|
|
|
|
}
|
|
|
|
static SYSDEV_ATTR(address, 0444, show_cpu_address, NULL);
|
|
|
|
|
|
|
|
|
|
|
|
static struct attribute *cpu_common_attrs[] = {
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
&attr_configure.attr,
|
|
|
|
#endif
|
|
|
|
&attr_address.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group cpu_common_attr_group = {
|
|
|
|
.attrs = cpu_common_attrs,
|
|
|
|
};
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-04-27 10:01:56 -04:00
|
|
|
static ssize_t show_capability(struct sys_device *dev, char *buf)
|
|
|
|
{
|
|
|
|
unsigned int capability;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = get_cpu_capability(&capability);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
return sprintf(buf, "%u\n", capability);
|
|
|
|
}
|
|
|
|
static SYSDEV_ATTR(capability, 0444, show_capability, NULL);
|
|
|
|
|
2007-10-22 06:52:39 -04:00
|
|
|
static ssize_t show_idle_count(struct sys_device *dev, char *buf)
|
|
|
|
{
|
|
|
|
struct s390_idle_data *idle;
|
|
|
|
unsigned long long idle_count;
|
|
|
|
|
|
|
|
idle = &per_cpu(s390_idle, dev->id);
|
|
|
|
spin_lock_irq(&idle->lock);
|
|
|
|
idle_count = idle->idle_count;
|
|
|
|
spin_unlock_irq(&idle->lock);
|
|
|
|
return sprintf(buf, "%llu\n", idle_count);
|
|
|
|
}
|
|
|
|
static SYSDEV_ATTR(idle_count, 0444, show_idle_count, NULL);
|
|
|
|
|
|
|
|
static ssize_t show_idle_time(struct sys_device *dev, char *buf)
|
|
|
|
{
|
|
|
|
struct s390_idle_data *idle;
|
|
|
|
unsigned long long new_time;
|
|
|
|
|
|
|
|
idle = &per_cpu(s390_idle, dev->id);
|
|
|
|
spin_lock_irq(&idle->lock);
|
|
|
|
if (idle->in_idle) {
|
|
|
|
new_time = get_clock();
|
|
|
|
idle->idle_time += new_time - idle->idle_enter;
|
|
|
|
idle->idle_enter = new_time;
|
|
|
|
}
|
|
|
|
new_time = idle->idle_time;
|
|
|
|
spin_unlock_irq(&idle->lock);
|
2007-11-05 05:10:13 -05:00
|
|
|
return sprintf(buf, "%llu\n", new_time >> 12);
|
2007-10-22 06:52:39 -04:00
|
|
|
}
|
2007-11-05 05:10:13 -05:00
|
|
|
static SYSDEV_ATTR(idle_time_us, 0444, show_idle_time, NULL);
|
2007-10-22 06:52:39 -04:00
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
static struct attribute *cpu_online_attrs[] = {
|
2007-10-22 06:52:39 -04:00
|
|
|
&attr_capability.attr,
|
|
|
|
&attr_idle_count.attr,
|
2007-11-05 05:10:13 -05:00
|
|
|
&attr_idle_time_us.attr,
|
2007-10-22 06:52:39 -04:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
static struct attribute_group cpu_online_attr_group = {
|
|
|
|
.attrs = cpu_online_attrs,
|
2007-10-22 06:52:39 -04:00
|
|
|
};
|
|
|
|
|
2007-04-27 10:01:56 -04:00
|
|
|
static int __cpuinit smp_cpu_notify(struct notifier_block *self,
|
|
|
|
unsigned long action, void *hcpu)
|
|
|
|
{
|
|
|
|
unsigned int cpu = (unsigned int)(long)hcpu;
|
|
|
|
struct cpu *c = &per_cpu(cpu_devices, cpu);
|
|
|
|
struct sys_device *s = &c->sysdev;
|
2007-10-22 06:52:39 -04:00
|
|
|
struct s390_idle_data *idle;
|
2007-04-27 10:01:56 -04:00
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case CPU_ONLINE:
|
2007-05-09 05:35:10 -04:00
|
|
|
case CPU_ONLINE_FROZEN:
|
2007-10-22 06:52:39 -04:00
|
|
|
idle = &per_cpu(s390_idle, cpu);
|
|
|
|
spin_lock_irq(&idle->lock);
|
|
|
|
idle->idle_enter = 0;
|
|
|
|
idle->idle_time = 0;
|
|
|
|
idle->idle_count = 0;
|
|
|
|
spin_unlock_irq(&idle->lock);
|
2008-01-26 08:10:56 -05:00
|
|
|
if (sysfs_create_group(&s->kobj, &cpu_online_attr_group))
|
2007-04-27 10:01:56 -04:00
|
|
|
return NOTIFY_BAD;
|
|
|
|
break;
|
|
|
|
case CPU_DEAD:
|
2007-05-09 05:35:10 -04:00
|
|
|
case CPU_DEAD_FROZEN:
|
2008-01-26 08:10:56 -05:00
|
|
|
sysfs_remove_group(&s->kobj, &cpu_online_attr_group);
|
2007-04-27 10:01:56 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block __cpuinitdata smp_cpu_nb = {
|
2007-04-27 10:02:00 -04:00
|
|
|
.notifier_call = smp_cpu_notify,
|
2007-04-27 10:01:56 -04:00
|
|
|
};
|
|
|
|
|
2008-02-05 10:50:40 -05:00
|
|
|
static int __devinit smp_add_present_cpu(int cpu)
|
2008-01-26 08:10:56 -05:00
|
|
|
{
|
|
|
|
struct cpu *c = &per_cpu(cpu_devices, cpu);
|
|
|
|
struct sys_device *s = &c->sysdev;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
c->hotpluggable = 1;
|
|
|
|
rc = register_cpu(c, cpu);
|
|
|
|
if (rc)
|
|
|
|
goto out;
|
|
|
|
rc = sysfs_create_group(&s->kobj, &cpu_common_attr_group);
|
|
|
|
if (rc)
|
|
|
|
goto out_cpu;
|
|
|
|
if (!cpu_online(cpu))
|
|
|
|
goto out;
|
|
|
|
rc = sysfs_create_group(&s->kobj, &cpu_online_attr_group);
|
|
|
|
if (!rc)
|
|
|
|
return 0;
|
|
|
|
sysfs_remove_group(&s->kobj, &cpu_common_attr_group);
|
|
|
|
out_cpu:
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
unregister_cpu(c);
|
|
|
|
#endif
|
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
2008-02-05 10:50:40 -05:00
|
|
|
static ssize_t __ref rescan_store(struct sys_device *dev,
|
|
|
|
const char *buf, size_t count)
|
2008-01-26 08:10:56 -05:00
|
|
|
{
|
|
|
|
cpumask_t newcpus;
|
|
|
|
int cpu;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
mutex_lock(&smp_cpu_state_mutex);
|
2008-01-26 08:11:31 -05:00
|
|
|
get_online_cpus();
|
2008-01-26 08:10:56 -05:00
|
|
|
newcpus = cpu_present_map;
|
|
|
|
rc = smp_rescan_cpus();
|
|
|
|
if (rc)
|
|
|
|
goto out;
|
|
|
|
cpus_andnot(newcpus, cpu_present_map, newcpus);
|
|
|
|
for_each_cpu_mask(cpu, newcpus) {
|
|
|
|
rc = smp_add_present_cpu(cpu);
|
|
|
|
if (rc)
|
|
|
|
cpu_clear(cpu, cpu_present_map);
|
|
|
|
}
|
|
|
|
rc = 0;
|
|
|
|
out:
|
2008-01-26 08:11:31 -05:00
|
|
|
put_online_cpus();
|
2008-01-26 08:10:56 -05:00
|
|
|
mutex_unlock(&smp_cpu_state_mutex);
|
|
|
|
return rc ? rc : count;
|
|
|
|
}
|
|
|
|
static SYSDEV_ATTR(rescan, 0200, NULL, rescan_store);
|
|
|
|
#endif /* CONFIG_HOTPLUG_CPU */
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
static int __init topology_init(void)
|
|
|
|
{
|
|
|
|
int cpu;
|
2007-10-22 06:52:39 -04:00
|
|
|
int rc;
|
2007-04-27 10:01:56 -04:00
|
|
|
|
|
|
|
register_cpu_notifier(&smp_cpu_nb);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-01-26 08:10:56 -05:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
rc = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
|
|
|
|
&attr_rescan.attr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
#endif
|
|
|
|
for_each_present_cpu(cpu) {
|
|
|
|
rc = smp_add_present_cpu(cpu);
|
2007-10-22 06:52:39 -04:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
subsys_initcall(topology_init);
|