[net-next-2.6.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 <linux/memblock.h>

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

#include <xen/page.h>
#include <xen/interface/callback.h>
#include <xen/interface/physdev.h>
#include <xen/interface/memory.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[];
extern void xen_sysenter_target(void);
extern void xen_syscall_target(void);
extern void xen_syscall32_target(void);

static unsigned long __init xen_release_chunk(phys_addr_t start_addr,
					      phys_addr_t end_addr)
{
	struct xen_memory_reservation reservation = {
		.address_bits = 0,
		.extent_order = 0,
		.domid        = DOMID_SELF
	};
	unsigned long start, end;
	unsigned long len = 0;
	unsigned long pfn;
	int ret;

	start = PFN_UP(start_addr);
	end = PFN_DOWN(end_addr);

	if (end <= start)
		return 0;

	printk(KERN_INFO "xen_release_chunk: looking at area pfn %lx-%lx: ",
	       start, end);
	for(pfn = start; pfn < end; pfn++) {
		unsigned long mfn = pfn_to_mfn(pfn);

		/* Make sure pfn exists to start with */
		if (mfn == INVALID_P2M_ENTRY || mfn_to_pfn(mfn) != pfn)
			continue;

		set_xen_guest_handle(reservation.extent_start, &mfn);
		reservation.nr_extents = 1;

		ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
					   &reservation);
		WARN(ret != 1, "Failed to release memory %lx-%lx err=%d\n",
		     start, end, ret);
		if (ret == 1) {
			set_phys_to_machine(pfn, INVALID_P2M_ENTRY);
			len++;
		}
	}
	printk(KERN_CONT "%ld pages freed\n", len);

	return len;
}

static unsigned long __init xen_return_unused_memory(unsigned long max_pfn,
						     const struct e820map *e820)
{
	phys_addr_t max_addr = PFN_PHYS(max_pfn);
	phys_addr_t last_end = 0;
	unsigned long released = 0;
	int i;

	for (i = 0; i < e820->nr_map && last_end < max_addr; i++) {
		phys_addr_t end = e820->map[i].addr;
		end = min(max_addr, end);

		released += xen_release_chunk(last_end, end);
		last_end = e820->map[i].addr + e820->map[i].size;
	}

	if (last_end < max_addr)
		released += xen_release_chunk(last_end, max_addr);

	printk(KERN_INFO "released %ld pages of unused memory\n", released);
	return released;
}

/**
 * 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;

	max_pfn = min(MAX_DOMAIN_PAGES, max_pfn);

	e820.nr_map = 0;

	e820_add_region(0, PFN_PHYS((u64)max_pfn), E820_RAM);

	/*
	 * Even though this is normal, usable memory under Xen, reserve
	 * ISA memory anyway because too many things think they can poke
	 * about in there.
	 */
	e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS,
			E820_RESERVED);

	/*
	 * Reserve Xen bits:
	 *  - mfn_list
	 *  - xen_start_info
	 * See comment above "struct start_info" in <xen/interface/xen.h>
	 */
	memblock_x86_reserve_range(__pa(xen_start_info->mfn_list),
		      __pa(xen_start_info->pt_base),
			"XEN START INFO");

	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);

	xen_return_unused_memory(xen_start_info->nr_pages, &e820);

	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.
 * We only need to bother in pure 32-bit mode; compat 32-bit processes
 * can have un-truncated segments, so wrapping around is allowed.
 */
static void __init fiddle_vdso(void)
{
#ifdef CONFIG_X86_32
	u32 *mask;
	mask = VDSO32_SYMBOL(&vdso32_int80_start, NOTE_MASK);
	*mask |= 1 << VDSO_NOTE_NONEGSEG_BIT;
	mask = VDSO32_SYMBOL(&vdso32_sysenter_start, NOTE_MASK);
	*mask |= 1 << VDSO_NOTE_NONEGSEG_BIT;
#endif
}

static __cpuinit int register_callback(unsigned type, const void *func)
{
	struct callback_register callback = {
		.type = type,
		.address = XEN_CALLBACK(__KERNEL_CS, func),
		.flags = CALLBACKF_mask_events,
	};

	return HYPERVISOR_callback_op(CALLBACKOP_register, &callback);
}

