Release 4.10 arch/powerpc/kernel/smp.c

Directory: arch/powerpc/kernel
/*
 * SMP support for ppc.
 *
 * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great
 * deal of code from the sparc and intel versions.
 *
 * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu>
 *
 * PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and
 * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */


#undef DEBUG

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/cache.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/cpu.h>
#include <linux/notifier.h>
#include <linux/topology.h>
#include <linux/profile.h>

#include <asm/ptrace.h>
#include <linux/atomic.h>
#include <asm/irq.h>
#include <asm/hw_irq.h>
#include <asm/kvm_ppc.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/prom.h>
#include <asm/smp.h>
#include <asm/time.h>
#include <asm/machdep.h>
#include <asm/cputhreads.h>
#include <asm/cputable.h>
#include <asm/mpic.h>
#include <asm/vdso_datapage.h>
#ifdef CONFIG_PPC64
#include <asm/paca.h>
#endif
#include <asm/vdso.h>
#include <asm/debug.h>
#include <asm/kexec.h>
#include <asm/asm-prototypes.h>
#include <asm/cpu_has_feature.h>

#ifdef DEBUG
#include <asm/udbg.h>

#define DBG(fmt...) udbg_printf(fmt)
#else

#define DBG(fmt...)
#endif

#ifdef CONFIG_HOTPLUG_CPU
/* State of each CPU during hotplug phases */
static DEFINE_PER_CPU(int, cpu_state) = { 0 };
#endif


struct thread_info *secondary_ti;

DEFINE_PER_CPU(cpumask_var_t, cpu_sibling_map);
DEFINE_PER_CPU(cpumask_var_t, cpu_core_map);


EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);

EXPORT_PER_CPU_SYMBOL(cpu_core_map);

/* SMP operations for this machine */

struct smp_ops_t *smp_ops;

/* Can't be static due to PowerMac hackery */

volatile unsigned int cpu_callin_map[NR_CPUS];


int smt_enabled_at_boot = 1;


static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL;

/*
 * Returns 1 if the specified cpu should be brought up during boot.
 * Used to inhibit booting threads if they've been disabled or
 * limited on the command line
 */


int smp_generic_cpu_bootable(unsigned int nr)
{
	/* Special case - we inhibit secondary thread startup
         * during boot if the user requests it.
         */
	if (system_state == SYSTEM_BOOTING && cpu_has_feature(CPU_FTR_SMT)) {
		if (!smt_enabled_at_boot && cpu_thread_in_core(nr) != 0)
			return 0;
		if (smt_enabled_at_boot
		    && cpu_thread_in_core(nr) >= smt_enabled_at_boot)
			return 0;
	}

	return 1;
}


Contributors
Person Tokens Prop Commits CommitProp
andy fleming andy fleming 55 100.00% 1 100.00%
Total 55 100.00% 1 100.00%

#ifdef CONFIG_PPC64


