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
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2013-06-05 04:31:34 +08:00
|
|
|
static void xen_smp_intr_free(unsigned int cpu)
|
|
|
|
{
|
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
|
|
|
};
|
2007-07-18 09:37:06 +08:00
|
|
|
static int xen_smp_intr_init(unsigned int cpu)
|
|
|
|
{
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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));
|
2007-07-18 09:37:06 +08:00
|
|
|
if (HYPERVISOR_vcpu_op(VCPUOP_initialise, cpu, ctxt))
|
|
|
|
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
|
|
|
xen_setup_timer(cpu);
|
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(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);
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
rc = xen_smp_intr_init(cpu);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
rc = HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL);
|
|
|
|
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
|
|
|
{
|
2013-04-09 08:56:35 +08:00
|
|
|
while (xen_pv_domain() && HYPERVISOR_vcpu_op(VCPUOP_is_up, 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();
|
|
|
|
HYPERVISOR_vcpu_op(VCPUOP_down, smp_processor_id(), NULL);
|
|
|
|
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();
|
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);
|
|
|
|
|
2007-07-18 09:37:06 +08:00
|
|
|
HYPERVISOR_vcpu_op(VCPUOP_down, cpu, NULL);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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_hvm_cpu_up(unsigned int cpu, struct task_struct *tidle)
|
2010-12-03 01:55:10 +08:00
|
|
|
{
|
|
|
|
int rc;
|
2015-02-26 03:42:15 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This can happen if CPU was offlined earlier and
|
|
|
|
* offlining timed out in common_cpu_die().
|
|
|
|
*/
|
|
|
|
if (cpu_report_state(cpu) == CPU_DEAD_FROZEN) {
|
|
|
|
xen_smp_intr_free(cpu);
|
|
|
|
xen_uninit_lock_cpu(cpu);
|
|
|
|
}
|
|
|
|
|
xen/smp: initialize IPI vectors before marking CPU online
An older PVHVM guest (v3.0 based) crashed during vCPU hot-plug with:
kernel BUG at drivers/xen/events.c:1328!
RCU has detected that a CPU has not entered a quiescent state within the
grace period. It needs to send the CPU a reschedule IPI if it is not
offline. rcu_implicit_offline_qs() does this check:
/*
* If the CPU is offline, it is in a quiescent state. We can
* trust its state not to change because interrupts are disabled.
*/
if (cpu_is_offline(rdp->cpu)) {
rdp->offline_fqs++;
return 1;
}
Else the CPU is online. Send it a reschedule IPI.
The CPU is in the middle of being hot-plugged and has been marked online
(!cpu_is_offline()). See start_secondary():
set_cpu_online(smp_processor_id(), true);
...
per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
start_secondary() then waits for the CPU bringing up the hot-plugged CPU to
mark it as active:
/*
* Wait until the cpu which brought this one up marked it
* online before enabling interrupts. If we don't do that then
* we can end up waking up the softirq thread before this cpu
* reached the active state, which makes the scheduler unhappy
* and schedule the softirq thread on the wrong cpu. This is
* only observable with forced threaded interrupts, but in
* theory it could also happen w/o them. It's just way harder
* to achieve.
*/
while (!cpumask_test_cpu(smp_processor_id(), cpu_active_mask))
cpu_relax();
/* enable local interrupts */
local_irq_enable();
The CPU being hot-plugged will be marked active after it has been fully
initialized by the CPU managing the hot-plug. In the Xen PVHVM case
xen_smp_intr_init() is called to set up the hot-plugged vCPU's
XEN_RESCHEDULE_VECTOR.
The hot-plugging CPU is marked online, not marked active and does not have
its IPI vectors set up. rcu_implicit_offline_qs() sees the hot-plugging
cpu is !cpu_is_offline() and tries to send it a reschedule IPI:
This will lead to:
kernel BUG at drivers/xen/events.c:1328!
xen_send_IPI_one()
xen_smp_send_reschedule()
rcu_implicit_offline_qs()
rcu_implicit_dynticks_qs()
force_qs_rnp()
force_quiescent_state()
__rcu_process_callbacks()
rcu_process_callbacks()
__do_softirq()
call_softirq()
do_softirq()
irq_exit()
xen_evtchn_do_upcall()
because xen_send_IPI_one() will attempt to use an uninitialized IRQ for
the XEN_RESCHEDULE_VECTOR.
There is at least one other place that has caused the same crash:
xen_smp_send_reschedule()
wake_up_idle_cpu()
add_timer_on()
clocksource_watchdog()
call_timer_fn()
run_timer_softirq()
__do_softirq()
call_softirq()
do_softirq()
irq_exit()
xen_evtchn_do_upcall()
xen_hvm_callback_vector()
clocksource_watchdog() uses cpu_online_mask to pick the next CPU to handle
a watchdog timer:
/*
* Cycle through CPUs to check if the CPUs stay synchronized
* to each other.
*/
next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
if (next_cpu >= nr_cpu_ids)
next_cpu = cpumask_first(cpu_online_mask);
watchdog_timer.expires += WATCHDOG_INTERVAL;
add_timer_on(&watchdog_timer, next_cpu);
This resulted in an attempt to send an IPI to a hot-plugging CPU that
had not initialized its reschedule vector. One option would be to make
the RCU code check to not check for CPU offline but for CPU active.
As becoming active is done after a CPU is online (in older kernels).
But Srivatsa pointed out that "the cpu_active vs cpu_online ordering has been
completely reworked - in the online path, cpu_active is set *before* cpu_online,
and also, in the cpu offline path, the cpu_active bit is reset in the CPU_DYING
notification instead of CPU_DOWN_PREPARE." Drilling in this the bring-up
path: "[brought up CPU].. send out a CPU_STARTING notification, and in response
to that, the scheduler sets the CPU in the cpu_active_mask. Again, this mask
is better left to the scheduler alone, since it has the intelligence to use it
judiciously."
The conclusion was that:
"
1. At the IPI sender side:
It is incorrect to send an IPI to an offline CPU (cpu not present in
the cpu_online_mask). There are numerous places where we check this
and warn/complain.
2. At the IPI receiver side:
It is incorrect to let the world know of our presence (by setting
ourselves in global bitmasks) until our initialization steps are complete
to such an extent that we can handle the consequences (such as
receiving interrupts without crashing the sender etc.)
" (from Srivatsa)
As the native code enables the interrupts at some point we need to be
able to service them. In other words a CPU must have valid IPI vectors
if it has been marked online.
It doesn't need to handle the IPI (interrupts may be disabled) but needs
to have valid IPI vectors because another CPU may find it in cpu_online_mask
and attempt to send it an IPI.
This patch will change the order of the Xen vCPU bring-up functions so that
Xen vectors have been set up before start_secondary() is called.
It also will not continue to bring up a Xen vCPU if xen_smp_intr_init() fails
to initialize it.
Orabug 13823853
Signed-off-by Chuck Anderson <chuck.anderson@oracle.com>
Acked-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
2013-08-07 06:12:19 +08:00
|
|
|
/*
|
|
|
|
* xen_smp_intr_init() needs to run before native_cpu_up()
|
|
|
|
* so that IPI vectors are set up on the booting CPU before
|
|
|
|
* it is marked online in native_cpu_up().
|
|
|
|
*/
|
|
|
|
rc = xen_smp_intr_init(cpu);
|
|
|
|
WARN_ON(rc);
|
|
|
|
if (!rc)
|
|
|
|
rc = native_cpu_up(cpu, tidle);
|
2013-08-13 23:47:21 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We must initialize the slowpath CPU kicker _after_ the native
|
|
|
|
* path has executed. If we initialized it before none of the
|
|
|
|
* unlocker IPI kicks would reach the booting CPU as the booting
|
|
|
|
* CPU had not set itself 'online' in cpu_online_mask. That mask
|
|
|
|
* is checked when IPIs are sent (on HVM at least).
|
|
|
|
*/
|
|
|
|
xen_init_lock_cpu(cpu);
|
2010-12-03 01:55:10 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init xen_hvm_smp_init(void)
|
|
|
|
{
|
2011-08-17 21:15:00 +08:00
|
|
|
if (!xen_have_vector_callback)
|
|
|
|
return;
|
2010-12-03 01:55:10 +08:00
|
|
|
smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus;
|
|
|
|
smp_ops.smp_send_reschedule = xen_smp_send_reschedule;
|
|
|
|
smp_ops.cpu_up = xen_hvm_cpu_up;
|
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
|
|
|
}
|