void __cpuinit xen_enable_sysenter(void)
{
	int ret;
	unsigned sysenter_feature;

#ifdef CONFIG_X86_32
	sysenter_feature = X86_FEATURE_SEP;
#else
	sysenter_feature = X86_FEATURE_SYSENTER32;
#endif

	if (!boot_cpu_has(sysenter_feature))
		return;

	ret = register_callback(CALLBACKTYPE_sysenter, xen_sysenter_target);
	if(ret != 0)
		setup_clear_cpu_cap(sysenter_feature);
}

void __cpuinit xen_enable_syscall(void)
{
#ifdef CONFIG_X86_64
	int ret;

	ret = register_callback(CALLBACKTYPE_syscall, xen_syscall_target);
	if (ret != 0) {
		printk(KERN_ERR "Failed to set syscall callback: %d\n", ret);
		/* Pretty fatal; 64-bit userspace has no other
		   mechanism for syscalls. */
	}

	if (boot_cpu_has(X86_FEATURE_SYSCALL32)) {
		ret = register_callback(CALLBACKTYPE_syscall32,
					xen_syscall32_target);
		if (ret != 0)
			setup_clear_cpu_cap(X86_FEATURE_SYSCALL32);
	}
#endif /* CONFIG_X86_64 */
}

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

	xen_panic_handler_init();

	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);

	if (register_callback(CALLBACKTYPE_event, xen_hypervisor_callback) ||
	    register_callback(CALLBACKTYPE_failsafe, xen_failsafe_callback))
		BUG();

	xen_enable_sysenter();
	xen_enable_syscall();

	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;

	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>
a9ce6bc1	11	#include <linux/memblock.h>
5ead97c8 JF	12
5ead97c8 JF	13	#include <asm/elf.h>
6c3652ef	14	#include <asm/vdso.h>
5ead97c8 JF	15	#include <asm/e820.h>
5ead97c8 JF	16	#include <asm/setup.h>
b792c755	17	#include <asm/acpi.h>
5ead97c8 JF	18	#include <asm/xen/hypervisor.h>
	19	#include <asm/xen/hypercall.h>
	20
8006ec3e	21	#include <xen/page.h>
e2a81baf	22	#include <xen/interface/callback.h>
5ead97c8	23	#include <xen/interface/physdev.h>
093d7b46	24	#include <xen/interface/memory.h>
5ead97c8 JF	25	#include <xen/features.h>
	26
	27	#include "xen-ops.h"
d2eea68e	28	#include "vdso.h"
5ead97c8 JF	29
	30	/* These are code, but not functions. Defined in entry.S */
	31	extern const char xen_hypervisor_callback[];
	32	extern const char xen_failsafe_callback[];
f63c2f24 T	33	extern void xen_sysenter_target(void);
	34	extern void xen_syscall_target(void);
	35	extern void xen_syscall32_target(void);
5ead97c8	36
f89e048e JF	37	static unsigned long __init xen_release_chunk(phys_addr_t start_addr,
f89e048e JF	38	phys_addr_t end_addr)
093d7b46 MR	39	{
	40	struct xen_memory_reservation reservation = {
	41	.address_bits = 0,
	42	.extent_order = 0,
	43	.domid = DOMID_SELF
	44	};
093d7b46	45	unsigned long start, end;
f89e048e	46	unsigned long len = 0;
093d7b46 MR	47	unsigned long pfn;
	48	int ret;
	49
	50	start = PFN_UP(start_addr);
f89e048e	51	end = PFN_DOWN(end_addr);
093d7b46 MR	52
	53	if (end <= start)
	54	return 0;
	55
f89e048e JF	56	printk(KERN_INFO "xen_release_chunk: looking at area pfn %lx-%lx: ",
	57	start, end);
	58	for(pfn = start; pfn < end; pfn++) {
	59	unsigned long mfn = pfn_to_mfn(pfn);
	60
	61	/* Make sure pfn exists to start with */
	62	if (mfn == INVALID_P2M_ENTRY \|\| mfn_to_pfn(mfn) != pfn)
	63	continue;
	64
	65	set_xen_guest_handle(reservation.extent_start, &mfn);
	66	reservation.nr_extents = 1;
	67
	68	ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
	69	&reservation);
	70	WARN(ret != 1, "Failed to release memory %lx-%lx err=%d\n",
	71	start, end, ret);
	72	if (ret == 1) {
	73	set_phys_to_machine(pfn, INVALID_P2M_ENTRY);
	74	len++;
	75	}
	76	}
	77	printk(KERN_CONT "%ld pages freed\n", len);
