Add Xen support

2009-03-11  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* i386/i386/vm_param.h (VM_MIN_KERNEL_ADDRESS) [MACH_XEN]: Set to
	0x20000000.
	* i386/i386/i386asm.sym (pfn_list) [VM_MIN_KERNEL_ADDRESS ==
	LINEAR_MIN_KERNEL_ADDRESS]: Define to constant PFN_LIST.

2009-02-27  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* i386/intel/pmap.c [MACH_HYP] (INVALIDATE_TLB): Call hyp_invlpg
	instead of flush_tlb when e - s is compile-time known to be
	PAGE_SIZE.

2008-11-27  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* i386/configfrag.ac (enable_pae): Enable by default on the Xen
	platform.

2007-11-14  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* i386/i386at/model_dep.c (machine_relax): New function.
	(c_boot_entry): Refuse to boot as dom0.

2007-10-17  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* i386/i386/fpu.c [MACH_XEN]: Disable unused fpintr().

2007-08-12  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* Makefile.am (clib_routines): Add _START.
	* i386/xen/xen_boothdr: Use _START for VIRT_BASE and PADDR_OFFSET. Add
	GUEST_VERSION and XEN_ELFNOTE_FEATURES.

2007-06-13  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* i386/i386/user_ldt.h (user_ldt) [MACH_XEN]: Add alloc field.
	* i386/i386/user_ldt.c (i386_set_ldt) [MACH_XEN]: Round allocation of
	LDT to a page, set back LDT pages read/write before freeing them.
	(user_ldt_free) [MACH_XEN]: Likewise.

2007-04-18  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	* device/ds_routines.c [MACH_HYP]: Add hypervisor block and net devices.

2007-02-19  Thomas Schwinge  <tschwinge@gnu.org>

	* i386/xen/Makefrag.am [PLATFORM_xen] (gnumach_LINKFLAGS): Define.

	* Makefrag.am: Include `xen/Makefrag.am'.
	* configure.ac: Include `xen/configfrag.ac'.
	(--enable-platform): Support the `xen' platform.
	* i386/configfrag.ac: Likewise.
	* i386/Makefrag.am [PLATFORM_xen]: Include `i386/xen/Makefrag.am'.

2007-02-19  Samuel Thibault  <samuel.thibault@ens-lyon.org>
	    Thomas Schwinge  <tschwinge@gnu.org>

	* i386/xen/Makefrag.am: New file.
	* xen/Makefrag.am: Likewise.
	* xen/configfrag.ac: Likewise.

