2005-04-16 18:20:36 -04:00
|
|
|
/* smp.c: Sparc64 SMP support.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/profile.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
|
|
|
|
#include <asm/head.h>
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/cpudata.h>
|
|
|
|
|
|
|
|
#include <asm/irq.h>
|
2006-10-08 08:23:28 -04:00
|
|
|
#include <asm/irq_regs.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/oplib.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/timer.h>
|
|
|
|
#include <asm/starfire.h>
|
|
|
|
#include <asm/tlb.h>
|
2006-02-27 02:24:22 -05:00
|
|
|
#include <asm/sections.h>
|
2006-06-22 02:34:02 -04:00
|
|
|
#include <asm/prom.h>
|
2007-05-25 18:49:59 -04:00
|
|
|
#include <asm/mdesc.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
extern void calibrate_delay(void);
|
|
|
|
|
|
|
|
/* Please don't make this stuff initdata!!! --DaveM */
|
2007-02-22 09:24:10 -05:00
|
|
|
unsigned char boot_cpu_id;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-07-12 15:09:43 -04:00
|
|
|
cpumask_t cpu_online_map __read_mostly = CPU_MASK_NONE;
|
|
|
|
cpumask_t phys_cpu_present_map __read_mostly = CPU_MASK_NONE;
|
2006-03-08 19:09:19 -05:00
|
|
|
cpumask_t cpu_sibling_map[NR_CPUS] __read_mostly =
|
|
|
|
{ [0 ... NR_CPUS-1] = CPU_MASK_NONE };
|
2005-04-16 18:20:36 -04:00
|
|
|
static cpumask_t smp_commenced_mask;
|
|
|
|
static cpumask_t cpu_callout_map;
|
|
|
|
|
|
|
|
void smp_info(struct seq_file *m)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
seq_printf(m, "State:\n");
|
2006-03-23 06:01:05 -05:00
|
|
|
for_each_online_cpu(i)
|
|
|
|
seq_printf(m, "CPU%d:\t\tonline\n", i);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void smp_bogo(struct seq_file *m)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2006-03-23 06:01:05 -05:00
|
|
|
for_each_online_cpu(i)
|
|
|
|
seq_printf(m,
|
|
|
|
"Cpu%dBogo\t: %lu.%02lu\n"
|
|
|
|
"Cpu%dClkTck\t: %016lx\n",
|
|
|
|
i, cpu_data(i).udelay_val / (500000/HZ),
|
|
|
|
(cpu_data(i).udelay_val / (5000/HZ)) % 100,
|
|
|
|
i, cpu_data(i).clock_tick);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-03-05 18:28:37 -05:00
|
|
|
extern void setup_sparc64_timer(void);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static volatile unsigned long callin_flag = 0;
|
|
|
|
|
|
|
|
void __init smp_callin(void)
|
|
|
|
{
|
|
|
|
int cpuid = hard_smp_processor_id();
|
|
|
|
|
2006-02-27 02:24:22 -05:00
|
|
|
__local_per_cpu_offset = __per_cpu_offset(cpuid);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-02-14 16:49:32 -05:00
|
|
|
if (tlb_type == hypervisor)
|
2006-02-11 17:41:18 -05:00
|
|
|
sun4v_ktsb_register();
|
2006-02-08 00:51:08 -05:00
|
|
|
|
2006-02-27 02:24:22 -05:00
|
|
|
__flush_tlb_all();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2007-03-05 18:28:37 -05:00
|
|
|
setup_sparc64_timer();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-05-23 18:52:08 -04:00
|
|
|
if (cheetah_pcache_forced_on)
|
|
|
|
cheetah_enable_pcache();
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
local_irq_enable();
|
|
|
|
|
|
|
|
calibrate_delay();
|
2007-05-25 18:49:59 -04:00
|
|
|
cpu_data(cpuid).udelay_val = loops_per_jiffy;
|
2005-04-16 18:20:36 -04:00
|
|
|
callin_flag = 1;
|
|
|
|
__asm__ __volatile__("membar #Sync\n\t"
|
|
|
|
"flush %%g6" : : : "memory");
|
|
|
|
|
|
|
|
/* Clear this or we will die instantly when we
|
|
|
|
* schedule back to this idler...
|
|
|
|
*/
|
2005-07-24 22:36:26 -04:00
|
|
|
current_thread_info()->new_child = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Attach to the address space of init_task. */
|
|
|
|
atomic_inc(&init_mm.mm_count);
|
|
|
|
current->active_mm = &init_mm;
|
|
|
|
|
|
|
|
while (!cpu_isset(cpuid, smp_commenced_mask))
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
cpu_set(cpuid, cpu_online_map);
|
2005-11-09 00:39:01 -05:00
|
|
|
|
|
|
|
/* idle thread is expected to have preempt disabled */
|
|
|
|
preempt_disable();
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_panic(void)
|
|
|
|
{
|
|
|
|
printk("CPU[%d]: Returns from cpu_idle!\n", smp_processor_id());
|
|
|
|
panic("SMP bolixed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This tick register synchronization scheme is taken entirely from
|
|
|
|
* the ia64 port, see arch/ia64/kernel/smpboot.c for details and credit.
|
|
|
|
*
|
|
|
|
* The only change I've made is to rework it so that the master
|
|
|
|
* initiates the synchonization instead of the slave. -DaveM
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define MASTER 0
|
|
|
|
#define SLAVE (SMP_CACHE_BYTES/sizeof(unsigned long))
|
|
|
|
|
|
|
|
#define NUM_ROUNDS 64 /* magic value */
|
|
|
|
#define NUM_ITERS 5 /* likewise */
|
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(itc_sync_lock);
|
|
|
|
static unsigned long go[SLAVE + 1];
|
|
|
|
|
|
|
|
#define DEBUG_TICK_SYNC 0
|
|
|
|
|
|
|
|
static inline long get_delta (long *rt, long *master)
|
|
|
|
{
|
|
|
|
unsigned long best_t0 = 0, best_t1 = ~0UL, best_tm = 0;
|
|
|
|
unsigned long tcenter, t0, t1, tm;
|
|
|
|
unsigned long i;
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_ITERS; i++) {
|
|
|
|
t0 = tick_ops->get_tick();
|
|
|
|
go[MASTER] = 1;
|
2005-08-29 15:46:22 -04:00
|
|
|
membar_storeload();
|
2005-04-16 18:20:36 -04:00
|
|
|
while (!(tm = go[SLAVE]))
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
go[SLAVE] = 0;
|
2005-08-29 15:46:22 -04:00
|
|
|
wmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
t1 = tick_ops->get_tick();
|
|
|
|
|
|
|
|
if (t1 - t0 < best_t1 - best_t0)
|
|
|
|
best_t0 = t0, best_t1 = t1, best_tm = tm;
|
|
|
|
}
|
|
|
|
|
|
|
|
*rt = best_t1 - best_t0;
|
|
|
|
*master = best_tm - best_t0;
|
|
|
|
|
|
|
|
/* average best_t0 and best_t1 without overflow: */
|
|
|
|
tcenter = (best_t0/2 + best_t1/2);
|
|
|
|
if (best_t0 % 2 + best_t1 % 2 == 2)
|
|
|
|
tcenter++;
|
|
|
|
return tcenter - best_tm;
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_synchronize_tick_client(void)
|
|
|
|
{
|
|
|
|
long i, delta, adj, adjust_latency = 0, done = 0;
|
|
|
|
unsigned long flags, rt, master_time_stamp, bound;
|
|
|
|
#if DEBUG_TICK_SYNC
|
|
|
|
struct {
|
|
|
|
long rt; /* roundtrip time */
|
|
|
|
long master; /* master's timestamp */
|
|
|
|
long diff; /* difference between midpoint and master's timestamp */
|
|
|
|
long lat; /* estimate of itc adjustment latency */
|
|
|
|
} t[NUM_ROUNDS];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
go[MASTER] = 1;
|
|
|
|
|
|
|
|
while (go[MASTER])
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
{
|
|
|
|
for (i = 0; i < NUM_ROUNDS; i++) {
|
|
|
|
delta = get_delta(&rt, &master_time_stamp);
|
|
|
|
if (delta == 0) {
|
|
|
|
done = 1; /* let's lock on to this... */
|
|
|
|
bound = rt;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!done) {
|
|
|
|
if (i > 0) {
|
|
|
|
adjust_latency += -delta;
|
|
|
|
adj = -delta + adjust_latency/4;
|
|
|
|
} else
|
|
|
|
adj = -delta;
|
|
|
|
|
2007-03-05 18:28:37 -05:00
|
|
|
tick_ops->add_tick(adj);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
#if DEBUG_TICK_SYNC
|
|
|
|
t[i].rt = rt;
|
|
|
|
t[i].master = master_time_stamp;
|
|
|
|
t[i].diff = delta;
|
|
|
|
t[i].lat = adjust_latency/4;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
#if DEBUG_TICK_SYNC
|
|
|
|
for (i = 0; i < NUM_ROUNDS; i++)
|
|
|
|
printk("rt=%5ld master=%5ld diff=%5ld adjlat=%5ld\n",
|
|
|
|
t[i].rt, t[i].master, t[i].diff, t[i].lat);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
printk(KERN_INFO "CPU %d: synchronized TICK with master CPU (last diff %ld cycles,"
|
|
|
|
"maxerr %lu cycles)\n", smp_processor_id(), delta, rt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void smp_start_sync_tick_client(int cpu);
|
|
|
|
|
|
|
|
static void smp_synchronize_one_tick(int cpu)
|
|
|
|
{
|
|
|
|
unsigned long flags, i;
|
|
|
|
|
|
|
|
go[MASTER] = 0;
|
|
|
|
|
|
|
|
smp_start_sync_tick_client(cpu);
|
|
|
|
|
|
|
|
/* wait for client to be ready */
|
|
|
|
while (!go[MASTER])
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* now let the client proceed into his loop */
|
|
|
|
go[MASTER] = 0;
|
2005-08-29 15:46:22 -04:00
|
|
|
membar_storeload();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
spin_lock_irqsave(&itc_sync_lock, flags);
|
|
|
|
{
|
|
|
|
for (i = 0; i < NUM_ROUNDS*NUM_ITERS; i++) {
|
|
|
|
while (!go[MASTER])
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
go[MASTER] = 0;
|
2005-08-29 15:46:22 -04:00
|
|
|
wmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
go[SLAVE] = tick_ops->get_tick();
|
2005-08-29 15:46:22 -04:00
|
|
|
membar_storeload();
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&itc_sync_lock, flags);
|
|
|
|
}
|
|
|
|
|
[SPARC64]: Get SUN4V SMP working.
The sibling cpu bringup is extremely fragile. We can only
perform the most basic calls until we take over the trap
table from the firmware/hypervisor on the new cpu.
This means no accesses to %g4, %g5, %g6 since those can't be
TLB translated without our trap handlers.
In order to achieve this:
1) Change sun4v_init_mondo_queues() so that it can operate in
several modes.
It can allocate the queues, or install them in the current
processor, or both.
The boot cpu does both in it's call early on.
Later, the boot cpu allocates the sibling cpu queue, starts
the sibling cpu, then the sibling cpu loads them in.
2) init_cur_cpu_trap() is changed to take the current_thread_info()
as an argument instead of reading %g6 directly on the current
cpu.
3) Create a trampoline stack for the sibling cpus. We do our basic
kernel calls using this stack, which is locked into the kernel
image, then go to our proper thread stack after taking over the
trap table.
4) While we are in this delicate startup state, we put 0xdeadbeef
into %g4/%g5/%g6 in order to catch accidental accesses.
5) On the final prom_set_trap_table*() call, we put &init_thread_union
into %g6. This is a hack to make prom_world(0) work. All that
wants to do is restore the %asi register using
get_thread_current_ds().
Longer term we should just do the OBP calls to set the trap table by
hand just like we do for everything else. This would avoid that silly
prom_world(0) issue, then we can remove the init_thread_union hack.
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-02-17 04:29:17 -05:00
|
|
|
extern void sun4v_init_mondo_queues(int use_bootmem, int cpu, int alloc, int load);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
extern unsigned long sparc64_cpu_startup;
|
|
|
|
|
|
|
|
/* The OBP cpu startup callback truncates the 3rd arg cookie to
|
|
|
|
* 32-bits (I think) so to be safe we have it read the pointer
|
|
|
|
* contained here so we work on >4GB machines. -DaveM
|
|
|
|
*/
|
|
|
|
static struct thread_info *cpu_new_thread = NULL;
|
|
|
|
|
|
|
|
static int __devinit smp_boot_one_cpu(unsigned int cpu)
|
|
|
|
{
|
|
|
|
unsigned long entry =
|
|
|
|
(unsigned long)(&sparc64_cpu_startup);
|
|
|
|
unsigned long cookie =
|
|
|
|
(unsigned long)(&cpu_new_thread);
|
|
|
|
struct task_struct *p;
|
2006-02-15 05:26:54 -05:00
|
|
|
int timeout, ret;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
p = fork_idle(cpu);
|
|
|
|
callin_flag = 0;
|
2006-01-12 04:05:42 -05:00
|
|
|
cpu_new_thread = task_thread_info(p);
|
2005-04-16 18:20:36 -04:00
|
|
|
cpu_set(cpu, cpu_callout_map);
|
|
|
|
|
2006-02-15 05:26:54 -05:00
|
|
|
if (tlb_type == hypervisor) {
|
[SPARC64]: Get SUN4V SMP working.
The sibling cpu bringup is extremely fragile. We can only
perform the most basic calls until we take over the trap
table from the firmware/hypervisor on the new cpu.
This means no accesses to %g4, %g5, %g6 since those can't be
TLB translated without our trap handlers.
In order to achieve this:
1) Change sun4v_init_mondo_queues() so that it can operate in
several modes.
It can allocate the queues, or install them in the current
processor, or both.
The boot cpu does both in it's call early on.
Later, the boot cpu allocates the sibling cpu queue, starts
the sibling cpu, then the sibling cpu loads them in.
2) init_cur_cpu_trap() is changed to take the current_thread_info()
as an argument instead of reading %g6 directly on the current
cpu.
3) Create a trampoline stack for the sibling cpus. We do our basic
kernel calls using this stack, which is locked into the kernel
image, then go to our proper thread stack after taking over the
trap table.
4) While we are in this delicate startup state, we put 0xdeadbeef
into %g4/%g5/%g6 in order to catch accidental accesses.
5) On the final prom_set_trap_table*() call, we put &init_thread_union
into %g6. This is a hack to make prom_world(0) work. All that
wants to do is restore the %asi register using
get_thread_current_ds().
Longer term we should just do the OBP calls to set the trap table by
hand just like we do for everything else. This would avoid that silly
prom_world(0) issue, then we can remove the init_thread_union hack.
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-02-17 04:29:17 -05:00
|
|
|
/* Alloc the mondo queues, cpu will load them. */
|
|
|
|
sun4v_init_mondo_queues(0, cpu, 1, 0);
|
|
|
|
|
2006-02-15 05:26:54 -05:00
|
|
|
prom_startcpu_cpuid(cpu, entry, cookie);
|
|
|
|
} else {
|
2007-05-25 18:49:59 -04:00
|
|
|
struct device_node *dp = of_find_node_by_cpuid(cpu);
|
2006-02-15 05:26:54 -05:00
|
|
|
|
2006-06-22 02:34:02 -04:00
|
|
|
prom_startcpu(dp->node, entry, cookie);
|
2006-02-15 05:26:54 -05:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
for (timeout = 0; timeout < 5000000; timeout++) {
|
|
|
|
if (callin_flag)
|
|
|
|
break;
|
|
|
|
udelay(100);
|
|
|
|
}
|
[SPARC64]: Get SUN4V SMP working.
The sibling cpu bringup is extremely fragile. We can only
perform the most basic calls until we take over the trap
table from the firmware/hypervisor on the new cpu.
This means no accesses to %g4, %g5, %g6 since those can't be
TLB translated without our trap handlers.
In order to achieve this:
1) Change sun4v_init_mondo_queues() so that it can operate in
several modes.
It can allocate the queues, or install them in the current
processor, or both.
The boot cpu does both in it's call early on.
Later, the boot cpu allocates the sibling cpu queue, starts
the sibling cpu, then the sibling cpu loads them in.
2) init_cur_cpu_trap() is changed to take the current_thread_info()
as an argument instead of reading %g6 directly on the current
cpu.
3) Create a trampoline stack for the sibling cpus. We do our basic
kernel calls using this stack, which is locked into the kernel
image, then go to our proper thread stack after taking over the
trap table.
4) While we are in this delicate startup state, we put 0xdeadbeef
into %g4/%g5/%g6 in order to catch accidental accesses.
5) On the final prom_set_trap_table*() call, we put &init_thread_union
into %g6. This is a hack to make prom_world(0) work. All that
wants to do is restore the %asi register using
get_thread_current_ds().
Longer term we should just do the OBP calls to set the trap table by
hand just like we do for everything else. This would avoid that silly
prom_world(0) issue, then we can remove the init_thread_union hack.
Signed-off-by: David S. Miller <davem@davemloft.net>
2006-02-17 04:29:17 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (callin_flag) {
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
printk("Processor %d is stuck.\n", cpu);
|
|
|
|
cpu_clear(cpu, cpu_callout_map);
|
|
|
|
ret = -ENODEV;
|
|
|
|
}
|
|
|
|
cpu_new_thread = NULL;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void spitfire_xcall_helper(u64 data0, u64 data1, u64 data2, u64 pstate, unsigned long cpu)
|
|
|
|
{
|
|
|
|
u64 result, target;
|
|
|
|
int stuck, tmp;
|
|
|
|
|
|
|
|
if (this_is_starfire) {
|
|
|
|
/* map to real upaid */
|
|
|
|
cpu = (((cpu & 0x3c) << 1) |
|
|
|
|
((cpu & 0x40) >> 4) |
|
|
|
|
(cpu & 0x3));
|
|
|
|
}
|
|
|
|
|
|
|
|
target = (cpu << 14) | 0x70;
|
|
|
|
again:
|
|
|
|
/* Ok, this is the real Spitfire Errata #54.
|
|
|
|
* One must read back from a UDB internal register
|
|
|
|
* after writes to the UDB interrupt dispatch, but
|
|
|
|
* before the membar Sync for that write.
|
|
|
|
* So we use the high UDB control register (ASI 0x7f,
|
|
|
|
* ADDR 0x20) for the dummy read. -DaveM
|
|
|
|
*/
|
|
|
|
tmp = 0x40;
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"wrpr %1, %2, %%pstate\n\t"
|
|
|
|
"stxa %4, [%0] %3\n\t"
|
|
|
|
"stxa %5, [%0+%8] %3\n\t"
|
|
|
|
"add %0, %8, %0\n\t"
|
|
|
|
"stxa %6, [%0+%8] %3\n\t"
|
|
|
|
"membar #Sync\n\t"
|
|
|
|
"stxa %%g0, [%7] %3\n\t"
|
|
|
|
"membar #Sync\n\t"
|
|
|
|
"mov 0x20, %%g1\n\t"
|
|
|
|
"ldxa [%%g1] 0x7f, %%g0\n\t"
|
|
|
|
"membar #Sync"
|
|
|
|
: "=r" (tmp)
|
|
|
|
: "r" (pstate), "i" (PSTATE_IE), "i" (ASI_INTR_W),
|
|
|
|
"r" (data0), "r" (data1), "r" (data2), "r" (target),
|
|
|
|
"r" (0x10), "0" (tmp)
|
|
|
|
: "g1");
|
|
|
|
|
|
|
|
/* NOTE: PSTATE_IE is still clear. */
|
|
|
|
stuck = 100000;
|
|
|
|
do {
|
|
|
|
__asm__ __volatile__("ldxa [%%g0] %1, %0"
|
|
|
|
: "=r" (result)
|
|
|
|
: "i" (ASI_INTR_DISPATCH_STAT));
|
|
|
|
if (result == 0) {
|
|
|
|
__asm__ __volatile__("wrpr %0, 0x0, %%pstate"
|
|
|
|
: : "r" (pstate));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
stuck -= 1;
|
|
|
|
if (stuck == 0)
|
|
|
|
break;
|
|
|
|
} while (result & 0x1);
|
|
|
|
__asm__ __volatile__("wrpr %0, 0x0, %%pstate"
|
|
|
|
: : "r" (pstate));
|
|
|
|
if (stuck == 0) {
|
|
|
|
printk("CPU[%d]: mondo stuckage result[%016lx]\n",
|
|
|
|
smp_processor_id(), result);
|
|
|
|
} else {
|
|
|
|
udelay(2);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline__ void spitfire_xcall_deliver(u64 data0, u64 data1, u64 data2, cpumask_t mask)
|
|
|
|
{
|
|
|
|
u64 pstate;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
__asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
|
|
|
|
for_each_cpu_mask(i, mask)
|
|
|
|
spitfire_xcall_helper(data0, data1, data2, pstate, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cheetah now allows to send the whole 64-bytes of data in the interrupt
|
|
|
|
* packet, but we have no use for that. However we do take advantage of
|
|
|
|
* the new pipelining feature (ie. dispatch to multiple cpus simultaneously).
|
|
|
|
*/
|
|
|
|
static void cheetah_xcall_deliver(u64 data0, u64 data1, u64 data2, cpumask_t mask)
|
|
|
|
{
|
|
|
|
u64 pstate, ver;
|
2007-05-26 04:14:43 -04:00
|
|
|
int nack_busy_id, is_jbus, need_more;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (cpus_empty(mask))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Unfortunately, someone at Sun had the brilliant idea to make the
|
|
|
|
* busy/nack fields hard-coded by ITID number for this Ultra-III
|
|
|
|
* derivative processor.
|
|
|
|
*/
|
|
|
|
__asm__ ("rdpr %%ver, %0" : "=r" (ver));
|
2006-02-27 02:27:19 -05:00
|
|
|
is_jbus = ((ver >> 32) == __JALAPENO_ID ||
|
|
|
|
(ver >> 32) == __SERRANO_ID);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
__asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
|
|
|
|
|
|
|
|
retry:
|
2007-05-26 04:14:43 -04:00
|
|
|
need_more = 0;
|
2005-04-16 18:20:36 -04:00
|
|
|
__asm__ __volatile__("wrpr %0, %1, %%pstate\n\t"
|
|
|
|
: : "r" (pstate), "i" (PSTATE_IE));
|
|
|
|
|
|
|
|
/* Setup the dispatch data registers. */
|
|
|
|
__asm__ __volatile__("stxa %0, [%3] %6\n\t"
|
|
|
|
"stxa %1, [%4] %6\n\t"
|
|
|
|
"stxa %2, [%5] %6\n\t"
|
|
|
|
"membar #Sync\n\t"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (data0), "r" (data1), "r" (data2),
|
|
|
|
"r" (0x40), "r" (0x50), "r" (0x60),
|
|
|
|
"i" (ASI_INTR_W));
|
|
|
|
|
|
|
|
nack_busy_id = 0;
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_cpu_mask(i, mask) {
|
|
|
|
u64 target = (i << 14) | 0x70;
|
|
|
|
|
2006-02-27 02:27:19 -05:00
|
|
|
if (!is_jbus)
|
2005-04-16 18:20:36 -04:00
|
|
|
target |= (nack_busy_id << 24);
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"stxa %%g0, [%0] %1\n\t"
|
|
|
|
"membar #Sync\n\t"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (target), "i" (ASI_INTR_W));
|
|
|
|
nack_busy_id++;
|
2007-05-26 04:14:43 -04:00
|
|
|
if (nack_busy_id == 32) {
|
|
|
|
need_more = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now, poll for completion. */
|
|
|
|
{
|
|
|
|
u64 dispatch_stat;
|
|
|
|
long stuck;
|
|
|
|
|
|
|
|
stuck = 100000 * nack_busy_id;
|
|
|
|
do {
|
|
|
|
__asm__ __volatile__("ldxa [%%g0] %1, %0"
|
|
|
|
: "=r" (dispatch_stat)
|
|
|
|
: "i" (ASI_INTR_DISPATCH_STAT));
|
|
|
|
if (dispatch_stat == 0UL) {
|
|
|
|
__asm__ __volatile__("wrpr %0, 0x0, %%pstate"
|
|
|
|
: : "r" (pstate));
|
2007-05-26 04:14:43 -04:00
|
|
|
if (unlikely(need_more)) {
|
|
|
|
int i, cnt = 0;
|
|
|
|
for_each_cpu_mask(i, mask) {
|
|
|
|
cpu_clear(i, mask);
|
|
|
|
cnt++;
|
|
|
|
if (cnt == 32)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto retry;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!--stuck)
|
|
|
|
break;
|
|
|
|
} while (dispatch_stat & 0x5555555555555555UL);
|
|
|
|
|
|
|
|
__asm__ __volatile__("wrpr %0, 0x0, %%pstate"
|
|
|
|
: : "r" (pstate));
|
|
|
|
|
|
|
|
if ((dispatch_stat & ~(0x5555555555555555UL)) == 0) {
|
|
|
|
/* Busy bits will not clear, continue instead
|
|
|
|
* of freezing up on this cpu.
|
|
|
|
*/
|
|
|
|
printk("CPU[%d]: mondo stuckage result[%016lx]\n",
|
|
|
|
smp_processor_id(), dispatch_stat);
|
|
|
|
} else {
|
|
|
|
int i, this_busy_nack = 0;
|
|
|
|
|
|
|
|
/* Delay some random time with interrupts enabled
|
|
|
|
* to prevent deadlock.
|
|
|
|
*/
|
|
|
|
udelay(2 * nack_busy_id);
|
|
|
|
|
|
|
|
/* Clear out the mask bits for cpus which did not
|
|
|
|
* NACK us.
|
|
|
|
*/
|
|
|
|
for_each_cpu_mask(i, mask) {
|
|
|
|
u64 check_mask;
|
|
|
|
|
2006-02-27 02:27:19 -05:00
|
|
|
if (is_jbus)
|
2005-04-16 18:20:36 -04:00
|
|
|
check_mask = (0x2UL << (2*i));
|
|
|
|
else
|
|
|
|
check_mask = (0x2UL <<
|
|
|
|
this_busy_nack);
|
|
|
|
if ((dispatch_stat & check_mask) == 0)
|
|
|
|
cpu_clear(i, mask);
|
|
|
|
this_busy_nack += 2;
|
2007-05-26 04:14:43 -04:00
|
|
|
if (this_busy_nack == 64)
|
|
|
|
break;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-08 19:41:20 -05:00
|
|
|
/* Multi-cpu list version. */
|
2006-02-04 06:10:53 -05:00
|
|
|
static void hypervisor_xcall_deliver(u64 data0, u64 data1, u64 data2, cpumask_t mask)
|
|
|
|
{
|
2006-02-28 18:10:26 -05:00
|
|
|
struct trap_per_cpu *tb;
|
|
|
|
u16 *cpu_list;
|
|
|
|
u64 *mondo;
|
|
|
|
cpumask_t error_mask;
|
|
|
|
unsigned long flags, status;
|
2006-03-03 00:50:47 -05:00
|
|
|
int cnt, retries, this_cpu, prev_sent, i;
|
2006-02-28 18:10:26 -05:00
|
|
|
|
2007-05-14 05:01:52 -04:00
|
|
|
if (cpus_empty(mask))
|
|
|
|
return;
|
|
|
|
|
2006-02-28 18:10:26 -05:00
|
|
|
/* We have to do this whole thing with interrupts fully disabled.
|
|
|
|
* Otherwise if we send an xcall from interrupt context it will
|
|
|
|
* corrupt both our mondo block and cpu list state.
|
|
|
|
*
|
|
|
|
* One consequence of this is that we cannot use timeout mechanisms
|
|
|
|
* that depend upon interrupts being delivered locally. So, for
|
|
|
|
* example, we cannot sample jiffies and expect it to advance.
|
|
|
|
*
|
|
|
|
* Fortunately, udelay() uses %stick/%tick so we can use that.
|
|
|
|
*/
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
|
|
this_cpu = smp_processor_id();
|
|
|
|
tb = &trap_block[this_cpu];
|
2006-02-08 19:41:20 -05:00
|
|
|
|
2006-02-28 18:10:26 -05:00
|
|
|
mondo = __va(tb->cpu_mondo_block_pa);
|
2006-02-08 19:41:20 -05:00
|
|
|
mondo[0] = data0;
|
|
|
|
mondo[1] = data1;
|
|
|
|
mondo[2] = data2;
|
|
|
|
wmb();
|
|
|
|
|
2006-02-28 18:10:26 -05:00
|
|
|
cpu_list = __va(tb->cpu_list_pa);
|
|
|
|
|
|
|
|
/* Setup the initial cpu list. */
|
|
|
|
cnt = 0;
|
|
|
|
for_each_cpu_mask(i, mask)
|
|
|
|
cpu_list[cnt++] = i;
|
|
|
|
|
|
|
|
cpus_clear(error_mask);
|
2006-02-08 19:41:20 -05:00
|
|
|
retries = 0;
|
2006-03-03 00:50:47 -05:00
|
|
|
prev_sent = 0;
|
2006-02-08 19:41:20 -05:00
|
|
|
do {
|
2006-03-03 00:50:47 -05:00
|
|
|
int forward_progress, n_sent;
|
2006-02-08 19:41:20 -05:00
|
|
|
|
2006-02-28 18:10:26 -05:00
|
|
|
status = sun4v_cpu_mondo_send(cnt,
|
|
|
|
tb->cpu_list_pa,
|
|
|
|
tb->cpu_mondo_block_pa);
|
|
|
|
|
|
|
|
/* HV_EOK means all cpus received the xcall, we're done. */
|
|
|
|
if (likely(status == HV_EOK))
|
2006-02-08 19:41:20 -05:00
|
|
|
break;
|
2006-02-28 18:10:26 -05:00
|
|
|
|
2006-03-03 00:50:47 -05:00
|
|
|
/* First, see if we made any forward progress.
|
|
|
|
*
|
|
|
|
* The hypervisor indicates successful sends by setting
|
|
|
|
* cpu list entries to the value 0xffff.
|
2006-02-28 18:10:26 -05:00
|
|
|
*/
|
2006-03-03 00:50:47 -05:00
|
|
|
n_sent = 0;
|
2006-02-28 18:10:26 -05:00
|
|
|
for (i = 0; i < cnt; i++) {
|
2006-03-03 00:50:47 -05:00
|
|
|
if (likely(cpu_list[i] == 0xffff))
|
|
|
|
n_sent++;
|
2006-02-08 19:41:20 -05:00
|
|
|
}
|
|
|
|
|
2006-03-03 00:50:47 -05:00
|
|
|
forward_progress = 0;
|
|
|
|
if (n_sent > prev_sent)
|
|
|
|
forward_progress = 1;
|
|
|
|
|
|
|
|
prev_sent = n_sent;
|
|
|
|
|
2006-02-28 18:10:26 -05:00
|
|
|
/* If we get a HV_ECPUERROR, then one or more of the cpus
|
|
|
|
* in the list are in error state. Use the cpu_state()
|
|
|
|
* hypervisor call to find out which cpus are in error state.
|
|
|
|
*/
|
|
|
|
if (unlikely(status == HV_ECPUERROR)) {
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
long err;
|
|
|
|
u16 cpu;
|
|
|
|
|
|
|
|
cpu = cpu_list[i];
|
|
|
|
if (cpu == 0xffff)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
err = sun4v_cpu_state(cpu);
|
|
|
|
if (err >= 0 &&
|
|
|
|
err == HV_CPU_STATE_ERROR) {
|
2006-03-03 00:50:47 -05:00
|
|
|
cpu_list[i] = 0xffff;
|
2006-02-28 18:10:26 -05:00
|
|
|
cpu_set(cpu, error_mask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (unlikely(status != HV_EWOULDBLOCK))
|
|
|
|
goto fatal_mondo_error;
|
|
|
|
|
2006-03-03 00:50:47 -05:00
|
|
|
/* Don't bother rewriting the CPU list, just leave the
|
|
|
|
* 0xffff and non-0xffff entries in there and the
|
|
|
|
* hypervisor will do the right thing.
|
|
|
|
*
|
|
|
|
* Only advance timeout state if we didn't make any
|
|
|
|
* forward progress.
|
|
|
|
*/
|
2006-02-28 18:10:26 -05:00
|
|
|
if (unlikely(!forward_progress)) {
|
|
|
|
if (unlikely(++retries > 10000))
|
|
|
|
goto fatal_mondo_timeout;
|
|
|
|
|
|
|
|
/* Delay a little bit to let other cpus catch up
|
|
|
|
* on their cpu mondo queue work.
|
|
|
|
*/
|
|
|
|
udelay(2 * cnt);
|
|
|
|
}
|
2006-02-08 19:41:20 -05:00
|
|
|
} while (1);
|
|
|
|
|
2006-02-28 18:10:26 -05:00
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
if (unlikely(!cpus_empty(error_mask)))
|
|
|
|
goto fatal_mondo_cpu_error;
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
fatal_mondo_cpu_error:
|
|
|
|
printk(KERN_CRIT "CPU[%d]: SUN4V mondo cpu error, some target cpus "
|
|
|
|
"were in error state\n",
|
|
|
|
this_cpu);
|
|
|
|
printk(KERN_CRIT "CPU[%d]: Error mask [ ", this_cpu);
|
|
|
|
for_each_cpu_mask(i, error_mask)
|
|
|
|
printk("%d ", i);
|
|
|
|
printk("]\n");
|
|
|
|
return;
|
|
|
|
|
|
|
|
fatal_mondo_timeout:
|
|
|
|
local_irq_restore(flags);
|
|
|
|
printk(KERN_CRIT "CPU[%d]: SUN4V mondo timeout, no forward "
|
|
|
|
" progress after %d retries.\n",
|
|
|
|
this_cpu, retries);
|
|
|
|
goto dump_cpu_list_and_out;
|
|
|
|
|
|
|
|
fatal_mondo_error:
|
|
|
|
local_irq_restore(flags);
|
|
|
|
printk(KERN_CRIT "CPU[%d]: Unexpected SUN4V mondo error %lu\n",
|
|
|
|
this_cpu, status);
|
|
|
|
printk(KERN_CRIT "CPU[%d]: Args were cnt(%d) cpulist_pa(%lx) "
|
|
|
|
"mondo_block_pa(%lx)\n",
|
|
|
|
this_cpu, cnt, tb->cpu_list_pa, tb->cpu_mondo_block_pa);
|
|
|
|
|
|
|
|
dump_cpu_list_and_out:
|
|
|
|
printk(KERN_CRIT "CPU[%d]: CPU list [ ", this_cpu);
|
|
|
|
for (i = 0; i < cnt; i++)
|
|
|
|
printk("%u ", cpu_list[i]);
|
|
|
|
printk("]\n");
|
2006-02-08 19:41:20 -05:00
|
|
|
}
|
2006-02-04 06:10:53 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Send cross call to all processors mentioned in MASK
|
|
|
|
* except self.
|
|
|
|
*/
|
|
|
|
static void smp_cross_call_masked(unsigned long *func, u32 ctx, u64 data1, u64 data2, cpumask_t mask)
|
|
|
|
{
|
|
|
|
u64 data0 = (((u64)ctx)<<32 | (((u64)func) & 0xffffffff));
|
|
|
|
int this_cpu = get_cpu();
|
|
|
|
|
|
|
|
cpus_and(mask, mask, cpu_online_map);
|
|
|
|
cpu_clear(this_cpu, mask);
|
|
|
|
|
|
|
|
if (tlb_type == spitfire)
|
|
|
|
spitfire_xcall_deliver(data0, data1, data2, mask);
|
2006-02-04 06:10:53 -05:00
|
|
|
else if (tlb_type == cheetah || tlb_type == cheetah_plus)
|
2005-04-16 18:20:36 -04:00
|
|
|
cheetah_xcall_deliver(data0, data1, data2, mask);
|
2006-02-04 06:10:53 -05:00
|
|
|
else
|
|
|
|
hypervisor_xcall_deliver(data0, data1, data2, mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
/* NOTE: Caller runs local copy on master. */
|
|
|
|
|
|
|
|
put_cpu();
|
|
|
|
}
|
|
|
|
|
|
|
|
extern unsigned long xcall_sync_tick;
|
|
|
|
|
|
|
|
static void smp_start_sync_tick_client(int cpu)
|
|
|
|
{
|
|
|
|
cpumask_t mask = cpumask_of_cpu(cpu);
|
|
|
|
|
|
|
|
smp_cross_call_masked(&xcall_sync_tick,
|
|
|
|
0, 0, 0, mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send cross call to all processors except self. */
|
|
|
|
#define smp_cross_call(func, ctx, data1, data2) \
|
|
|
|
smp_cross_call_masked(func, ctx, data1, data2, cpu_online_map)
|
|
|
|
|
|
|
|
struct call_data_struct {
|
|
|
|
void (*func) (void *info);
|
|
|
|
void *info;
|
|
|
|
atomic_t finished;
|
|
|
|
int wait;
|
|
|
|
};
|
|
|
|
|
2006-04-06 19:54:33 -04:00
|
|
|
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(call_lock);
|
2005-04-16 18:20:36 -04:00
|
|
|
static struct call_data_struct *call_data;
|
|
|
|
|
|
|
|
extern unsigned long xcall_call_function;
|
|
|
|
|
2006-04-06 19:54:33 -04:00
|
|
|
/**
|
|
|
|
* smp_call_function(): Run a function on all other CPUs.
|
|
|
|
* @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.
|
|
|
|
*
|
2005-04-16 18:20:36 -04:00
|
|
|
* You must not call this function with disabled interrupts or from a
|
|
|
|
* hardware interrupt handler or from a bottom half handler.
|
|
|
|
*/
|
2006-01-31 21:31:38 -05:00
|
|
|
static int smp_call_function_mask(void (*func)(void *info), void *info,
|
|
|
|
int nonatomic, int wait, cpumask_t mask)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
struct call_data_struct data;
|
2006-03-07 01:50:44 -05:00
|
|
|
int cpus;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Can deadlock when called with interrupts disabled */
|
|
|
|
WARN_ON(irqs_disabled());
|
|
|
|
|
|
|
|
data.func = func;
|
|
|
|
data.info = info;
|
|
|
|
atomic_set(&data.finished, 0);
|
|
|
|
data.wait = wait;
|
|
|
|
|
|
|
|
spin_lock(&call_lock);
|
|
|
|
|
2006-03-07 01:50:44 -05:00
|
|
|
cpu_clear(smp_processor_id(), mask);
|
|
|
|
cpus = cpus_weight(mask);
|
|
|
|
if (!cpus)
|
|
|
|
goto out_unlock;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
call_data = &data;
|
2006-04-06 19:54:33 -04:00
|
|
|
mb();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-01-31 21:31:38 -05:00
|
|
|
smp_cross_call_masked(&xcall_call_function, 0, 0, 0, mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-04-06 19:54:33 -04:00
|
|
|
/* Wait for response */
|
|
|
|
while (atomic_read(&data.finished) != cpus)
|
|
|
|
cpu_relax();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-03-07 01:50:44 -05:00
|
|
|
out_unlock:
|
2005-04-16 18:20:36 -04:00
|
|
|
spin_unlock(&call_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-31 21:31:38 -05:00
|
|
|
int smp_call_function(void (*func)(void *info), void *info,
|
|
|
|
int nonatomic, int wait)
|
|
|
|
{
|
|
|
|
return smp_call_function_mask(func, info, nonatomic, wait,
|
|
|
|
cpu_online_map);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
void smp_call_function_client(int irq, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
void (*func) (void *info) = call_data->func;
|
|
|
|
void *info = call_data->info;
|
|
|
|
|
|
|
|
clear_softint(1 << irq);
|
|
|
|
if (call_data->wait) {
|
|
|
|
/* let initiator proceed only after completion */
|
|
|
|
func(info);
|
|
|
|
atomic_inc(&call_data->finished);
|
|
|
|
} else {
|
|
|
|
/* let initiator proceed after getting data */
|
|
|
|
atomic_inc(&call_data->finished);
|
|
|
|
func(info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-31 21:31:38 -05:00
|
|
|
static void tsb_sync(void *info)
|
|
|
|
{
|
2006-03-28 16:29:26 -05:00
|
|
|
struct trap_per_cpu *tp = &trap_block[raw_smp_processor_id()];
|
2006-01-31 21:31:38 -05:00
|
|
|
struct mm_struct *mm = info;
|
|
|
|
|
2006-03-28 16:29:26 -05:00
|
|
|
/* It is not valid to test "currrent->active_mm == mm" here.
|
|
|
|
*
|
|
|
|
* The value of "current" is not changed atomically with
|
|
|
|
* switch_mm(). But that's OK, we just need to check the
|
|
|
|
* current cpu's trap block PGD physical address.
|
|
|
|
*/
|
|
|
|
if (tp->pgd_paddr == __pa(mm->pgd))
|
2006-01-31 21:31:38 -05:00
|
|
|
tsb_context_switch(mm);
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_tsb_sync(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
smp_call_function_mask(tsb_sync, mm, 0, 1, mm->cpu_vm_mask);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
extern unsigned long xcall_flush_tlb_mm;
|
|
|
|
extern unsigned long xcall_flush_tlb_pending;
|
|
|
|
extern unsigned long xcall_flush_tlb_kernel_range;
|
|
|
|
extern unsigned long xcall_report_regs;
|
|
|
|
extern unsigned long xcall_receive_signal;
|
2006-03-07 01:50:44 -05:00
|
|
|
extern unsigned long xcall_new_mmu_context_version;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#ifdef DCACHE_ALIASING_POSSIBLE
|
|
|
|
extern unsigned long xcall_flush_dcache_page_cheetah;
|
|
|
|
#endif
|
|
|
|
extern unsigned long xcall_flush_dcache_page_spitfire;
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
extern atomic_t dcpage_flushes;
|
|
|
|
extern atomic_t dcpage_flushes_xcall;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static __inline__ void __local_flush_dcache_page(struct page *page)
|
|
|
|
{
|
|
|
|
#ifdef DCACHE_ALIASING_POSSIBLE
|
|
|
|
__flush_dcache_page(page_address(page),
|
|
|
|
((tlb_type == spitfire) &&
|
|
|
|
page_mapping(page) != NULL));
|
|
|
|
#else
|
|
|
|
if (page_mapping(page) != NULL &&
|
|
|
|
tlb_type == spitfire)
|
|
|
|
__flush_icache_page(__pa(page_address(page)));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_flush_dcache_page_impl(struct page *page, int cpu)
|
|
|
|
{
|
|
|
|
cpumask_t mask = cpumask_of_cpu(cpu);
|
2006-02-04 06:10:53 -05:00
|
|
|
int this_cpu;
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
return;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
atomic_inc(&dcpage_flushes);
|
|
|
|
#endif
|
2006-02-04 06:10:53 -05:00
|
|
|
|
|
|
|
this_cpu = get_cpu();
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (cpu == this_cpu) {
|
|
|
|
__local_flush_dcache_page(page);
|
|
|
|
} else if (cpu_online(cpu)) {
|
|
|
|
void *pg_addr = page_address(page);
|
|
|
|
u64 data0;
|
|
|
|
|
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
data0 =
|
|
|
|
((u64)&xcall_flush_dcache_page_spitfire);
|
|
|
|
if (page_mapping(page) != NULL)
|
|
|
|
data0 |= ((u64)1 << 32);
|
|
|
|
spitfire_xcall_deliver(data0,
|
|
|
|
__pa(pg_addr),
|
|
|
|
(u64) pg_addr,
|
|
|
|
mask);
|
2006-02-04 06:10:53 -05:00
|
|
|
} else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef DCACHE_ALIASING_POSSIBLE
|
|
|
|
data0 =
|
|
|
|
((u64)&xcall_flush_dcache_page_cheetah);
|
|
|
|
cheetah_xcall_deliver(data0,
|
|
|
|
__pa(pg_addr),
|
|
|
|
0, mask);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
atomic_inc(&dcpage_flushes_xcall);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
put_cpu();
|
|
|
|
}
|
|
|
|
|
|
|
|
void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
|
|
|
|
{
|
|
|
|
void *pg_addr = page_address(page);
|
|
|
|
cpumask_t mask = cpu_online_map;
|
|
|
|
u64 data0;
|
2006-02-04 06:10:53 -05:00
|
|
|
int this_cpu;
|
|
|
|
|
|
|
|
if (tlb_type == hypervisor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this_cpu = get_cpu();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
cpu_clear(this_cpu, mask);
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
atomic_inc(&dcpage_flushes);
|
|
|
|
#endif
|
|
|
|
if (cpus_empty(mask))
|
|
|
|
goto flush_self;
|
|
|
|
if (tlb_type == spitfire) {
|
|
|
|
data0 = ((u64)&xcall_flush_dcache_page_spitfire);
|
|
|
|
if (page_mapping(page) != NULL)
|
|
|
|
data0 |= ((u64)1 << 32);
|
|
|
|
spitfire_xcall_deliver(data0,
|
|
|
|
__pa(pg_addr),
|
|
|
|
(u64) pg_addr,
|
|
|
|
mask);
|
2006-02-04 06:10:53 -05:00
|
|
|
} else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef DCACHE_ALIASING_POSSIBLE
|
|
|
|
data0 = ((u64)&xcall_flush_dcache_page_cheetah);
|
|
|
|
cheetah_xcall_deliver(data0,
|
|
|
|
__pa(pg_addr),
|
|
|
|
0, mask);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_DEBUG_DCFLUSH
|
|
|
|
atomic_inc(&dcpage_flushes_xcall);
|
|
|
|
#endif
|
|
|
|
flush_self:
|
|
|
|
__local_flush_dcache_page(page);
|
|
|
|
|
|
|
|
put_cpu();
|
|
|
|
}
|
|
|
|
|
2006-02-23 17:19:28 -05:00
|
|
|
static void __smp_receive_signal_mask(cpumask_t mask)
|
|
|
|
{
|
|
|
|
smp_cross_call_masked(&xcall_receive_signal, 0, 0, 0, mask);
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
void smp_receive_signal(int cpu)
|
|
|
|
{
|
|
|
|
cpumask_t mask = cpumask_of_cpu(cpu);
|
|
|
|
|
2006-02-23 17:19:28 -05:00
|
|
|
if (cpu_online(cpu))
|
|
|
|
__smp_receive_signal_mask(mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void smp_receive_signal_client(int irq, struct pt_regs *regs)
|
2006-03-07 01:50:44 -05:00
|
|
|
{
|
|
|
|
clear_softint(1 << irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_new_mmu_context_version_client(int irq, struct pt_regs *regs)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2006-02-23 17:19:28 -05:00
|
|
|
struct mm_struct *mm;
|
2006-03-07 01:50:44 -05:00
|
|
|
unsigned long flags;
|
2006-02-23 17:19:28 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
clear_softint(1 << irq);
|
2006-02-23 17:19:28 -05:00
|
|
|
|
|
|
|
/* See if we need to allocate a new TLB context because
|
|
|
|
* the version of the one we are using is now out of date.
|
|
|
|
*/
|
|
|
|
mm = current->active_mm;
|
2006-03-07 01:50:44 -05:00
|
|
|
if (unlikely(!mm || (mm == &init_mm)))
|
|
|
|
return;
|
2006-02-23 17:19:28 -05:00
|
|
|
|
2006-03-07 01:50:44 -05:00
|
|
|
spin_lock_irqsave(&mm->context.lock, flags);
|
2006-02-27 20:56:51 -05:00
|
|
|
|
2006-03-07 01:50:44 -05:00
|
|
|
if (unlikely(!CTX_VALID(mm->context)))
|
|
|
|
get_new_mmu_context(mm);
|
2006-02-27 20:56:51 -05:00
|
|
|
|
2006-03-07 01:50:44 -05:00
|
|
|
spin_unlock_irqrestore(&mm->context.lock, flags);
|
2006-02-27 20:56:51 -05:00
|
|
|
|
2006-03-07 01:50:44 -05:00
|
|
|
load_secondary_context(mm);
|
|
|
|
__flush_tlb_mm(CTX_HWBITS(mm->context),
|
|
|
|
SECONDARY_CONTEXT);
|
2006-02-23 17:19:28 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void smp_new_mmu_context_version(void)
|
|
|
|
{
|
2006-03-07 01:50:44 -05:00
|
|
|
smp_cross_call(&xcall_new_mmu_context_version, 0, 0, 0);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void smp_report_regs(void)
|
|
|
|
{
|
|
|
|
smp_cross_call(&xcall_report_regs, 0, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We know that the window frames of the user have been flushed
|
|
|
|
* to the stack before we get here because all callers of us
|
|
|
|
* are flush_tlb_*() routines, and these run after flush_cache_*()
|
|
|
|
* which performs the flushw.
|
|
|
|
*
|
|
|
|
* The SMP TLB coherency scheme we use works as follows:
|
|
|
|
*
|
|
|
|
* 1) mm->cpu_vm_mask is a bit mask of which cpus an address
|
|
|
|
* space has (potentially) executed on, this is the heuristic
|
|
|
|
* we use to avoid doing cross calls.
|
|
|
|
*
|
|
|
|
* Also, for flushing from kswapd and also for clones, we
|
|
|
|
* use cpu_vm_mask as the list of cpus to make run the TLB.
|
|
|
|
*
|
|
|
|
* 2) TLB context numbers are shared globally across all processors
|
|
|
|
* in the system, this allows us to play several games to avoid
|
|
|
|
* cross calls.
|
|
|
|
*
|
|
|
|
* One invariant is that when a cpu switches to a process, and
|
|
|
|
* that processes tsk->active_mm->cpu_vm_mask does not have the
|
|
|
|
* current cpu's bit set, that tlb context is flushed locally.
|
|
|
|
*
|
|
|
|
* If the address space is non-shared (ie. mm->count == 1) we avoid
|
|
|
|
* cross calls when we want to flush the currently running process's
|
|
|
|
* tlb state. This is done by clearing all cpu bits except the current
|
|
|
|
* processor's in current->active_mm->cpu_vm_mask and performing the
|
|
|
|
* flush locally only. This will force any subsequent cpus which run
|
|
|
|
* this task to flush the context from the local tlb if the process
|
|
|
|
* migrates to another cpu (again).
|
|
|
|
*
|
|
|
|
* 3) For shared address spaces (threads) and swapping we bite the
|
|
|
|
* bullet for most cases and perform the cross call (but only to
|
|
|
|
* the cpus listed in cpu_vm_mask).
|
|
|
|
*
|
|
|
|
* The performance gain from "optimizing" away the cross call for threads is
|
|
|
|
* questionable (in theory the big win for threads is the massive sharing of
|
|
|
|
* address space state across processors).
|
|
|
|
*/
|
2005-11-07 17:09:58 -05:00
|
|
|
|
|
|
|
/* This currently is only used by the hugetlb arch pre-fault
|
|
|
|
* hook on UltraSPARC-III+ and later when changing the pagesize
|
|
|
|
* bits of the context register for an address space.
|
|
|
|
*/
|
2005-04-16 18:20:36 -04:00
|
|
|
void smp_flush_tlb_mm(struct mm_struct *mm)
|
|
|
|
{
|
2005-11-07 17:09:58 -05:00
|
|
|
u32 ctx = CTX_HWBITS(mm->context);
|
|
|
|
int cpu = get_cpu();
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 17:09:58 -05:00
|
|
|
if (atomic_read(&mm->mm_users) == 1) {
|
|
|
|
mm->cpu_vm_mask = cpumask_of_cpu(cpu);
|
|
|
|
goto local_flush_and_out;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 17:09:58 -05:00
|
|
|
smp_cross_call_masked(&xcall_flush_tlb_mm,
|
|
|
|
ctx, 0, 0,
|
|
|
|
mm->cpu_vm_mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 17:09:58 -05:00
|
|
|
local_flush_and_out:
|
|
|
|
__flush_tlb_mm(ctx, SECONDARY_CONTEXT);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-11-07 17:09:58 -05:00
|
|
|
put_cpu();
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void smp_flush_tlb_pending(struct mm_struct *mm, unsigned long nr, unsigned long *vaddrs)
|
|
|
|
{
|
|
|
|
u32 ctx = CTX_HWBITS(mm->context);
|
|
|
|
int cpu = get_cpu();
|
|
|
|
|
[SPARC64] mm: context switch ptlock
sparc64 is unique among architectures in taking the page_table_lock in
its context switch (well, cris does too, but erroneously, and it's not
yet SMP anyway).
This seems to be a private affair between switch_mm and activate_mm,
using page_table_lock as a per-mm lock, without any relation to its uses
elsewhere. That's fine, but comment it as such; and unlock sooner in
switch_mm, more like in activate_mm (preemption is disabled here).
There is a block of "if (0)"ed code in smp_flush_tlb_pending which would
have liked to rely on the page_table_lock, in switch_mm and elsewhere;
but its comment explains how dup_mmap's flush_tlb_mm defeated it. And
though that could have been changed at any time over the past few years,
now the chance vanishes as we push the page_table_lock downwards, and
perhaps split it per page table page. Just delete that block of code.
Which leaves the mysterious spin_unlock_wait(&oldmm->page_table_lock)
in kernel/fork.c copy_mm. Textual analysis (supported by Nick Piggin)
suggests that the comment was written by DaveM, and that it relates to
the defeated approach in the sparc64 smp_flush_tlb_pending. Just delete
this block too.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-11-07 17:09:01 -05:00
|
|
|
if (mm == current->active_mm && atomic_read(&mm->mm_users) == 1)
|
2005-04-16 18:20:36 -04:00
|
|
|
mm->cpu_vm_mask = cpumask_of_cpu(cpu);
|
[SPARC64] mm: context switch ptlock
sparc64 is unique among architectures in taking the page_table_lock in
its context switch (well, cris does too, but erroneously, and it's not
yet SMP anyway).
This seems to be a private affair between switch_mm and activate_mm,
using page_table_lock as a per-mm lock, without any relation to its uses
elsewhere. That's fine, but comment it as such; and unlock sooner in
switch_mm, more like in activate_mm (preemption is disabled here).
There is a block of "if (0)"ed code in smp_flush_tlb_pending which would
have liked to rely on the page_table_lock, in switch_mm and elsewhere;
but its comment explains how dup_mmap's flush_tlb_mm defeated it. And
though that could have been changed at any time over the past few years,
now the chance vanishes as we push the page_table_lock downwards, and
perhaps split it per page table page. Just delete that block of code.
Which leaves the mysterious spin_unlock_wait(&oldmm->page_table_lock)
in kernel/fork.c copy_mm. Textual analysis (supported by Nick Piggin)
suggests that the comment was written by DaveM, and that it relates to
the defeated approach in the sparc64 smp_flush_tlb_pending. Just delete
this block too.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-11-07 17:09:01 -05:00
|
|
|
else
|
|
|
|
smp_cross_call_masked(&xcall_flush_tlb_pending,
|
|
|
|
ctx, nr, (unsigned long) vaddrs,
|
|
|
|
mm->cpu_vm_mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
__flush_tlb_pending(ctx, nr, vaddrs);
|
|
|
|
|
|
|
|
put_cpu();
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_flush_tlb_kernel_range(unsigned long start, unsigned long end)
|
|
|
|
{
|
|
|
|
start &= PAGE_MASK;
|
|
|
|
end = PAGE_ALIGN(end);
|
|
|
|
if (start != end) {
|
|
|
|
smp_cross_call(&xcall_flush_tlb_kernel_range,
|
|
|
|
0, start, end);
|
|
|
|
|
|
|
|
__flush_tlb_kernel_range(start, end);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CPU capture. */
|
|
|
|
/* #define CAPTURE_DEBUG */
|
|
|
|
extern unsigned long xcall_capture;
|
|
|
|
|
|
|
|
static atomic_t smp_capture_depth = ATOMIC_INIT(0);
|
|
|
|
static atomic_t smp_capture_registry = ATOMIC_INIT(0);
|
|
|
|
static unsigned long penguins_are_doing_time;
|
|
|
|
|
|
|
|
void smp_capture(void)
|
|
|
|
{
|
|
|
|
int result = atomic_add_ret(1, &smp_capture_depth);
|
|
|
|
|
|
|
|
if (result == 1) {
|
|
|
|
int ncpus = num_online_cpus();
|
|
|
|
|
|
|
|
#ifdef CAPTURE_DEBUG
|
|
|
|
printk("CPU[%d]: Sending penguins to jail...",
|
|
|
|
smp_processor_id());
|
|
|
|
#endif
|
|
|
|
penguins_are_doing_time = 1;
|
2005-08-29 15:46:22 -04:00
|
|
|
membar_storestore_loadstore();
|
2005-04-16 18:20:36 -04:00
|
|
|
atomic_inc(&smp_capture_registry);
|
|
|
|
smp_cross_call(&xcall_capture, 0, 0, 0);
|
|
|
|
while (atomic_read(&smp_capture_registry) != ncpus)
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef CAPTURE_DEBUG
|
|
|
|
printk("done\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_release(void)
|
|
|
|
{
|
|
|
|
if (atomic_dec_and_test(&smp_capture_depth)) {
|
|
|
|
#ifdef CAPTURE_DEBUG
|
|
|
|
printk("CPU[%d]: Giving pardon to "
|
|
|
|
"imprisoned penguins\n",
|
|
|
|
smp_processor_id());
|
|
|
|
#endif
|
|
|
|
penguins_are_doing_time = 0;
|
2005-08-29 15:46:22 -04:00
|
|
|
membar_storeload_storestore();
|
2005-04-16 18:20:36 -04:00
|
|
|
atomic_dec(&smp_capture_registry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Imprisoned penguins run with %pil == 15, but PSTATE_IE set, so they
|
|
|
|
* can service tlb flush xcalls...
|
|
|
|
*/
|
|
|
|
extern void prom_world(int);
|
2006-01-31 21:32:29 -05:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
void smp_penguin_jailcell(int irq, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
clear_softint(1 << irq);
|
|
|
|
|
|
|
|
preempt_disable();
|
|
|
|
|
|
|
|
__asm__ __volatile__("flushw");
|
|
|
|
prom_world(1);
|
|
|
|
atomic_inc(&smp_capture_registry);
|
2005-08-29 15:46:22 -04:00
|
|
|
membar_storeload_storestore();
|
2005-04-16 18:20:36 -04:00
|
|
|
while (penguins_are_doing_time)
|
2005-08-29 15:46:22 -04:00
|
|
|
rmb();
|
2005-04-16 18:20:36 -04:00
|
|
|
atomic_dec(&smp_capture_registry);
|
|
|
|
prom_world(0);
|
|
|
|
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init smp_tick_init(void)
|
|
|
|
{
|
|
|
|
boot_cpu_id = hard_smp_processor_id();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* /proc/profile writes can call this, don't __init it please. */
|
|
|
|
int setup_profiling_timer(unsigned int multiplier)
|
|
|
|
{
|
2007-02-22 09:24:10 -05:00
|
|
|
return -EINVAL;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2006-06-11 01:02:17 -04:00
|
|
|
static void __init smp_tune_scheduling(void)
|
|
|
|
{
|
2007-05-25 18:49:59 -04:00
|
|
|
unsigned int smallest = ~0U;
|
|
|
|
int i;
|
2006-06-11 01:02:17 -04:00
|
|
|
|
2007-05-25 18:49:59 -04:00
|
|
|
for (i = 0; i < NR_CPUS; i++) {
|
|
|
|
unsigned int val = cpu_data(i).ecache_size;
|
2006-06-11 01:02:17 -04:00
|
|
|
|
2007-05-25 18:49:59 -04:00
|
|
|
if (val && val < smallest)
|
2006-06-11 01:02:17 -04:00
|
|
|
smallest = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Any value less than 256K is nonsense. */
|
|
|
|
if (smallest < (256U * 1024U))
|
|
|
|
smallest = 256 * 1024;
|
|
|
|
|
|
|
|
max_cache_size = smallest;
|
|
|
|
|
|
|
|
if (smallest < 1U * 1024U * 1024U)
|
|
|
|
printk(KERN_INFO "Using max_cache_size of %uKB\n",
|
|
|
|
smallest / 1024U);
|
|
|
|
else
|
|
|
|
printk(KERN_INFO "Using max_cache_size of %uMB\n",
|
|
|
|
smallest / 1024U / 1024U);
|
|
|
|
}
|
|
|
|
|
2006-02-25 16:39:56 -05:00
|
|
|
/* Constrain the number of cpus to max_cpus. */
|
2005-04-16 18:20:36 -04:00
|
|
|
void __init smp_prepare_cpus(unsigned int max_cpus)
|
|
|
|
{
|
2006-03-08 19:09:19 -05:00
|
|
|
int i;
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (num_possible_cpus() > max_cpus) {
|
2007-05-25 18:49:59 -04:00
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
if (i != boot_cpu_id) {
|
|
|
|
cpu_clear(i, phys_cpu_present_map);
|
|
|
|
cpu_clear(i, cpu_present_map);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (num_possible_cpus() <= max_cpus)
|
|
|
|
break;
|
|
|
|
}
|
2006-03-08 19:09:19 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-25 18:49:59 -04:00
|
|
|
cpu_data(boot_cpu_id).udelay_val = loops_per_jiffy;
|
2006-06-11 01:02:17 -04:00
|
|
|
smp_tune_scheduling();
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-05-25 18:49:59 -04:00
|
|
|
void __devinit smp_prepare_boot_cpu(void)
|
2006-02-25 16:39:56 -05:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-05-25 18:49:59 -04:00
|
|
|
void __devinit smp_fill_in_sib_core_maps(void)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2007-05-25 18:49:59 -04:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
unsigned int j;
|
|
|
|
|
|
|
|
if (cpu_data(i).core_id == 0) {
|
|
|
|
cpu_set(i, cpu_sibling_map[i]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for_each_possible_cpu(j) {
|
|
|
|
if (cpu_data(i).core_id ==
|
|
|
|
cpu_data(j).core_id)
|
|
|
|
cpu_set(j, cpu_sibling_map[i]);
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2007-01-11 02:15:34 -05:00
|
|
|
int __cpuinit __cpu_up(unsigned int cpu)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
int ret = smp_boot_one_cpu(cpu);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
cpu_set(cpu, smp_commenced_mask);
|
|
|
|
while (!cpu_isset(cpu, cpu_online_map))
|
|
|
|
mb();
|
|
|
|
if (!cpu_isset(cpu, cpu_online_map)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
} else {
|
2006-02-12 02:22:47 -05:00
|
|
|
/* On SUN4V, writes to %tick and %stick are
|
|
|
|
* not allowed.
|
|
|
|
*/
|
|
|
|
if (tlb_type != hypervisor)
|
|
|
|
smp_synchronize_one_tick(cpu);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init smp_cpus_done(unsigned int max_cpus)
|
|
|
|
{
|
|
|
|
unsigned long bogosum = 0;
|
|
|
|
int i;
|
|
|
|
|
2006-03-23 06:01:05 -05:00
|
|
|
for_each_online_cpu(i)
|
|
|
|
bogosum += cpu_data(i).udelay_val;
|
2005-04-16 18:20:36 -04:00
|
|
|
printk("Total of %ld processors activated "
|
|
|
|
"(%lu.%02lu BogoMIPS).\n",
|
|
|
|
(long) num_online_cpus(),
|
|
|
|
bogosum/(500000/HZ),
|
|
|
|
(bogosum/(5000/HZ))%100);
|
|
|
|
}
|
|
|
|
|
|
|
|
void smp_send_reschedule(int cpu)
|
|
|
|
{
|
[PATCH] sched: resched and cpu_idle rework
Make some changes to the NEED_RESCHED and POLLING_NRFLAG to reduce
confusion, and make their semantics rigid. Improves efficiency of
resched_task and some cpu_idle routines.
* In resched_task:
- TIF_NEED_RESCHED is only cleared with the task's runqueue lock held,
and as we hold it during resched_task, then there is no need for an
atomic test and set there. The only other time this should be set is
when the task's quantum expires, in the timer interrupt - this is
protected against because the rq lock is irq-safe.
- If TIF_NEED_RESCHED is set, then we don't need to do anything. It
won't get unset until the task get's schedule()d off.
- If we are running on the same CPU as the task we resched, then set
TIF_NEED_RESCHED and no further action is required.
- If we are running on another CPU, and TIF_POLLING_NRFLAG is *not* set
after TIF_NEED_RESCHED has been set, then we need to send an IPI.
Using these rules, we are able to remove the test and set operation in
resched_task, and make clear the previously vague semantics of
POLLING_NRFLAG.
* In idle routines:
- Enter cpu_idle with preempt disabled. When the need_resched() condition
becomes true, explicitly call schedule(). This makes things a bit clearer
(IMO), but haven't updated all architectures yet.
- Many do a test and clear of TIF_NEED_RESCHED for some reason. According
to the resched_task rules, this isn't needed (and actually breaks the
assumption that TIF_NEED_RESCHED is only cleared with the runqueue lock
held). So remove that. Generally one less locked memory op when switching
to the idle thread.
- Many idle routines clear TIF_POLLING_NRFLAG, and only set it in the inner
most polling idle loops. The above resched_task semantics allow it to be
set until before the last time need_resched() is checked before going into
a halt requiring interrupt wakeup.
Many idle routines simply never enter such a halt, and so POLLING_NRFLAG
can be always left set, completely eliminating resched IPIs when rescheduling
the idle task.
POLLING_NRFLAG width can be increased, to reduce the chance of resched IPIs.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Con Kolivas <kernel@kolivas.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-09 00:39:04 -05:00
|
|
|
smp_receive_signal(cpu);
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This is a nop because we capture all other cpus
|
|
|
|
* anyways when making the PROM active.
|
|
|
|
*/
|
|
|
|
void smp_send_stop(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-07-10 18:45:11 -04:00
|
|
|
unsigned long __per_cpu_base __read_mostly;
|
|
|
|
unsigned long __per_cpu_shift __read_mostly;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
EXPORT_SYMBOL(__per_cpu_base);
|
|
|
|
EXPORT_SYMBOL(__per_cpu_shift);
|
|
|
|
|
2007-05-25 18:49:59 -04:00
|
|
|
void __init real_setup_per_cpu_areas(void)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
unsigned long goal, size, i;
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
/* Copy section for each CPU (we discard the original) */
|
2006-12-15 02:40:57 -05:00
|
|
|
goal = PERCPU_ENOUGH_ROOM;
|
|
|
|
|
2007-05-02 13:27:12 -04:00
|
|
|
__per_cpu_shift = PAGE_SHIFT;
|
|
|
|
for (size = PAGE_SIZE; size < goal; size <<= 1UL)
|
2005-04-16 18:20:36 -04:00
|
|
|
__per_cpu_shift++;
|
|
|
|
|
2007-05-02 13:27:12 -04:00
|
|
|
ptr = alloc_bootmem_pages(size * NR_CPUS);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
__per_cpu_base = ptr - __per_cpu_start;
|
|
|
|
|
|
|
|
for (i = 0; i < NR_CPUS; i++, ptr += size)
|
|
|
|
memcpy(ptr, __per_cpu_start, __per_cpu_end - __per_cpu_start);
|
2006-05-31 04:24:02 -04:00
|
|
|
|
|
|
|
/* Setup %g5 for the boot cpu. */
|
|
|
|
__local_per_cpu_offset = __per_cpu_offset(smp_processor_id());
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|