int smp_generic_kick_cpu(int nr)
{
	BUG_ON(nr < 0 || nr >= NR_CPUS);

	/*
         * The processor is currently spinning, waiting for the
         * cpu_start field to become non-zero After we set cpu_start,
         * the processor will continue on to secondary_start
         */
	if (!paca[nr].cpu_start) {
		paca[nr].cpu_start = 1;
		smp_mb();
		return 0;
	}

#ifdef CONFIG_HOTPLUG_CPU
	/*
         * Ok it's not there, so it might be soft-unplugged, let's
         * try to bring it back
         */
	generic_set_cpu_up(nr);
	smp_wmb();
	smp_send_reschedule(nr);
#endif /* CONFIG_HOTPLUG_CPU */

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
benjamin herrenschmidt benjamin herrenschmidt 46 65.71% 2 25.00%
anton blanchard anton blanchard 16 22.86% 3 37.50%
michael ellerman michael ellerman 4 5.71% 1 12.50%
andrew morton andrew morton 3 4.29% 1 12.50%
chen-hui zhao chen-hui zhao 1 1.43% 1 12.50%
Total 70 100.00% 8 100.00%

#endif /* CONFIG_PPC64 */



static irqreturn_t call_function_action(int irq, void *data)
{
	generic_smp_call_function_interrupt();
	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static irqreturn_t reschedule_action(int irq, void *data)
{
	scheduler_ipi();
	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 16 84.21% 1 50.00%
peter zijlstra peter zijlstra 3 15.79% 1 50.00%
Total 19 100.00% 2 100.00%



static irqreturn_t tick_broadcast_ipi_action(int irq, void *data)
{
	tick_broadcast_ipi_handler();
	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 15 78.95% 1 50.00%
srivatsa s. bhat srivatsa s. bhat 4 21.05% 1 50.00%
Total 19 100.00% 2 100.00%



static irqreturn_t debug_ipi_action(int irq, void *data)
{
	if (crash_ipi_function_ptr) {
		crash_ipi_function_ptr(get_irq_regs());
		return IRQ_HANDLED;
	}

#ifdef CONFIG_DEBUGGER
	debugger_ipi(get_irq_regs());
#endif /* CONFIG_DEBUGGER */

	return IRQ_HANDLED;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 43 100.00% 3 100.00%
Total 43 100.00% 3 100.00%


static irq_handler_t smp_ipi_action[] = {
	[PPC_MSG_CALL_FUNCTION] =  call_function_action,
	[PPC_MSG_RESCHEDULE] = reschedule_action,
	[PPC_MSG_TICK_BROADCAST] = tick_broadcast_ipi_action,
	[PPC_MSG_DEBUGGER_BREAK] = debug_ipi_action,
};


const char *smp_ipi_name[] = {
	[PPC_MSG_CALL_FUNCTION] =  "ipi call function",
	[PPC_MSG_RESCHEDULE] = "ipi reschedule",
	[PPC_MSG_TICK_BROADCAST] = "ipi tick-broadcast",
	[PPC_MSG_DEBUGGER_BREAK] = "ipi debugger",
};

/* optional function to request ipi, for controllers with >= 4 ipis */


int smp_request_message_ipi(int virq, int msg)
{
	int err;

	if (msg < 0 || msg > PPC_MSG_DEBUGGER_BREAK) {
		return -EINVAL;
	}
#if !defined(CONFIG_DEBUGGER) && !defined(CONFIG_KEXEC_CORE)
	if (msg == PPC_MSG_DEBUGGER_BREAK) {
		return 1;
	}
#endif
	err = request_irq(virq, smp_ipi_action[msg],
			  IRQF_PERCPU | IRQF_NO_THREAD | IRQF_NO_SUSPEND,
			  smp_ipi_name[msg], NULL);
	WARN(err < 0, "unable to request_irq %d for %s (rc %d)\n",
		virq, smp_ipi_name[msg], err);

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 96 94.12% 1 20.00%
chen-hui zhao chen-hui zhao 2 1.96% 1 20.00%
thomas gleixner thomas gleixner 2 1.96% 1 20.00%
anton blanchard anton blanchard 1 0.98% 1 20.00%
thiago jung bauermann thiago jung bauermann 1 0.98% 1 20.00%
Total 102 100.00% 5 100.00%

#ifdef CONFIG_PPC_SMP_MUXED_IPI

struct cpu_messages {
	
long messages;			/* current messages */
	
unsigned long data;		/* data for cause ipi */
};
static DEFINE_PER_CPU_SHARED_ALIGNED(struct cpu_messages, ipi_message);



void smp_muxed_ipi_set_data(int cpu, unsigned long data)
{
	struct cpu_messages *info = &per_cpu(ipi_message, cpu);

	info->data = data;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 31 100.00% 1 100.00%
Total 31 100.00% 1 100.00%



void smp_muxed_ipi_set_message(int cpu, int msg)
{
	struct cpu_messages *info = &per_cpu(ipi_message, cpu);
	char *message = (char *)&info->messages;

	/*
         * Order previous accesses before accesses in the IPI handler.
         */
	smp_mb();
	message[msg] = 1;
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 42 87.50% 2 50.00%
paul mackerras paul mackerras 4 8.33% 1 25.00%
suresh e. warrier suresh e. warrier 2 4.17% 1 25.00%
Total 48 100.00% 4 100.00%



void smp_muxed_ipi_message_pass(int cpu, int msg)
{
	struct cpu_messages *info = &per_cpu(ipi_message, cpu);

	smp_muxed_ipi_set_message(cpu, msg);
	/*
         * cause_ipi functions are required to include a full barrier
         * before doing whatever causes the IPI.
         */
	smp_ops->cause_ipi(cpu, info->data);
}

Contributors
Person Tokens Prop Commits CommitProp
suresh e. warrier suresh e. warrier 30 69.77% 1 33.33%
milton d. miller milton d. miller 12 27.91% 1 33.33%
paul mackerras paul mackerras 1 2.33% 1 33.33%
Total 43 100.00% 3 100.00%

#ifdef __BIG_ENDIAN__

#define IPI_MESSAGE(A) (1uL << ((BITS_PER_LONG - 8) - 8 * (A)))
#else

#define IPI_MESSAGE(A) (1uL << (8 * (A)))
#endif



irqreturn_t smp_ipi_demux(void)
{
	struct cpu_messages *info = this_cpu_ptr(&ipi_message);
	unsigned long all;

	mb();	/* order any irq clear */

	do {
		all = xchg(&info->messages, 0);
#if defined(CONFIG_KVM_XICS) && defined(CONFIG_KVM_BOOK3S_HV_POSSIBLE)
		/*
                 * Must check for PPC_MSG_RM_HOST_ACTION messages
                 * before PPC_MSG_CALL_FUNCTION messages because when
                 * a VM is destroyed, we call kick_all_cpus_sync()
                 * to ensure that any pending PPC_MSG_RM_HOST_ACTION
                 * messages have completed before we free any VCPUs.
                 */
		if (all & IPI_MESSAGE(PPC_MSG_RM_HOST_ACTION))
			kvmppc_xics_ipi_action();
#endif
		if (all & IPI_MESSAGE(PPC_MSG_CALL_FUNCTION))
			generic_smp_call_function_interrupt();
		if (all & IPI_MESSAGE(PPC_MSG_RESCHEDULE))
			scheduler_ipi();
		if (all & IPI_MESSAGE(PPC_MSG_TICK_BROADCAST))
			tick_broadcast_ipi_handler();
		if (all & IPI_MESSAGE(PPC_MSG_DEBUGGER_BREAK))
			debug_ipi_action(0, NULL);
	} while (info->messages);

	return IRQ_HANDLED;
}
Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 76 58.91% 2 22.22%
suresh e. warrier suresh e. warrier 27 20.93% 2 22.22%
srivatsa s. bhat srivatsa s. bhat 12 9.30% 1 11.11%
anton blanchard anton blanchard 9 6.98% 1 11.11%
benjamin herrenschmidt benjamin herrenschmidt 2 1.55% 1 11.11%
christoph lameter christoph lameter 2 1.55% 1 11.11%
paul mackerras paul mackerras 1 0.78% 1 11.11%
Total 129 100.00% 9 100.00%

#endif /* CONFIG_PPC_SMP_MUXED_IPI */



static inline void do_message_pass(int cpu, int msg)
{
	if (smp_ops->message_pass)
		smp_ops->message_pass(cpu, msg);
#ifdef CONFIG_PPC_SMP_MUXED_IPI
	else
		smp_muxed_ipi_message_pass(cpu, msg);
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
paul mackerras paul mackerras 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%



void smp_send_reschedule(int cpu)
{
	if (likely(smp_ops))
		do_message_pass(cpu, PPC_MSG_RESCHEDULE);
}
Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 16 72.73% 1 25.00%
avi kivity avi kivity 4 18.18% 1 25.00%
will schmidt will schmidt 1 4.55% 1 25.00%
paul mackerras paul mackerras 1 4.55% 1 25.00%
Total 22 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(smp_send_reschedule);



void arch_send_call_function_single_ipi(int cpu)
{
	do_message_pass(cpu, PPC_MSG_CALL_FUNCTION);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 10 66.67% 1 25.00%
will schmidt will schmidt 3 20.00% 1 25.00%
paul mackerras paul mackerras 1 6.67% 1 25.00%
srivatsa s. bhat srivatsa s. bhat 1 6.67% 1 25.00%
Total 15 100.00% 4 100.00%



void arch_send_call_function_ipi_mask(const struct cpumask *mask)
{
	unsigned int cpu;

	for_each_cpu(cpu, mask)
		do_message_pass(cpu, PPC_MSG_CALL_FUNCTION);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 9 32.14% 1 20.00%
olof johansson olof johansson 7 25.00% 1 20.00%
rusty russell rusty russell 6 21.43% 1 20.00%
satyam sharma satyam sharma 5 17.86% 1 20.00%
paul mackerras paul mackerras 1 3.57% 1 20.00%
Total 28 100.00% 5 100.00%

#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST


void tick_broadcast(const struct cpumask *mask)
{
	unsigned int cpu;

	for_each_cpu(cpu, mask)
		do_message_pass(cpu, PPC_MSG_TICK_BROADCAST);
}
Contributors
Person Tokens Prop Commits CommitProp
srivatsa s. bhat srivatsa s. bhat 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%

#endif

#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC_CORE)


void smp_send_debugger_break(void)
{
	int cpu;
	int me = raw_smp_processor_id();

	if (unlikely(!smp_ops))
		return;

	for_each_online_cpu(cpu)
		if (cpu != me)
			do_message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
}
Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 23 54.76% 1 20.00%
jens axboe jens axboe 11 26.19% 1 20.00%
olof johansson olof johansson 4 9.52% 1 20.00%
satyam sharma satyam sharma 3 7.14% 1 20.00%
paul mackerras paul mackerras 1 2.38% 1 20.00%
Total 42 100.00% 5 100.00%

#endif

#ifdef CONFIG_KEXEC_CORE


void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
{
	crash_ipi_function_ptr = crash_ipi_callback;
	if (crash_ipi_callback) {
		mb();
		smp_send_debugger_break();
	}
}
Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 13 40.62% 1 20.00%
anton blanchard anton blanchard 10 31.25% 1 20.00%
andrew morton andrew morton 7 21.88% 2 40.00%
milton d. miller milton d. miller 2 6.25% 1 20.00%
Total 32 100.00% 5 100.00%

#endif



static void stop_this_cpu(void *dummy)
{
	/* Remove this CPU */
	set_cpu_online(smp_processor_id(), false);

	local_irq_disable();
	while (1)
		;
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 14 51.85% 1 25.00%
valentine barshak valentine barshak 9 33.33% 1 25.00%
andrew morton andrew morton 3 11.11% 1 25.00%
anton blanchard anton blanchard 1 3.70% 1 25.00%
Total 27 100.00% 4 100.00%



void smp_send_stop(void)
{
	smp_call_function(stop_this_cpu, NULL, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
jens axboe jens axboe 11 68.75% 1 50.00%
andrew morton andrew morton 5 31.25% 1 50.00%
Total 16 100.00% 2 100.00%


struct thread_info *current_set[NR_CPUS];



static void smp_store_cpu_info(int id)
{
	per_cpu(cpu_pvr, id) = mfspr(SPRN_PVR);
#ifdef CONFIG_PPC_FSL_BOOK3E
	per_cpu(next_tlbcam_idx, id)
		= (mfspr(SPRN_TLB1CFG) & TLBnCFG_N_ENTRY) - 1;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
becky bruce becky bruce 23 52.27% 1 25.00%
andrew morton andrew morton 16 36.36% 1 25.00%
benjamin herrenschmidt benjamin herrenschmidt 4 9.09% 1 25.00%
tejun heo tejun heo 1 2.27% 1 25.00%
Total 44 100.00% 4 100.00%



void __init smp_prepare_cpus(unsigned int max_cpus)
{
	unsigned int cpu;

	DBG("smp_prepare_cpus\n");

	/* 
         * setup_cpu may need to be called on the boot cpu. We havent
         * spun any cpus up but lets be paranoid.
         */
	BUG_ON(boot_cpuid != smp_processor_id());

	/* Fixup boot cpu */
	smp_store_cpu_info(boot_cpuid);
	cpu_callin_map[boot_cpuid] = 1;

	for_each_possible_cpu(cpu) {
		zalloc_cpumask_var_node(&per_cpu(cpu_sibling_map, cpu),
					GFP_KERNEL, cpu_to_node(cpu));
		zalloc_cpumask_var_node(&per_cpu(cpu_core_map, cpu),
					GFP_KERNEL, cpu_to_node(cpu));
		/*
                 * numa_node_id() works after this.
                 */
		if (cpu_present(cpu)) {
			set_cpu_numa_node(cpu, numa_cpu_lookup_table[cpu]);
			set_cpu_numa_mem(cpu,
				local_memory_node(numa_cpu_lookup_table[cpu]));
		}
	}

	cpumask_set_cpu(boot_cpuid, cpu_sibling_mask(boot_cpuid));
	cpumask_set_cpu(boot_cpuid, cpu_core_mask(boot_cpuid));

	if (smp_ops && smp_ops->probe)
		smp_ops->probe();
}

Contributors
Person Tokens Prop Commits CommitProp
anton blanchard anton blanchard 88 59.06% 3 27.27%
nishanth aravamudan nishanth aravamudan 24 16.11% 1 9.09%
andrew morton andrew morton 15 10.07% 2 18.18%
li zhong li zhong 9 6.04% 1 9.09%
benjamin herrenschmidt benjamin herrenschmidt 8 5.37% 2 18.18%
kumar gala kumar gala 4 2.68% 1 9.09%
chen gang chen gang 1 0.67% 1 9.09%
Total 149 100.00% 11 100.00%



void smp_prepare_boot_cpu(void)
{
	BUG_ON(smp_processor_id() != boot_cpuid);
#ifdef CONFIG_PPC64
	paca[boot_cpuid].__current = current;
#endif
	set_numa_node(numa_cpu_lookup_table[boot_cpuid]);
	current_set[boot_cpuid] = task_thread_info(current);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 30 63.83% 2 33.33%
nishanth aravamudan nishanth aravamudan 8 17.02% 1 16.67%
paul mackerras paul mackerras 5 10.64% 1 16.67%
al viro al viro 3 6.38% 1 16.67%
david gibson david gibson 1 2.13% 1 16.67%
Total 47 100.00% 6 100.00%

#ifdef CONFIG_HOTPLUG_CPU



int generic_cpu_disable(void)
{
	unsigned int cpu = smp_processor_id();

	if (cpu == boot_cpuid)
		return -EBUSY;

	set_cpu_online(cpu, false);
#ifdef CONFIG_PPC64
	vdso_data->processorCount--;
#endif
	migrate_irqs();
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
zwane mwaikambo zwane mwaikambo 36 76.60% 1 16.67%
paul mackerras paul mackerras 5 10.64% 2 33.33%
benjamin herrenschmidt benjamin herrenschmidt 4 8.51% 2 33.33%
rusty russell rusty russell 2 4.26% 1 16.67%
Total 47 100.00% 6 100.00%



void generic_cpu_die(unsigned int cpu)
{
	int i;

	for (i = 0; i < 100; i++) {
		smp_rmb();
		if (is_cpu_dead(cpu))
			return;
		msleep(100);
	}
	printk(KERN_ERR "CPU%d didn't die...\n", cpu);
}

Contributors
Person Tokens Prop Commits CommitProp
zwane mwaikambo zwane mwaikambo 49 96.08% 1 33.33%
chen-hui zhao chen-hui zhao 1 1.96% 1 33.33%
anton blanchard anton blanchard 1 1.96% 1 33.33%
Total 51 100.00% 3 100.00%



void generic_set_cpu_dead(unsigned int cpu)
{
	per_cpu(cpu_state, cpu) = CPU_DEAD;
}

Contributors
Person Tokens Prop Commits CommitProp
benjamin herrenschmidt benjamin herrenschmidt 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%

/*
 * The cpu_state should be set to CPU_UP_PREPARE in kick_cpu(), otherwise
 * the cpu_state is always CPU_DEAD after calling generic_set_cpu_dead(),
 * which makes the delay in generic_cpu_die() not happen.
 */


void generic_set_cpu_up(unsigned int cpu)
{
	per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
}

Contributors
Person Tokens Prop Commits CommitProp
chen-hui zhao chen-hui zhao 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



int generic_check_cpu_restart(unsigned int cpu)
{
	return per_cpu(cpu_state, cpu) == CPU_UP_PREPARE;
}

Contributors
Person Tokens Prop Commits CommitProp
benjamin herrenschmidt benjamin herrenschmidt 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



int is_cpu_dead(unsigned int cpu)
{
	return per_cpu(cpu_state, cpu) == CPU_DEAD;
}

Contributors
Person Tokens Prop Commits CommitProp
chen-hui zhao chen-hui zhao 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static bool secondaries_inhibited(void)
{
	return kvm_hv_mode_active();
}

Contributors
Person Tokens Prop Commits CommitProp
paul mackerras paul mackerras 9 75.00% 1 50.00%
michael ellerman michael ellerman 3 25.00% 1 50.00%
Total 12 100.00% 2 100.00%

#else /* HOTPLUG_CPU */


#define secondaries_inhibited()		0

#endif



static void cpu_idle_thread_init(unsigned int cpu, struct task_struct *idle)
{
	struct thread_info *ti = task_thread_info(idle);

#ifdef CONFIG_PPC64
	paca[cpu].__current = idle;
	paca[cpu].kstack = (unsigned long)ti + THREAD_SIZE - STACK_FRAME_OVERHEAD;
#endif
	ti->cpu = cpu;
	secondary_ti = current_set[cpu] = ti;
}

Contributors
Person Tokens Prop Commits CommitProp
benjamin herrenschmidt benjamin herrenschmidt 62 87.32% 1 50.00%
thomas gleixner thomas gleixner 9 12.68% 1 50.00%
Total 71 100.00% 2 100.00%



int __cpu_up(unsigned int cpu, struct task_struct *tidle)
{
	int rc, c;

	/*
         * Don't allow secondary threads to come online if inhibited
         */
	if (threads_per_core > 1 && secondaries_inhibited() &&
	    cpu_thread_in_subcore(cpu))
		return -EBUSY;

	if (smp_ops == NULL ||
	    (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu)))
		return -EINVAL;

	cpu_idle_thread_init(cpu, tidle);

	/* Make sure callin-map entry is 0 (can be leftover a CPU
         * hotplug
         */
	cpu_callin_map[cpu] = 0;

	/* The information for processor bringup must
         * be written out to main store before we release
         * the processor.
         */
	smp_mb();

	/* wake up cpus */
	DBG("smp: kicking cpu %d\n", cpu);
	rc = smp_ops->kick_cpu(cpu);
	if (rc) {
		pr_err("smp: failed starting cpu %d (rc %d)\n", cpu, rc);
		return rc;
	}

	/*
         * wait to see if the cpu made a callin (is actually up).
         * use this value that I found through experimentation.
         * -- Cort
         */
	if (system_state < SYSTEM_RUNNING)
		for (c = 50000; c && !cpu_callin_map[cpu]; c--)
			udelay(100);
#ifdef CONFIG_HOTPLUG_CPU
	else
		/*
                 * CPUs can take much longer to come up in the
                 * hotplug case.  Wait five seconds.
                 */
		for (c = 5000; c && !cpu_callin_map[cpu]; c--)
			msleep(1);
#endif

	if (!cpu_callin_map[cpu]) {
		printk(KERN_ERR "Processor %u is stuck.\n", cpu);
		return -ENOENT;
	}

	DBG("Processor %u found.\n", cpu);

	if (smp_ops->give_timebase)
		smp_ops->give_timebase();

	/* Wait until cpu puts itself in the online & active maps */
	while (!cpu_online(cpu))
		cpu_relax();

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
anton blanchard anton blanchard 90 39.30% 4 17.39%
andrew morton andrew morton 42 18.34% 3 13.04%
benjamin herrenschmidt benjamin herrenschmidt 27 11.79% 3 13.04%
paul mackerras paul mackerras 24 10.48% 3 13.04%
michael ellerman michael ellerman 24 10.48% 3 13.04%
thomas gleixner thomas gleixner 8 3.49% 2 8.70%
srivatsa vaddagiri srivatsa vaddagiri 7 3.06% 1 4.35%
zwane mwaikambo zwane mwaikambo 2 0.87% 1 4.35%
gautham r shenoy gautham r shenoy 2 0.87% 1 4.35%
darren hart darren hart 2 0.87% 1 4.35%
jon loeliger jon loeliger 1 0.44% 1 4.35%
Total 229 100.00% 23 100.00%

/* Return the value of the reg property corresponding to the given
 * logical cpu.
 */


int cpu_to_core_id(int cpu)
{
	struct device_node *np;
	const __be32 *reg;
	int id = -1;

	np = of_get_cpu_node(cpu, NULL);
	if (!np)
		goto out;

	reg = of_get_property(np, "reg", NULL);
	if (!reg)
		goto out;

	id = be32_to_cpup(reg);
out:
	of_node_put(np);
	return id;
}
Contributors
Person Tokens Prop Commits CommitProp
nathan t. lynch nathan t. lynch 73 94.81% 1 50.00%
anton blanchard anton blanchard 4 5.19% 1 50.00%
Total 77 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(cpu_to_core_id);

/* Helper routines for cpu to core mapping */


int cpu_core_index_of_thread(int cpu)
{
	return cpu >> threads_shift;
}
Contributors
Person Tokens Prop Commits CommitProp
vaidyanathan srinivasan vaidyanathan srinivasan 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cpu_core_index_of_thread);



int cpu_first_thread_of_core(int core)
{
	return core << threads_shift;
}
Contributors
Person Tokens Prop Commits CommitProp
vaidyanathan srinivasan vaidyanathan srinivasan 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cpu_first_thread_of_core);



static void traverse_siblings_chip_id(int cpu, bool add, int chipid)
{
	const struct cpumask *mask;
	struct device_node *np;
	int i, plen;
	const __be32 *prop;

	mask = add ? cpu_online_mask : cpu_present_mask;
	for_each_cpu(i, mask) {
		np = of_get_cpu_node(i, NULL);
		if (!np)
			continue;
		prop = of_get_property(np, "ibm,chip-id", &plen);
		if (prop && plen == sizeof(int) &&
		    of_read_number(prop, 1) == chipid) {
			if (add) {
				cpumask_set_cpu(cpu, cpu_core_mask(i));
				cpumask_set_cpu(i, cpu_core_mask(cpu));
			} else {
				cpumask_clear_cpu(cpu, cpu_core_mask(i));
				cpumask_clear_cpu(i, cpu_core_mask(cpu));
			}
		}
		of_node_put(np);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
paul mackerras paul mackerras 155 100.00% 1 100.00%
Total 155 100.00% 1 100.00%

/* Must be called when no change can occur to cpu_present_mask,
 * i.e. during cpu online or offline.
 */


static struct device_node *cpu_to_l2cache(int cpu)
{
	struct device_node *np;
	struct device_node *cache;

	if (!cpu_present(cpu))
		return NULL;

	np = of_get_cpu_node(cpu, NULL);
	if (np == NULL)
		return NULL;

	cache = of_find_next_cache_node(np);

	of_node_put(np);

	return cache;
}

Contributors
Person Tokens Prop Commits CommitProp
nathan t. lynch nathan t. lynch 65 100.00% 2 100.00%
Total 65 100.00% 2 100.00%



static void traverse_core_siblings(int cpu, bool add)
{
	struct device_node *l2_cache, *np;
	const struct cpumask *mask;
	int i, chip, plen;
	const __be32 *prop;

	/* First see if we have ibm,chip-id properties in cpu nodes */
	np = of_get_cpu_node(cpu, NULL);
	if (np) {
		chip = -1;
		prop = of_get_property(np, "ibm,chip-id", &plen);
		if (prop && plen == sizeof(int))
			chip = of_read_number(prop, 1);
		of_node_put(np);
		if (chip >= 0) {
			traverse_siblings_chip_id(cpu, add, chip);
			return;
		}
	}

	l2_cache = cpu_to_l2cache(cpu);
	mask = add ? cpu_online_mask : cpu_present_mask;
	for_each_cpu(i, mask) {
		np = cpu_to_l2cache(i);
		if (!np)
			continue;
		if (np == l2_cache) {
			if (add) {
				cpumask_set_cpu(cpu, cpu_core_mask(i));
				cpumask_set_cpu(i, cpu_core_mask(cpu));
			} else {
				cpumask_clear_cpu(cpu, cpu_core_mask(i));
				cpumask_clear_cpu(i, cpu_core_mask(cpu));
			}
		}
		of_node_put(np);
	}
	of_node_put(l2_cache);
}

Contributors
Person Tokens Prop Commits CommitProp
paul mackerras paul mackerras 217 100.00% 2 100.00%
Total 217 100.00% 2 100.00%

/* Activate a secondary processor. */


void start_secondary(void *unused)
{
	unsigned int cpu = smp_processor_id();
	int i, base;

	atomic_inc(&init_mm.mm_count);
	current->active_mm = &init_mm;

	smp_store_cpu_info(cpu);
	set_dec(tb_ticks_per_jiffy);
	preempt_disable();
	cpu_callin_map[cpu] = 1;

	if (smp_ops->setup_cpu)
		smp_ops->setup_cpu(cpu);
	if (smp_ops->take_timebase)
		smp_ops->take_timebase();

	secondary_cpu_time_init();

#ifdef CONFIG_PPC64
	if (system_state == SYSTEM_RUNNING)
		vdso_data->processorCount++;

	vdso_getcpu_init();
#endif
	/* Update sibling maps */
	base = cpu_first_thread_sibling(cpu);
	for (i = 0; i < threads_per_core; i++) {
		if (cpu_is_offline(base + i) && (cpu != base + i))
			continue;
		cpumask_set_cpu(cpu, cpu_sibling_mask(base + i));
		cpumask_set_cpu(base + i, cpu_sibling_mask(cpu));

		/* cpu_core_map should be a superset of
                 * cpu_sibling_map even if we don't have cache
                 * information, so update the former here, too.
                 */
		cpumask_set_cpu(cpu, cpu_core_mask(base + i));
		cpumask_set_cpu(base + i, cpu_core_mask(cpu));
	}
	traverse_core_siblings(cpu, true);

	set_numa_node(numa_cpu_lookup_table[cpu]);
	set_numa_mem(local_memory_node(numa_cpu_lookup_table[cpu]));

	smp_wmb();
	notify_cpu_starting(cpu);
	set_cpu_online(cpu, true);

	local_irq_enable();

	cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);

	BUG();
}

Contributors
Person Tokens Prop Commits CommitProp
nathan t. lynch nathan t. lynch 83 34.02% 2 9.52%
anton blanchard anton blanchard 70 28.69% 4 19.05%
li zhong li zhong 42 17.21% 2 9.52%
benjamin herrenschmidt benjamin herrenschmidt 20 8.20% 2 9.52%
michael ellerman michael ellerman 7 2.87% 1 4.76%
kumar gala kumar gala 6 2.46% 1 4.76%
thomas gleixner thomas gleixner 4 1.64% 2 9.52%
andrew morton andrew morton 3 1.23% 1 4.76%
paul mackerras paul mackerras 3 1.23% 2 9.52%
tony breeds tony breeds 3 1.23% 1 4.76%
oleg nesterov oleg nesterov 1 0.41% 1 4.76%
vaidyanathan srinivasan vaidyanathan srinivasan 1 0.41% 1 4.76%
ingo molnar ingo molnar 1 0.41% 1 4.76%
Total 244 100.00% 21 100.00%



int setup_profiling_timer(unsigned int multiplier)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
anton blanchard anton blanchard 12 100.00% 1 100.00%
Total 12 100.00% 1 100.00%

#ifdef CONFIG_SCHED_SMT
/* cpumask of CPUs with asymetric SMT dependancy */


static int powerpc_smt_flags(void)
{
	int flags = SD_SHARE_CPUCAPACITY | SD_SHARE_PKG_RESOURCES;

	if (cpu_has_feature(CPU_FTR_ASYM_SMT)) {
		printk_once(KERN_INFO "Enabling Asymmetric SMT scheduling\n");
		flags |= SD_ASYM_PACKING;
	}
	return flags;
}
Contributors
Person Tokens Prop Commits CommitProp
vincent guittot vincent guittot 36 97.30% 1 50.00%
nicolas pitre nicolas pitre 1 2.70% 1 50.00%
Total 37 100.00% 2 100.00%

#endif


static struct sched_domain_topology_level powerpc_topology[] = {
#ifdef CONFIG_SCHED_SMT
	{ cpu_smt_mask, powerpc_smt_flags, SD_INIT_NAME(SMT) },
#endif
	{ cpu_cpu_mask, SD_INIT_NAME(DIE) },
	{ NULL, },
};



void __init smp_cpus_done(unsigned int max_cpus)
{
	cpumask_var_t old_mask;

	/* We want the setup_cpu() here to be called from CPU 0, but our
         * init thread may have been "borrowed" by another CPU in the meantime
         * se we pin us down to CPU 0 for a short while
         */
	alloc_cpumask_var(&old_mask, GFP_NOWAIT);
	cpumask_copy(old_mask, tsk_cpus_allowed(current));
	set_cpus_allowed_ptr(current, cpumask_of(boot_cpuid));
	
	if (smp_ops && smp_ops->setup_cpu)
		smp_ops->setup_cpu(boot_cpuid);

	set_cpus_allowed_ptr(current, old_mask);

	free_cpumask_var(old_mask);

	if (smp_ops && smp_ops->bringup_done)
		smp_ops->bringup_done();

	dump_numa_cpu_topology();

	set_sched_topology(powerpc_topology);

}

Contributors
Person Tokens Prop Commits CommitProp
anton blanchard anton blanchard 37 41.11% 5 38.46%
andrew morton andrew morton 20 22.22% 1 7.69%
benjamin herrenschmidt benjamin herrenschmidt 17 18.89% 2 15.38%
kumar gala kumar gala 4 4.44% 1 7.69%
michael neuling michael neuling 4 4.44% 1 7.69%
kosaki motohiro kosaki motohiro 3 3.33% 1 7.69%
julia lawall julia lawall 3 3.33% 1 7.69%
vincent guittot vincent guittot 2 2.22% 1 7.69%
Total 90 100.00% 13 100.00%

#ifdef CONFIG_HOTPLUG_CPU


int __cpu_disable(void)
{
	int cpu = smp_processor_id();
	int base, i;
	int err;

	if (!smp_ops->cpu_disable)
		return -ENOSYS;

	err = smp_ops->cpu_disable();
	if (err)
		return err;

	/* Update sibling maps */
	base = cpu_first_thread_sibling(cpu);
	for (i = 0; i < threads_per_core && base + i < nr_cpu_ids; i++) {
		cpumask_clear_cpu(cpu, cpu_sibling_mask(base + i));
		cpumask_clear_cpu(base + i, cpu_sibling_mask(cpu));
		cpumask_clear_cpu(cpu, cpu_core_mask(base + i));
		cpumask_clear_cpu(base + i, cpu_core_mask(cpu));
	}
	traverse_core_siblings(cpu, false);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
nathan t. lynch nathan t. lynch 95 71.43% 2 28.57%
zwane mwaikambo zwane mwaikambo 21 15.79% 1 14.29%
anton blanchard anton blanchard 8 6.02% 1 14.29%
boqun feng boqun feng 6 4.51% 1 14.29%
paul mackerras paul mackerras 2 1.50% 1 14.29%
vaidyanathan srinivasan vaidyanathan srinivasan 1 0.75% 1 14.29%
Total 133 100.00% 7 100.00%



void __cpu_die(unsigned int cpu)
{
	if (smp_ops->cpu_die)
		smp_ops->cpu_die(cpu);
}

Contributors
Person Tokens Prop Commits CommitProp
zwane mwaikambo zwane mwaikambo 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



void cpu_die(void)
{
	if (ppc_md.cpu_die)
		ppc_md.cpu_die();

	/* If we return, we re-enter start_secondary */
	start_secondary_resume();
}

Contributors
Person Tokens Prop Commits CommitProp
milton d. miller milton d. miller 18 81.82% 1 50.00%
benjamin herrenschmidt benjamin herrenschmidt 4 18.18% 1 50.00%
Total 22 100.00% 2 100.00%

#endif
Overall Contributors
Person Tokens Prop Commits CommitProp
paul mackerras paul mackerras 496 15.93% 11 8.15%
milton d. miller milton d. miller 490 15.74% 7 5.19%
anton blanchard anton blanchard 456 14.64% 21 15.56%
nathan t. lynch nathan t. lynch 331 10.63% 4 2.96%
benjamin herrenschmidt benjamin herrenschmidt 281 9.02% 13 9.63%
andrew morton andrew morton 157 5.04% 9 6.67%
zwane mwaikambo zwane mwaikambo 143 4.59% 2 1.48%
jens axboe jens axboe 91 2.92% 1 0.74%
vincent guittot vincent guittot 81 2.60% 1 0.74%
michael ellerman michael ellerman 63 2.02% 7 5.19%
suresh e. warrier suresh e. warrier 62 1.99% 3 2.22%
srivatsa s. bhat srivatsa s. bhat 57 1.83% 2 1.48%
andy fleming andy fleming 56 1.80% 1 0.74%
li zhong li zhong 51 1.64% 2 1.48%
chen-hui zhao chen-hui zhao 42 1.35% 3 2.22%
vaidyanathan srinivasan vaidyanathan srinivasan 39 1.25% 1 0.74%
nishanth aravamudan nishanth aravamudan 32 1.03% 2 1.48%
becky bruce becky bruce 23 0.74% 1 0.74%
thomas gleixner thomas gleixner 23 0.74% 5 3.70%
kumar gala kumar gala 14 0.45% 1 0.74%
olof johansson olof johansson 11 0.35% 1 0.74%
valentine barshak valentine barshak 9 0.29% 1 0.74%
rusty russell rusty russell 8 0.26% 2 1.48%
satyam sharma satyam sharma 8 0.26% 1 0.74%
srivatsa vaddagiri srivatsa vaddagiri 7 0.22% 1 0.74%
mike travis mike travis 6 0.19% 1 0.74%
boqun feng boqun feng 6 0.19% 1 0.74%
daniel axtens daniel axtens 6 0.19% 2 1.48%
mauricio faria de oliveira mauricio faria de oliveira 5 0.16% 1 0.74%
michael neuling michael neuling 4 0.13% 1 0.74%
kosaki motohiro kosaki motohiro 4 0.13% 1 0.74%
avi kivity avi kivity 4 0.13% 1 0.74%
christian krafft christian krafft 4 0.13% 1 0.74%
will schmidt will schmidt 4 0.13% 1 0.74%
julia lawall julia lawall 3 0.10% 1 0.74%
al viro al viro 3 0.10% 1 0.74%
tony breeds tony breeds 3 0.10% 1 0.74%
kevin hao kevin hao 3 0.10% 1 0.74%
david howells david howells 3 0.10% 1 0.74%
thiago jung bauermann thiago jung bauermann 3 0.10% 1 0.74%
peter zijlstra peter zijlstra 3 0.10% 1 0.74%
gautham r shenoy gautham r shenoy 2 0.06% 1 0.74%
christoph lameter christoph lameter 2 0.06% 1 0.74%
arnaldo carvalho de melo arnaldo carvalho de melo 2 0.06% 1 0.74%
darren hart darren hart 2 0.06% 1 0.74%
david gibson david gibson 1 0.03% 1 0.74%
oleg nesterov oleg nesterov 1 0.03% 1 0.74%
arun sharma arun sharma 1 0.03% 1 0.74%
nicolas pitre nicolas pitre 1 0.03% 1 0.74%
ingo molnar ingo molnar 1 0.03% 1 0.74%
paul gortmaker paul gortmaker 1 0.03% 1 0.74%
jon loeliger jon loeliger 1 0.03% 1 0.74%
chen gang chen gang 1 0.03% 1 0.74%
kay sievers kay sievers 1 0.03% 1 0.74%
matthew dobson matthew dobson 1 0.03% 1 0.74%
tejun heo tejun heo 1 0.03% 1 0.74%
Total 3114 100.00% 135 100.00%
Directory: arch/powerpc/kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
andy fleming	andy fleming	55	100.00%	1	100.00%
	Total	55	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 arch/powerpc/kernel/smp.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
