2007-07-18 09:37:06 +08:00
|
|
|
/*
|
|
|
|
* Xen SMP support
|
|
|
|
*
|
|
|
|
* This file implements the Xen versions of smp_ops. SMP under Xen is
|
|
|
|
* very straightforward. Bringing a CPU up is simply a matter of
|
|
|
|
* loading its initial context and setting it running.
|
|
|
|
*
|
|
|
|
* IPIs are handled through the Xen event mechanism.
|
|
|
|
*
|
|
|
|
* Because virtual CPUs can be scheduled onto any real CPU, there's no
|
|
|
|
* useful topology information for the kernel to make use of. As a
|
|
|
|
* result, all CPUs are treated as if they're single-core and
|
|
|
|
* single-threaded.
|
|
|
|
*/
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/err.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-07-18 09:37:06 +08:00
|
|
|
#include <linux/smp.h>
|
2012-04-21 00:11:05 +08:00
|
|
|
#include <linux/irq_work.h>
|
2013-06-03 22:33:55 +08:00
|
|
|
#include <linux/tick.h>
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
#include <asm/paravirt.h>
|
|
|
|
#include <asm/desc.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/cpu.h>
|
|
|
|
|
|
|
|
#include <xen/interface/xen.h>
|
|
|
|
#include <xen/interface/vcpu.h>
|
2015-08-11 04:34:34 +08:00
|
|
|
#include <xen/interface/xenpmu.h>
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
#include <asm/xen/interface.h>
|
|
|
|
#include <asm/xen/hypercall.h>
|
|
|
|
|
2010-10-27 00:28:33 +08:00
|
|
|
#include <xen/xen.h>
|
2007-07-18 09:37:06 +08:00
|
|
|
#include <xen/page.h>
|
|
|
|
#include <xen/events.h>
|
|
|
|
|
2011-09-01 21:48:27 +08:00
|
|
|
#include <xen/hvc-console.h>
|
2007-07-18 09:37:06 +08:00
|
|
|
#include "xen-ops.h"
|
|
|
|
#include "mmu.h"
|
2014-09-11 07:36:06 +08:00
|
|
|
#include "smp.h"
|
2015-08-11 04:34:34 +08:00
|
|
|
#include "pmu.h"
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2008-12-17 09:33:57 +08:00
|
|
|
cpumask_var_t xen_cpu_initialized_map;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2013-06-05 04:37:44 +08:00
|
|
|
struct xen_common_irq {
|
|
|
|
int irq;
|
|
|
|
char *name;
|
|
|
|
};
|
2013-06-05 04:42:29 +08:00
|
|
|
static DEFINE_PER_CPU(struct xen_common_irq, xen_resched_irq) = { .irq = -1 };
|
|
|
|
static DEFINE_PER_CPU(struct xen_common_irq, xen_callfunc_irq) = { .irq = -1 };
|
|
|
|
static DEFINE_PER_CPU(struct xen_common_irq, xen_callfuncsingle_irq) = { .irq = -1 };
|
|
|
|
static DEFINE_PER_CPU(struct xen_common_irq, xen_irq_work) = { .irq = -1 };
|
2013-06-05 04:37:44 +08:00
|
|
|
static DEFINE_PER_CPU(struct xen_common_irq, xen_debug_irq) = { .irq = -1 };
|
2015-08-11 04:34:34 +08:00
|
|
|
static DEFINE_PER_CPU(struct xen_common_irq, xen_pmu_irq) = { .irq = -1 };
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
|
2008-06-26 17:21:54 +08:00
|
|
|
static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
|
2012-04-21 00:11:05 +08:00
|
|
|
static irqreturn_t xen_irq_work_interrupt(int irq, void *dev_id);
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
/*
|
2011-04-05 23:23:39 +08:00
|
|
|
* Reschedule call back.
|
2007-07-18 09:37:06 +08:00
|
|
|
*/
|
|
|
|
static irqreturn_t xen_reschedule_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
2009-01-18 23:38:57 +08:00
|
|
|
inc_irq_stat(irq_resched_count);
|
2011-04-05 23:23:39 +08:00
|
|
|
scheduler_ipi();
|
2008-05-27 06:31:16 +08:00
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
x86: delete __cpuinit usage from all x86 files
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/x86 uses of the __cpuinit macros from
all C files. x86 only had the one __CPUINIT used in assembly files,
and it wasn't paired off with a .previous or a __FINIT, so we can
delete it directly w/o any corresponding additional change there.
[1] https://lkml.org/lkml/2013/5/20/589
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: x86@kernel.org
Acked-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: H. Peter Anvin <hpa@linux.intel.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-19 06:23:59 +08:00
|
|
|
static void cpu_bringup(void)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
2012-03-22 20:59:24 +08:00
|
|
|
int cpu;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
cpu_init();
|
2008-08-22 18:52:15 +08:00
|
|
|
touch_softlockup_watchdog();
|
2008-07-09 06:06:43 +08:00
|
|
|
preempt_disable();
|
|
|
|
|
2013-12-14 00:48:08 +08:00
|
|
|
/* PVH runs in ring 0 and allows us to do native syscalls. Yay! */
|
|
|
|
if (!xen_feature(XENFEAT_supervisor_mode_kernel)) {
|
|
|
|
xen_enable_sysenter();
|
|
|
|
xen_enable_syscall();
|
|
|
|
}
|
2008-07-09 06:06:43 +08:00
|
|
|
cpu = smp_processor_id();
|
|
|
|
smp_store_cpu_info(cpu);
|
|
|
|
cpu_data(cpu).x86_max_cores = 1;
|
|
|
|
set_cpu_sibling_map(cpu);
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2016-10-06 01:09:33 +08:00
|
|
|
/*
|
|
|
|
* identify_cpu() may have set logical_pkg_id to -1 due
|
|
|
|
* to incorrect phys_proc_id. Let's re-comupte it.
|
|
|
|
*/
|
|
|
|
topology_update_package_map(apic->cpu_present_to_apicid(cpu), cpu);
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
xen_setup_cpu_clockevents();
|
|
|
|
|
2012-03-22 01:03:45 +08:00
|
|
|
notify_cpu_starting(cpu);
|
|
|
|
|
2009-11-03 12:28:38 +08:00
|
|
|
set_cpu_online(cpu, true);
|
2012-03-22 01:03:45 +08:00
|
|
|
|
2015-02-26 03:42:15 +08:00
|
|
|
cpu_set_state_online(cpu); /* Implies full memory barrier. */
|
2008-07-09 06:06:43 +08:00
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
/* We can take interrupts now: we're officially "up". */
|
|
|
|
local_irq_enable();
|
2008-08-22 18:52:15 +08:00
|
|
|
}
|
|
|
|
|
2014-09-11 07:36:06 +08:00
|
|
|
/*
|
|
|
|
* Note: cpu parameter is only relevant for PVH. The reason for passing it
|
|
|
|
* is we can't do smp_processor_id until the percpu segments are loaded, for
|
|
|
|
* which we need the cpu number! So we pass it in rdi as first parameter.
|
|
|
|
*/
|
|
|
|
asmlinkage __visible void cpu_bringup_and_idle(int cpu)
|
2008-08-22 18:52:15 +08:00
|
|
|
{
|
2014-09-11 07:36:06 +08:00
|
|
|
#ifdef CONFIG_XEN_PVH
|
2013-12-14 00:48:08 +08:00
|
|
|
if (xen_feature(XENFEAT_auto_translated_physmap) &&
|
|
|
|
xen_feature(XENFEAT_supervisor_mode_kernel))
|
2014-01-20 22:20:07 +08:00
|
|
|
xen_pvh_secondary_vcpu_init(cpu);
|
2013-12-14 00:48:08 +08:00
|
|
|
#endif
|
2008-08-22 18:52:15 +08:00
|
|
|
cpu_bringup();
|
2016-02-27 02:43:40 +08:00
|
|
|
cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
|
|
|
|
2016-08-04 01:22:27 +08:00
|
|
|
void xen_smp_intr_free(unsigned int cpu)
|
2013-06-05 04:31:34 +08:00
|
|
|
{
|
2013-06-05 04:42:29 +08:00
|
|
|
if (per_cpu(xen_resched_irq, cpu).irq >= 0) {
|
2013-06-05 04:37:44 +08:00
|
|
|
unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu).irq, NULL);
|
2013-06-05 04:42:29 +08:00
|
|
|
per_cpu(xen_resched_irq, cpu).irq = -1;
|
2013-06-05 04:47:17 +08:00
|
|
|
kfree(per_cpu(xen_resched_irq, cpu).name);
|
|
|
|
per_cpu(xen_resched_irq, cpu).name = NULL;
|
2013-06-05 04:42:29 +08:00
|
|
|
}
|
|
|
|
if (per_cpu(xen_callfunc_irq, cpu).irq >= 0) {
|
2013-06-05 04:37:44 +08:00
|
|
|
unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu).irq, NULL);
|
2013-06-05 04:42:29 +08:00
|
|
|
per_cpu(xen_callfunc_irq, cpu).irq = -1;
|
2013-06-05 04:47:17 +08:00
|
|
|
kfree(per_cpu(xen_callfunc_irq, cpu).name);
|
|
|
|
per_cpu(xen_callfunc_irq, cpu).name = NULL;
|
2013-06-05 04:42:29 +08:00
|
|
|
}
|
|
|
|
if (per_cpu(xen_debug_irq, cpu).irq >= 0) {
|
2013-06-05 04:37:44 +08:00
|
|
|
unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu).irq, NULL);
|
2013-06-05 04:42:29 +08:00
|
|
|
per_cpu(xen_debug_irq, cpu).irq = -1;
|
2013-06-05 04:47:17 +08:00
|
|
|
kfree(per_cpu(xen_debug_irq, cpu).name);
|
|
|
|
per_cpu(xen_debug_irq, cpu).name = NULL;
|
2013-06-05 04:42:29 +08:00
|
|
|
}
|
|
|
|
if (per_cpu(xen_callfuncsingle_irq, cpu).irq >= 0) {
|
2013-06-05 04:37:44 +08:00
|
|
|
unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu).irq,
|
2013-06-05 04:31:34 +08:00
|
|
|
NULL);
|
2013-06-05 04:42:29 +08:00
|
|
|
per_cpu(xen_callfuncsingle_irq, cpu).irq = -1;
|
2013-06-05 04:47:17 +08:00
|
|
|
kfree(per_cpu(xen_callfuncsingle_irq, cpu).name);
|
|
|
|
per_cpu(xen_callfuncsingle_irq, cpu).name = NULL;
|
2013-06-05 04:42:29 +08:00
|
|
|
}
|
2013-06-05 04:31:34 +08:00
|
|
|
if (xen_hvm_domain())
|
|
|
|
return;
|
|
|
|
|
2013-06-05 04:42:29 +08:00
|
|
|
if (per_cpu(xen_irq_work, cpu).irq >= 0) {
|
2013-06-05 04:37:44 +08:00
|
|
|
unbind_from_irqhandler(per_cpu(xen_irq_work, cpu).irq, NULL);
|
2013-06-05 04:42:29 +08:00
|
|
|
per_cpu(xen_irq_work, cpu).irq = -1;
|
2013-06-05 04:47:17 +08:00
|
|
|
kfree(per_cpu(xen_irq_work, cpu).name);
|
|
|
|
per_cpu(xen_irq_work, cpu).name = NULL;
|
2013-06-05 04:42:29 +08:00
|
|
|
}
|
2015-08-11 04:34:34 +08:00
|
|
|
|
|
|
|
if (per_cpu(xen_pmu_irq, cpu).irq >= 0) {
|
|
|
|
unbind_from_irqhandler(per_cpu(xen_pmu_irq, cpu).irq, NULL);
|
|
|
|
per_cpu(xen_pmu_irq, cpu).irq = -1;
|
|
|
|
kfree(per_cpu(xen_pmu_irq, cpu).name);
|
|
|
|
per_cpu(xen_pmu_irq, cpu).name = NULL;
|
|
|
|
}
|
2013-06-05 04:31:34 +08:00
|
|
|
};
|
2016-08-04 01:22:27 +08:00
|
|
|
int xen_smp_intr_init(unsigned int cpu)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
int rc;
|
2015-08-11 04:34:34 +08:00
|
|
|
char *resched_name, *callfunc_name, *debug_name, *pmu_name;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
resched_name = kasprintf(GFP_KERNEL, "resched%d", cpu);
|
|
|
|
rc = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR,
|
|
|
|
cpu,
|
|
|
|
xen_reschedule_interrupt,
|
2013-09-07 14:46:49 +08:00
|
|
|
IRQF_PERCPU|IRQF_NOBALANCING,
|
2007-07-18 09:37:06 +08:00
|
|
|
resched_name,
|
|
|
|
NULL);
|
|
|
|
if (rc < 0)
|
|
|
|
goto fail;
|
2013-06-05 04:37:44 +08:00
|
|
|
per_cpu(xen_resched_irq, cpu).irq = rc;
|
2013-06-05 04:47:17 +08:00
|
|
|
per_cpu(xen_resched_irq, cpu).name = resched_name;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
callfunc_name = kasprintf(GFP_KERNEL, "callfunc%d", cpu);
|
|
|
|
rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_VECTOR,
|
|
|
|
cpu,
|
|
|
|
xen_call_function_interrupt,
|
2013-09-07 14:46:49 +08:00
|
|
|
IRQF_PERCPU|IRQF_NOBALANCING,
|
2007-07-18 09:37:06 +08:00
|
|
|
callfunc_name,
|
|
|
|
NULL);
|
|
|
|
if (rc < 0)
|
|
|
|
goto fail;
|
2013-06-05 04:37:44 +08:00
|
|
|
per_cpu(xen_callfunc_irq, cpu).irq = rc;
|
2013-06-05 04:47:17 +08:00
|
|
|
per_cpu(xen_callfunc_irq, cpu).name = callfunc_name;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2008-03-18 07:37:18 +08:00
|
|
|
debug_name = kasprintf(GFP_KERNEL, "debug%d", cpu);
|
|
|
|
rc = bind_virq_to_irqhandler(VIRQ_DEBUG, cpu, xen_debug_interrupt,
|
2013-09-07 14:46:49 +08:00
|
|
|
IRQF_PERCPU | IRQF_NOBALANCING,
|
2008-03-18 07:37:18 +08:00
|
|
|
debug_name, NULL);
|
|
|
|
if (rc < 0)
|
|
|
|
goto fail;
|
2013-06-05 04:37:44 +08:00
|
|
|
per_cpu(xen_debug_irq, cpu).irq = rc;
|
2013-06-05 04:47:17 +08:00
|
|
|
per_cpu(xen_debug_irq, cpu).name = debug_name;
|
2008-03-18 07:37:18 +08:00
|
|
|
|
2008-06-26 17:21:54 +08:00
|
|
|
callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);
|
|
|
|
rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_SINGLE_VECTOR,
|
|
|
|
cpu,
|
|
|
|
xen_call_function_single_interrupt,
|
2013-09-07 14:46:49 +08:00
|
|
|
IRQF_PERCPU|IRQF_NOBALANCING,
|
2008-06-26 17:21:54 +08:00
|
|
|
callfunc_name,
|
|
|
|
NULL);
|
|
|
|
if (rc < 0)
|
|
|
|
goto fail;
|
2013-06-05 04:37:44 +08:00
|
|
|
per_cpu(xen_callfuncsingle_irq, cpu).irq = rc;
|
2013-06-05 04:47:17 +08:00
|
|
|
per_cpu(xen_callfuncsingle_irq, cpu).name = callfunc_name;
|
2008-06-26 17:21:54 +08:00
|
|
|
|
2013-04-17 02:37:04 +08:00
|
|
|
/*
|
|
|
|
* The IRQ worker on PVHVM goes through the native path and uses the
|
|
|
|
* IPI mechanism.
|
|
|
|
*/
|
|
|
|
if (xen_hvm_domain())
|
|
|
|
return 0;
|
|
|
|
|
2012-04-21 00:11:05 +08:00
|
|
|
callfunc_name = kasprintf(GFP_KERNEL, "irqwork%d", cpu);
|
|
|
|
rc = bind_ipi_to_irqhandler(XEN_IRQ_WORK_VECTOR,
|
|
|
|
cpu,
|
|
|
|
xen_irq_work_interrupt,
|
2013-09-07 14:46:49 +08:00
|
|
|
IRQF_PERCPU|IRQF_NOBALANCING,
|
2012-04-21 00:11:05 +08:00
|
|
|
callfunc_name,
|
|
|
|
NULL);
|
|
|
|
if (rc < 0)
|
|
|
|
goto fail;
|
2013-06-05 04:37:44 +08:00
|
|
|
per_cpu(xen_irq_work, cpu).irq = rc;
|
2013-06-05 04:47:17 +08:00
|
|
|
per_cpu(xen_irq_work, cpu).name = callfunc_name;
|
2012-04-21 00:11:05 +08:00
|
|
|
|
2015-08-11 04:34:34 +08:00
|
|
|
if (is_xen_pmu(cpu)) {
|
|
|
|
pmu_name = kasprintf(GFP_KERNEL, "pmu%d", cpu);
|
|
|
|
rc = bind_virq_to_irqhandler(VIRQ_XENPMU, cpu,
|
|
|
|
xen_pmu_irq_handler,
|
|
|
|
IRQF_PERCPU|IRQF_NOBALANCING,
|
|
|
|
pmu_name, NULL);
|
|
|
|
if (rc < 0)
|
|
|
|
goto fail;
|
|
|
|
per_cpu(xen_pmu_irq, cpu).irq = rc;
|
|
|
|
per_cpu(xen_pmu_irq, cpu).name = pmu_name;
|
|
|
|
}
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2013-06-05 04:31:34 +08:00
|
|
|
xen_smp_intr_free(cpu);
|
2007-07-18 09:37:06 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-07-09 06:06:43 +08:00
|
|
|
static void __init xen_fill_possible_map(void)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
int i, rc;
|
|
|
|
|
2010-10-27 00:28:33 +08:00
|
|
|
if (xen_initial_domain())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_cpu_ids; i++) {
|
|
|
|
rc = HYPERVISOR_vcpu_op(VCPUOP_is_up, i, NULL);
|
|
|
|
if (rc >= 0) {
|
|
|
|
num_processors++;
|
|
|
|
set_cpu_possible(i, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init xen_filter_cpu_maps(void)
|
|
|
|
{
|
|
|
|
int i, rc;
|
xen/smp: Fix crash when booting with ACPI hotplug CPUs.
When we boot on a machine that can hotplug CPUs and we
are using 'dom0_max_vcpus=X' on the Xen hypervisor line
to clip the amount of CPUs available to the initial domain,
we get this:
(XEN) Command line: com1=115200,8n1 dom0_mem=8G noreboot dom0_max_vcpus=8 sync_console mce_verbosity=verbose console=com1,vga loglvl=all guest_loglvl=all
.. snip..
DMI: Intel Corporation S2600CP/S2600CP, BIOS SE5C600.86B.99.99.x032.072520111118 07/25/2011
.. snip.
SMP: Allowing 64 CPUs, 32 hotplug CPUs
installing Xen timer for CPU 7
cpu 7 spinlock event irq 361
NMI watchdog: disabled (cpu7): hardware events not enabled
Brought up 8 CPUs
.. snip..
[acpi processor finds the CPUs are not initialized and starts calling
arch_register_cpu, which creates /sys/devices/system/cpu/cpu8/online]
CPU 8 got hotplugged
CPU 9 got hotplugged
CPU 10 got hotplugged
.. snip..
initcall 1_acpi_battery_init_async+0x0/0x1b returned 0 after 406 usecs
calling erst_init+0x0/0x2bb @ 1
[and the scheduler sticks newly started tasks on the new CPUs, but
said CPUs cannot be initialized b/c the hypervisor has limited the
amount of vCPUS to 8 - as per the dom0_max_vcpus=8 flag.
The spinlock tries to kick the other CPU, but the structure for that
is not initialized and we crash.]
BUG: unable to handle kernel paging request at fffffffffffffed8
IP: [<ffffffff81035289>] xen_spin_lock+0x29/0x60
PGD 180d067 PUD 180e067 PMD 0
Oops: 0002 [#1] SMP
CPU 7
Modules linked in:
Pid: 1, comm: swapper/0 Not tainted 3.4.0-rc2upstream-00001-gf5154e8 #1 Intel Corporation S2600CP/S2600CP
RIP: e030:[<ffffffff81035289>] [<ffffffff81035289>] xen_spin_lock+0x29/0x60
RSP: e02b:ffff8801fb9b3a70 EFLAGS: 00010282
With this patch, we cap the amount of vCPUS that the initial domain
can run, to exactly what dom0_max_vcpus=X has specified.
In the future, if there is a hypercall that will allow a running
domain to expand past its initial set of vCPUS, this patch should
be re-evaluated.
CC: stable@kernel.org
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
2012-04-27 01:50:03 +08:00
|
|
|
unsigned int subtract = 0;
|
2010-10-27 00:28:33 +08:00
|
|
|
|
|
|
|
if (!xen_initial_domain())
|
|
|
|
return;
|
|
|
|
|
2010-09-23 19:06:25 +08:00
|
|
|
num_processors = 0;
|
|
|
|
disabled_cpus = 0;
|
2008-12-17 09:33:52 +08:00
|
|
|
for (i = 0; i < nr_cpu_ids; i++) {
|
2007-07-18 09:37:06 +08:00
|
|
|
rc = HYPERVISOR_vcpu_op(VCPUOP_is_up, i, NULL);
|
2008-07-09 06:06:56 +08:00
|
|
|
if (rc >= 0) {
|
|
|
|
num_processors++;
|
2009-03-13 12:19:54 +08:00
|
|
|
set_cpu_possible(i, true);
|
2010-09-23 19:06:25 +08:00
|
|
|
} else {
|
|
|
|
set_cpu_possible(i, false);
|
|
|
|
set_cpu_present(i, false);
|
xen/smp: Fix crash when booting with ACPI hotplug CPUs.
When we boot on a machine that can hotplug CPUs and we
are using 'dom0_max_vcpus=X' on the Xen hypervisor line
to clip the amount of CPUs available to the initial domain,
we get this:
(XEN) Command line: com1=115200,8n1 dom0_mem=8G noreboot dom0_max_vcpus=8 sync_console mce_verbosity=verbose console=com1,vga loglvl=all guest_loglvl=all
.. snip..
DMI: Intel Corporation S2600CP/S2600CP, BIOS SE5C600.86B.99.99.x032.072520111118 07/25/2011
.. snip.
SMP: Allowing 64 CPUs, 32 hotplug CPUs
installing Xen timer for CPU 7
cpu 7 spinlock event irq 361
NMI watchdog: disabled (cpu7): hardware events not enabled
Brought up 8 CPUs
.. snip..
[acpi processor finds the CPUs are not initialized and starts calling
arch_register_cpu, which creates /sys/devices/system/cpu/cpu8/online]
CPU 8 got hotplugged
CPU 9 got hotplugged
CPU 10 got hotplugged
.. snip..
initcall 1_acpi_battery_init_async+0x0/0x1b returned 0 after 406 usecs
calling erst_init+0x0/0x2bb @ 1
[and the scheduler sticks newly started tasks on the new CPUs, but
said CPUs cannot be initialized b/c the hypervisor has limited the
amount of vCPUS to 8 - as per the dom0_max_vcpus=8 flag.
The spinlock tries to kick the other CPU, but the structure for that
is not initialized and we crash.]
BUG: unable to handle kernel paging request at fffffffffffffed8
IP: [<ffffffff81035289>] xen_spin_lock+0x29/0x60
PGD 180d067 PUD 180e067 PMD 0
Oops: 0002 [#1] SMP
CPU 7
Modules linked in:
Pid: 1, comm: swapper/0 Not tainted 3.4.0-rc2upstream-00001-gf5154e8 #1 Intel Corporation S2600CP/S2600CP
RIP: e030:[<ffffffff81035289>] [<ffffffff81035289>] xen_spin_lock+0x29/0x60
RSP: e02b:ffff8801fb9b3a70 EFLAGS: 00010282
With this patch, we cap the amount of vCPUS that the initial domain
can run, to exactly what dom0_max_vcpus=X has specified.
In the future, if there is a hypercall that will allow a running
domain to expand past its initial set of vCPUS, this patch should
be re-evaluated.
CC: stable@kernel.org
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
2012-04-27 01:50:03 +08:00
|
|
|
subtract++;
|
2008-07-09 06:06:56 +08:00
|
|
|
}
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
xen/smp: Fix crash when booting with ACPI hotplug CPUs.
When we boot on a machine that can hotplug CPUs and we
are using 'dom0_max_vcpus=X' on the Xen hypervisor line
to clip the amount of CPUs available to the initial domain,
we get this:
(XEN) Command line: com1=115200,8n1 dom0_mem=8G noreboot dom0_max_vcpus=8 sync_console mce_verbosity=verbose console=com1,vga loglvl=all guest_loglvl=all
.. snip..
DMI: Intel Corporation S2600CP/S2600CP, BIOS SE5C600.86B.99.99.x032.072520111118 07/25/2011
.. snip.
SMP: Allowing 64 CPUs, 32 hotplug CPUs
installing Xen timer for CPU 7
cpu 7 spinlock event irq 361
NMI watchdog: disabled (cpu7): hardware events not enabled
Brought up 8 CPUs
.. snip..
[acpi processor finds the CPUs are not initialized and starts calling
arch_register_cpu, which creates /sys/devices/system/cpu/cpu8/online]
CPU 8 got hotplugged
CPU 9 got hotplugged
CPU 10 got hotplugged
.. snip..
initcall 1_acpi_battery_init_async+0x0/0x1b returned 0 after 406 usecs
calling erst_init+0x0/0x2bb @ 1
[and the scheduler sticks newly started tasks on the new CPUs, but
said CPUs cannot be initialized b/c the hypervisor has limited the
amount of vCPUS to 8 - as per the dom0_max_vcpus=8 flag.
The spinlock tries to kick the other CPU, but the structure for that
is not initialized and we crash.]
BUG: unable to handle kernel paging request at fffffffffffffed8
IP: [<ffffffff81035289>] xen_spin_lock+0x29/0x60
PGD 180d067 PUD 180e067 PMD 0
Oops: 0002 [#1] SMP
CPU 7
Modules linked in:
Pid: 1, comm: swapper/0 Not tainted 3.4.0-rc2upstream-00001-gf5154e8 #1 Intel Corporation S2600CP/S2600CP
RIP: e030:[<ffffffff81035289>] [<ffffffff81035289>] xen_spin_lock+0x29/0x60
RSP: e02b:ffff8801fb9b3a70 EFLAGS: 00010282
With this patch, we cap the amount of vCPUS that the initial domain
can run, to exactly what dom0_max_vcpus=X has specified.
In the future, if there is a hypercall that will allow a running
domain to expand past its initial set of vCPUS, this patch should
be re-evaluated.
CC: stable@kernel.org
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
2012-04-27 01:50:03 +08:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
/* This is akin to using 'nr_cpus' on the Linux command line.
|
|
|
|
* Which is OK as when we use 'dom0_max_vcpus=X' we can only
|
|
|
|
* have up to X, while nr_cpu_ids is greater than X. This
|
|
|
|
* normally is not a problem, except when CPU hotplugging
|
|
|
|
* is involved and then there might be more than X CPUs
|
|
|
|
* in the guest - which will not work as there is no
|
|
|
|
* hypercall to expand the max number of VCPUs an already
|
|
|
|
* running guest has. So cap it up to X. */
|
|
|
|
if (subtract)
|
|
|
|
nr_cpu_ids = nr_cpu_ids - subtract;
|
|
|
|
#endif
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
|
|
|
|
2008-07-09 06:06:41 +08:00
|
|
|
static void __init xen_smp_prepare_boot_cpu(void)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
BUG_ON(smp_processor_id() != 0);
|
|
|
|
native_smp_prepare_boot_cpu();
|
|
|
|
|
2013-08-17 02:39:56 +08:00
|
|
|
if (xen_pv_domain()) {
|
2013-12-14 00:48:08 +08:00
|
|
|
if (!xen_feature(XENFEAT_writable_page_tables))
|
|
|
|
/* We've switched to the "real" per-cpu gdt, so make
|
|
|
|
* sure the old memory can be recycled. */
|
|
|
|
make_lowmem_page_readwrite(xen_initial_gdt);
|
2007-07-18 09:37:07 +08:00
|
|
|
|
2013-10-10 22:39:37 +08:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
/*
|
|
|
|
* Xen starts us with XEN_FLAT_RING1_DS, but linux code
|
|
|
|
* expects __USER_DS
|
|
|
|
*/
|
|
|
|
loadsegment(ds, __USER_DS);
|
|
|
|
loadsegment(es, __USER_DS);
|
|
|
|
#endif
|
|
|
|
|
2013-08-17 02:39:56 +08:00
|
|
|
xen_filter_cpu_maps();
|
|
|
|
xen_setup_vcpu_info_placement();
|
|
|
|
}
|
2016-06-30 23:56:43 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup vcpu_info for boot CPU.
|
|
|
|
*/
|
|
|
|
if (xen_hvm_domain())
|
|
|
|
xen_vcpu_setup(0);
|
|
|
|
|
2013-08-17 02:39:56 +08:00
|
|
|
/*
|
|
|
|
* The alternative logic (which patches the unlock/lock) runs before
|
|
|
|
* the smp bootup up code is activated. Hence we need to set this up
|
|
|
|
* the core kernel is being patched. Otherwise we will have only
|
|
|
|
* modules patched but not core code.
|
|
|
|
*/
|
2013-08-09 22:21:52 +08:00
|
|
|
xen_init_spinlocks();
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
|
|
|
|
2008-07-09 06:06:41 +08:00
|
|
|
static void __init xen_smp_prepare_cpus(unsigned int max_cpus)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
unsigned cpu;
|
2009-12-18 17:31:31 +08:00
|
|
|
unsigned int i;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2011-09-01 21:48:27 +08:00
|
|
|
if (skip_ioapic_setup) {
|
|
|
|
char *m = (max_cpus == 0) ?
|
|
|
|
"The nosmp parameter is incompatible with Xen; " \
|
|
|
|
"use Xen dom0_max_vcpus=1 parameter" :
|
|
|
|
"The noapic parameter is incompatible with Xen";
|
|
|
|
|
|
|
|
xen_raw_printk(m);
|
|
|
|
panic(m);
|
|
|
|
}
|
xen: implement Xen-specific spinlocks
The standard ticket spinlocks are very expensive in a virtual
environment, because their performance depends on Xen's scheduler
giving vcpus time in the order that they're supposed to take the
spinlock.
This implements a Xen-specific spinlock, which should be much more
efficient.
The fast-path is essentially the old Linux-x86 locks, using a single
lock byte. The locker decrements the byte; if the result is 0, then
they have the lock. If the lock is negative, then locker must spin
until the lock is positive again.
When there's contention, the locker spin for 2^16[*] iterations waiting
to get the lock. If it fails to get the lock in that time, it adds
itself to the contention count in the lock and blocks on a per-cpu
event channel.
When unlocking the spinlock, the locker looks to see if there's anyone
blocked waiting for the lock by checking for a non-zero waiter count.
If there's a waiter, it traverses the per-cpu "lock_spinners"
variable, which contains which lock each CPU is waiting on. It picks
one CPU waiting on the lock and sends it an event to wake it up.
This allows efficient fast-path spinlock operation, while allowing
spinning vcpus to give up their processor time while waiting for a
contended lock.
[*] 2^16 iterations is threshold at which 98% locks have been taken
according to Thomas Friebel's Xen Summit talk "Preventing Guests from
Spinning Around". Therefore, we'd expect the lock and unlock slow
paths will only be entered 2% of the time.
Signed-off-by: Jeremy Fitzhardinge <jeremy.fitzhardinge@citrix.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Christoph Lameter <clameter@linux-foundation.org>
Cc: Petr Tesarik <ptesarik@suse.cz>
Cc: Virtualization <virtualization@lists.linux-foundation.org>
Cc: Xen devel <xen-devel@lists.xensource.com>
Cc: Thomas Friebel <thomas.friebel@amd.com>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-08 03:07:53 +08:00
|
|
|
xen_init_lock_cpu(0);
|
|
|
|
|
2012-12-18 09:29:32 +08:00
|
|
|
smp_store_boot_cpu_info();
|
2008-07-09 06:06:43 +08:00
|
|
|
cpu_data(0).x86_max_cores = 1;
|
2009-12-18 17:31:31 +08:00
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
zalloc_cpumask_var(&per_cpu(cpu_sibling_map, i), GFP_KERNEL);
|
|
|
|
zalloc_cpumask_var(&per_cpu(cpu_core_map, i), GFP_KERNEL);
|
|
|
|
zalloc_cpumask_var(&per_cpu(cpu_llc_shared_map, i), GFP_KERNEL);
|
|
|
|
}
|
2007-07-18 09:37:06 +08:00
|
|
|
set_cpu_sibling_map(0);
|
|
|
|
|
2015-08-11 04:34:34 +08:00
|
|
|
xen_pmu_init(0);
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
if (xen_smp_intr_init(0))
|
|
|
|
BUG();
|
|
|
|
|
2008-12-17 09:33:57 +08:00
|
|
|
if (!alloc_cpumask_var(&xen_cpu_initialized_map, GFP_KERNEL))
|
|
|
|
panic("could not allocate xen_cpu_initialized_map\n");
|
|
|
|
|
|
|
|
cpumask_copy(xen_cpu_initialized_map, cpumask_of(0));
|
2007-07-18 09:37:06 +08:00
|
|
|
|
|
|
|
/* Restrict the possible_map according to max_cpus. */
|
|
|
|
while ((num_possible_cpus() > 1) && (num_possible_cpus() > max_cpus)) {
|
2008-12-17 09:33:52 +08:00
|
|
|
for (cpu = nr_cpu_ids - 1; !cpu_possible(cpu); cpu--)
|
2007-07-18 09:37:06 +08:00
|
|
|
continue;
|
2009-03-13 12:19:54 +08:00
|
|
|
set_cpu_possible(cpu, false);
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
|
|
|
|
2012-04-20 21:05:48 +08:00
|
|
|
for_each_possible_cpu(cpu)
|
2009-03-13 12:19:54 +08:00
|
|
|
set_cpu_present(cpu, true);
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
|
|
|
|
x86: delete __cpuinit usage from all x86 files
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/x86 uses of the __cpuinit macros from
all C files. x86 only had the one __CPUINIT used in assembly files,
and it wasn't paired off with a .previous or a __FINIT, so we can
delete it directly w/o any corresponding additional change there.
[1] https://lkml.org/lkml/2013/5/20/589
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: x86@kernel.org
Acked-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: H. Peter Anvin <hpa@linux.intel.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-19 06:23:59 +08:00
|
|
|
static int
|
2007-07-18 09:37:06 +08:00
|
|
|
cpu_initialize_context(unsigned int cpu, struct task_struct *idle)
|
|
|
|
{
|
|
|
|
struct vcpu_guest_context *ctxt;
|
2008-07-09 06:06:43 +08:00
|
|
|
struct desc_struct *gdt;
|
2009-02-28 01:19:26 +08:00
|
|
|
unsigned long gdt_mfn;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2014-06-20 20:23:11 +08:00
|
|
|
/* used to tell cpu_init() that it can proceed with initialization */
|
|
|
|
cpumask_set_cpu(cpu, cpu_callout_mask);
|
2008-12-17 09:33:57 +08:00
|
|
|
if (cpumask_test_and_set_cpu(cpu, xen_cpu_initialized_map))
|
2007-07-18 09:37:06 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
|
|
|
|
if (ctxt == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-07-09 06:06:43 +08:00
|
|
|
gdt = get_cpu_gdt_table(cpu);
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_32
|
2013-12-14 00:48:08 +08:00
|
|
|
/* Note: PVH is not yet supported on x86_32. */
|
2008-07-09 06:06:43 +08:00
|
|
|
ctxt->user_regs.fs = __KERNEL_PERCPU;
|
2009-08-28 03:46:35 +08:00
|
|
|
ctxt->user_regs.gs = __KERNEL_STACK_CANARY;
|
2008-07-09 06:06:43 +08:00
|
|
|
#endif
|
2007-07-18 09:37:06 +08:00
|
|
|
memset(&ctxt->fpu_ctxt, 0, sizeof(ctxt->fpu_ctxt));
|
|
|
|
|
2013-12-14 00:48:08 +08:00
|
|
|
if (!xen_feature(XENFEAT_auto_translated_physmap)) {
|
2014-09-11 07:36:06 +08:00
|
|
|
ctxt->user_regs.eip = (unsigned long)cpu_bringup_and_idle;
|
2013-12-14 00:48:08 +08:00
|
|
|
ctxt->flags = VGCF_IN_KERNEL;
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->user_regs.eflags = 0x1000; /* IOPL_RING1 */
|
|
|
|
ctxt->user_regs.ds = __USER_DS;
|
|
|
|
ctxt->user_regs.es = __USER_DS;
|
2013-12-14 00:48:08 +08:00
|
|
|
ctxt->user_regs.ss = __KERNEL_DS;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2012-10-22 23:35:16 +08:00
|
|
|
xen_copy_trap_info(ctxt->trap_ctxt);
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->ldt_ents = 0;
|
2009-02-28 01:19:26 +08:00
|
|
|
|
2012-10-22 23:35:16 +08:00
|
|
|
BUG_ON((unsigned long)gdt & ~PAGE_MASK);
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2012-10-22 23:35:16 +08:00
|
|
|
gdt_mfn = arbitrary_virt_to_mfn(gdt);
|
|
|
|
make_lowmem_page_readonly(gdt);
|
|
|
|
make_lowmem_page_readonly(mfn_to_virt(gdt_mfn));
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->gdt_frames[0] = gdt_mfn;
|
|
|
|
ctxt->gdt_ents = GDT_ENTRIES;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->kernel_ss = __KERNEL_DS;
|
|
|
|
ctxt->kernel_sp = idle->thread.sp0;
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2008-07-09 06:06:43 +08:00
|
|
|
#ifdef CONFIG_X86_32
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->event_callback_cs = __KERNEL_CS;
|
|
|
|
ctxt->failsafe_callback_cs = __KERNEL_CS;
|
2013-12-14 00:48:08 +08:00
|
|
|
#else
|
|
|
|
ctxt->gs_base_kernel = per_cpu_offset(cpu);
|
2008-07-09 06:06:43 +08:00
|
|
|
#endif
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->event_callback_eip =
|
|
|
|
(unsigned long)xen_hypervisor_callback;
|
|
|
|
ctxt->failsafe_callback_eip =
|
|
|
|
(unsigned long)xen_failsafe_callback;
|
2013-12-14 00:48:08 +08:00
|
|
|
ctxt->user_regs.cs = __KERNEL_CS;
|
|
|
|
per_cpu(xen_cr3, cpu) = __pa(swapper_pg_dir);
|
2012-10-22 23:35:16 +08:00
|
|
|
}
|
2014-09-11 07:36:06 +08:00
|
|
|
#ifdef CONFIG_XEN_PVH
|
|
|
|
else {
|
|
|
|
/*
|
|
|
|
* The vcpu comes on kernel page tables which have the NX pte
|
|
|
|
* bit set. This means before DS/SS is touched, NX in
|
|
|
|
* EFER must be set. Hence the following assembly glue code.
|
2013-12-14 00:48:08 +08:00
|
|
|
*/
|
2014-09-11 07:36:06 +08:00
|
|
|
ctxt->user_regs.eip = (unsigned long)xen_pvh_early_cpu_init;
|
2013-12-14 00:48:08 +08:00
|
|
|
ctxt->user_regs.rdi = cpu;
|
2014-09-11 07:36:06 +08:00
|
|
|
ctxt->user_regs.rsi = true; /* entry == true */
|
|
|
|
}
|
2013-12-14 00:48:08 +08:00
|
|
|
#endif
|
2012-10-22 23:35:16 +08:00
|
|
|
ctxt->user_regs.esp = idle->thread.sp0 - sizeof(struct pt_regs);
|
2015-08-08 00:34:37 +08:00
|
|
|
ctxt->ctrlreg[3] = xen_pfn_to_cr3(virt_to_gfn(swapper_pg_dir));
|
2016-06-30 23:56:38 +08:00
|
|
|
if (HYPERVISOR_vcpu_op(VCPUOP_initialise, xen_vcpu_nr(cpu), ctxt))
|
2007-07-18 09:37:06 +08:00
|
|
|
BUG();
|
|
|
|
|
|
|
|
kfree(ctxt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
x86: delete __cpuinit usage from all x86 files
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/x86 uses of the __cpuinit macros from
all C files. x86 only had the one __CPUINIT used in assembly files,
and it wasn't paired off with a .previous or a __FINIT, so we can
delete it directly w/o any corresponding additional change there.
[1] https://lkml.org/lkml/2013/5/20/589
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: x86@kernel.org
Acked-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: H. Peter Anvin <hpa@linux.intel.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-19 06:23:59 +08:00
|
|
|
static int xen_cpu_up(unsigned int cpu, struct task_struct *idle)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2015-04-01 22:12:14 +08:00
|
|
|
common_cpu_up(cpu, idle);
|
2014-04-11 00:17:09 +08:00
|
|
|
|
2009-11-25 01:32:48 +08:00
|
|
|
xen_setup_runstate_info(cpu);
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2015-02-26 03:42:15 +08:00
|
|
|
/*
|
|
|
|
* PV VCPUs are always successfully taken down (see 'while' loop
|
|
|
|
* in xen_cpu_die()), so -EBUSY is an error.
|
|
|
|
*/
|
|
|
|
rc = cpu_check_up_prepare(cpu);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2008-07-09 06:06:43 +08:00
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
/* make sure interrupts start blocked */
|
|
|
|
per_cpu(xen_vcpu, cpu)->evtchn_upcall_mask = 1;
|
|
|
|
|
|
|
|
rc = cpu_initialize_context(cpu, idle);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2015-08-11 04:34:34 +08:00
|
|
|
xen_pmu_init(cpu);
|
|
|
|
|
2016-06-30 23:56:38 +08:00
|
|
|
rc = HYPERVISOR_vcpu_op(VCPUOP_up, xen_vcpu_nr(cpu), NULL);
|
2007-07-18 09:37:06 +08:00
|
|
|
BUG_ON(rc);
|
|
|
|
|
2015-02-26 03:42:15 +08:00
|
|
|
while (cpu_report_state(cpu) != CPU_ONLINE)
|
2009-03-06 03:13:57 +08:00
|
|
|
HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
|
2008-07-09 06:06:43 +08:00
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-09 06:06:41 +08:00
|
|
|
static void xen_smp_cpus_done(unsigned int max_cpus)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-09-08 20:43:33 +08:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
2008-09-08 20:43:34 +08:00
|
|
|
static int xen_cpu_disable(void)
|
2008-08-22 18:52:15 +08:00
|
|
|
{
|
|
|
|
unsigned int cpu = smp_processor_id();
|
|
|
|
if (cpu == 0)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
cpu_disable_common();
|
|
|
|
|
|
|
|
load_cr3(swapper_pg_dir);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-08 20:43:34 +08:00
|
|
|
static void xen_cpu_die(unsigned int cpu)
|
2008-08-22 18:52:15 +08:00
|
|
|
{
|
2016-06-30 23:56:38 +08:00
|
|
|
while (xen_pv_domain() && HYPERVISOR_vcpu_op(VCPUOP_is_up,
|
|
|
|
xen_vcpu_nr(cpu), NULL)) {
|
2015-01-26 18:10:08 +08:00
|
|
|
__set_current_state(TASK_UNINTERRUPTIBLE);
|
2008-08-22 18:52:15 +08:00
|
|
|
schedule_timeout(HZ/10);
|
|
|
|
}
|
2014-10-31 23:49:32 +08:00
|
|
|
|
2015-02-26 03:42:15 +08:00
|
|
|
if (common_cpu_die(cpu) == 0) {
|
|
|
|
xen_smp_intr_free(cpu);
|
|
|
|
xen_uninit_lock_cpu(cpu);
|
|
|
|
xen_teardown_timer(cpu);
|
2015-08-11 04:34:34 +08:00
|
|
|
xen_pmu_finish(cpu);
|
2015-02-26 03:42:15 +08:00
|
|
|
}
|
2008-08-22 18:52:15 +08:00
|
|
|
}
|
|
|
|
|
x86: delete __cpuinit usage from all x86 files
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/x86 uses of the __cpuinit macros from
all C files. x86 only had the one __CPUINIT used in assembly files,
and it wasn't paired off with a .previous or a __FINIT, so we can
delete it directly w/o any corresponding additional change there.
[1] https://lkml.org/lkml/2013/5/20/589
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: x86@kernel.org
Acked-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: H. Peter Anvin <hpa@linux.intel.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-19 06:23:59 +08:00
|
|
|
static void xen_play_dead(void) /* used only with HOTPLUG_CPU */
|
2008-08-22 18:52:15 +08:00
|
|
|
{
|
|
|
|
play_dead_common();
|
2016-06-30 23:56:38 +08:00
|
|
|
HYPERVISOR_vcpu_op(VCPUOP_down, xen_vcpu_nr(smp_processor_id()), NULL);
|
2008-08-22 18:52:15 +08:00
|
|
|
cpu_bringup();
|
2013-06-03 22:33:55 +08:00
|
|
|
/*
|
|
|
|
* commit 4b0c0f294 (tick: Cleanup NOHZ per cpu data on cpu down)
|
|
|
|
* clears certain data that the cpu_idle loop (which called us
|
|
|
|
* and that we return from) expects. The only way to get that
|
|
|
|
* data back is to call:
|
|
|
|
*/
|
|
|
|
tick_nohz_idle_enter();
|
2016-03-17 21:03:25 +08:00
|
|
|
|
|
|
|
cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
|
2008-08-22 18:52:15 +08:00
|
|
|
}
|
|
|
|
|
2008-09-08 20:43:33 +08:00
|
|
|
#else /* !CONFIG_HOTPLUG_CPU */
|
2008-09-08 20:43:34 +08:00
|
|
|
static int xen_cpu_disable(void)
|
2008-09-08 20:43:33 +08:00
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
|
2008-09-08 20:43:34 +08:00
|
|
|
static void xen_cpu_die(unsigned int cpu)
|
2008-09-08 20:43:33 +08:00
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2008-09-08 20:43:34 +08:00
|
|
|
static void xen_play_dead(void)
|
2008-09-08 20:43:33 +08:00
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2007-07-18 09:37:06 +08:00
|
|
|
static void stop_self(void *v)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
/* make sure we're not pinning something down */
|
|
|
|
load_cr3(swapper_pg_dir);
|
|
|
|
/* should set up a minimal gdt */
|
|
|
|
|
2010-08-04 05:55:14 +08:00
|
|
|
set_cpu_online(cpu, false);
|
|
|
|
|
2016-06-30 23:56:38 +08:00
|
|
|
HYPERVISOR_vcpu_op(VCPUOP_down, xen_vcpu_nr(cpu), NULL);
|
2007-07-18 09:37:06 +08:00
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2010-10-12 05:37:08 +08:00
|
|
|
static void xen_stop_other_cpus(int wait)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
2010-10-12 05:37:08 +08:00
|
|
|
smp_call_function(stop_self, NULL, wait);
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
|
|
|
|
2008-07-09 06:06:41 +08:00
|
|
|
static void xen_smp_send_reschedule(int cpu)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
|
|
|
|
}
|
|
|
|
|
2012-04-21 00:11:04 +08:00
|
|
|
static void __xen_send_IPI_mask(const struct cpumask *mask,
|
|
|
|
int vector)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
|
|
|
unsigned cpu;
|
|
|
|
|
2008-12-17 09:33:59 +08:00
|
|
|
for_each_cpu_and(cpu, mask, cpu_online_mask)
|
2007-07-18 09:37:06 +08:00
|
|
|
xen_send_IPI_one(cpu, vector);
|
|
|
|
}
|
|
|
|
|
2008-12-17 09:33:59 +08:00
|
|
|
static void xen_smp_send_call_function_ipi(const struct cpumask *mask)
|
2008-06-26 17:21:54 +08:00
|
|
|
{
|
|
|
|
int cpu;
|
|
|
|
|
2012-04-21 00:11:04 +08:00
|
|
|
__xen_send_IPI_mask(mask, XEN_CALL_FUNCTION_VECTOR);
|
2008-06-26 17:21:54 +08:00
|
|
|
|
|
|
|
/* Make sure other vcpus get a chance to run if they need to. */
|
2008-12-17 09:33:59 +08:00
|
|
|
for_each_cpu(cpu, mask) {
|
2008-06-26 17:21:54 +08:00
|
|
|
if (xen_vcpu_stolen(cpu)) {
|
2009-03-06 03:13:57 +08:00
|
|
|
HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
|
2008-06-26 17:21:54 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-09 06:06:41 +08:00
|
|
|
static void xen_smp_send_call_function_single_ipi(int cpu)
|
2008-06-26 17:21:54 +08:00
|
|
|
{
|
2012-04-21 00:11:04 +08:00
|
|
|
__xen_send_IPI_mask(cpumask_of(cpu),
|
2008-12-17 09:33:52 +08:00
|
|
|
XEN_CALL_FUNCTION_SINGLE_VECTOR);
|
2008-06-26 17:21:54 +08:00
|
|
|
}
|
|
|
|
|
2012-04-21 00:11:04 +08:00
|
|
|
static inline int xen_map_vector(int vector)
|
|
|
|
{
|
|
|
|
int xen_vector;
|
|
|
|
|
|
|
|
switch (vector) {
|
|
|
|
case RESCHEDULE_VECTOR:
|
|
|
|
xen_vector = XEN_RESCHEDULE_VECTOR;
|
|
|
|
break;
|
|
|
|
case CALL_FUNCTION_VECTOR:
|
|
|
|
xen_vector = XEN_CALL_FUNCTION_VECTOR;
|
|
|
|
break;
|
|
|
|
case CALL_FUNCTION_SINGLE_VECTOR:
|
|
|
|
xen_vector = XEN_CALL_FUNCTION_SINGLE_VECTOR;
|
|
|
|
break;
|
2012-04-21 00:11:05 +08:00
|
|
|
case IRQ_WORK_VECTOR:
|
|
|
|
xen_vector = XEN_IRQ_WORK_VECTOR;
|
|
|
|
break;
|
2013-07-19 23:51:31 +08:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
case NMI_VECTOR:
|
|
|
|
case APIC_DM_NMI: /* Some use that instead of NMI_VECTOR */
|
|
|
|
xen_vector = XEN_NMI_VECTOR;
|
|
|
|
break;
|
|
|
|
#endif
|
2012-04-21 00:11:04 +08:00
|
|
|
default:
|
|
|
|
xen_vector = -1;
|
|
|
|
printk(KERN_ERR "xen: vector 0x%x is not implemented\n",
|
|
|
|
vector);
|
|
|
|
}
|
|
|
|
|
|
|
|
return xen_vector;
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_send_IPI_mask(const struct cpumask *mask,
|
|
|
|
int vector)
|
|
|
|
{
|
|
|
|
int xen_vector = xen_map_vector(vector);
|
|
|
|
|
|
|
|
if (xen_vector >= 0)
|
|
|
|
__xen_send_IPI_mask(mask, xen_vector);
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_send_IPI_all(int vector)
|
|
|
|
{
|
|
|
|
int xen_vector = xen_map_vector(vector);
|
|
|
|
|
|
|
|
if (xen_vector >= 0)
|
|
|
|
__xen_send_IPI_mask(cpu_online_mask, xen_vector);
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_send_IPI_self(int vector)
|
|
|
|
{
|
|
|
|
int xen_vector = xen_map_vector(vector);
|
|
|
|
|
|
|
|
if (xen_vector >= 0)
|
|
|
|
xen_send_IPI_one(smp_processor_id(), xen_vector);
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_send_IPI_mask_allbutself(const struct cpumask *mask,
|
|
|
|
int vector)
|
|
|
|
{
|
|
|
|
unsigned cpu;
|
|
|
|
unsigned int this_cpu = smp_processor_id();
|
2013-05-08 22:37:35 +08:00
|
|
|
int xen_vector = xen_map_vector(vector);
|
2012-04-21 00:11:04 +08:00
|
|
|
|
2013-05-08 22:37:35 +08:00
|
|
|
if (!(num_online_cpus() > 1) || (xen_vector < 0))
|
2012-04-21 00:11:04 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
for_each_cpu_and(cpu, mask, cpu_online_mask) {
|
|
|
|
if (this_cpu == cpu)
|
|
|
|
continue;
|
|
|
|
|
2013-05-08 22:37:35 +08:00
|
|
|
xen_send_IPI_one(cpu, xen_vector);
|
2012-04-21 00:11:04 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void xen_send_IPI_allbutself(int vector)
|
|
|
|
{
|
2013-05-08 22:37:35 +08:00
|
|
|
xen_send_IPI_mask_allbutself(cpu_online_mask, vector);
|
2012-04-21 00:11:04 +08:00
|
|
|
}
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
irq_enter();
|
2008-06-26 17:21:54 +08:00
|
|
|
generic_smp_call_function_interrupt();
|
2009-01-18 23:38:57 +08:00
|
|
|
inc_irq_stat(irq_call_count);
|
2007-07-18 09:37:06 +08:00
|
|
|
irq_exit();
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2008-06-26 17:21:54 +08:00
|
|
|
static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id)
|
2007-07-18 09:37:06 +08:00
|
|
|
{
|
2008-06-26 17:21:54 +08:00
|
|
|
irq_enter();
|
|
|
|
generic_smp_call_function_single_interrupt();
|
2009-01-18 23:38:57 +08:00
|
|
|
inc_irq_stat(irq_call_count);
|
2008-06-26 17:21:54 +08:00
|
|
|
irq_exit();
|
2007-07-18 09:37:06 +08:00
|
|
|
|
2008-06-26 17:21:54 +08:00
|
|
|
return IRQ_HANDLED;
|
2007-07-18 09:37:06 +08:00
|
|
|
}
|
2008-07-09 06:06:41 +08:00
|
|
|
|
2012-04-21 00:11:05 +08:00
|
|
|
static irqreturn_t xen_irq_work_interrupt(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
irq_enter();
|
|
|
|
irq_work_run();
|
|
|
|
inc_irq_stat(apic_irq_work_irqs);
|
|
|
|
irq_exit();
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2011-05-05 02:18:05 +08:00
|
|
|
static const struct smp_ops xen_smp_ops __initconst = {
|
2008-07-09 06:06:41 +08:00
|
|
|
.smp_prepare_boot_cpu = xen_smp_prepare_boot_cpu,
|
|
|
|
.smp_prepare_cpus = xen_smp_prepare_cpus,
|
|
|
|
.smp_cpus_done = xen_smp_cpus_done,
|
|
|
|
|
2008-08-22 18:52:15 +08:00
|
|
|
.cpu_up = xen_cpu_up,
|
|
|
|
.cpu_die = xen_cpu_die,
|
|
|
|
.cpu_disable = xen_cpu_disable,
|
|
|
|
.play_dead = xen_play_dead,
|
|
|
|
|
2010-10-12 05:37:08 +08:00
|
|
|
.stop_other_cpus = xen_stop_other_cpus,
|
2008-07-09 06:06:41 +08:00
|
|
|
.smp_send_reschedule = xen_smp_send_reschedule,
|
|
|
|
|
|
|
|
.send_call_func_ipi = xen_smp_send_call_function_ipi,
|
|
|
|
.send_call_func_single_ipi = xen_smp_send_call_function_single_ipi,
|
|
|
|
};
|
|
|
|
|
|
|
|
void __init xen_smp_init(void)
|
|
|
|
{
|
|
|
|
smp_ops = xen_smp_ops;
|
2008-07-09 06:06:43 +08:00
|
|
|
xen_fill_possible_map();
|
2008-07-09 06:06:41 +08:00
|
|
|
}
|
2010-12-03 01:55:10 +08:00
|
|
|
|
|
|
|
static void __init xen_hvm_smp_prepare_cpus(unsigned int max_cpus)
|
|
|
|
{
|
|
|
|
native_smp_prepare_cpus(max_cpus);
|
|
|
|
WARN_ON(xen_smp_intr_init(0));
|
|
|
|
|
|
|
|
xen_init_lock_cpu(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init xen_hvm_smp_init(void)
|
|
|
|
{
|
|
|
|
smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus;
|
|
|
|
smp_ops.smp_send_reschedule = xen_smp_send_reschedule;
|
2015-02-26 03:42:15 +08:00
|
|
|
smp_ops.cpu_die = xen_cpu_die;
|
2010-12-03 01:55:10 +08:00
|
|
|
smp_ops.send_call_func_ipi = xen_smp_send_call_function_ipi;
|
|
|
|
smp_ops.send_call_func_single_ipi = xen_smp_send_call_function_single_ipi;
|
2013-08-17 02:39:56 +08:00
|
|
|
smp_ops.smp_prepare_boot_cpu = xen_smp_prepare_boot_cpu;
|
2010-12-03 01:55:10 +08:00
|
|
|
}
|