[mirror_ubuntu-hirsute-kernel.git] / arch / x86 / xen / setup.c

/*
 * Machine specific setup for xen
 *
 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/pm.h>

#include <asm/elf.h>
#include <asm/vdso.h>
#include <asm/e820.h>
#include <asm/setup.h>
#include <asm/xen/hypervisor.h>
#include <asm/xen/hypercall.h>

#include <xen/interface/callback.h>
#include <xen/interface/physdev.h>
#include <xen/features.h>

#include "xen-ops.h"
#include "vdso.h"

/* These are code, but not functions.  Defined in entry.S */
extern const char xen_hypervisor_callback[];
extern const char xen_failsafe_callback[];

unsigned long *phys_to_machine_mapping;
EXPORT_SYMBOL(phys_to_machine_mapping);

/**
 * machine_specific_memory_setup - Hook for machine specific memory setup.
 **/

char * __init xen_memory_setup(void)
{
	unsigned long max_pfn = xen_start_info->nr_pages;

	e820.nr_map = 0;
	add_memory_region(0, LOWMEMSIZE(), E820_RAM);
	add_memory_region(HIGH_MEMORY, PFN_PHYS(max_pfn)-HIGH_MEMORY, E820_RAM);

	return "Xen";
}

static void xen_idle(void)
{
	local_irq_disable();

	if (need_resched())
		local_irq_enable();
	else {
		current_thread_info()->status &= ~TS_POLLING;
		smp_mb__after_clear_bit();
		safe_halt();
		current_thread_info()->status |= TS_POLLING;
	}
}

/*
 * Set the bit indicating "nosegneg" library variants should be used.
 */
static void __init fiddle_vdso(void)
{
	extern const char vdso32_default_start;
	u32 *mask = VDSO32_SYMBOL(&vdso32_default_start, NOTE_MASK);
	*mask |= 1 << VDSO_NOTE_NONEGSEG_BIT;
}

void xen_enable_sysenter(void)
{
	int cpu = smp_processor_id();
	extern void xen_sysenter_target(void);
	/* Mask events on entry, even though they get enabled immediately */
	static struct callback_register sysenter = {
		.type = CALLBACKTYPE_sysenter,
		.address = { __KERNEL_CS, (unsigned long)xen_sysenter_target },
		.flags = CALLBACKF_mask_events,
	};

	if (!boot_cpu_has(X86_FEATURE_SEP) ||
	    HYPERVISOR_callback_op(CALLBACKOP_register, &sysenter) != 0) {
		clear_cpu_cap(&cpu_data(cpu), X86_FEATURE_SEP);
		clear_cpu_cap(&boot_cpu_data, X86_FEATURE_SEP);
	}
}

void __init xen_arch_setup(void)
{
	struct physdev_set_iopl set_iopl;
	int rc;

	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments);
	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables);

	if (!xen_feature(XENFEAT_auto_translated_physmap))
		HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_pae_extended_cr3);

	HYPERVISOR_set_callbacks(__KERNEL_CS, (unsigned long)xen_hypervisor_callback,
				 __KERNEL_CS, (unsigned long)xen_failsafe_callback);

	xen_enable_sysenter();

	set_iopl.iopl = 1;
	rc = HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
	if (rc != 0)
		printk(KERN_INFO "physdev_op failed %d\n", rc);

#ifdef CONFIG_ACPI
	if (!(xen_start_info->flags & SIF_INITDOMAIN)) {
		printk(KERN_INFO "ACPI in unprivileged domain disabled\n");
		disable_acpi();
	}
#endif

	memcpy(boot_command_line, xen_start_info->cmd_line,
	       MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ?
	       COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE);

	pm_idle = xen_idle;

#ifdef CONFIG_SMP
	/* fill cpus_possible with all available cpus */
	xen_fill_possible_map();
#endif

	paravirt_disable_iospace();

	fiddle_vdso();
}
Commit	Line	Data
5ead97c8 JF	1	/*
	2	* Machine specific setup for xen
	3	*
	4	* Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
	5	*/
	6
	7	#include <linux/module.h>
	8	#include <linux/sched.h>
	9	#include <linux/mm.h>
	10	#include <linux/pm.h>
	11
	12	#include <asm/elf.h>
6c3652ef	13	#include <asm/vdso.h>
5ead97c8 JF	14	#include <asm/e820.h>
	15	#include <asm/setup.h>
	16	#include <asm/xen/hypervisor.h>
	17	#include <asm/xen/hypercall.h>
	18
e2a81baf	19	#include <xen/interface/callback.h>
5ead97c8 JF	20	#include <xen/interface/physdev.h>
	21	#include <xen/features.h>
	22
	23	#include "xen-ops.h"