093d7b46 MR	78
	79	return len;
	80	}
	81
f89e048e JF	82	static unsigned long __init xen_return_unused_memory(unsigned long max_pfn,
f89e048e JF	83	const struct e820map *e820)
093d7b46	84	{
f89e048e JF	85	phys_addr_t max_addr = PFN_PHYS(max_pfn);
f89e048e JF	86	phys_addr_t last_end = 0;
093d7b46 MR	87	unsigned long released = 0;
	88	int i;
	89
f89e048e JF	90	for (i = 0; i < e820->nr_map && last_end < max_addr; i++) {
	91	phys_addr_t end = e820->map[i].addr;
	92	end = min(max_addr, end);
	93
	94	released += xen_release_chunk(last_end, end);
093d7b46 MR	95	last_end = e820->map[i].addr + e820->map[i].size;
	96	}
	97
f89e048e JF	98	if (last_end < max_addr)
f89e048e JF	99	released += xen_release_chunk(last_end, max_addr);
093d7b46 MR	100
	101	printk(KERN_INFO "released %ld pages of unused memory\n", released);
	102	return released;
	103	}
5ead97c8 JF	104
	105	/**
	106	* machine_specific_memory_setup - Hook for machine specific memory setup.
	107	**/
	108
	109	char * __init xen_memory_setup(void)
	110	{
	111	unsigned long max_pfn = xen_start_info->nr_pages;
	112
8006ec3e JF	113	max_pfn = min(MAX_DOMAIN_PAGES, max_pfn);
8006ec3e JF	114
5ead97c8	115	e820.nr_map = 0;
be5bf9fa	116
5670a43d	117	e820_add_region(0, PFN_PHYS((u64)max_pfn), E820_RAM);
b792c755 JF	118
	119	/*
	120	* Even though this is normal, usable memory under Xen, reserve
	121	* ISA memory anyway because too many things think they can poke
	122	* about in there.
	123	*/
	124	e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS,
	125	E820_RESERVED);
5ead97c8	126
be5bf9fa JF	127	/*
	128	* Reserve Xen bits:
	129	* - mfn_list
	130	* - xen_start_info
	131	* See comment above "struct start_info" in <xen/interface/xen.h>
	132	*/
a9ce6bc1	133	memblock_x86_reserve_range(__pa(xen_start_info->mfn_list),
6b2e8523 JF	134	__pa(xen_start_info->pt_base),
6b2e8523 JF	135	"XEN START INFO");
be5bf9fa JF	136
	137	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
	138
f89e048e	139	xen_return_unused_memory(xen_start_info->nr_pages, &e820);
093d7b46	140
5ead97c8 JF	141	return "Xen";
	142	}
	143
	144	static void xen_idle(void)
	145	{
	146	local_irq_disable();
	147
	148	if (need_resched())
	149	local_irq_enable();
	150	else {
	151	current_thread_info()->status &= ~TS_POLLING;
	152	smp_mb__after_clear_bit();
	153	safe_halt();
	154	current_thread_info()->status \|= TS_POLLING;
	155	}
	156	}
	157