2007-02-11 (and later dates)  Samuel Thibault  <samuel.thibault@ens-lyon.org>

	Xen support
	* Makefile.am (clib_routines): Add _start.
	* Makefrag.am (include_mach_HEADERS): Add include/mach/xen.h.
	* device/cons.c (cnputc): Call hyp_console_write.
	* i386/Makefrag.am (libkernel_a_SOURCES): Move non-Xen source to
	[PLATFORM_at].
	* i386/i386/debug_trace.S: Include <i386/xen.h>
	* i386/i386/fpu.c [MACH_HYP] (init_fpu): Call set_ts() and clear_ts(),
	do not enable CR0_EM.
	* i386/i386/gdt.c: Include <mach/xen.h> and <intel/pmap.h>.
	[MACH_XEN]: Make gdt array extern.
	[MACH_XEN] (gdt_init): Register gdt with hypervisor.  Request 4gb
	segments assist.  Shift la_shift.
	[MACH_PSEUDO_PHYS] (gdt_init): Shift pfn_list.
	* i386/i386/gdt.h [MACH_XEN]: Don't define KERNEL_LDT and LINEAR_DS.
	* i386/i386/i386asm.sym: Include <i386/xen.h>.
	[MACH_XEN]: Remove KERNEL_LDT, Add shared_info's CPU_CLI, CPU_PENDING,
	CPU_PENDING_SEL, PENDING, EVTMASK and CR2.
	* i386/i386/idt.c [MACH_HYP] (idt_init): Register trap table with
	hypervisor.
	* i386/i386/idt_inittab.S: Include <i386/i386asm.h>.
	[MACH_XEN]: Set IDT_ENTRY() for hypervisor. Set trap table terminator.
	* i386/i386/ktss.c [MACH_XEN] (ktss_init): Request exception task switch
	from hypervisor.
	* i386/i386/ldt.c: Include <mach/xen.h> and <intel/pmap.h>
	[MACH_XEN]: Make ldt array extern.
	[MACH_XEN] (ldt_init): Set ldt readwrite.
	[MACH_HYP] (ldt_init): Register ldt with hypervisor.
	* i386/i386/locore.S: Include <i386/xen.h>. Handle KERNEL_RING == 1
	case.
	[MACH_XEN]: Read hyp_shared_info's CR2 instead of %cr2.
	[MACH_PSEUDO_PHYS]: Add mfn_to_pfn computation.
	[MACH_HYP]: Drop Cyrix I/O-based detection.  Read cr3 instead of %cr3.
	Make hypervisor call for pte invalidation.
	* i386/i386/mp_desc.c: Include <mach/xen.h>.
	[MACH_HYP] (mp_desc_init): Panic.
	* i386/i386/pcb.c: Include <mach/xen.h>.
	[MACH_XEN] (switch_ktss): Request stack switch from hypervisor.
	[MACH_HYP] (switch_ktss): Request ldt and gdt switch from hypervisor.
	* i386/i386/phys.c: Include <mach/xen.h>
	[MACH_PSEUDO_PHYS] (kvtophys): Do page translation.
	* i386/i386/proc_reg.h [MACH_HYP] (cr3): New declaration.
	(set_cr3, get_cr3, set_ts, clear_ts): Implement macros.
	* i386/i386/seg.h [MACH_HYP]: Define KERNEL_RING macro.  Include
	<mach/xen.h>
	[MACH_XEN] (fill_descriptor): Register descriptor with hypervisor.
	* i386/i386/spl.S: Include <i386/xen.h> and <i386/i386/asm.h>
	[MACH_XEN] (pic_mask): #define to int_mask.
	[MACH_XEN] (SETMASK): Implement.
	* i386/i386/vm_param.h [MACH_XEN] (HYP_VIRT_START): New macro.
	[MACH_XEN]: Set VM_MAX_KERNEL_ADDRESS to HYP_VIRT_START-
	LINEAR_MIN_KERNEL_ADDRESS + VM_MIN_KERNEL_ADDRESS.  Increase
	KERNEL_STACK_SIZE and INTSTACK_SIZE to 4 pages.
	* i386/i386at/conf.c [MACH_HYP]: Remove hardware devices, add hypervisor
	console device.
	* i386/i386at/cons_conf.c [MACH_HYP]: Add hypervisor console device.
	* i386/i386at/model_dep.c: Include <sys/types.h>, <mach/xen.h>.
	[MACH_XEN] Include <xen/console.h>, <xen/store.h>, <xen/evt.h>,
	<xen/xen.h>.
	[MACH_PSEUDO_PHYS]: New boot_info, mfn_list, pfn_list variables.
	[MACH_XEN]: New la_shift variable.
	[MACH_HYP] (avail_next, mem_size_init): Drop BIOS skipping mecanism.
	[MACH_HYP] (machine_init): Call hyp_init(), drop hardware
	initialization.
	[MACH_HYP] (machine_idle): Call hyp_idle().
	[MACH_HYP] (halt_cpu): Call hyp_halt().
	[MACH_HYP] (halt_all_cpus): Call hyp_reboot() or hyp_halt().
	[MACH_HYP] (i386at_init): Initialize with hypervisor.
	[MACH_XEN] (c_boot_entry): Add Xen-specific initialization.
	[MACH_HYP] (init_alloc_aligned, pmap_valid_page): Drop zones skipping
	mecanism.
	* i386/intel/pmap.c: Include <mach/xen.h>.
	[MACH_PSEUDO_PHYS] (WRITE_PTE): Do page translation.
	[MACH_HYP] (INVALIDATE_TLB): Request invalidation from hypervisor.
	[MACH_XEN] (pmap_map_bd, pmap_create, pmap_destroy, pmap_remove_range)
	(pmap_page_protect, pmap_protect, pmap_enter, pmap_change_wiring)
	(pmap_attribute_clear, pmap_unmap_page_zero, pmap_collect): Request MMU
	update from hypervisor.
	[MACH_XEN] (pmap_bootstrap): Request pagetable initialization from
	hypervisor.
	[MACH_XEN] (pmap_set_page_readwrite, pmap_set_page_readonly)
	(pmap_set_page_readonly_init, pmap_clear_bootstrap_pagetable)
	(pmap_map_mfn): New functions.
	* i386/intel/pmap.h [MACH_XEN] (INTEL_PTE_GLOBAL): Disable global page
	support.
	[MACH_PSEUDO_PHYS] (pte_to_pa): Do page translation.
	[MACH_XEN] (pmap_set_page_readwrite, pmap_set_page_readonly)
	(pmap_set_page_readonly_init, pmap_clear_bootstrap_pagetable)
	(pmap_map_mfn): Declare functions.
	* i386/i386/xen.h: New file.
	* i386/xen/xen.c: New file.
	* i386/xen/xen_boothdr.S: New file.
	* i386/xen/xen_locore.S: New file.
	* include/mach/xen.h: New file.
	* kern/bootstrap.c [MACH_XEN] (boot_info): Declare variable.
	[MACH_XEN] (bootstrap_create): Rebase multiboot header.
	* kern/debug.c: Include <mach/xen.h>.
	[MACH_HYP] (panic): Call hyp_crash() without delay.
	* linux/dev/include/asm-i386/segment.h [MACH_HYP] (KERNEL_CS)
	(KERNEL_DS): Use ring 1.
	* xen/block.c: New file.
	* xen/block.h: Likewise.
	* xen/console.c: Likewise.
	* xen/console.h: Likewise.
	* xen/evt.c: Likewise.
	* xen/evt.h: Likewise.
	* xen/grant.c: Likewise.
	* xen/grant.h: Likewise.
	* xen/net.c: Likewise.
	* xen/net.h: Likewise.
	* xen/ring.c: Likewise.
	* xen/ring.h: Likewise.
	* xen/store.c: Likewise.
	* xen/store.h: Likewise.
	* xen/time.c: Likewise.
	* xen/time.h: Likewise.
	* xen/xen.c: Likewise.
	* xen/xen.h: Likewise.
	* xen/public/COPYING: Import file from Xen.
	* xen/public/callback.h: Likewise.
	* xen/public/dom0_ops.h: Likewise.
	* xen/public/domctl.h: Likewise.
	* xen/public/elfnote.h: Likewise.
	* xen/public/elfstructs.h: Likewise.
	* xen/public/event_channel.h: Likewise.
	* xen/public/features.h: Likewise.
	* xen/public/grant_table.h: Likewise.
	* xen/public/kexec.h: Likewise.
	* xen/public/libelf.h: Likewise.
	* xen/public/memory.h: Likewise.
	* xen/public/nmi.h: Likewise.
	* xen/public/physdev.h: Likewise.
	* xen/public/platform.h: Likewise.
	* xen/public/sched.h: Likewise.
	* xen/public/sysctl.h: Likewise.
	* xen/public/trace.h: Likewise.
	* xen/public/vcpu.h: Likewise.
	* xen/public/version.h: Likewise.
	* xen/public/xen-compat.h: Likewise.
	* xen/public/xen.h: Likewise.
	* xen/public/xencomm.h: Likewise.
	* xen/public/xenoprof.h: Likewise.
	* xen/public/arch-x86/xen-mca.h: Likewise.
	* xen/public/arch-x86/xen-x86_32.h: Likewise.
	* xen/public/arch-x86/xen-x86_64.h: Likewise.
	* xen/public/arch-x86/xen.h: Likewise.
	* xen/public/arch-x86_32.h: Likewise.
	* xen/public/arch-x86_64.h: Likewise.
	* xen/public/io/blkif.h: Likewise.
	* xen/public/io/console.h: Likewise.
	* xen/public/io/fbif.h: Likewise.
	* xen/public/io/fsif.h: Likewise.
	* xen/public/io/kbdif.h: Likewise.
	* xen/public/io/netif.h: Likewise.
	* xen/public/io/pciif.h: Likewise.
	* xen/public/io/protocols.h: Likewise.
	* xen/public/io/ring.h: Likewise.
	* xen/public/io/tpmif.h: Likewise.
	* xen/public/io/xenbus.h: Likewise.
	* xen/public/io/xs_wire.h: Likewise.