d2eea68e	24	#include "vdso.h"
5ead97c8 JF	25
	26	/* These are code, but not functions. Defined in entry.S */
	27	extern const char xen_hypervisor_callback[];
	28	extern const char xen_failsafe_callback[];
	29
5ead97c8 JF	30	unsigned long *phys_to_machine_mapping;
	31	EXPORT_SYMBOL(phys_to_machine_mapping);
	32
	33	/**
	34	* machine_specific_memory_setup - Hook for machine specific memory setup.
	35	**/
	36
	37	char * __init xen_memory_setup(void)
	38	{
	39	unsigned long max_pfn = xen_start_info->nr_pages;
	40
	41	e820.nr_map = 0;
87d034f3 IC	42	add_memory_region(0, LOWMEMSIZE(), E820_RAM);
87d034f3 IC	43	add_memory_region(HIGH_MEMORY, PFN_PHYS(max_pfn)-HIGH_MEMORY, E820_RAM);
5ead97c8 JF	44
	45	return "Xen";
	46	}
	47
	48	static void xen_idle(void)
	49	{
	50	local_irq_disable();
	51
	52	if (need_resched())
	53	local_irq_enable();
	54	else {
	55	current_thread_info()->status &= ~TS_POLLING;
	56	smp_mb__after_clear_bit();
	57	safe_halt();
	58	current_thread_info()->status \|= TS_POLLING;
	59	}
	60	}
	61
d2eea68e RM	62	/*
	63	* Set the bit indicating "nosegneg" library variants should be used.
	64	*/
08b6d290	65	static void __init fiddle_vdso(void)
d2eea68e	66	{
af65d648 RM	67	extern const char vdso32_default_start;
af65d648 RM	68	u32 *mask = VDSO32_SYMBOL(&vdso32_default_start, NOTE_MASK);
d2eea68e RM	69	*mask \|= 1 << VDSO_NOTE_NONEGSEG_BIT;
	70	}
	71
e2a81baf JF	72	void xen_enable_sysenter(void)
	73	{
	74	int cpu = smp_processor_id();
	75	extern void xen_sysenter_target(void);
	76	/* Mask events on entry, even though they get enabled immediately */
	77	static struct callback_register sysenter = {
	78	.type = CALLBACKTYPE_sysenter,
	79	.address = { __KERNEL_CS, (unsigned long)xen_sysenter_target },
	80	.flags = CALLBACKF_mask_events,
	81	};
	82
	83	if (!boot_cpu_has(X86_FEATURE_SEP) \|\|
	84	HYPERVISOR_callback_op(CALLBACKOP_register, &sysenter) != 0) {
	85	clear_cpu_cap(&cpu_data(cpu), X86_FEATURE_SEP);
	86	clear_cpu_cap(&boot_cpu_data, X86_FEATURE_SEP);
	87	}
	88	}
	89
5ead97c8 JF	90	void __init xen_arch_setup(void)
	91	{
	92	struct physdev_set_iopl set_iopl;
	93	int rc;
	94
	95	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments);
	96	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables);
	97
	98	if (!xen_feature(XENFEAT_auto_translated_physmap))
	99	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_pae_extended_cr3);
	100
	101	HYPERVISOR_set_callbacks(__KERNEL_CS, (unsigned long)xen_hypervisor_callback,
	102	__KERNEL_CS, (unsigned long)xen_failsafe_callback);
	103
e2a81baf JF	104	xen_enable_sysenter();
e2a81baf JF	105
5ead97c8 JF	106	set_iopl.iopl = 1;
	107	rc = HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
	108	if (rc != 0)
	109	printk(KERN_INFO "physdev_op failed %d\n", rc);
	110
	111	#ifdef CONFIG_ACPI
	112	if (!(xen_start_info->flags & SIF_INITDOMAIN)) {
	113	printk(KERN_INFO "ACPI in unprivileged domain disabled\n");
	114	disable_acpi();
	115	}
	116	#endif
	117
	118	memcpy(boot_command_line, xen_start_info->cmd_line,
	119	MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ?
	120	COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE);
	121
	122	pm_idle = xen_idle;
f87e4cac JF	123
	124	#ifdef CONFIG_SMP
	125	/* fill cpus_possible with all available cpus */
	126	xen_fill_possible_map();
	127	#endif
dfdcdd42 JF	128
dfdcdd42 JF	129	paravirt_disable_iospace();
d2eea68e RM	130
d2eea68e RM	131	fiddle_vdso();
5ead97c8	132	}