d2eea68e RM	158	/*
d2eea68e RM	159	* Set the bit indicating "nosegneg" library variants should be used.
6a52e4b1 JF	160	* We only need to bother in pure 32-bit mode; compat 32-bit processes
6a52e4b1 JF	161	* can have un-truncated segments, so wrapping around is allowed.
d2eea68e	162	*/
08b6d290	163	static void __init fiddle_vdso(void)
d2eea68e	164	{
6a52e4b1 JF	165	#ifdef CONFIG_X86_32
	166	u32 *mask;
	167	mask = VDSO32_SYMBOL(&vdso32_int80_start, NOTE_MASK);
	168	*mask \|= 1 << VDSO_NOTE_NONEGSEG_BIT;
	169	mask = VDSO32_SYMBOL(&vdso32_sysenter_start, NOTE_MASK);
d2eea68e	170	*mask \|= 1 << VDSO_NOTE_NONEGSEG_BIT;
6fcac6d3	171	#endif
d2eea68e RM	172	}
d2eea68e RM	173
88459d4c	174	static __cpuinit int register_callback(unsigned type, const void *func)
e2a81baf	175	{
88459d4c JF	176	struct callback_register callback = {
	177	.type = type,
	178	.address = XEN_CALLBACK(__KERNEL_CS, func),
e2a81baf JF	179	.flags = CALLBACKF_mask_events,
	180	};
	181
88459d4c JF	182	return HYPERVISOR_callback_op(CALLBACKOP_register, &callback);
	183	}
	184
	185	void __cpuinit xen_enable_sysenter(void)
	186	{
6fcac6d3	187	int ret;
62541c37	188	unsigned sysenter_feature;
6fcac6d3 JF	189
6fcac6d3 JF	190	#ifdef CONFIG_X86_32
62541c37	191	sysenter_feature = X86_FEATURE_SEP;
6fcac6d3	192	#else
62541c37	193	sysenter_feature = X86_FEATURE_SYSENTER32;
6fcac6d3	194	#endif
88459d4c	195
62541c37 JF	196	if (!boot_cpu_has(sysenter_feature))
	197	return;
	198
6fcac6d3	199	ret = register_callback(CALLBACKTYPE_sysenter, xen_sysenter_target);
62541c37 JF	200	if(ret != 0)
62541c37 JF	201	setup_clear_cpu_cap(sysenter_feature);
e2a81baf JF	202	}
e2a81baf JF	203
6fcac6d3 JF	204	void __cpuinit xen_enable_syscall(void)
	205	{
	206	#ifdef CONFIG_X86_64
6fcac6d3	207	int ret;
6fcac6d3 JF	208
	209	ret = register_callback(CALLBACKTYPE_syscall, xen_syscall_target);
	210	if (ret != 0) {
d5303b81	211	printk(KERN_ERR "Failed to set syscall callback: %d\n", ret);
62541c37 JF	212	/* Pretty fatal; 64-bit userspace has no other
	213	mechanism for syscalls. */
	214	}
	215
	216	if (boot_cpu_has(X86_FEATURE_SYSCALL32)) {
6fcac6d3 JF	217	ret = register_callback(CALLBACKTYPE_syscall32,
6fcac6d3 JF	218	xen_syscall32_target);
d5303b81	219	if (ret != 0)
62541c37	220	setup_clear_cpu_cap(X86_FEATURE_SYSCALL32);
6fcac6d3 JF	221	}
	222	#endif /* CONFIG_X86_64 */
	223	}
	224
5ead97c8 JF	225	void __init xen_arch_setup(void)
	226	{
	227	struct physdev_set_iopl set_iopl;
	228	int rc;
	229
f09f6d19 DD	230	xen_panic_handler_init();
f09f6d19 DD	231
5ead97c8 JF	232	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_4gb_segments);
	233	HYPERVISOR_vm_assist(VMASST_CMD_enable, VMASST_TYPE_writable_pagetables);
	234
	235	if (!xen_feature(XENFEAT_auto_translated_physmap))
f63c2f24 T	236	HYPERVISOR_vm_assist(VMASST_CMD_enable,
f63c2f24 T	237	VMASST_TYPE_pae_extended_cr3);
5ead97c8	238
88459d4c JF	239	if (register_callback(CALLBACKTYPE_event, xen_hypervisor_callback) \|\|
	240	register_callback(CALLBACKTYPE_failsafe, xen_failsafe_callback))
	241	BUG();
5ead97c8	242
e2a81baf	243	xen_enable_sysenter();
6fcac6d3	244	xen_enable_syscall();
e2a81baf	245
5ead97c8 JF	246	set_iopl.iopl = 1;
	247	rc = HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
	248	if (rc != 0)
	249	printk(KERN_INFO "physdev_op failed %d\n", rc);
	250
	251	#ifdef CONFIG_ACPI
	252	if (!(xen_start_info->flags & SIF_INITDOMAIN)) {
	253	printk(KERN_INFO "ACPI in unprivileged domain disabled\n");
	254	disable_acpi();
	255	}
	256	#endif
	257
	258	memcpy(boot_command_line, xen_start_info->cmd_line,
	259	MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ?
	260	COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE);
	261
	262	pm_idle = xen_idle;
f87e4cac	263
dfdcdd42	264	paravirt_disable_iospace();
d2eea68e RM	265
d2eea68e RM	266	fiddle_vdso();
5ead97c8	267	}