1 files changed, 334 insertions, 0 deletions

diff --git a/xen/store.c b/xen/store.c
new file mode 100644
index 00000000..3c6baebf
--- /dev/null
+++ b/xen/store.c
@@ -0,0 +1,334 @@
+/*
+ *  Copyright (C) 2006 Samuel Thibault <samuel.thibault@ens-lyon.org>
+ *
+ * This program is free software ; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation ; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY ; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with the program ; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <sys/types.h>
+#include <mach/mig_support.h>
+#include <machine/pmap.h>
+#include <machine/ipl.h>
+#include <stdarg.h>
+#include <string.h>
+#include <alloca.h>
+#include <xen/public/xen.h>
+#include <xen/public/io/xs_wire.h>
+#include <util/atoi.h>
+#include "store.h"
+#include "ring.h"
+#include "evt.h"
+#include "xen.h"
+
+/* TODO use events instead of just yielding */
+
+/* Hypervisor part */
+
+decl_simple_lock_data(static, lock);
+
+static struct xenstore_domain_interface *store;
+
+struct store_req {
+	const char *data;
+	unsigned len;
+};
+
+/* Send a request */
+static void store_put(hyp_store_transaction_t t, unsigned32_t type, struct store_req *req, unsigned nr_reqs) {
+	struct xsd_sockmsg head = {
+		.type = type,
+		.req_id = 0,
+		.tx_id = t,
+	};
+	unsigned totlen, len;
+	unsigned i;
+
+	totlen = 0;
+	for (i = 0; i < nr_reqs; i++)
+		totlen += req[i].len;
+	head.len = totlen;
+	totlen += sizeof(head);
+
+	if (totlen > sizeof(store->req) - 1)
+		panic("too big store message %d, max %d", totlen, sizeof(store->req));
+
+	while (hyp_ring_available(store->req, store->req_prod, store->req_cons) < totlen)
+		hyp_yield();
+
+	mb();
+	hyp_ring_store(&hyp_ring_cell(store->req, store->req_prod), &head, sizeof(head), store->req, store->req + sizeof(store->req));
+	len = sizeof(head);
+	for (i=0; i<nr_reqs; i++) {
+		hyp_ring_store(&hyp_ring_cell(store->req, store->req_prod + len), req[i].data, req[i].len, store->req, store->req + sizeof(store->req));
+		len += req[i].len;
+	}
+
+	wmb();
+	store->req_prod += totlen;
+	hyp_event_channel_send(boot_info.store_evtchn);
+}
+
+static const char *errors[] = {
+	"EINVAL",
+	"EACCES",
+	"EEXIST",
+	"EISDIR",
+	"ENOENT",
+	"ENOMEM",
+	"ENOSPC",
+	"EIO",
+	"ENOTEMPTY",
+	"ENOSYS",
+	"EROFS",
+	"EBUSY",
+	"EAGAIN",
+	"EISCONN",
+	NULL,
+};
+
+/* Send a request and wait for a reply, whose header is put in head, and
+ * data is returned (beware, that's in the ring !)
+ * On error, returns NULL.  Else takes the lock and return pointer on data and
+ * store_put_wait_end shall be called after reading it.  */
+static struct xsd_sockmsg head;
+const char *hyp_store_error;
+
+static void *store_put_wait(hyp_store_transaction_t t, unsigned32_t type, struct store_req *req, unsigned nr_reqs) {
+	unsigned len;
+	const char **error;
+	void *data;
+
+	simple_lock(&lock);
+	store_put(t, type, req, nr_reqs);
+again:
+	while (store->rsp_prod - store->rsp_cons < sizeof(head))
+		hyp_yield();
+	rmb();
+	hyp_ring_fetch(&head, &hyp_ring_cell(store->rsp, store->rsp_cons), sizeof(head), store->rsp, store->rsp + sizeof(store->rsp));
+	len = sizeof(head) + head.len;
+	while (store->rsp_prod - store->rsp_cons < len)
+		hyp_yield();
+	rmb();
+	if (head.type == XS_WATCH_EVENT) {
+		/* Spurious watch event, drop */
+		store->rsp_cons += sizeof(head) + head.len;
+		hyp_event_channel_send(boot_info.store_evtchn);
+		goto again;
+	}
+	data = &hyp_ring_cell(store->rsp, store->rsp_cons + sizeof(head));
+	if (head.len <= 10) {
+		char c[10];
+		hyp_ring_fetch(c, data, head.len, store->rsp, store->rsp + sizeof(store->rsp));
+		for (error = errors; *error; error++) {
+			if (head.len == strlen(*error) + 1 && !memcmp(*error, c, head.len)) {
+				hyp_store_error = *error;
+				store->rsp_cons += len;
+				hyp_event_channel_send(boot_info.store_evtchn);
+				simple_unlock(&lock);
+				return NULL;
+			}
+		}
+	}
+	return data;
+}
+
+/* Must be called after each store_put_wait.  Releases lock.  */
+static void store_put_wait_end(void) {
+	mb();
+	store->rsp_cons += sizeof(head) + head.len;
+	hyp_event_channel_send(boot_info.store_evtchn);
+	simple_unlock(&lock);
+}
+
+/* Start a transaction.  */
+hyp_store_transaction_t hyp_store_transaction_start(void) {
+	struct store_req req = {
+		.data = "",
+		.len = 1,
+	};
+	char *rep;
+	char *s;
+	int i;
+
+	rep = store_put_wait(0, XS_TRANSACTION_START, &req, 1);
+	if (!rep)
+		panic("couldn't start transaction (%s)", hyp_store_error);
+	s = alloca(head.len);
+	hyp_ring_fetch(s, rep, head.len, store->rsp, store->rsp + sizeof(store->rsp));
+	mach_atoi((u_char*) s, &i);
+	if (i == MACH_ATOI_DEFAULT)
+		panic("bogus transaction id len %d '%s'", head.len, s);
+	store_put_wait_end();
+	return i;
+}
+
+/* Stop a transaction.  */
+int hyp_store_transaction_stop(hyp_store_transaction_t t) {
+	struct store_req req = {
+		.data = "T",
+		.len = 2,
+	};
+	int ret = 1;
+	void *rep;
+	rep = store_put_wait(t, XS_TRANSACTION_END, &req, 1);
+	if (!rep)
+		return 0;
+	store_put_wait_end();
+	return ret;
+}
+
+/* List a directory: returns an array to file names, terminated by NULL.  Free
+ * with kfree.  */
+char **hyp_store_ls(hyp_store_transaction_t t, int n, ...) {
+	struct store_req req[n];
+	va_list listp;
+	int i;
+	char *rep;
+	char *c;
+	char **res, **rsp;
+
+	va_start (listp, n);
+	for (i = 0; i < n; i++) {
+		req[i].data = va_arg(listp, char *);
+		req[i].len = strlen(req[i].data);
+	}
+	req[n - 1].len++;
+	va_end (listp);
+
+	rep = store_put_wait(t, XS_DIRECTORY, req, n);
+	if (!rep)
+		return NULL;
+	i = 0;
+	for (	c = rep, n = 0;
+		n < head.len;
+		n += hyp_ring_next_word(&c, store->rsp, store->rsp + sizeof(store->rsp)) + 1)
+		i++;
+	res = (void*) kalloc((i + 1) * sizeof(char*) + head.len);
+	if (!res)
+		hyp_store_error = "ENOMEM";
+	else {
+		hyp_ring_fetch(res + (i + 1), rep, head.len, store->rsp, store->rsp + sizeof(store->rsp));
+		rsp = res;
+		for (c = (char*) (res + (i + 1)); i; i--, c += strlen(c) + 1)
+			*rsp++ = c;
+		*rsp = NULL;
+	}
+	store_put_wait_end();
+	return res;
+}
+
+/* Get the value of an entry, va version.  */
+static void *hyp_store_read_va(hyp_store_transaction_t t, int n, va_list listp) {
+	struct store_req req[n];
+	int i;
+	void *rep;
+	char *res;
+
+	for (i = 0; i < n; i++) {
+		req[i].data = va_arg(listp, char *);
+		req[i].len = strlen(req[i].data);
+	}
+	req[n - 1].len++;
+
+	rep = store_put_wait(t, XS_READ, req, n);
+	if (!rep)
+		return NULL;
+	res = (void*) kalloc(head.len + 1);
+	if (!res)
+		hyp_store_error = "ENOMEM";
+	else {
+		hyp_ring_fetch(res, rep, head.len, store->rsp, store->rsp + sizeof(store->rsp));
+		res[head.len] = 0;
+	}
+	store_put_wait_end();
+	return res;
+}
+
+/* Get the value of an entry.  Free with kfree.  */
+void *hyp_store_read(hyp_store_transaction_t t, int n, ...) {
+	va_list listp;
+	char *res;
+
+	va_start(listp, n);
+	res = hyp_store_read_va(t, n, listp);
+	va_end(listp);
+	return res;
+}
+
+/* Get the integer value of an entry, -1 on error.  */
+int hyp_store_read_int(hyp_store_transaction_t t, int n, ...) {
+	va_list listp;
+	char *res;
+	int i;
+
+	va_start(listp, n);
+	res = hyp_store_read_va(t, n, listp);
+	va_end(listp);
+	if (!res)
+		return -1;
+	mach_atoi((u_char *) res, &i);
+	if (i == MACH_ATOI_DEFAULT)
+		printf("bogus integer '%s'\n", res);
+	kfree((vm_offset_t) res, strlen(res)+1);
+	return i;
+}
+
+/* Set the value of an entry.  */
+char *hyp_store_write(hyp_store_transaction_t t, const char *data, int n, ...) {
+	struct store_req req[n + 1];
+	va_list listp;
+	int i;
+	void *rep;
+	char *res;
+
+	va_start (listp, n);
+	for (i = 0; i < n; i++) {
+		req[i].data = va_arg(listp, char *);
+		req[i].len = strlen(req[i].data);
+	}
+	req[n - 1].len++;
+	req[n].data = data;
+	req[n].len = strlen (data);
+	va_end (listp);
+
+	rep = store_put_wait (t, XS_WRITE, req, n + 1);
+	if (!rep)
+		return NULL;
+	res = (void*) kalloc(head.len + 1);
+	if (!res)
+		hyp_store_error = NULL;
+	else {
+		hyp_ring_fetch(res, rep, head.len, store->rsp, store->rsp + sizeof(store->rsp));
+		res[head.len] = 0;
+	}
+	store_put_wait_end();
+	return res;
+}
+
+static void hyp_store_handler(int unit)
+{
+	thread_wakeup(&boot_info.store_evtchn);
+}
+
+/* Map store's shared page.  */
+void hyp_store_init(void)
+{
+	if (store)
+		return;
+	simple_lock_init(&lock);
+	store = (void*) mfn_to_kv(boot_info.store_mfn);
+	pmap_set_page_readwrite(store);
+	/* SPL sched */
+	hyp_evt_handler(boot_info.store_evtchn, hyp_store_handler, 0, SPL7);
+}