Tue Mar 25 10:49:13 UTC 2008

Author: markmc

Update of /cvs/pkgs/rpms/kernel-xen-2.6/devel
In directory cvs-int.fedora.redhat.com:/tmp/cvs-serv2656

Modified Files:
	Makefile Makefile.config kernel.spec 
Added Files:
	linux-2.6-xen-0001-squashfs-Fix-build-without-CONFIG_SMP.patch 
	linux-2.6-xen-0002-xen-execshield-Add-xen-specific-load_user_cs_desc.patch 
	linux-2.6-xen-0003-xen-execshield-fix-endless-GPF-fault-loop.patch 
	linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch 
	linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch 
	linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch 
	linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch 
	linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch 
	linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch 
	linux-2.6-xen-0010-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch 
	linux-2.6-xen-0011-xen-Add-a-vmlinuz-target.patch 
	linux-2.6-xen-0012-xen-Add-empty-xenctrl-module.patch 
	linux-2.6-xen-0013-xen-Add-proc-xen-capabilities.patch 
	linux-2.6-xen-0014-xen-Add-proc-xen-privcmd.patch 
	linux-2.6-xen-0015-xen-Add-proc-xen-xenbus.patch 
	linux-2.6-xen-0016-xen-Add-Xen-s-sys-hypervisor-interface.patch 
	linux-2.6-xen-0017-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch 
	linux-2.6-xen-0018-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch 
Removed Files:
	linux-2.6-xen-0001-Revert-linux-2.6-execshield.patch.patch 
	linux-2.6-xen-0002-squashfs-Fix-build-without-CONFIG_SMP.patch 
	linux-2.6-xen-0003-xen-Make-hvc0-the-preferred-console-in-domU.patch 
	linux-2.6-xen-0004-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch 
	linux-2.6-xen-0005-fbdev-Make-deferred-I-O-work-as-advertized.patch 
	linux-2.6-xen-0006-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch 
	linux-2.6-xen-0007-xen-Module-autoprobing-support-for-frontend-drivers.patch 
	linux-2.6-xen-0008-xen-Add-compatibility-aliases-for-frontend-drivers.patch 
	linux-2.6-xen-0009-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch 
	linux-2.6-xen-0010-xen-Add-a-vmlinuz-target.patch 
	linux-2.6-xen-0011-xen-Add-empty-xenctrl-module.patch 
	linux-2.6-xen-0012-xen-Add-proc-xen-capabilities.patch 
	linux-2.6-xen-0013-xen-Add-proc-xen-privcmd.patch 
	linux-2.6-xen-0014-xen-Add-proc-xen-xenbus.patch 
	linux-2.6-xen-0015-xen-Add-Xen-s-sys-hypervisor-interface.patch 
	linux-2.6-xen-0016-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch 
	linux-2.6-xen-0017-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch 
Log Message:
* Tue Mar 25 2008 Mark McLoughlin <markmc at redhat.com>
- Re-enable execshield (bug #434759)


linux-2.6-xen-0001-squashfs-Fix-build-without-CONFIG_SMP.patch:

--- NEW FILE linux-2.6-xen-0001-squashfs-Fix-build-without-CONFIG_SMP.patch ---
>From 9f1956a96db70970723ec983771988d70cb8286d Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Wed, 5 Mar 2008 12:50:50 +0000
Subject: [PATCH] squashfs: Fix build without CONFIG_SMP

wait_event() needs various definitions from <linux/sched.h>

With CONFIG_SMP, <linux/smp_lock.h> pulls in <linux/sched.h>,
but without CONFIG_SMP it fails to build.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 fs/squashfs/inode.c |    1 +
 1 files changed, 1 insertions(+), 0 deletions(-)

diff --git a/fs/squashfs/inode.c b/fs/squashfs/inode.c
index f578528..f5829f2 100644
--- a/fs/squashfs/inode.c
+++ b/fs/squashfs/inode.c
@@ -32,6 +32,7 @@
 #include <linux/vmalloc.h>
 #include <linux/smp_lock.h>
 #include <linux/exportfs.h>
+#include <linux/sched.h>
 
 #include "squashfs.h"
 
-- 
1.5.4.1


linux-2.6-xen-0002-xen-execshield-Add-xen-specific-load_user_cs_desc.patch:

--- NEW FILE linux-2.6-xen-0002-xen-execshield-Add-xen-specific-load_user_cs_desc.patch ---
>From bfbd59d692de3fd904957de3d66047dd830e89f5 Mon Sep 17 00:00:00 2001
From: Stephen Tweedie <sct at redhat.com>
Date: Tue, 11 Mar 2008 18:05:30 +0000
Subject: [PATCH] xen execshield: Add xen-specific load_user_cs_desc()

x86 32-bit execshield uses load_user_cs_desc() to setup the user CS
descriptor, but the Xen version needs to do this via a hypercall.

Add this via a new pv_cpu_ops->load_user_cs_desc pv_ops indirection
so that it can be selected appropriately at run-time.

Signed-off-by: Stephen Tweedie <sct at redhat.com>
---
 arch/x86/kernel/paravirt.c |    1 +
 arch/x86/xen/enlighten.c   |   17 +++++++++++++++++
 include/asm-x86/desc.h     |    8 ++++++--
 include/asm-x86/paravirt.h |    6 ++++++
 4 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/arch/x86/kernel/paravirt.c b/arch/x86/kernel/paravirt.c
index 075962c..d59db07 100644
--- a/arch/x86/kernel/paravirt.c
+++ b/arch/x86/kernel/paravirt.c
@@ -331,6 +331,7 @@ struct pv_cpu_ops pv_cpu_ops = {
 	.read_tscp = native_read_tscp,
 	.load_tr_desc = native_load_tr_desc,
 	.set_ldt = native_set_ldt,
+	.load_user_cs_desc = native_load_user_cs_desc,
 	.load_gdt = native_load_gdt,
 	.load_idt = native_load_idt,
 	.store_gdt = native_store_gdt,
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index 8b9ee27..e9a84f6 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -289,6 +289,22 @@ static void xen_set_ldt(const void *addr, unsigned entries)
 	xen_mc_issue(PARAVIRT_LAZY_CPU);
 }
 
+static inline void xen_load_user_cs_desc(int cpu, struct mm_struct *mm)
+{
+	void *gdt;
+	xmaddr_t mgdt;
+	u64 descriptor;
+	struct desc_struct user_cs;
+	
+	gdt = &get_cpu_gdt_table(cpu)[GDT_ENTRY_DEFAULT_USER_CS];
+	mgdt = virt_to_machine(gdt);
+
+	user_cs = mm->context.user_cs;
+	descriptor = (u64) user_cs.a | ((u64) user_cs.b) << 32;
+
+	HYPERVISOR_update_descriptor(mgdt.maddr, descriptor);
+}
+
 static void xen_load_gdt(const struct desc_ptr *dtr)
 {
 	unsigned long *frames;
@@ -974,6 +990,7 @@ static const struct pv_cpu_ops xen_cpu_ops __initdata = {
 
 	.load_tr_desc = paravirt_nop,
 	.set_ldt = xen_set_ldt,
+	.load_user_cs_desc = xen_load_user_cs_desc,
 	.load_gdt = xen_load_gdt,
 	.load_idt = xen_load_idt,
 	.load_tls = xen_load_tls,
diff --git a/include/asm-x86/desc.h b/include/asm-x86/desc.h
index 7ad80b9..ec3a84a 100644
--- a/include/asm-x86/desc.h
+++ b/include/asm-x86/desc.h
@@ -6,6 +6,7 @@
 #include <asm/ldt.h>
 #include <asm/mmu.h>
 #include <linux/smp.h>
+#include <linux/mm_types.h>
 
 static inline void fill_ldt(struct desc_struct *desc,
 			    const struct user_desc *info)
@@ -94,6 +95,7 @@ static inline int desc_empty(const void *ptr)
 
 #define load_TLS(t, cpu) native_load_tls(t, cpu)
 #define set_ldt native_set_ldt
+#define load_user_cs_desc native_load_user_cs_desc
 
 #define write_ldt_entry(dt, entry, desc) \
 				native_write_ldt_entry(dt, entry, desc)
@@ -360,8 +362,10 @@ static inline void set_user_cs(struct desc_struct *desc, unsigned long limit)
 	desc->b = (limit & 0xf0000) | 0x00c0fb00;
 }
 
-#define load_user_cs_desc(cpu, mm) \
-	get_cpu_gdt_table(cpu)[GDT_ENTRY_DEFAULT_USER_CS] = (mm)->context.user_cs
+static inline void native_load_user_cs_desc(int cpu, struct mm_struct *mm)
+{
+	get_cpu_gdt_table(cpu)[GDT_ENTRY_DEFAULT_USER_CS] = mm->context.user_cs;
+}
 
 #ifdef CONFIG_X86_32
 extern void arch_add_exec_range(struct mm_struct *mm, unsigned long limit);
diff --git a/include/asm-x86/paravirt.h b/include/asm-x86/paravirt.h
index d6236eb..ff8d218 100644
--- a/include/asm-x86/paravirt.h
+++ b/include/asm-x86/paravirt.h
@@ -113,6 +113,7 @@ struct pv_cpu_ops {
 	void (*store_gdt)(struct desc_ptr *);
 	void (*store_idt)(struct desc_ptr *);
 	void (*set_ldt)(const void *desc, unsigned entries);
+	void (*load_user_cs_desc)(int cpu, struct mm_struct *mm);
 	unsigned long (*store_tr)(void);
 	void (*load_tls)(struct thread_struct *t, unsigned int cpu);
 	void (*write_ldt_entry)(struct desc_struct *ldt, int entrynum,
@@ -754,6 +755,11 @@ static inline void set_ldt(const void *addr, unsigned entries)
 {
 	PVOP_VCALL2(pv_cpu_ops.set_ldt, addr, entries);
 }
+static inline void load_user_cs_desc(unsigned int cpu, 
+				     struct mm_struct *mm)
+{
+	PVOP_VCALL2(pv_cpu_ops.load_user_cs_desc, cpu, mm);
+}
 static inline void store_gdt(struct desc_ptr *dtr)
 {
 	PVOP_VCALL1(pv_cpu_ops.store_gdt, dtr);
-- 
1.5.4.1


linux-2.6-xen-0003-xen-execshield-fix-endless-GPF-fault-loop.patch:

--- NEW FILE linux-2.6-xen-0003-xen-execshield-fix-endless-GPF-fault-loop.patch ---
>From ec424a24c665e0177e74a2a3a68af50f5e73e68c Mon Sep 17 00:00:00 2001
From: Stephen Tweedie <sct at redhat.com>
Date: Tue, 11 Mar 2008 18:07:31 +0000
Subject: [PATCH] xen execshield: fix endless GPF fault loop

Under Xen, loading the user_cs descriptor does not necessarily load
the descriptor with the exact same values the kernel requested: some
of the control bits in the descriptor may be modified by the
hypervisor.

With execshield, the check_lazy_exec_limit() function is needed to
test whether a fault has been caused by the existing user_cs
descriptor being too constrained: if so, it performs a lazy expansion
of the legal cs segment bounds.  But it does so via an exact match on
the descriptor values against their current expected values, so if
Xen modifies any control bits in the descriptor, it looks as if the
user_cs is out-of-sync; so check_lazy_exec_limit() resets the
descriptor and retakes the fault unnecessarily.

This means that a GPF fault can be retried indefinitely, with the
kernel always seeing the wrong values in user_cs and continually
trying to correct them and retake the fault.

Fix it by masking off the xen-sensitive control bits when checking
that the segment descriptor is up-to-date, and comparing only the
bits which affect the segment base and limit.

Affects 32-bit only; execshield on 64-bit uses NX for this
functionality.

Signed-off-by: Stephen Tweedie <sct at redhat.com>
---
 arch/x86/kernel/traps_32.c |    3 ++-
 1 files changed, 2 insertions(+), 1 deletions(-)

diff --git a/arch/x86/kernel/traps_32.c b/arch/x86/kernel/traps_32.c
index 7865615..3d36a99 100644
--- a/arch/x86/kernel/traps_32.c
+++ b/arch/x86/kernel/traps_32.c
@@ -629,7 +629,8 @@ check_lazy_exec_limit(int cpu, struct pt_regs *regs, long error_code)
 	desc1 = &current->mm->context.user_cs;
 	desc2 = get_cpu_gdt_table(cpu) + GDT_ENTRY_DEFAULT_USER_CS;
 
-	if (desc1->a != desc2->a || desc1->b != desc2->b) {
+	if ((desc1->a & 0xff0000ff) != (desc2->a & 0xff0000ff) || 
+	    desc1->b != desc2->b) {
 		/*
 		 * The CS was not in sync - reload it and retry the
 		 * instruction. If the instruction still faults then
-- 
1.5.4.1


linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch:

Index: linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch
===================================================================
RCS file: linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch
diff -N linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch	25 Mar 2008 10:49:00 -0000	1.2
@@ -0,0 +1,39 @@
+From 2d56ff36bb367c6d64568bc4b92ef3f3a0e00d1e Mon Sep 17 00:00:00 2001
+From: Markus Armbruster <armbru at redhat.com>
+Date: Fri, 29 Feb 2008 17:37:43 +0000
+Subject: [PATCH] xen: Make hvc0 the preferred console in domU
+
+This makes the Xen console just work.  Before, you had to ask for it
+on the kernel command line with console=hvc0
+
+Signed-off-by: Markus Armbruster <armbru at redhat.com>
+Signed-off-by: Mark McLoughlin <markmc at redhat.com>
+---
+ arch/x86/xen/enlighten.c |    4 ++++
+ 1 files changed, 4 insertions(+), 0 deletions(-)
+
+diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
+index e9a84f6..75daa55 100644
+--- a/arch/x86/xen/enlighten.c
++++ b/arch/x86/xen/enlighten.c
+@@ -25,6 +25,7 @@
+ #include <linux/mm.h>
+ #include <linux/page-flags.h>
+ #include <linux/highmem.h>
++#include <linux/console.h>
+ 
+ #include <xen/interface/xen.h>
+ #include <xen/interface/physdev.h>
+@@ -1227,6 +1228,9 @@ asmlinkage void __init xen_start_kernel(void)
+ 		? __pa(xen_start_info->mod_start) : 0;
+ 	boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
+ 
++	if (!is_initial_xendomain())
++		add_preferred_console("hvc", 0, NULL);
++
+ 	/* Start the world */
+ 	start_kernel();
+ }
+-- 
+1.5.4.1
+

linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch:

Index: linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
===================================================================
RCS file: linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
diff -N linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch	25 Mar 2008 10:49:00 -0000	1.2
@@ -0,0 +1,78 @@
+From df43a93787049a8559b6d19e67231cb5e617cfa7 Mon Sep 17 00:00:00 2001
+From: Markus Armbruster <armbru at redhat.com>
+Date: Mon, 25 Feb 2008 14:02:24 +0100
+Subject: [PATCH] xen: Make xen-blkfront write its protocol ABI to xenstore
+
+Frontends are expected to write their protocol ABI to xenstore.  Since
+the protocol ABI defaults to the backend's native ABI, things work
+fine without that as long as the frontend's native ABI is identical to
+the backend's native ABI.  This is not the case for xen-blkfront
+running 32-on-64, because its ABI differs between 32 and 64 bit, and
+thus needs this fix.
+
+Based on http://xenbits.xensource.com/xen-unstable.hg?rev/c545932a18f3
+and http://xenbits.xensource.com/xen-unstable.hg?rev/ffe52263b430 by
+Gerd Hoffmann <kraxel at suse.de>
+
+Signed-off-by: Markus Armbruster <armbru at redhat.com>
+---
+ drivers/block/xen-blkfront.c         |    7 +++++++
+ include/xen/interface/io/protocols.h |   21 +++++++++++++++++++++
+ 2 files changed, 28 insertions(+), 0 deletions(-)
+ create mode 100644 include/xen/interface/io/protocols.h
+
+diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
+index 9c6f3f9..2e7c81e 100644
+--- a/drivers/block/xen-blkfront.c
++++ b/drivers/block/xen-blkfront.c
+@@ -47,6 +47,7 @@
+ 
+ #include <xen/interface/grant_table.h>
+ #include <xen/interface/io/blkif.h>
++#include <xen/interface/io/protocols.h>
+ 
+ #include <asm/xen/hypervisor.h>
+ 
+@@ -614,6 +615,12 @@ again:
+ 		message = "writing event-channel";
+ 		goto abort_transaction;
+ 	}
++	err = xenbus_printf(xbt, dev->nodename, "protocol", "%s",
++			    XEN_IO_PROTO_ABI_NATIVE);
++	if (err) {
++		message = "writing protocol";
++		goto abort_transaction;
++	}
+ 
+ 	err = xenbus_transaction_end(xbt, 0);
+ 	if (err) {
+diff --git a/include/xen/interface/io/protocols.h b/include/xen/interface/io/protocols.h
+new file mode 100644
+index 0000000..01fc8ae
+--- /dev/null
++++ b/include/xen/interface/io/protocols.h
+@@ -0,0 +1,21 @@
++#ifndef __XEN_PROTOCOLS_H__
++#define __XEN_PROTOCOLS_H__
++
++#define XEN_IO_PROTO_ABI_X86_32     "x86_32-abi"
++#define XEN_IO_PROTO_ABI_X86_64     "x86_64-abi"
++#define XEN_IO_PROTO_ABI_IA64       "ia64-abi"
++#define XEN_IO_PROTO_ABI_POWERPC64  "powerpc64-abi"
++
++#if defined(__i386__)
++# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_32
++#elif defined(__x86_64__)
++# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_64
++#elif defined(__ia64__)
++# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_IA64
++#elif defined(__powerpc64__)
++# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_POWERPC64
++#else
++# error arch fixup needed here
++#endif
++
++#endif
+-- 
+1.5.4.1
+

linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch:

Index: linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch
===================================================================
RCS file: linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch
diff -N linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch	25 Mar 2008 10:49:00 -0000	1.2
@@ -0,0 +1,87 @@
+From 2844965832a1b6b0540415ff1f99b4589b59784a Mon Sep 17 00:00:00 2001
+From: Markus Armbruster <armbru at redhat.com>
+Date: Mon, 25 Feb 2008 14:03:52 +0100
+Subject: [PATCH] fbdev: Make deferred I/O work as advertized
+
+Deferred I/O was utterly broken.  Reading the mmap()ed framebuffer
+worked, but writing it made the VM endlessly invoke
+vm_ops.page_mkwrite().  That happened because we failed to set
+page->mapping and page->index.
+
+The fix is to set them, and clean up properly before the framebuffer
+gets released.
+
+Fix extracted from this linux-fbdev-devel message:
+
+    Subject: [PATCH 1/1 2.6.24] fbdev: defio and Metronomefb
+    From: Jaya Kumar <jayakumar.lkml at gmail.com>
+    Date: 2008-02-18 13:41:26
+
+Signed-off-by: Jaya Kumar <jayakumar.lkml at gmail.com>
+Signed-off-by: Markus Armbruster <armbru at redhat.com>
+---
+ drivers/video/fb_defio.c |   22 ++++++++++++++++++++--
+ 1 files changed, 20 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
+index 0f8cfb9..24843fd 100644
+--- a/drivers/video/fb_defio.c
++++ b/drivers/video/fb_defio.c
+@@ -4,7 +4,7 @@
+  *  Copyright (C) 2006 Jaya Kumar
+  *
+  * This file is subject to the terms and conditions of the GNU General Public
+- * License.  See the file COPYING in the main directory of this archive
++ * License. See the file COPYING in the main directory of this archive
+  * for more details.
+  */
+ 
+@@ -31,7 +31,7 @@ static int fb_deferred_io_fault(struct vm_area_struct *vma,
+ 	unsigned long offset;
+ 	struct page *page;
+ 	struct fb_info *info = vma->vm_private_data;
+-	/* info->screen_base is in System RAM */
++	/* info->screen_base is virtual memory */
+ 	void *screen_base = (void __force *) info->screen_base;
+ 
+ 	offset = vmf->pgoff << PAGE_SHIFT;
+@@ -43,6 +43,15 @@ static int fb_deferred_io_fault(struct vm_area_struct *vma,
+ 		return VM_FAULT_SIGBUS;
+ 
+ 	get_page(page);
++
++	if (vma->vm_file)
++		page->mapping = vma->vm_file->f_mapping;
++	else
++		printk(KERN_ERR "no mapping available\n");
++
++	BUG_ON(!page->mapping);
++	page->index = vmf->pgoff;
++
+ 	vmf->page = page;
+ 	return 0;
+ }
+@@ -138,11 +147,20 @@ EXPORT_SYMBOL_GPL(fb_deferred_io_init);
+ 
+ void fb_deferred_io_cleanup(struct fb_info *info)
+ {
++	void *screen_base = (void __force *) info->screen_base;
+ 	struct fb_deferred_io *fbdefio = info->fbdefio;
++	struct page *page;
++	int i;
+ 
+ 	BUG_ON(!fbdefio);
+ 	cancel_delayed_work(&info->deferred_work);
+ 	flush_scheduled_work();
++
++	/* clear out the mapping that we setup */
++	for (i = 0 ; i < info->fix.smem_len; i += PAGE_SIZE) {
++		page = vmalloc_to_page(screen_base + i);
++		page->mapping = NULL;
++	}
+ }
+ EXPORT_SYMBOL_GPL(fb_deferred_io_cleanup);
+ 
+-- 
+1.5.4.1
+

linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch:

Index: linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
===================================================================
RCS file: linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
diff -N linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch	25 Mar 2008 10:49:00 -0000	1.2
@@ -0,0 +1,1254 @@
+From e75a7e2c2ad264cd145b7b0bff64a5bfa1f97c8f Mon Sep 17 00:00:00 2001
+From: Markus Armbruster <armbru at redhat.com>
+Date: Mon, 25 Feb 2008 14:06:46 +0100
+Subject: [PATCH] xen pvfb: Para-virtual framebuffer, keyboard and pointer driver
+
+This is a pair of Xen para-virtual frontend device drivers:
+drivers/video/xen-fbfront.c provides a framebuffer, and
+drivers/input/xen-kbdfront provides keyboard and mouse.
+
+The backends run in dom0 user space.
+
+The two drivers are not in two separate patches, because the
+intermediate step (one driver, not the other) is somewhat problematic:
+the backend in dom0 needs both drivers, and will refuse to complete
+device initialization unless they're both present.
+
+Signed-off-by: Markus Armbruster <armbru at redhat.com>
+---
+ drivers/input/Kconfig            |    9 +
+ drivers/input/Makefile           |    2 +
+ drivers/input/xen-kbdfront.c     |  340 +++++++++++++++++++++++
+ drivers/video/Kconfig            |   14 +
+ drivers/video/Makefile           |    1 +
+ drivers/video/xen-fbfront.c      |  550 ++++++++++++++++++++++++++++++++++++++
+ include/xen/interface/io/fbif.h  |  124 +++++++++
+ include/xen/interface/io/kbdif.h |  114 ++++++++
+ 8 files changed, 1154 insertions(+), 0 deletions(-)
+ create mode 100644 drivers/input/xen-kbdfront.c
+ create mode 100644 drivers/video/xen-fbfront.c
+ create mode 100644 include/xen/interface/io/fbif.h
+ create mode 100644 include/xen/interface/io/kbdif.h
+
+diff --git a/drivers/input/Kconfig b/drivers/input/Kconfig
+index d84ac4a..747633c 100644
+--- a/drivers/input/Kconfig
++++ b/drivers/input/Kconfig
+@@ -149,6 +149,15 @@ config INPUT_APMPOWER
+ 	  To compile this driver as a module, choose M here: the
+ 	  module will be called apm-power.
+ 
++config XEN_KBDDEV_FRONTEND
++	tristate "Xen virtual keyboard and mouse support"
++	depends on XEN_FBDEV_FRONTEND
++	default y
++	help
++	  This driver implements the front-end of the Xen virtual
++	  keyboard and mouse device driver.  It communicates with a back-end
++	  in another domain.
++
+ comment "Input Device Drivers"
+ 
+ source "drivers/input/keyboard/Kconfig"
+diff --git a/drivers/input/Makefile b/drivers/input/Makefile
+index 24bdec1..606e1b9 100644
+--- a/drivers/input/Makefile
++++ b/drivers/input/Makefile
+@@ -24,3 +24,5 @@ obj-$(CONFIG_INPUT_MISC)	+= misc/
+ obj-$(CONFIG_INPUT_LIRC)	+= lirc/
+ 
+ obj-$(CONFIG_INPUT_APMPOWER)	+= apm-power.o
++
++obj-$(CONFIG_XEN_KBDDEV_FRONTEND)	+= xen-kbdfront.o
+diff --git a/drivers/input/xen-kbdfront.c b/drivers/input/xen-kbdfront.c
+new file mode 100644
+index 0000000..0f47f46
+--- /dev/null
++++ b/drivers/input/xen-kbdfront.c
+@@ -0,0 +1,340 @@
++/*
++ * Xen para-virtual input device
++ *
++ * Copyright (C) 2005 Anthony Liguori <aliguori at us.ibm.com>
++ * Copyright (C) 2006-2008 Red Hat, Inc., Markus Armbruster <armbru at redhat.com>
++ *
++ *  Based on linux/drivers/input/mouse/sermouse.c
++ *
++ *  This file is subject to the terms and conditions of the GNU General Public
++ *  License. See the file COPYING in the main directory of this archive for
++ *  more details.
++ */
++
++/*
++ * TODO:
++ *
++ * Switch to grant tables together with xen-fbfront.c.
++ */
++
++#include <linux/kernel.h>
++#include <linux/errno.h>
++#include <linux/module.h>
++#include <linux/input.h>
++#include <asm/xen/hypervisor.h>
++#include <xen/events.h>
++#include <xen/page.h>
++#include <xen/interface/io/fbif.h>
++#include <xen/interface/io/kbdif.h>
++#include <xen/xenbus.h>
++
++struct xenkbd_info {
++	struct input_dev *kbd;
++	struct input_dev *ptr;
++	struct xenkbd_page *page;
++	int irq;
++	struct xenbus_device *xbdev;
++	char phys[32];
++};
++
++static int xenkbd_remove(struct xenbus_device *);
++static int xenkbd_connect_backend(struct xenbus_device *, struct xenkbd_info *);
++static void xenkbd_disconnect_backend(struct xenkbd_info *);
++
++/*
++ * Note: if you need to send out events, see xenfb_do_update() for how
++ * to do that.
++ */
++
++static irqreturn_t input_handler(int rq, void *dev_id)
++{
++	struct xenkbd_info *info = dev_id;
++	struct xenkbd_page *page = info->page;
++	__u32 cons, prod;
++
++	prod = page->in_prod;
++	if (prod == page->in_cons)
++		return IRQ_HANDLED;
++	rmb();			/* ensure we see ring contents up to prod */
++	for (cons = page->in_cons; cons != prod; cons++) {
++		union xenkbd_in_event *event;
++		struct input_dev *dev;
++		event = &XENKBD_IN_RING_REF(page, cons);
++
++		dev = info->ptr;
++		switch (event->type) {
++		case XENKBD_TYPE_MOTION:
++			input_report_rel(dev, REL_X, event->motion.rel_x);
++			input_report_rel(dev, REL_Y, event->motion.rel_y);
++			break;
++		case XENKBD_TYPE_KEY:
++			dev = NULL;
++			if (test_bit(event->key.keycode, info->kbd->keybit))
++				dev = info->kbd;
++			if (test_bit(event->key.keycode, info->ptr->keybit))
++				dev = info->ptr;
++			if (dev)
++				input_report_key(dev, event->key.keycode,
++						 event->key.pressed);
++			else
++				printk(KERN_WARNING
++				       "xenkbd: unhandled keycode 0x%x\n",
++				       event->key.keycode);
++			break;
++		case XENKBD_TYPE_POS:
++			input_report_abs(dev, ABS_X, event->pos.abs_x);
++			input_report_abs(dev, ABS_Y, event->pos.abs_y);
++			break;
++		}
++		if (dev)
++			input_sync(dev);
++	}
++	mb();			/* ensure we got ring contents */
++	page->in_cons = cons;
++	notify_remote_via_irq(info->irq);
++
++	return IRQ_HANDLED;
++}
++
++static int __devinit xenkbd_probe(struct xenbus_device *dev,
++				  const struct xenbus_device_id *id)
++{
++	int ret, i;
++	struct xenkbd_info *info;
++	struct input_dev *kbd, *ptr;
++
++	info = kzalloc(sizeof(*info), GFP_KERNEL);
++	if (!info) {
++		xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
++		return -ENOMEM;
++	}
++	dev->dev.driver_data = info;
++	info->xbdev = dev;
++	info->irq = -1;
++	snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename);
++
++	info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
++	if (!info->page)
++		goto error_nomem;
++
++	/* keyboard */
++	kbd = input_allocate_device();
++	if (!kbd)
++		goto error_nomem;
++	kbd->name = "Xen Virtual Keyboard";
++	kbd->phys = info->phys;
++	kbd->id.bustype = BUS_PCI;
++	kbd->id.vendor = 0x5853;
++	kbd->id.product = 0xffff;
++	kbd->evbit[0] = BIT(EV_KEY);
++	for (i = KEY_ESC; i < KEY_UNKNOWN; i++)
++		set_bit(i, kbd->keybit);
++	for (i = KEY_OK; i < KEY_MAX; i++)
++		set_bit(i, kbd->keybit);
++
++	ret = input_register_device(kbd);
++	if (ret) {
++		input_free_device(kbd);
++		xenbus_dev_fatal(dev, ret, "input_register_device(kbd)");
++		goto error;
++	}
++	info->kbd = kbd;
++
++	/* pointing device */
++	ptr = input_allocate_device();
++	if (!ptr)
++		goto error_nomem;
++	ptr->name = "Xen Virtual Pointer";
++	ptr->phys = info->phys;
++	ptr->id.bustype = BUS_PCI;
++	ptr->id.vendor = 0x5853;
++	ptr->id.product = 0xfffe;
++	ptr->evbit[0] = BIT(EV_KEY) | BIT(EV_REL) | BIT(EV_ABS);
++	for (i = BTN_LEFT; i <= BTN_TASK; i++)
++		set_bit(i, ptr->keybit);
++	ptr->relbit[0] = BIT(REL_X) | BIT(REL_Y);
++	input_set_abs_params(ptr, ABS_X, 0, XENFB_WIDTH, 0, 0);
++	input_set_abs_params(ptr, ABS_Y, 0, XENFB_HEIGHT, 0, 0);
++
++	ret = input_register_device(ptr);
++	if (ret) {
++		input_free_device(ptr);
++		xenbus_dev_fatal(dev, ret, "input_register_device(ptr)");
++		goto error;
++	}
++	info->ptr = ptr;
++
++	ret = xenkbd_connect_backend(dev, info);
++	if (ret < 0)
++		goto error;
++
++	return 0;
++
++ error_nomem:
++	ret = -ENOMEM;
++	xenbus_dev_fatal(dev, ret, "allocating device memory");
++ error:
++	xenkbd_remove(dev);
++	return ret;
++}
++
++static int xenkbd_resume(struct xenbus_device *dev)
++{
++	struct xenkbd_info *info = dev->dev.driver_data;
++
++	xenkbd_disconnect_backend(info);
++	memset(info->page, 0, PAGE_SIZE);
++	return xenkbd_connect_backend(dev, info);
++}
++
++static int xenkbd_remove(struct xenbus_device *dev)
++{
++	struct xenkbd_info *info = dev->dev.driver_data;
++
++	xenkbd_disconnect_backend(info);
++	if (info->kbd)
++		input_unregister_device(info->kbd);
++	if (info->ptr)
++		input_unregister_device(info->ptr);
++	free_page((unsigned long)info->page);
++	kfree(info);
++	return 0;
++}
++
++static int xenkbd_connect_backend(struct xenbus_device *dev,
++				  struct xenkbd_info *info)
++{
++	int ret, evtchn;
++	struct xenbus_transaction xbt;
++
++	ret = xenbus_alloc_evtchn(dev, &evtchn);
++	if (ret)
++		return ret;
++	ret = bind_evtchn_to_irqhandler(evtchn, input_handler,
++					0, dev->devicetype, info);
++	if (ret < 0) {
++		xenbus_free_evtchn(dev, evtchn);
++		xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
++		return ret;
++	}
++	info->irq = ret;
++
++ again:
++	ret = xenbus_transaction_start(&xbt);
++	if (ret) {
++		xenbus_dev_fatal(dev, ret, "starting transaction");
++		return ret;
++	}
++	ret = xenbus_printf(xbt, dev->nodename, "page-ref", "%lu",
++			    virt_to_mfn(info->page));
++	if (ret)
++		goto error_xenbus;
++	ret = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
++			    evtchn);
++	if (ret)
++		goto error_xenbus;
++	ret = xenbus_transaction_end(xbt, 0);
++	if (ret) {
++		if (ret == -EAGAIN)
++			goto again;
++		xenbus_dev_fatal(dev, ret, "completing transaction");
++		return ret;
++	}
++
++	xenbus_switch_state(dev, XenbusStateInitialised);
++	return 0;
++
++ error_xenbus:
++	xenbus_transaction_end(xbt, 1);
++	xenbus_dev_fatal(dev, ret, "writing xenstore");
++	return ret;
++}
++
++static void xenkbd_disconnect_backend(struct xenkbd_info *info)
++{
++	if (info->irq >= 0)
++		unbind_from_irqhandler(info->irq, info);
++	info->irq = -1;
++}
++
++static void xenkbd_backend_changed(struct xenbus_device *dev,
++				   enum xenbus_state backend_state)
++{
++	struct xenkbd_info *info = dev->dev.driver_data;
++	int ret, val;
++
++	switch (backend_state) {
++	case XenbusStateInitialising:
++	case XenbusStateInitialised:
++	case XenbusStateUnknown:
++	case XenbusStateClosed:
++		break;
++
++	case XenbusStateInitWait:
++InitWait:
++		ret = xenbus_scanf(XBT_NIL, info->xbdev->otherend,
++				   "feature-abs-pointer", "%d", &val);
++		if (ret < 0)
++			val = 0;
++		if (val) {
++			ret = xenbus_printf(XBT_NIL, info->xbdev->nodename,
++					    "request-abs-pointer", "1");
++			if (ret)
++				printk(KERN_WARNING
++				       "xenkbd: can't request abs-pointer");
++		}
++		xenbus_switch_state(dev, XenbusStateConnected);
++		break;
++
++	case XenbusStateConnected:
++		/*
++		 * Work around xenbus race condition: If backend goes
++		 * through InitWait to Connected fast enough, we can
++		 * get Connected twice here.
++		 */
++		if (dev->state != XenbusStateConnected)
++			goto InitWait; /* no InitWait seen yet, fudge it */
++		break;
++
++	case XenbusStateClosing:
++		xenbus_frontend_closed(dev);
++		break;
++	}
++}
++
++static struct xenbus_device_id xenkbd_ids[] = {
++	{ "vkbd" },
++	{ "" }
++};
++
++static struct xenbus_driver xenkbd = {
++	.name = "vkbd",
++	.owner = THIS_MODULE,
++	.ids = xenkbd_ids,
++	.probe = xenkbd_probe,
++	.remove = xenkbd_remove,
++	.resume = xenkbd_resume,
++	.otherend_changed = xenkbd_backend_changed,
++};
++
++static int __init xenkbd_init(void)
++{
++	if (!is_running_on_xen())
++		return -ENODEV;
++
++	/* Nothing to do if running in dom0. */
++	if (is_initial_xendomain())
++		return -ENODEV;
++
++	return xenbus_register_frontend(&xenkbd);
++}
++
++static void __exit xenkbd_cleanup(void)
++{
++	xenbus_unregister_driver(&xenkbd);
++}
++
++module_init(xenkbd_init);
++module_exit(xenkbd_cleanup);
++
++MODULE_LICENSE("GPL");
+diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
+index 758435f..67de177 100644
+--- a/drivers/video/Kconfig
++++ b/drivers/video/Kconfig
+@@ -1903,6 +1903,20 @@ config FB_VIRTUAL
+ 
+ 	  If unsure, say N.
+ 
++config XEN_FBDEV_FRONTEND
++	tristate "Xen virtual frame buffer support"
++	depends on FB && XEN
++	select FB_SYS_FILLRECT
++	select FB_SYS_COPYAREA
++	select FB_SYS_IMAGEBLIT
++	select FB_SYS_FOPS
++	select FB_DEFERRED_IO
++	default y
++	help
++	  This driver implements the front-end of the Xen virtual
++	  frame buffer driver.  It communicates with a back-end
++	  in another domain.
++
+ source "drivers/video/omap/Kconfig"
+ 
+ source "drivers/video/backlight/Kconfig"
+diff --git a/drivers/video/Makefile b/drivers/video/Makefile
+index 83e02b3..d3ab9b2 100644
+--- a/drivers/video/Makefile
++++ b/drivers/video/Makefile
+@@ -113,6 +113,7 @@ obj-$(CONFIG_FB_PS3)		  += ps3fb.o
+ obj-$(CONFIG_FB_SM501)            += sm501fb.o
+ obj-$(CONFIG_FB_XILINX)           += xilinxfb.o
+ obj-$(CONFIG_FB_OMAP)             += omap/
++obj-$(CONFIG_XEN_FBDEV_FRONTEND)  += xen-fbfront.o
+ 
+ # Platform or fallback drivers go here
+ obj-$(CONFIG_FB_UVESA)            += uvesafb.o
+diff --git a/drivers/video/xen-fbfront.c b/drivers/video/xen-fbfront.c
+new file mode 100644
+index 0000000..619a6f8
+--- /dev/null
++++ b/drivers/video/xen-fbfront.c
+@@ -0,0 +1,550 @@
++/*
++ * Xen para-virtual frame buffer device
++ *
++ * Copyright (C) 2005-2006 Anthony Liguori <aliguori at us.ibm.com>
++ * Copyright (C) 2006-2008 Red Hat, Inc., Markus Armbruster <armbru at redhat.com>
++ *
++ *  Based on linux/drivers/video/q40fb.c
++ *
++ *  This file is subject to the terms and conditions of the GNU General Public
++ *  License. See the file COPYING in the main directory of this archive for
++ *  more details.
++ */
++
++/*
++ * TODO:
++ *
++ * Switch to grant tables when they become capable of dealing with the
++ * frame buffer.
++ */
++
++#include <linux/kernel.h>
++#include <linux/errno.h>
++#include <linux/fb.h>
++#include <linux/module.h>
++#include <linux/vmalloc.h>
++#include <linux/mm.h>
++#include <asm/xen/hypervisor.h>
++#include <xen/events.h>
++#include <xen/page.h>
++#include <xen/interface/io/fbif.h>
++#include <xen/interface/io/protocols.h>
++#include <xen/xenbus.h>
++
++struct xenfb_info {
++	unsigned char		*fb;
++	struct fb_info		*fb_info;
++	int			x1, y1, x2, y2;	/* dirty rectangle,
++						   protected by dirty_lock */
++	spinlock_t		dirty_lock;
++	int			nr_pages;
++	int			irq;
++	struct xenfb_page	*page;
++	unsigned long 		*mfns;
++	int			update_wanted; /* XENFB_TYPE_UPDATE wanted */
++
++	struct xenbus_device	*xbdev;
++};
++
++static u32 xenfb_mem_len = XENFB_WIDTH * XENFB_HEIGHT * XENFB_DEPTH / 8;
++
++static int xenfb_remove(struct xenbus_device *);
++static void xenfb_init_shared_page(struct xenfb_info *);
++static int xenfb_connect_backend(struct xenbus_device *, struct xenfb_info *);
++static void xenfb_disconnect_backend(struct xenfb_info *);
++
++static void xenfb_do_update(struct xenfb_info *info,
++			    int x, int y, int w, int h)
++{
++	union xenfb_out_event event;
++	u32 prod;
++
++	event.type = XENFB_TYPE_UPDATE;
++	event.update.x = x;
++	event.update.y = y;
++	event.update.width = w;
++	event.update.height = h;
++
++	prod = info->page->out_prod;
++	/* caller ensures !xenfb_queue_full() */
++	mb();			/* ensure ring space available */
++	XENFB_OUT_RING_REF(info->page, prod) = event;
++	wmb();			/* ensure ring contents visible */
++	info->page->out_prod = prod + 1;
++
++	notify_remote_via_irq(info->irq);
++}
++
++static int xenfb_queue_full(struct xenfb_info *info)
++{
++	u32 cons, prod;
++
++	prod = info->page->out_prod;
++	cons = info->page->out_cons;
++	return prod - cons == XENFB_OUT_RING_LEN;
++}
++
++static void xenfb_refresh(struct xenfb_info *info,
++			  int x1, int y1, int w, int h)
++{
++	unsigned long flags;
++	int y2 = y1 + h - 1;
++	int x2 = x1 + w - 1;
++
++	if (!info->update_wanted)
++		return;
++
++	spin_lock_irqsave(&info->dirty_lock, flags);
++
++	/* Combine with dirty rectangle: */
++	if (info->y1 < y1)
++		y1 = info->y1;
++	if (info->y2 > y2)
++		y2 = info->y2;
++	if (info->x1 < x1)
++		x1 = info->x1;
++	if (info->x2 > x2)
++		x2 = info->x2;
++
++	if (xenfb_queue_full(info)) {
++		/* Can't send right now, stash it in the dirty rectangle */
++		info->x1 = x1;
++		info->x2 = x2;
++		info->y1 = y1;
++		info->y2 = y2;
++		spin_unlock_irqrestore(&info->dirty_lock, flags);
++		return;
++	}
++
++	/* Clear dirty rectangle: */
++	info->x1 = info->y1 = INT_MAX;
++	info->x2 = info->y2 = 0;
++
++	spin_unlock_irqrestore(&info->dirty_lock, flags);
++
++	if (x1 <= x2 && y1 <= y2)
++		xenfb_do_update(info, x1, y1, x2 - x1 + 1, y2 - y1 + 1);
++}
++
++static void xenfb_deferred_io(struct fb_info *fb_info,
++			      struct list_head *pagelist)
++{
++	struct xenfb_info *info = fb_info->par;
++	struct page *page;
++	unsigned long beg, end;
++	int y1, y2, miny, maxy;
++
++	miny = INT_MAX;
++	maxy = 0;
++	list_for_each_entry(page, pagelist, lru) {
++		beg = page->index << PAGE_SHIFT;
++		end = beg + PAGE_SIZE - 1;
++		y1 = beg / fb_info->fix.line_length;
++		y2 = end / fb_info->fix.line_length;
++		if (y2 >= fb_info->var.yres)
++			y2 = fb_info->var.yres - 1;
++		if (miny > y1)
++			miny = y1;
++		if (maxy < y2)
++			maxy = y2;
++	}
++	xenfb_refresh(info, 0, miny, fb_info->var.xres, maxy - miny + 1);
++}
++
++static struct fb_deferred_io xenfb_defio = {
++	.delay		= HZ / 20,
++	.deferred_io	= xenfb_deferred_io,
++};
++
++static int xenfb_setcolreg(unsigned regno, unsigned red, unsigned green,
++			   unsigned blue, unsigned transp,
++			   struct fb_info *info)
++{
++	u32 v;
++
++	if (regno > info->cmap.len)
++		return 1;
++
++#define CNVT_TOHW(val, width) ((((val)<<(width))+0x7FFF-(val))>>16)
++	red = CNVT_TOHW(red, info->var.red.length);
++	green = CNVT_TOHW(green, info->var.green.length);
++	blue = CNVT_TOHW(blue, info->var.blue.length);
++	transp = CNVT_TOHW(transp, info->var.transp.length);
++#undef CNVT_TOHW
++
++	v = (red << info->var.red.offset) |
++	    (green << info->var.green.offset) |
++	    (blue << info->var.blue.offset);
++
++	switch (info->var.bits_per_pixel) {
++	case 16:
++	case 24:
++	case 32:
++		((u32 *)info->pseudo_palette)[regno] = v;
++		break;
++	}
++
++	return 0;
++}
++
++static void xenfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
++{
++	struct xenfb_info *info = p->par;
++
++	sys_fillrect(p, rect);
++	xenfb_refresh(info, rect->dx, rect->dy, rect->width, rect->height);
++}
++
++static void xenfb_imageblit(struct fb_info *p, const struct fb_image *image)
++{
++	struct xenfb_info *info = p->par;
++
++	sys_imageblit(p, image);
++	xenfb_refresh(info, image->dx, image->dy, image->width, image->height);
++}
++
++static void xenfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
++{
++	struct xenfb_info *info = p->par;
++
++	sys_copyarea(p, area);
++	xenfb_refresh(info, area->dx, area->dy, area->width, area->height);
++}
++
++static ssize_t xenfb_write(struct fb_info *p, const char __user *buf,
++			size_t count, loff_t *ppos)
++{
++	struct xenfb_info *info = p->par;
++	ssize_t res;
++
++	res = fb_sys_write(p, buf, count, ppos);
++	xenfb_refresh(info, 0, 0, info->page->width, info->page->height);
++	return res;
++}
++
++static struct fb_ops xenfb_fb_ops = {
++	.owner		= THIS_MODULE,
++	.fb_read	= fb_sys_read,
++	.fb_write	= xenfb_write,
++	.fb_setcolreg	= xenfb_setcolreg,
++	.fb_fillrect	= xenfb_fillrect,
++	.fb_copyarea	= xenfb_copyarea,
++	.fb_imageblit	= xenfb_imageblit,
++};
++
++static irqreturn_t xenfb_event_handler(int rq, void *dev_id)
++{
++	/*
++	 * No in events recognized, simply ignore them all.
++	 * If you need to recognize some, see xen-kbdfront's
++	 * input_handler() for how to do that.
++	 */
++	struct xenfb_info *info = dev_id;
++	struct xenfb_page *page = info->page;
++
++	if (page->in_cons != page->in_prod) {
++		info->page->in_cons = info->page->in_prod;
++		notify_remote_via_irq(info->irq);
++	}
++
++	/* Flush dirty rectangle: */
++	xenfb_refresh(info, INT_MAX, INT_MAX, -INT_MAX, -INT_MAX);
++
++	return IRQ_HANDLED;
++}
++
++static int __devinit xenfb_probe(struct xenbus_device *dev,
++				 const struct xenbus_device_id *id)
++{
++	struct xenfb_info *info;
++	struct fb_info *fb_info;
++	int ret;
++
++	info = kzalloc(sizeof(*info), GFP_KERNEL);
++	if (info == NULL) {
++		xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
++		return -ENOMEM;
++	}
++	dev->dev.driver_data = info;
++	info->xbdev = dev;
++	info->irq = -1;
++	info->x1 = info->y1 = INT_MAX;
++	spin_lock_init(&info->dirty_lock);
++
++	info->fb = vmalloc(xenfb_mem_len);
++	if (info->fb == NULL)
++		goto error_nomem;
++	memset(info->fb, 0, xenfb_mem_len);
++
++	info->nr_pages = (xenfb_mem_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
++
++	info->mfns = vmalloc(sizeof(unsigned long) * info->nr_pages);
++	if (!info->mfns)
++		goto error_nomem;
++
++	/* set up shared page */
++	info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
++	if (!info->page)
++		goto error_nomem;
++
++	xenfb_init_shared_page(info);
++
++	/* abusing framebuffer_alloc() to allocate pseudo_palette */
++	fb_info = framebuffer_alloc(sizeof(u32) * 256, NULL);
++	if (fb_info == NULL)
++		goto error_nomem;
++
++	/* complete the abuse: */
++	fb_info->pseudo_palette = fb_info->par;
++	fb_info->par = info;
++
++	fb_info->screen_base = info->fb;
++
++	fb_info->fbops = &xenfb_fb_ops;
++	fb_info->var.xres_virtual = fb_info->var.xres = info->page->width;
++	fb_info->var.yres_virtual = fb_info->var.yres = info->page->height;
++	fb_info->var.bits_per_pixel = info->page->depth;
++
++	fb_info->var.red = (struct fb_bitfield){16, 8, 0};
++	fb_info->var.green = (struct fb_bitfield){8, 8, 0};
++	fb_info->var.blue = (struct fb_bitfield){0, 8, 0};
++
++	fb_info->var.activate = FB_ACTIVATE_NOW;
++	fb_info->var.height = -1;
++	fb_info->var.width = -1;
++	fb_info->var.vmode = FB_VMODE_NONINTERLACED;
++
++	fb_info->fix.visual = FB_VISUAL_TRUECOLOR;
++	fb_info->fix.line_length = info->page->line_length;
++	fb_info->fix.smem_start = 0;
++	fb_info->fix.smem_len = xenfb_mem_len;
++	strcpy(fb_info->fix.id, "xen");
++	fb_info->fix.type = FB_TYPE_PACKED_PIXELS;
++	fb_info->fix.accel = FB_ACCEL_NONE;
++
++	fb_info->flags = FBINFO_FLAG_DEFAULT;
++
++	ret = fb_alloc_cmap(&fb_info->cmap, 256, 0);
++	if (ret < 0) {
++		framebuffer_release(fb_info);
++		xenbus_dev_fatal(dev, ret, "fb_alloc_cmap");
++		goto error;
++	}
++
++	fb_info->fbdefio = &xenfb_defio;
++	fb_deferred_io_init(fb_info);
++
++	ret = register_framebuffer(fb_info);
++	if (ret) {
++		fb_deferred_io_cleanup(fb_info);
++		fb_dealloc_cmap(&fb_info->cmap);
++		framebuffer_release(fb_info);
++		xenbus_dev_fatal(dev, ret, "register_framebuffer");
++		goto error;
++	}
++	info->fb_info = fb_info;
++
++	ret = xenfb_connect_backend(dev, info);
++	if (ret < 0)
++		goto error;
++
++	return 0;
++
++ error_nomem:
++	ret = -ENOMEM;
++	xenbus_dev_fatal(dev, ret, "allocating device memory");
++ error:
++	xenfb_remove(dev);
++	return ret;
++}
++
++static int xenfb_resume(struct xenbus_device *dev)
++{
++	struct xenfb_info *info = dev->dev.driver_data;
++
++	xenfb_disconnect_backend(info);
++	xenfb_init_shared_page(info);
++	return xenfb_connect_backend(dev, info);
++}
++
++static int xenfb_remove(struct xenbus_device *dev)
++{
++	struct xenfb_info *info = dev->dev.driver_data;
++
++	xenfb_disconnect_backend(info);
++	if (info->fb_info) {
++		fb_deferred_io_cleanup(info->fb_info);
++		unregister_framebuffer(info->fb_info);
++		fb_dealloc_cmap(&info->fb_info->cmap);
++		framebuffer_release(info->fb_info);
++	}
++	free_page((unsigned long)info->page);
++	vfree(info->mfns);
++	vfree(info->fb);
++	kfree(info);
++
++	return 0;
++}
++
++static unsigned long vmalloc_to_mfn(void *address)
++{
++	return pfn_to_mfn(vmalloc_to_pfn(address));
++}
++
++static void xenfb_init_shared_page(struct xenfb_info *info)
++{
++	int i;
++
++	for (i = 0; i < info->nr_pages; i++)
++		info->mfns[i] = vmalloc_to_mfn(info->fb + i * PAGE_SIZE);
++
++	info->page->pd[0] = vmalloc_to_mfn(info->mfns);
++	info->page->pd[1] = 0;
++	info->page->width = XENFB_WIDTH;
++	info->page->height = XENFB_HEIGHT;
++	info->page->depth = XENFB_DEPTH;
++	info->page->line_length = (info->page->depth / 8) * info->page->width;
++	info->page->mem_length = xenfb_mem_len;
++	info->page->in_cons = info->page->in_prod = 0;
++	info->page->out_cons = info->page->out_prod = 0;
++}
++
++static int xenfb_connect_backend(struct xenbus_device *dev,
++				 struct xenfb_info *info)
++{
++	int ret, evtchn;
++	struct xenbus_transaction xbt;
++
++	ret = xenbus_alloc_evtchn(dev, &evtchn);
++	if (ret)
++		return ret;
++	ret = bind_evtchn_to_irqhandler(evtchn, xenfb_event_handler,
++					0, dev->devicetype, info);
++	if (ret < 0) {
++		xenbus_free_evtchn(dev, evtchn);
++		xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
++		return ret;
++	}
++	info->irq = ret;
++
++ again:
++	ret = xenbus_transaction_start(&xbt);
++	if (ret) {
++		xenbus_dev_fatal(dev, ret, "starting transaction");
++		return ret;
++	}
++	ret = xenbus_printf(xbt, dev->nodename, "page-ref", "%lu",
++			    virt_to_mfn(info->page));
++	if (ret)
++		goto error_xenbus;
++	ret = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
++			    evtchn);
++	if (ret)
++		goto error_xenbus;
++	ret = xenbus_printf(xbt, dev->nodename, "protocol", "%s",
++			    XEN_IO_PROTO_ABI_NATIVE);
++	if (ret)
++		goto error_xenbus;
++	ret = xenbus_printf(xbt, dev->nodename, "feature-update", "1");
++	if (ret)
++		goto error_xenbus;
++	ret = xenbus_transaction_end(xbt, 0);
++	if (ret) {
++		if (ret == -EAGAIN)
++			goto again;
++		xenbus_dev_fatal(dev, ret, "completing transaction");
++		return ret;
++	}
++
++	xenbus_switch_state(dev, XenbusStateInitialised);
++	return 0;
++
++ error_xenbus:
++	xenbus_transaction_end(xbt, 1);
++	xenbus_dev_fatal(dev, ret, "writing xenstore");
++	return ret;
++}
++
++static void xenfb_disconnect_backend(struct xenfb_info *info)
++{
++	if (info->irq >= 0)
++		unbind_from_irqhandler(info->irq, info);
++	info->irq = -1;
++}
++
++static void xenfb_backend_changed(struct xenbus_device *dev,
++				  enum xenbus_state backend_state)
++{
++	struct xenfb_info *info = dev->dev.driver_data;
++	int val;
++
++	switch (backend_state) {
++	case XenbusStateInitialising:
++	case XenbusStateInitialised:
++	case XenbusStateUnknown:
++	case XenbusStateClosed:
++		break;
++
++	case XenbusStateInitWait:
++InitWait:
++		xenbus_switch_state(dev, XenbusStateConnected);
++		break;
++
++	case XenbusStateConnected:
++		/*
++		 * Work around xenbus race condition: If backend goes
++		 * through InitWait to Connected fast enough, we can
++		 * get Connected twice here.
++		 */
++		if (dev->state != XenbusStateConnected)
++			goto InitWait; /* no InitWait seen yet, fudge it */
++
++		if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
++				 "request-update", "%d", &val) < 0)
++			val = 0;
++		if (val)
++			info->update_wanted = 1;
++		break;
++
++	case XenbusStateClosing:
++		xenbus_frontend_closed(dev);
++		break;
++	}
++}
++
++static struct xenbus_device_id xenfb_ids[] = {
++	{ "vfb" },
++	{ "" }
++};
++
++static struct xenbus_driver xenfb = {
++	.name = "vfb",
++	.owner = THIS_MODULE,
++	.ids = xenfb_ids,
++	.probe = xenfb_probe,
++	.remove = xenfb_remove,
++	.resume = xenfb_resume,
++	.otherend_changed = xenfb_backend_changed,
++};
++
++static int __init xenfb_init(void)
++{
++	if (!is_running_on_xen())
++		return -ENODEV;
++
++	/* Nothing to do if running in dom0. */
++	if (is_initial_xendomain())
++		return -ENODEV;
++
++	return xenbus_register_frontend(&xenfb);
++}
++
++static void __exit xenfb_cleanup(void)
++{
++	xenbus_unregister_driver(&xenfb);
++}
++
++module_init(xenfb_init);
++module_exit(xenfb_cleanup);
++
++MODULE_LICENSE("GPL");
+diff --git a/include/xen/interface/io/fbif.h b/include/xen/interface/io/fbif.h
+new file mode 100644
+index 0000000..5a934dd
+--- /dev/null
++++ b/include/xen/interface/io/fbif.h
+@@ -0,0 +1,124 @@
++/*
++ * fbif.h -- Xen virtual frame buffer device
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ *
++ * Copyright (C) 2005 Anthony Liguori <aliguori at us.ibm.com>
++ * Copyright (C) 2006 Red Hat, Inc., Markus Armbruster <armbru at redhat.com>
++ */
++
++#ifndef __XEN_PUBLIC_IO_FBIF_H__
++#define __XEN_PUBLIC_IO_FBIF_H__
++
++/* Out events (frontend -> backend) */
++
++/*
++ * Out events may be sent only when requested by backend, and receipt
++ * of an unknown out event is an error.
++ */
++
++/* Event type 1 currently not used */
++/*
++ * Framebuffer update notification event
++ * Capable frontend sets feature-update in xenstore.
++ * Backend requests it by setting request-update in xenstore.
++ */
++#define XENFB_TYPE_UPDATE 2
++
++struct xenfb_update {
++	uint8_t type;		/* XENFB_TYPE_UPDATE */
++	int32_t x;		/* source x */
++	int32_t y;		/* source y */
++	int32_t width;		/* rect width */
++	int32_t height;		/* rect height */
++};
++
++#define XENFB_OUT_EVENT_SIZE 40
++
++union xenfb_out_event {
++	uint8_t type;
++	struct xenfb_update update;
++	char pad[XENFB_OUT_EVENT_SIZE];
++};
++
++/* In events (backend -> frontend) */
++
++/*
++ * Frontends should ignore unknown in events.
++ * No in events currently defined.
++ */
++
++#define XENFB_IN_EVENT_SIZE 40
++
++union xenfb_in_event {
++	uint8_t type;
++	char pad[XENFB_IN_EVENT_SIZE];
++};
++
++/* shared page */
++
++#define XENFB_IN_RING_SIZE 1024
++#define XENFB_IN_RING_LEN (XENFB_IN_RING_SIZE / XENFB_IN_EVENT_SIZE)
++#define XENFB_IN_RING_OFFS 1024
++#define XENFB_IN_RING(page) \
++	((union xenfb_in_event *)((char *)(page) + XENFB_IN_RING_OFFS))
++#define XENFB_IN_RING_REF(page, idx) \
++	(XENFB_IN_RING((page))[(idx) % XENFB_IN_RING_LEN])
++
++#define XENFB_OUT_RING_SIZE 2048
++#define XENFB_OUT_RING_LEN (XENFB_OUT_RING_SIZE / XENFB_OUT_EVENT_SIZE)
++#define XENFB_OUT_RING_OFFS (XENFB_IN_RING_OFFS + XENFB_IN_RING_SIZE)
++#define XENFB_OUT_RING(page) \
++	((union xenfb_out_event *)((char *)(page) + XENFB_OUT_RING_OFFS))
++#define XENFB_OUT_RING_REF(page, idx) \
++	(XENFB_OUT_RING((page))[(idx) % XENFB_OUT_RING_LEN])
++
++struct xenfb_page {
++	uint32_t in_cons, in_prod;
++	uint32_t out_cons, out_prod;
++
++	int32_t width;          /* width of the framebuffer (in pixels) */
++	int32_t height;         /* height of the framebuffer (in pixels) */
++	uint32_t line_length;   /* length of a row of pixels (in bytes) */
++	uint32_t mem_length;    /* length of the framebuffer (in bytes) */
++	uint8_t depth;          /* depth of a pixel (in bits) */
++
++	/*
++	 * Framebuffer page directory
++	 *
++	 * Each directory page holds PAGE_SIZE / sizeof(*pd)
++	 * framebuffer pages, and can thus map up to PAGE_SIZE *
++	 * PAGE_SIZE / sizeof(*pd) bytes.  With PAGE_SIZE == 4096 and
++	 * sizeof(unsigned long) == 4, that's 4 Megs.  Two directory
++	 * pages should be enough for a while.
++	 */
++	unsigned long pd[2];
++};
++
++/*
++ * Wart: xenkbd needs to know resolution.  Put it here until a better
++ * solution is found, but don't leak it to the backend.
++ */
++#ifdef __KERNEL__
++#define XENFB_WIDTH 800
++#define XENFB_HEIGHT 600
++#define XENFB_DEPTH 32
++#endif
++
++#endif
+diff --git a/include/xen/interface/io/kbdif.h b/include/xen/interface/io/kbdif.h
+new file mode 100644
+index 0000000..fb97f42
+--- /dev/null
++++ b/include/xen/interface/io/kbdif.h
+@@ -0,0 +1,114 @@
++/*
++ * kbdif.h -- Xen virtual keyboard/mouse
++ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
++ * of this software and associated documentation files (the "Software"), to
++ * deal in the Software without restriction, including without limitation the
++ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
++ * sell copies of the Software, and to permit persons to whom the Software is
++ * furnished to do so, subject to the following conditions:
++ *
++ * The above copyright notice and this permission notice shall be included in
++ * all copies or substantial portions of the Software.
++ *
++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
++ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
++ * DEALINGS IN THE SOFTWARE.
++ *
++ * Copyright (C) 2005 Anthony Liguori <aliguori at us.ibm.com>
++ * Copyright (C) 2006 Red Hat, Inc., Markus Armbruster <armbru at redhat.com>
++ */
++
++#ifndef __XEN_PUBLIC_IO_KBDIF_H__
++#define __XEN_PUBLIC_IO_KBDIF_H__
++
++/* In events (backend -> frontend) */
++
++/*
++ * Frontends should ignore unknown in events.
++ */
++
++/* Pointer movement event */
++#define XENKBD_TYPE_MOTION  1
++/* Event type 2 currently not used */
++/* Key event (includes pointer buttons) */
++#define XENKBD_TYPE_KEY     3
++/*
++ * Pointer position event
++ * Capable backend sets feature-abs-pointer in xenstore.
++ * Frontend requests ot instead of XENKBD_TYPE_MOTION by setting
++ * request-abs-update in xenstore.
++ */
++#define XENKBD_TYPE_POS     4
++
++struct xenkbd_motion {
++	uint8_t type;		/* XENKBD_TYPE_MOTION */
++	int32_t rel_x;		/* relative X motion */
++	int32_t rel_y;		/* relative Y motion */
++};
++
++struct xenkbd_key {
++	uint8_t type;		/* XENKBD_TYPE_KEY */
++	uint8_t pressed;	/* 1 if pressed; 0 otherwise */
++	uint32_t keycode;	/* KEY_* from linux/input.h */
++};
++
++struct xenkbd_position {
++	uint8_t type;		/* XENKBD_TYPE_POS */
++	int32_t abs_x;		/* absolute X position (in FB pixels) */
++	int32_t abs_y;		/* absolute Y position (in FB pixels) */
++};
++
++#define XENKBD_IN_EVENT_SIZE 40
++
++union xenkbd_in_event {
++	uint8_t type;
++	struct xenkbd_motion motion;
++	struct xenkbd_key key;
++	struct xenkbd_position pos;
++	char pad[XENKBD_IN_EVENT_SIZE];
++};
++
++/* Out events (frontend -> backend) */
++
++/*
++ * Out events may be sent only when requested by backend, and receipt
++ * of an unknown out event is an error.
++ * No out events currently defined.
++ */
++
++#define XENKBD_OUT_EVENT_SIZE 40
++
++union xenkbd_out_event {
++	uint8_t type;
++	char pad[XENKBD_OUT_EVENT_SIZE];
++};
++
++/* shared page */
++
++#define XENKBD_IN_RING_SIZE 2048
++#define XENKBD_IN_RING_LEN (XENKBD_IN_RING_SIZE / XENKBD_IN_EVENT_SIZE)
++#define XENKBD_IN_RING_OFFS 1024
++#define XENKBD_IN_RING(page) \
++	((union xenkbd_in_event *)((char *)(page) + XENKBD_IN_RING_OFFS))
++#define XENKBD_IN_RING_REF(page, idx) \
++	(XENKBD_IN_RING((page))[(idx) % XENKBD_IN_RING_LEN])
++
++#define XENKBD_OUT_RING_SIZE 1024
++#define XENKBD_OUT_RING_LEN (XENKBD_OUT_RING_SIZE / XENKBD_OUT_EVENT_SIZE)
++#define XENKBD_OUT_RING_OFFS (XENKBD_IN_RING_OFFS + XENKBD_IN_RING_SIZE)
++#define XENKBD_OUT_RING(page) \
++	((union xenkbd_out_event *)((char *)(page) + XENKBD_OUT_RING_OFFS))
++#define XENKBD_OUT_RING_REF(page, idx) \
++	(XENKBD_OUT_RING((page))[(idx) % XENKBD_OUT_RING_LEN])
++
++struct xenkbd_page {
++	uint32_t in_cons, in_prod;
++	uint32_t out_cons, out_prod;
++};
++
++#endif
+-- 
+1.5.4.1
+

linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch:

Index: linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch
===================================================================
RCS file: linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch
diff -N linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch	25 Mar 2008 10:49:00 -0000	1.2
@@ -0,0 +1,97 @@
+From 1e23f8718e4c5b6b306d96afdb9ac5d9daa81883 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc at redhat.com>
+Date: Fri, 22 Feb 2008 12:42:52 +0000
+Subject: [PATCH] xen: Module autoprobing support for frontend drivers
+
+Add module aliases to support autoprobing modules
+for xen frontend devices.
+
+Signed-off-by: Mark McLoughlin <markmc at redhat.com>
+---
+ drivers/block/xen-blkfront.c      |    1 +
+ drivers/net/xen-netfront.c        |    1 +
+ drivers/xen/xenbus/xenbus_probe.c |   27 +++++++++++++++++++++++++--
+ 3 files changed, 27 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
+index 2e7c81e..0c47c02 100644
+--- a/drivers/block/xen-blkfront.c
++++ b/drivers/block/xen-blkfront.c
+@@ -1005,3 +1005,4 @@ module_exit(xlblk_exit);
+ MODULE_DESCRIPTION("Xen virtual block device frontend");
+ MODULE_LICENSE("GPL");
+ MODULE_ALIAS_BLOCKDEV_MAJOR(XENVBD_MAJOR);
++MODULE_ALIAS("xen:vbd");
+diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
+index 7483d45..b3fa27e 100644
+--- a/drivers/net/xen-netfront.c
++++ b/drivers/net/xen-netfront.c
+@@ -1809,3 +1809,4 @@ module_exit(netif_exit);
+ 
+ MODULE_DESCRIPTION("Xen virtual network device frontend");
+ MODULE_LICENSE("GPL");
++MODULE_ALIAS("xen:vif");
+diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
+index 4750de3..336363c 100644
+--- a/drivers/xen/xenbus/xenbus_probe.c
++++ b/drivers/xen/xenbus/xenbus_probe.c
+@@ -88,6 +88,16 @@ int xenbus_match(struct device *_dev, struct device_driver *_drv)
+ 	return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
+ }
+ 
++static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)
++{
++	struct xenbus_device *dev = to_xenbus_device(_dev);
++
++	if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
++		return -ENOMEM;
++
++	return 0;
++}
++
+ /* device/<type>/<id> => <type>-<id> */
+ static int frontend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename)
+ {
+@@ -166,6 +176,7 @@ static struct xen_bus_type xenbus_frontend = {
+ 	.bus = {
+ 		.name     = "xen",
+ 		.match    = xenbus_match,
++		.uevent   = xenbus_uevent,
+ 		.probe    = xenbus_dev_probe,
+ 		.remove   = xenbus_dev_remove,
+ 		.shutdown = xenbus_dev_shutdown,
+@@ -438,6 +449,12 @@ static ssize_t xendev_show_devtype(struct device *dev,
+ }
+ DEVICE_ATTR(devtype, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_devtype, NULL);
+ 
++static ssize_t xendev_show_modalias(struct device *dev,
++				    struct device_attribute *attr, char *buf)
++{
++	return sprintf(buf, "xen:%s\n", to_xenbus_device(dev)->devicetype);
++}
++DEVICE_ATTR(modalias, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_modalias, NULL);
+ 
+ int xenbus_probe_node(struct xen_bus_type *bus,
+ 		      const char *type,
+@@ -492,10 +509,16 @@ int xenbus_probe_node(struct xen_bus_type *bus,
+ 
+ 	err = device_create_file(&xendev->dev, &dev_attr_devtype);
+ 	if (err)
+-		goto fail_remove_file;
++		goto fail_remove_nodename;
++
++	err = device_create_file(&xendev->dev, &dev_attr_modalias);
++	if (err)
++		goto fail_remove_devtype;
+ 
+ 	return 0;
+-fail_remove_file:
++fail_remove_devtype:
++	device_remove_file(&xendev->dev, &dev_attr_devtype);
++fail_remove_nodename:
+ 	device_remove_file(&xendev->dev, &dev_attr_nodename);
+ fail_unregister:
+ 	device_unregister(&xendev->dev);
+-- 
+1.5.4.1
+

linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch:

Index: linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch
===================================================================
RCS file: linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch
diff -N linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch	25 Mar 2008 10:49:00 -0000	1.2
@@ -0,0 +1,37 @@
+From ed9042627f1adab5942abd91b95b39c2ca7af170 Mon Sep 17 00:00:00 2001
+From: Mark McLoughlin <markmc at redhat.com>
+Date: Thu, 21 Feb 2008 11:13:12 +0000
+Subject: [PATCH] xen: Add compatibility aliases for frontend drivers
+
+Before getting merged, xen-blkfront was xenblk and
+xen-netfront was xennet.
+
+Add compatibility module aliases to ease upgrades.
+
+Signed-off-by: Mark McLoughlin <markmc at redhat.com>
+---
+ drivers/block/xen-blkfront.c |    1 +
+ drivers/net/xen-netfront.c   |    1 +
+ 2 files changed, 2 insertions(+), 0 deletions(-)
+
+diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
+index 0c47c02..8ce168d 100644
+--- a/drivers/block/xen-blkfront.c
++++ b/drivers/block/xen-blkfront.c
+@@ -1006,3 +1006,4 @@ MODULE_DESCRIPTION("Xen virtual block device frontend");
+ MODULE_LICENSE("GPL");
+ MODULE_ALIAS_BLOCKDEV_MAJOR(XENVBD_MAJOR);
+ MODULE_ALIAS("xen:vbd");
++MODULE_ALIAS("xenblk");
+diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
+index b3fa27e..e62018a 100644
+--- a/drivers/net/xen-netfront.c
++++ b/drivers/net/xen-netfront.c
+@@ -1810,3 +1810,4 @@ module_exit(netif_exit);
+ MODULE_DESCRIPTION("Xen virtual network device frontend");
+ MODULE_LICENSE("GPL");
+ MODULE_ALIAS("xen:vif");
++MODULE_ALIAS("xennet");
+-- 
+1.5.4.1
+

linux-2.6-xen-0010-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch:

--- NEW FILE linux-2.6-xen-0010-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch ---
>From 0341660bf0c36cc5de8eb63911693b4b3cd264de Mon Sep 17 00:00:00 2001
From: Christian Limpach <Christian.Limpach at xensource.com>
Date: Wed, 19 Mar 2008 15:54:48 +0000
Subject: [PATCH] xen blkfront: Delay wait for block devices until after the disk is added.

When the xen block frontend driver is built as a module the module load
is only synchronous up to the point where the frontend and the backend
become connected rather than when the disk is added.

This means that there can be a race on boot between loading the module and
loading the dm-* modules and doing the scan for LVM physical volumes (all
in the initrd). In the failure case the disk is not present until after the
scan for physical volumes is complete.

Taken from:

  http://xenbits.xensource.com/linux-2.6.18-xen.hg?rev/11483a00c017

Signed-off-by: Christian Limpach <Christian.Limpach at xensource.com>
Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 drivers/block/xen-blkfront.c      |   11 +++++++++++
 drivers/xen/xenbus/xenbus_probe.c |    5 ++++-
 include/xen/xenbus.h              |    1 +
 3 files changed, 16 insertions(+), 1 deletions(-)

diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 8ce168d..74f943a 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -89,6 +89,7 @@ struct blkfront_info
 	struct blk_shadow shadow[BLK_RING_SIZE];
 	unsigned long shadow_free;
 	int feature_barrier;
+	int is_ready;
 
 	/**
 	 * The number of people holding this device open.  We won't allow a
@@ -840,6 +841,8 @@ static void blkfront_connect(struct blkfront_info *info)
 	spin_unlock_irq(&blkif_io_lock);
 
 	add_disk(info->gd);
+
+	info->is_ready = 1;
 }
 
 /**
@@ -932,6 +935,13 @@ static int blkfront_remove(struct xenbus_device *dev)
 	return 0;
 }
 
+static int blkfront_is_ready(struct xenbus_device *dev)
+{
+	struct blkfront_info *info = dev->dev.driver_data;
+
+	return info->is_ready;
+}
+
 static int blkif_open(struct inode *inode, struct file *filep)
 {
 	struct blkfront_info *info = inode->i_bdev->bd_disk->private_data;
@@ -978,6 +988,7 @@ static struct xenbus_driver blkfront = {
 	.remove = blkfront_remove,
 	.resume = blkfront_resume,
 	.otherend_changed = backend_changed,
+	.is_ready = blkfront_is_ready,
 };
 
 static int __init xlblk_init(void)
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 336363c..57ceb53 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -869,6 +869,7 @@ static int is_disconnected_device(struct device *dev, void *data)
 {
 	struct xenbus_device *xendev = to_xenbus_device(dev);
 	struct device_driver *drv = data;
+	struct xenbus_driver *xendrv;
 
 	/*
 	 * A device with no driver will never connect. We care only about
@@ -881,7 +882,9 @@ static int is_disconnected_device(struct device *dev, void *data)
 	if (drv && (dev->driver != drv))
 		return 0;
 
-	return (xendev->state != XenbusStateConnected);
+	xendrv = to_xenbus_driver(dev->driver);
+	return (xendev->state != XenbusStateConnected ||
+		(xendrv->is_ready && !xendrv->is_ready(xendev)));
 }
 
 static int exists_disconnected_device(struct device_driver *drv)
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index 6f7c290..6369d89 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -97,6 +97,7 @@ struct xenbus_driver {
 	int (*uevent)(struct xenbus_device *, char **, int, char *, int);
 	struct device_driver driver;
 	int (*read_otherend_details)(struct xenbus_device *dev);
+	int (*is_ready)(struct xenbus_device *dev);
 };
 
 static inline struct xenbus_driver *to_xenbus_driver(struct device_driver *drv)
-- 
1.5.4.1


linux-2.6-xen-0011-xen-Add-a-vmlinuz-target.patch:

--- NEW FILE linux-2.6-xen-0011-xen-Add-a-vmlinuz-target.patch ---
>From d3f123a8bee410ff807b2311d994e74804128dfc Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Tue, 19 Feb 2008 15:34:32 +0000
Subject: [PATCH] xen: Add a vmlinuz target

Although patches are in progress to allow Xen boot
a DomU using a bzImage, support for booting a Dom0
using a bzImage is still a ways off.

For now, just add a target to build a gzip-ed ELF
file which Xen can use to boot both Dom0 and DomU.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 arch/x86/Makefile        |    9 +++++++++
 arch/x86/boot/.gitignore |    1 +
 arch/x86/boot/Makefile   |    9 +++++++++
 3 files changed, 19 insertions(+), 0 deletions(-)

diff --git a/arch/x86/Makefile b/arch/x86/Makefile
index f1e739a..14a752e 100644
--- a/arch/x86/Makefile
+++ b/arch/x86/Makefile
@@ -206,6 +206,15 @@ boot := arch/x86/boot
 PHONY += zImage bzImage compressed zlilo bzlilo \
          zdisk bzdisk fdimage fdimage144 fdimage288 isoimage install
 
+ifdef CONFIG_XEN
+PHONY += vmlinuz
+all: vmlinuz
+
+vmlinuz: KBUILD_IMAGE := $(boot)/vmlinuz
+vmlinuz: vmlinux
+	$(Q)$(MAKE) $(build)=$(boot) $(KBUILD_IMAGE)
+endif
+
 # Default kernel to build
 all: bzImage
 
diff --git a/arch/x86/boot/.gitignore b/arch/x86/boot/.gitignore
index b1bdc4c..35e7956 100644
--- a/arch/x86/boot/.gitignore
+++ b/arch/x86/boot/.gitignore
@@ -5,3 +5,4 @@ setup.bin
 setup.elf
 cpustr.h
 mkcpustr
+vmlinuz
diff --git a/arch/x86/boot/Makefile b/arch/x86/boot/Makefile
index f88458e..61bba92 100644
--- a/arch/x86/boot/Makefile
+++ b/arch/x86/boot/Makefile
@@ -26,6 +26,7 @@ SVGA_MODE := -DSVGA_MODE=NORMAL_VGA
 #RAMDISK := -DRAMDISK=512
 
 targets		:= vmlinux.bin setup.bin setup.elf zImage bzImage
+targets		+= vmlinuz vmlinux-stripped
 subdir-		:= compressed
 
 setup-y		+= a20.o cmdline.o copy.o cpu.o cpucheck.o edd.o
@@ -105,6 +106,14 @@ $(obj)/setup.bin: $(obj)/setup.elf FORCE
 $(obj)/compressed/vmlinux: FORCE
 	$(Q)$(MAKE) $(build)=$(obj)/compressed IMAGE_OFFSET=$(IMAGE_OFFSET) $@
 
+$(obj)/vmlinuz: $(obj)/vmlinux-stripped FORCE
+	$(call if_changed,gzip)
+	@echo 'Kernel: $@ is ready' ' (#'`cat .version`')'
+
+$(obj)/vmlinux-stripped: OBJCOPYFLAGS := -g --strip-unneeded
+$(obj)/vmlinux-stripped: vmlinux FORCE
+	$(call if_changed,objcopy)
+
 # Set this if you want to pass append arguments to the zdisk/fdimage/isoimage kernel
 FDARGS =
 # Set this if you want an initrd included with the zdisk/fdimage/isoimage kernel
-- 
1.5.4.1


linux-2.6-xen-0012-xen-Add-empty-xenctrl-module.patch:

--- NEW FILE linux-2.6-xen-0012-xen-Add-empty-xenctrl-module.patch ---
>From b98894d7ab66204bee05f7326658f97658d0dc02 Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Mon, 4 Feb 2008 08:30:37 +0000
Subject: [PATCH] xen: Add empty xenctrl module

Add the basic infrastructure for a xenctrl module
which will contain the various kernel interfaces
used by (mainly Dom0) Xen userspace.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 arch/x86/xen/Kconfig         |    7 +++++
 drivers/xen/Makefile         |    2 +
 drivers/xen/xenctrl/Makefile |    4 +++
 drivers/xen/xenctrl/main.c   |   62 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 75 insertions(+), 0 deletions(-)
 create mode 100644 drivers/xen/xenctrl/Makefile
 create mode 100644 drivers/xen/xenctrl/main.c

diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
index 4d5f264..4723bc1 100644
--- a/arch/x86/xen/Kconfig
+++ b/arch/x86/xen/Kconfig
@@ -11,3 +11,10 @@ config XEN
 	  This is the Linux Xen port.  Enabling this will allow the
 	  kernel to boot in a paravirtualized environment under the
 	  Xen hypervisor.
+
+config XENCTRL
+	tristate "Xen's user space control interfaces"
+	depends on XEN && PROC_FS
+	default y if XEN
+	help
+	  This is the /proc/xen interface used by Xen's libxc.
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index 56592f0..6737463 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -1,2 +1,4 @@
 obj-y	+= grant-table.o
 obj-y	+= xenbus/
+
+obj-$(CONFIG_XENCTRL) += xenctrl/
diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
new file mode 100644
index 0000000..1f43a43
--- /dev/null
+++ b/drivers/xen/xenctrl/Makefile
@@ -0,0 +1,4 @@
+obj-$(CONFIG_XENCTRL) += xenctrl.o
+
+xenctrl-objs  =
+xenctrl-objs += main.o
diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
new file mode 100644
index 0000000..2965ceb
--- /dev/null
+++ b/drivers/xen/xenctrl/main.c
@@ -0,0 +1,62 @@
+/******************************************************************************
+ *
+ * main.c
+ *
+ * Xen userspace control interfaces
+ *
+ * Copyright (c) 2002-2004, K A Fraser, B Dragovic
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+#include <asm/xen/hypervisor.h>
+
+static int __init xenctrl_init(void)
+{
+	struct proc_dir_entry *dir;
+
+	if (!is_running_on_xen())
+		return -ENODEV;
+
+	dir = proc_mkdir("xen", NULL);
+	if (!dir)
+		return -ENOMEM;
+
+	dir->owner = THIS_MODULE;
+
+	return 0;
+}
+
+static void __exit xenctrl_exit(void)
+{
+	remove_proc_entry("xen", NULL);
+}
+
+module_init(xenctrl_init);
+module_exit(xenctrl_exit);
+
+MODULE_LICENSE("Dual BSD/GPL");
-- 
1.5.4.1


linux-2.6-xen-0013-xen-Add-proc-xen-capabilities.patch:

--- NEW FILE linux-2.6-xen-0013-xen-Add-proc-xen-capabilities.patch ---
>From 518802db5493700ccee19570a94a0391ff006b99 Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Mon, 4 Feb 2008 09:16:51 +0000
Subject: [PATCH] xen: Add /proc/xen/capabilities

/proc/xen/capabilities is used by the xend init script
to check whether it is running on Dom0.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 drivers/xen/xenctrl/Makefile       |    1 +
 drivers/xen/xenctrl/capabilities.c |   68 ++++++++++++++++++++++++++++++++++++
 drivers/xen/xenctrl/main.c         |   11 ++++++
 drivers/xen/xenctrl/xenctrl.h      |   39 ++++++++++++++++++++
 4 files changed, 119 insertions(+), 0 deletions(-)
 create mode 100644 drivers/xen/xenctrl/capabilities.c
 create mode 100644 drivers/xen/xenctrl/xenctrl.h

diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
index 1f43a43..631f535 100644
--- a/drivers/xen/xenctrl/Makefile
+++ b/drivers/xen/xenctrl/Makefile
@@ -2,3 +2,4 @@ obj-$(CONFIG_XENCTRL) += xenctrl.o
 
 xenctrl-objs  =
 xenctrl-objs += main.o
+xenctrl-objs += capabilities.o
diff --git a/drivers/xen/xenctrl/capabilities.c b/drivers/xen/xenctrl/capabilities.c
new file mode 100644
index 0000000..1ff078a
--- /dev/null
+++ b/drivers/xen/xenctrl/capabilities.c
@@ -0,0 +1,68 @@
+/******************************************************************************
+ *
+ * capabilities.c
+ *
+ * /proc/xen/capabilities
+ *
+ * Copyright (c) 2002-2004, K A Fraser, B Dragovic
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+#include <asm/xen/hypervisor.h>
+
+static int capabilities_read(char *page, char **start, off_t off,
+			     int count, int *eof, void *data)
+{
+	int len = 0;
+	*page = 0;
+
+	if (is_initial_xendomain())
+		len = sprintf(page, "control_d\n");
+
+	*eof = 1;
+	return len;
+}
+
+int __init capabilities_create_proc_entry(void)
+{
+	struct proc_dir_entry *entry;
+
+	entry = create_proc_entry("xen/capabilities", 0400, NULL);
+	if (!entry)
+		return -ENOMEM;
+
+	entry->owner = THIS_MODULE;
+	entry->read_proc = capabilities_read;
+
+	return 0;
+}
+
+void __exit capabilities_remove_proc_entry(void)
+{
+	remove_proc_entry("xen/capabilities", NULL);
+}
diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
index 2965ceb..0e42f7e 100644
--- a/drivers/xen/xenctrl/main.c
+++ b/drivers/xen/xenctrl/main.c
@@ -31,6 +31,8 @@
  * IN THE SOFTWARE.
  */
 
+#include "xenctrl.h"
+
 #include <linux/proc_fs.h>
 #include <linux/module.h>
 #include <asm/xen/hypervisor.h>
@@ -38,6 +40,7 @@
 static int __init xenctrl_init(void)
 {
 	struct proc_dir_entry *dir;
+	int ret;
 
 	if (!is_running_on_xen())
 		return -ENODEV;
@@ -48,11 +51,19 @@ static int __init xenctrl_init(void)
 
 	dir->owner = THIS_MODULE;
 
+	ret = capabilities_create_proc_entry();
+	if (ret)
+		goto fail1;
+
 	return 0;
+
+ fail1:	remove_proc_entry("xen", NULL);
+	return ret;
 }
 
 static void __exit xenctrl_exit(void)
 {
+	capabilities_remove_proc_entry();
 	remove_proc_entry("xen", NULL);
 }
 
diff --git a/drivers/xen/xenctrl/xenctrl.h b/drivers/xen/xenctrl/xenctrl.h
new file mode 100644
index 0000000..7378dde
--- /dev/null
+++ b/drivers/xen/xenctrl/xenctrl.h
@@ -0,0 +1,39 @@
+/******************************************************************************
+ * xenctl.h
+ * 
+ * Xen userspace control interfaces
+ * 
+ * Copyright (c) 2002-2004, K A Fraser, B Dragovic
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/init.h>
+
+/*
+ * capabilities.c
+ */
+int capabilities_create_proc_entry(void) __init;
+void capabilities_remove_proc_entry(void) __exit;
-- 
1.5.4.1


linux-2.6-xen-0014-xen-Add-proc-xen-privcmd.patch:

--- NEW FILE linux-2.6-xen-0014-xen-Add-proc-xen-privcmd.patch ---
>From c74a776c532b8f81319ae0eb9fb8f538b4ada503 Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Mon, 4 Feb 2008 08:24:57 +0000
Subject: [PATCH] xen: Add /proc/xen/privcmd

/proc/xen/privcmd is an ioctl() interface which allows
userspace apps to invoke hypercalls.

There should also be an ioctl (IOCTL_PRIVCMD_MMAP)
which is used to map foreign pages into a processes
address space, but we leave this unimplemented for
now pending further work on foreign page support.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 drivers/xen/xenctrl/Makefile    |    1 +
 drivers/xen/xenctrl/main.c      |    6 +++
 drivers/xen/xenctrl/privcmd.c   |   81 +++++++++++++++++++++++++++++++++++++++
 drivers/xen/xenctrl/xenctrl.h   |    6 +++
 include/asm-x86/xen/hypercall.h |   56 +++++++++++++++++++++++++++
 include/xen/sys/privcmd.h       |   79 ++++++++++++++++++++++++++++++++++++++
 6 files changed, 229 insertions(+), 0 deletions(-)
 create mode 100644 drivers/xen/xenctrl/privcmd.c
 create mode 100644 include/xen/sys/privcmd.h

diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
index 631f535..8a706cb 100644
--- a/drivers/xen/xenctrl/Makefile
+++ b/drivers/xen/xenctrl/Makefile
@@ -3,3 +3,4 @@ obj-$(CONFIG_XENCTRL) += xenctrl.o
 xenctrl-objs  =
 xenctrl-objs += main.o
 xenctrl-objs += capabilities.o
+xenctrl-objs += privcmd.o
diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
index 0e42f7e..d1fe6ef 100644
--- a/drivers/xen/xenctrl/main.c
+++ b/drivers/xen/xenctrl/main.c
@@ -55,14 +55,20 @@ static int __init xenctrl_init(void)
 	if (ret)
 		goto fail1;
 
+	ret = privcmd_create_proc_entry();
+	if (ret)
+		goto fail2;
+
 	return 0;
 
+ fail2: capabilities_remove_proc_entry();
  fail1:	remove_proc_entry("xen", NULL);
 	return ret;
 }
 
 static void __exit xenctrl_exit(void)
 {
+	privcmd_remove_proc_entry();
 	capabilities_remove_proc_entry();
 	remove_proc_entry("xen", NULL);
 }
diff --git a/drivers/xen/xenctrl/privcmd.c b/drivers/xen/xenctrl/privcmd.c
new file mode 100644
index 0000000..58c4b83
--- /dev/null
+++ b/drivers/xen/xenctrl/privcmd.c
@@ -0,0 +1,81 @@
+/******************************************************************************
+ * privcmd.c
+ * 
+ * Interface to privileged domain-0 commands.
+ * 
+ * Copyright (c) 2002-2004, K A Fraser, B Dragovic
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <asm/xen/hypervisor.h>
+#include <xen/sys/privcmd.h>
+
+static long privcmd_ioctl(struct file *file, unsigned int cmd,
+			  unsigned long arg)
+{
+	switch (cmd) {
+	case IOCTL_PRIVCMD_HYPERCALL: {
+		privcmd_hypercall_t cmd;
+  
+		if (copy_from_user(&cmd, (void __user *)arg, sizeof(cmd)))
+			return -EFAULT;
+
+		return privcmd_hypercall(&cmd);
+	}
+
+	case IOCTL_PRIVCMD_MMAP:
+	case IOCTL_PRIVCMD_MMAPBATCH:
+		printk(KERN_WARNING "IOCTL_PRIVCMD_MMAP ioctl not yet implemented\n");
+	default:
+		return -EINVAL;
+	}
+}
+
+static const struct file_operations privcmd_file_ops = {
+	.unlocked_ioctl = privcmd_ioctl,
+};
+
+int __init privcmd_create_proc_entry(void)
+{
+	static struct proc_dir_entry *entry;
+
+	entry = create_proc_entry("xen/privcmd", 0400, NULL);
+	if (!entry)
+		return -ENOMEM;
+
+	entry->owner = THIS_MODULE;
+	entry->proc_fops = &privcmd_file_ops;
+
+	return 0;
+}
+
+void __exit privcmd_remove_proc_entry(void)
+{
+	remove_proc_entry("xen/privcmd", NULL);
+}
diff --git a/drivers/xen/xenctrl/xenctrl.h b/drivers/xen/xenctrl/xenctrl.h
index 7378dde..a35209a 100644
--- a/drivers/xen/xenctrl/xenctrl.h
+++ b/drivers/xen/xenctrl/xenctrl.h
@@ -37,3 +37,9 @@
  */
 int capabilities_create_proc_entry(void) __init;
 void capabilities_remove_proc_entry(void) __exit;
+
+/*
+ * privcmd.c
+ */
+int privcmd_create_proc_entry(void) __init;
+void privcmd_remove_proc_entry(void) __exit;
diff --git a/include/asm-x86/xen/hypercall.h b/include/asm-x86/xen/hypercall.h
index bc0ee7d..b0c518c 100644
--- a/include/asm-x86/xen/hypercall.h
+++ b/include/asm-x86/xen/hypercall.h
@@ -410,4 +410,60 @@ MULTI_stack_switch(struct multicall_entry *mcl,
 	mcl->args[1] = esp;
 }
 
+#include <xen/sys/privcmd.h>
+
+#ifdef CONFIG_X86_32
+static inline int privcmd_hypercall(privcmd_hypercall_t *hypercall)
+{
+	int ret;
+
+	if (hypercall->op >= (PAGE_SIZE >> 5))
+		return -EINVAL;
+
+	__asm__ __volatile__ (
+		"pushl %%ebx; pushl %%ecx; pushl %%edx; "
+		"pushl %%esi; pushl %%edi; "
+		"movl  8(%%eax),%%ebx ;"
+		"movl 16(%%eax),%%ecx ;"
+		"movl 24(%%eax),%%edx ;"
+		"movl 32(%%eax),%%esi ;"
+		"movl 40(%%eax),%%edi ;"
+		"movl   (%%eax),%%eax ;"
+		"shll $5,%%eax ;"
+		"addl $hypercall_page,%%eax ;"
+		"call *%%eax ;"
+		"popl %%edi; popl %%esi; popl %%edx; "
+		"popl %%ecx; popl %%ebx"
+		: "=a" (ret) : "0" (hypercall) : "memory" );
+
+	return ret;
+}
+#else /* CONFIG_X86_32 */
+static inline int privcmd_hypercall(privcmd_hypercall_t *hypercall)
+{
+	int ret;
+        long ign1, ign2, ign3;
+
+	if (hypercall->op >= (PAGE_SIZE >> 5))
+		return -EINVAL;
+
+        __asm__ __volatile__ (
+		"movq %8,%%r10; movq %9,%%r8;"
+                "shll $5,%%eax ;"
+                "addq $hypercall_page,%%rax ;"
+                "call *%%rax"
+                : "=a" (ret), "=D" (ign1),
+                  "=S" (ign2), "=d" (ign3)
+                : "0" ((unsigned int)hypercall->op),
+                  "1" (hypercall->arg[0]),
+                  "2" (hypercall->arg[1]),
+                  "3" (hypercall->arg[2]),
+                  "g" (hypercall->arg[3]),
+                  "g" (hypercall->arg[4])
+                : "r8", "r10", "memory" );
+
+	return ret;
+}
+#endif /* CONFIG_X86_32 */
+
 #endif /* __HYPERCALL_H__ */
diff --git a/include/xen/sys/privcmd.h b/include/xen/sys/privcmd.h
new file mode 100644
index 0000000..9cfa9d7
--- /dev/null
+++ b/include/xen/sys/privcmd.h
@@ -0,0 +1,79 @@
+/******************************************************************************
+ * privcmd.h
+ * 
+ * Interface to /proc/xen/privcmd.
+ * 
+ * Copyright (c) 2003-2005, K A Fraser
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef __LINUX_PUBLIC_PRIVCMD_H__
+#define __LINUX_PUBLIC_PRIVCMD_H__
+
+#include <linux/types.h>
+
+#ifndef __user
+#define __user
+#endif
+
+typedef struct privcmd_hypercall
+{
+	__u64 op;
+	__u64 arg[5];
+} privcmd_hypercall_t;
+
+typedef struct privcmd_mmap_entry {
+	__u64 va;
+	__u64 mfn;
+	__u64 npages;
+} privcmd_mmap_entry_t; 
+
+typedef struct privcmd_mmap {
+	int num;
+	domid_t dom; /* target domain */
+	privcmd_mmap_entry_t __user *entry;
+} privcmd_mmap_t; 
+
+typedef struct privcmd_mmapbatch {
+	int num;     /* number of pages to populate */
+	domid_t dom; /* target domain */
+	__u64 addr;  /* virtual address */
+	ulong __user *arr; /* array of mfns - top nibble set on err */
+} privcmd_mmapbatch_t; 
+
+/*
+ * @cmd: IOCTL_PRIVCMD_HYPERCALL
+ * @arg: &privcmd_hypercall_t
+ * Return: Value returned from execution of the specified hypercall.
+ */
+#define IOCTL_PRIVCMD_HYPERCALL					\
+	_IOC(_IOC_NONE, 'P', 0, sizeof(privcmd_hypercall_t))
+#define IOCTL_PRIVCMD_MMAP					\
+	_IOC(_IOC_NONE, 'P', 2, sizeof(privcmd_mmap_t))
+#define IOCTL_PRIVCMD_MMAPBATCH					\
+	_IOC(_IOC_NONE, 'P', 3, sizeof(privcmd_mmapbatch_t))
+
+#endif /* __LINUX_PUBLIC_PRIVCMD_H__ */
-- 
1.5.4.1


linux-2.6-xen-0015-xen-Add-proc-xen-xenbus.patch:

--- NEW FILE linux-2.6-xen-0015-xen-Add-proc-xen-xenbus.patch ---
>From f96416ef6d859c2fb80658988c58635114f5285c Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Mon, 4 Feb 2008 22:04:36 +0000
Subject: [PATCH] xen: Add /proc/xen/xenbus

This interface is used by userspace programs to talk to
xenstored.

Since xenstored makes itself available to Dom0 userspace
via a socket this should only really be useful in Domu,
but it turns out that Dom0 apps historically default
to using /proc/xen/xenbus rather than the socket.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 drivers/xen/xenbus/xenbus_comms.h |    1 -
 drivers/xen/xenbus/xenbus_probe.c |    2 +
 drivers/xen/xenbus/xenbus_xs.c    |    1 +
 drivers/xen/xenctrl/Makefile      |    1 +
 drivers/xen/xenctrl/main.c        |    6 +
 drivers/xen/xenctrl/xenbus.c      |  398 +++++++++++++++++++++++++++++++++++++
 drivers/xen/xenctrl/xenctrl.h     |    6 +
 include/xen/xenbus.h              |    2 +
 8 files changed, 416 insertions(+), 1 deletions(-)
 create mode 100644 drivers/xen/xenctrl/xenbus.c

diff --git a/drivers/xen/xenbus/xenbus_comms.h b/drivers/xen/xenbus/xenbus_comms.h
index c21db75..fcc9b29 100644
--- a/drivers/xen/xenbus/xenbus_comms.h
+++ b/drivers/xen/xenbus/xenbus_comms.h
@@ -41,6 +41,5 @@ int xb_data_to_read(void);
 int xb_wait_for_data_to_read(void);
 int xs_input_avail(void);
 extern struct xenstore_domain_interface *xen_store_interface;
-extern int xen_store_evtchn;
 
 #endif /* _XENBUS_COMMS_H */
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 57ceb53..c811581 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -56,6 +56,8 @@
 #include "xenbus_probe.h"
 
 int xen_store_evtchn;
+EXPORT_SYMBOL_GPL(xen_store_evtchn);
+
 struct xenstore_domain_interface *xen_store_interface;
 static unsigned long xen_store_mfn;
 
diff --git a/drivers/xen/xenbus/xenbus_xs.c b/drivers/xen/xenbus/xenbus_xs.c
index 227d53b..810e24a 100644
--- a/drivers/xen/xenbus/xenbus_xs.c
+++ b/drivers/xen/xenbus/xenbus_xs.c
@@ -184,6 +184,7 @@ void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg)
 
 	return ret;
 }
+EXPORT_SYMBOL(xenbus_dev_request_and_reply);
 
 /* Send message to xs, get kmalloc'ed reply.  ERR_PTR() on error. */
 static void *xs_talkv(struct xenbus_transaction t,
diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
index 8a706cb..23dafa3 100644
--- a/drivers/xen/xenctrl/Makefile
+++ b/drivers/xen/xenctrl/Makefile
@@ -4,3 +4,4 @@ xenctrl-objs  =
 xenctrl-objs += main.o
 xenctrl-objs += capabilities.o
 xenctrl-objs += privcmd.o
+xenctrl-objs += xenbus.o
diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
index d1fe6ef..b0cf61b 100644
--- a/drivers/xen/xenctrl/main.c
+++ b/drivers/xen/xenctrl/main.c
@@ -59,8 +59,13 @@ static int __init xenctrl_init(void)
 	if (ret)
 		goto fail2;
 
+	ret = xenbus_create_proc_entry();
+	if (ret)
+		goto fail3;
+
 	return 0;
 
+ fail3: privcmd_remove_proc_entry();
  fail2: capabilities_remove_proc_entry();
  fail1:	remove_proc_entry("xen", NULL);
 	return ret;
@@ -68,6 +73,7 @@ static int __init xenctrl_init(void)
 
 static void __exit xenctrl_exit(void)
 {
+	xenbus_remove_proc_entry();
 	privcmd_remove_proc_entry();
 	capabilities_remove_proc_entry();
 	remove_proc_entry("xen", NULL);
diff --git a/drivers/xen/xenctrl/xenbus.c b/drivers/xen/xenctrl/xenbus.c
new file mode 100644
index 0000000..57d5501
--- /dev/null
+++ b/drivers/xen/xenctrl/xenbus.c
@@ -0,0 +1,398 @@
+/*
+ * xenbus.c
+ * 
+ * /proc/xen/xenbus gives user-space access to the kernel's xenbus
+ * connection to xenstore.
+ * 
+ * Copyright (c) 2005, Christian Limpach
+ * Copyright (c) 2005, Rusty Russell, IBM Corporation
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <linux/proc_fs.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/poll.h>
+
+#include <xen/xenbus.h>
+
+struct xenbus_dev_transaction {
+	struct list_head list;
+	struct xenbus_transaction handle;
+};
+
+struct read_buffer {
+	struct list_head list;
+	unsigned int cons;
+	unsigned int len;
+	char msg[];
+};
+
+struct xenbus_dev_data {
+	/* In-progress transaction. */
+	struct list_head transactions;
+
+	/* Active watches. */
+	struct list_head watches;
+
+	/* Partial request. */
+	unsigned int len;
+	union {
+		struct xsd_sockmsg msg;
+		char buffer[PAGE_SIZE];
+	} u;
+
+	/* Response queue. */
+	struct list_head read_buffers;
+	wait_queue_head_t read_waitq;
+
+	struct mutex reply_mutex;
+};
+
+static ssize_t xenbus_dev_read(struct file *filp,
+			       char __user *ubuf,
+			       size_t len, loff_t *ppos)
+{
+	struct xenbus_dev_data *u = filp->private_data;
+	struct read_buffer *rb;
+	int i, ret;
+
+	mutex_lock(&u->reply_mutex);
+	while (list_empty(&u->read_buffers)) {
+		mutex_unlock(&u->reply_mutex);
+		ret = wait_event_interruptible(u->read_waitq,
+					       !list_empty(&u->read_buffers));
+		if (ret)
+			return ret;
+		mutex_lock(&u->reply_mutex);
+	}
+
+	rb = list_entry(u->read_buffers.next, struct read_buffer, list);
+	for (i = 0; i < len;) {
+		put_user(rb->msg[rb->cons], ubuf + i);
+		i++;
+		rb->cons++;
+		if (rb->cons == rb->len) {
+			list_del(&rb->list);
+			kfree(rb);
+			if (list_empty(&u->read_buffers))
+				break;
+			rb = list_entry(u->read_buffers.next,
+					struct read_buffer, list);
+		}
+	}
+	mutex_unlock(&u->reply_mutex);
+
+	return i;
+}
+
+static void queue_reply(struct xenbus_dev_data *u,
+			char *data, unsigned int len)
+{
+	struct read_buffer *rb;
+
+	if (len == 0)
+		return;
+
+	rb = kmalloc(sizeof(*rb) + len, GFP_KERNEL);
+	BUG_ON(rb == NULL);
+
+	rb->cons = 0;
+	rb->len = len;
+
+	memcpy(rb->msg, data, len);
+
+	list_add_tail(&rb->list, &u->read_buffers);
+
+	wake_up(&u->read_waitq);
+}
+
+struct watch_adapter
+{
+	struct list_head list;
+	struct xenbus_watch watch;
+	struct xenbus_dev_data *dev_data;
+	char *token;
+};
+
+static void free_watch_adapter(struct watch_adapter *watch)
+{
+	kfree(watch->watch.node);
+	kfree(watch->token);
+	kfree(watch);
+}
+
+static void watch_fired(struct xenbus_watch *watch,
+			const char **vec,
+			unsigned int len)
+{
+	struct watch_adapter *adap =
+            container_of(watch, struct watch_adapter, watch);
+	struct xsd_sockmsg hdr;
+	const char *path, *token;
+	int path_len, tok_len, body_len;
+
+	path = vec[XS_WATCH_PATH];
+	token = adap->token;
+
+	path_len = strlen(path) + 1;
+	tok_len = strlen(token) + 1;
+	body_len = path_len + tok_len;
+
+	hdr.type = XS_WATCH_EVENT;
+	hdr.len = body_len;
+
+	mutex_lock(&adap->dev_data->reply_mutex);
+	queue_reply(adap->dev_data, (char *)&hdr, sizeof(hdr));
+	queue_reply(adap->dev_data, (char *)path, path_len);
+	queue_reply(adap->dev_data, (char *)token, tok_len);
+	mutex_unlock(&adap->dev_data->reply_mutex);
+}
+
+static LIST_HEAD(watch_list);
+
+static ssize_t xenbus_dev_write(struct file *filp,
+				const char __user *ubuf,
+				size_t len, loff_t *ppos)
+{
+	struct xenbus_dev_data *u = filp->private_data;
+	struct xenbus_dev_transaction *trans = NULL;
+	uint32_t msg_type;
+	void *reply;
+	char *path, *token;
+	struct watch_adapter *watch, *tmp_watch;
+	int err, rc = len;
+
+	if ((len + u->len) > sizeof(u->u.buffer)) {
+		rc = -EINVAL;
+		goto out;
+	}
+
+	if (copy_from_user(u->u.buffer + u->len, ubuf, len) != 0) {
+		rc = -EFAULT;
+		goto out;
+	}
+
+	u->len += len;
+	if ((u->len < sizeof(u->u.msg)) ||
+	    (u->len < (sizeof(u->u.msg) + u->u.msg.len)))
+		return rc;
+
+	msg_type = u->u.msg.type;
+
+	switch (msg_type) {
+	case XS_TRANSACTION_START:
+	case XS_TRANSACTION_END:
+	case XS_DIRECTORY:
+	case XS_READ:
+	case XS_GET_PERMS:
+	case XS_RELEASE:
+	case XS_GET_DOMAIN_PATH:
+	case XS_WRITE:
+	case XS_MKDIR:
+	case XS_RM:
+	case XS_SET_PERMS:
+		if (msg_type == XS_TRANSACTION_START) {
+			trans = kmalloc(sizeof(*trans), GFP_KERNEL);
+			if (!trans) {
+				rc = -ENOMEM;
+				goto out;
+			}
+		}
+
+		reply = xenbus_dev_request_and_reply(&u->u.msg);
+		if (IS_ERR(reply)) {
+			kfree(trans);
+			rc = PTR_ERR(reply);
+			goto out;
+		}
+
+		if (msg_type == XS_TRANSACTION_START) {
+			trans->handle.id = simple_strtoul(reply, NULL, 0);
+			list_add(&trans->list, &u->transactions);
+		} else if (msg_type == XS_TRANSACTION_END) {
+			list_for_each_entry(trans, &u->transactions, list)
+				if (trans->handle.id == u->u.msg.tx_id)
+					break;
+			BUG_ON(&trans->list == &u->transactions);
+			list_del(&trans->list);
+			kfree(trans);
+		}
+		mutex_lock(&u->reply_mutex);
+		queue_reply(u, (char *)&u->u.msg, sizeof(u->u.msg));
+		queue_reply(u, (char *)reply, u->u.msg.len);
+		mutex_unlock(&u->reply_mutex);
+		kfree(reply);
+		break;
+
+	case XS_WATCH:
+	case XS_UNWATCH: {
+		static const char *XS_RESP = "OK";
+		struct xsd_sockmsg hdr;
+
+		path = u->u.buffer + sizeof(u->u.msg);
+		token = memchr(path, 0, u->u.msg.len);
+		if (token == NULL) {
+			rc = -EILSEQ;
+			goto out;
+		}
+		token++;
+
+		if (msg_type == XS_WATCH) {
+			watch = kmalloc(sizeof(*watch), GFP_KERNEL);
+			watch->watch.node = kmalloc(strlen(path)+1,
+                                                    GFP_KERNEL);
+			strcpy((char *)watch->watch.node, path);
+			watch->watch.callback = watch_fired;
+			watch->token = kmalloc(strlen(token)+1, GFP_KERNEL);
+			strcpy(watch->token, token);
+			watch->dev_data = u;
+
+			err = register_xenbus_watch(&watch->watch);
+			if (err) {
+				free_watch_adapter(watch);
+				rc = err;
+				goto out;
+			}
+			
+			list_add(&watch->list, &u->watches);
+		} else {
+			list_for_each_entry_safe(watch, tmp_watch,
+                                                 &u->watches, list) {
+				if (!strcmp(watch->token, token) &&
+				    !strcmp(watch->watch.node, path))
+				{
+					unregister_xenbus_watch(&watch->watch);
+					list_del(&watch->list);
+					free_watch_adapter(watch);
+					break;
+				}
+			}
+		}
+
+		hdr.type = msg_type;
+		hdr.len = strlen(XS_RESP) + 1;
+		mutex_lock(&u->reply_mutex);
+		queue_reply(u, (char *)&hdr, sizeof(hdr));
+		queue_reply(u, (char *)XS_RESP, hdr.len);
+		mutex_unlock(&u->reply_mutex);
+		break;
+	}
+
+	default:
+		rc = -EINVAL;
+		break;
+	}
+
+ out:
+	u->len = 0;
+	return rc;
+}
+
+static int xenbus_dev_open(struct inode *inode, struct file *filp)
+{
+	struct xenbus_dev_data *u;
+
+	if (xen_store_evtchn == 0)
+		return -ENOENT;
+
+	nonseekable_open(inode, filp);
+
+	u = kzalloc(sizeof(*u), GFP_KERNEL);
+	if (u == NULL)
+		return -ENOMEM;
+
+	INIT_LIST_HEAD(&u->transactions);
+	INIT_LIST_HEAD(&u->watches);
+	INIT_LIST_HEAD(&u->read_buffers);
+	init_waitqueue_head(&u->read_waitq);
+
+	mutex_init(&u->reply_mutex);
+
+	filp->private_data = u;
+
+	return 0;
+}
+
+static int xenbus_dev_release(struct inode *inode, struct file *filp)
+{
+	struct xenbus_dev_data *u = filp->private_data;
+	struct xenbus_dev_transaction *trans, *tmp;
+	struct watch_adapter *watch, *tmp_watch;
+
+	list_for_each_entry_safe(trans, tmp, &u->transactions, list) {
+		xenbus_transaction_end(trans->handle, 1);
+		list_del(&trans->list);
+		kfree(trans);
+	}
+
+	list_for_each_entry_safe(watch, tmp_watch, &u->watches, list) {
+		unregister_xenbus_watch(&watch->watch);
+		list_del(&watch->list);
+		free_watch_adapter(watch);
+	}
+
+	kfree(u);
+
+	return 0;
+}
+
+static unsigned int xenbus_dev_poll(struct file *file, poll_table *wait)
+{
+	struct xenbus_dev_data *u = file->private_data;
+
+	poll_wait(file, &u->read_waitq, wait);
+	if (!list_empty(&u->read_buffers))
+		return POLLIN | POLLRDNORM;
+	return 0;
+}
+
+static const struct file_operations xenbus_dev_file_ops = {
+	.read = xenbus_dev_read,
+	.write = xenbus_dev_write,
+	.open = xenbus_dev_open,
+	.release = xenbus_dev_release,
+	.poll = xenbus_dev_poll,
+};
+
+int __init xenbus_create_proc_entry(void)
+{
+	struct proc_dir_entry *entry;
+
+	entry = create_proc_entry("xen/xenbus", 0400, NULL);
+	if (!entry)
+		return -ENOMEM;
+
+	entry->owner = THIS_MODULE;
+	entry->proc_fops = &xenbus_dev_file_ops;
+
+	return 0;
+}
+
+void __exit xenbus_remove_proc_entry(void)
+{
+	remove_proc_entry("xen/xenbus", NULL);
+}
diff --git a/drivers/xen/xenctrl/xenctrl.h b/drivers/xen/xenctrl/xenctrl.h
index a35209a..e585c4b 100644
--- a/drivers/xen/xenctrl/xenctrl.h
+++ b/drivers/xen/xenctrl/xenctrl.h
@@ -43,3 +43,9 @@ void capabilities_remove_proc_entry(void) __exit;
  */
 int privcmd_create_proc_entry(void) __init;
 void privcmd_remove_proc_entry(void) __exit;
+
+/*
+ * xenbus.c
+ */
+int xenbus_create_proc_entry(void) __init;
+void xenbus_remove_proc_entry(void) __exit;
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index 6369d89..a3fef9d 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -232,4 +232,6 @@ const char *xenbus_strstate(enum xenbus_state state);
 int xenbus_dev_is_online(struct xenbus_device *dev);
 int xenbus_frontend_closed(struct xenbus_device *dev);
 
+extern int xen_store_evtchn;
+
 #endif /* _XEN_XENBUS_H */
-- 
1.5.4.1


linux-2.6-xen-0016-xen-Add-Xen-s-sys-hypervisor-interface.patch:

--- NEW FILE linux-2.6-xen-0016-xen-Add-Xen-s-sys-hypervisor-interface.patch ---
>From 349ebcd3a208feb3885bf851ac525f77f75a5cc8 Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Thu, 7 Feb 2008 15:32:28 +0000
Subject: [PATCH] xen: Add Xen's /sys/hypervisor interface

Hook up Xen's /sys/hypervisor interface:

  /sys/hypervisor/
    -> type
    -> uuid
    -> compilation
         -> compile_date
         -> compiled_by
         -> compiler
    -> properties
         -> capabilities
         -> changeset
         -> pagesize
         -> virtual_start
         -> writable_pt
    -> version
         -> extra
         -> major
         -> minor

Note: the hypervisor subsys hook requires that
SYS_HYPERVISOR is selected to enabled it, which in
turns means that the subsys will be registered by
a pv-ops kernel with Xen support, even on bare
metal. This hook needs to be changed to be runtime
enabled.

Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 arch/x86/xen/Kconfig            |    3 +-
 drivers/xen/xenctrl/Makefile    |    1 +
 drivers/xen/xenctrl/main.c      |    6 +
 drivers/xen/xenctrl/sysfs.c     |  349 +++++++++++++++++++++++++++++++++++++++
 drivers/xen/xenctrl/xenctrl.h   |    6 +
 include/xen/interface/version.h |    6 +
 6 files changed, 370 insertions(+), 1 deletions(-)
 create mode 100644 drivers/xen/xenctrl/sysfs.c

diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
index 4723bc1..ff6a56a 100644
--- a/arch/x86/xen/Kconfig
+++ b/arch/x86/xen/Kconfig
@@ -14,7 +14,8 @@ config XEN
 
 config XENCTRL
 	tristate "Xen's user space control interfaces"
-	depends on XEN && PROC_FS
+	depends on XEN && PROC_FS && SYSFS
 	default y if XEN
+	select SYS_HYPERVISOR
 	help
 	  This is the /proc/xen interface used by Xen's libxc.
diff --git a/drivers/xen/xenctrl/Makefile b/drivers/xen/xenctrl/Makefile
index 23dafa3..e126e76 100644
--- a/drivers/xen/xenctrl/Makefile
+++ b/drivers/xen/xenctrl/Makefile
@@ -5,3 +5,4 @@ xenctrl-objs += main.o
 xenctrl-objs += capabilities.o
 xenctrl-objs += privcmd.o
 xenctrl-objs += xenbus.o
+xenctrl-objs += sysfs.o
diff --git a/drivers/xen/xenctrl/main.c b/drivers/xen/xenctrl/main.c
index b0cf61b..87d0dba 100644
--- a/drivers/xen/xenctrl/main.c
+++ b/drivers/xen/xenctrl/main.c
@@ -63,8 +63,13 @@ static int __init xenctrl_init(void)
 	if (ret)
 		goto fail3;
 
+	ret = sys_hypervisor_init();
+	if (ret)
+		goto fail4;
+
 	return 0;
 
+ fail4: xenbus_remove_proc_entry();
  fail3: privcmd_remove_proc_entry();
  fail2: capabilities_remove_proc_entry();
  fail1:	remove_proc_entry("xen", NULL);
@@ -73,6 +78,7 @@ static int __init xenctrl_init(void)
 
 static void __exit xenctrl_exit(void)
 {
+	sys_hypervisor_exit();
 	xenbus_remove_proc_entry();
 	privcmd_remove_proc_entry();
 	capabilities_remove_proc_entry();
diff --git a/drivers/xen/xenctrl/sysfs.c b/drivers/xen/xenctrl/sysfs.c
new file mode 100644
index 0000000..8cbf4d6
--- /dev/null
+++ b/drivers/xen/xenctrl/sysfs.c
@@ -0,0 +1,349 @@
+/*
+ *  copyright (c) 2006 IBM Corporation
+ *  Authored by: Mike D. Day <ncmike at us.ibm.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/kobject.h>
+#include <linux/sysfs.h>
+#include <linux/err.h>
+#include <asm/xen/hypervisor.h>
+#include <xen/xenbus.h>
+#include "xenctrl.h"
+
+#define HYPERVISOR_ATTR_RO(_name) \
+static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
+
+#define HYPERVISOR_ATTR_RW(_name) \
+static struct kobj_attribute _name##_attr = \
+	__ATTR(_name, 0644, _name##_show, _name##_store)
+
+static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	return sprintf(buffer, "xen\n");
+}
+
+HYPERVISOR_ATTR_RO(type);
+
+static int __init xen_sysfs_type_init(void)
+{
+	return sysfs_create_file(hypervisor_kobj, &type_attr.attr);
+}
+
+static void xen_sysfs_type_destroy(void)
+{
+	sysfs_remove_file(hypervisor_kobj, &type_attr.attr);
+}
+
+static ssize_t major_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	int version;
+
+	version = HYPERVISOR_xen_version(XENVER_version, NULL);
+	if (!version)
+		return -ENODEV;
+
+	return sprintf(buffer, "%d\n", version >> 16);
+}
+
+HYPERVISOR_ATTR_RO(major);
+
+static ssize_t minor_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	int version;
+
+	version = HYPERVISOR_xen_version(XENVER_version, NULL);
+	if (!version)
+		return -ENODEV;
+
+	return sprintf(buffer, "%d\n", version & 0xff);
+}
+
+HYPERVISOR_ATTR_RO(minor);
+
+static ssize_t extra_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	int ret;
+	struct xen_extraversion extra;
+
+	ret = HYPERVISOR_xen_version(XENVER_extraversion, &extra);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%s\n", extra.extraversion);
+}
+
+HYPERVISOR_ATTR_RO(extra);
+
+static struct attribute *version_attrs[] = {
+	&major_attr.attr,
+	&minor_attr.attr,
+	&extra_attr.attr,
+	NULL
+};
+
+static struct attribute_group version_group = {
+	.name = "version",
+	.attrs = version_attrs,
+};
+
+static int __init xen_sysfs_version_init(void)
+{
+	return sysfs_create_group(hypervisor_kobj, &version_group);
+}
+
+static void xen_sysfs_version_destroy(void)
+{
+	sysfs_remove_group(hypervisor_kobj, &version_group);
+}
+
+static ssize_t uuid_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	char *vm, *val;
+	int ret;
+
+	vm = xenbus_read(XBT_NIL, "vm", "", NULL);
+	if (IS_ERR(vm))
+		return PTR_ERR(vm);
+
+	val = xenbus_read(XBT_NIL, vm, "uuid", NULL);
+	if (IS_ERR(val)) {
+		ret = PTR_ERR(val);
+		goto out;
+	}
+
+	ret = sprintf(buffer, "%s\n", val);
+
+	kfree(val);
+out:	kfree(vm);
+
+	return ret;
+}
+
+HYPERVISOR_ATTR_RO(uuid);
+
+static int __init xen_sysfs_uuid_init(void)
+{
+	return sysfs_create_file(hypervisor_kobj, &uuid_attr.attr);
+}
+
+static void xen_sysfs_uuid_destroy(void)
+{
+	sysfs_remove_file(hypervisor_kobj, &uuid_attr.attr);
+}
+
+static ssize_t compiler_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_compile_info info;
+	int ret;
+
+	ret = HYPERVISOR_xen_version(XENVER_compile_info, &info);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%s\n", info.compiler);
+}
+
+HYPERVISOR_ATTR_RO(compiler);
+
+static ssize_t compiled_by_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_compile_info info;
+	int ret;
+
+	ret = HYPERVISOR_xen_version(XENVER_compile_info, &info);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%s\n", info.compile_by);
+}
+
+HYPERVISOR_ATTR_RO(compiled_by);
+
+static ssize_t compile_date_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_compile_info info;
+	int ret;
+
+	ret = HYPERVISOR_xen_version(XENVER_compile_info, &info);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%s\n", info.compile_date);
+}
+
+HYPERVISOR_ATTR_RO(compile_date);
+
+static struct attribute *xen_compile_attrs[] = {
+	&compiler_attr.attr,
+	&compiled_by_attr.attr,
+	&compile_date_attr.attr,
+	NULL
+};
+
+static struct attribute_group xen_compilation_group = {
+	.name = "compilation",
+	.attrs = xen_compile_attrs,
+};
+
+static int __init xen_compilation_init(void)
+{
+	return sysfs_create_group(hypervisor_kobj,
+				  &xen_compilation_group);
+}
+
+static void xen_compilation_destroy(void)
+{
+	sysfs_remove_group(hypervisor_kobj,
+			   &xen_compilation_group);
+}
+
+static ssize_t capabilities_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_capabilities_info *caps;
+	int ret;
+
+	caps = kmalloc(sizeof(struct xen_capabilities_info), GFP_KERNEL);
+	if (!caps)
+		return -ENOMEM;
+
+	ret = HYPERVISOR_xen_version(XENVER_capabilities, caps);
+	if (ret)
+		goto out;
+
+	ret = sprintf(buffer, "%s\n", caps->info);
+
+out:	kfree(caps);
+
+	return ret;
+}
+
+HYPERVISOR_ATTR_RO(capabilities);
+
+static ssize_t changeset_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_changeset_info cset;
+	int ret;
+
+	ret = HYPERVISOR_xen_version(XENVER_changeset, &cset);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%s\n", cset.info);
+}
+
+HYPERVISOR_ATTR_RO(changeset);
+
+static ssize_t virtual_start_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_platform_parameters parms;
+	int ret;
+
+	ret = HYPERVISOR_xen_version(XENVER_platform_parameters, &parms);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%lx\n", parms.virt_start);
+}
+
+HYPERVISOR_ATTR_RO(virtual_start);
+
+static ssize_t pagesize_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	int ret;
+
+	ret = HYPERVISOR_xen_version(XENVER_pagesize, NULL);
+	if (ret < 0)
+		return ret;
+
+	return sprintf(buffer, "%x\n", ret);
+}
+
+HYPERVISOR_ATTR_RO(pagesize);
+
+static ssize_t writable_pt_show(struct kobject *kobj, struct kobj_attribute *attr, char *buffer)
+{
+	struct xen_feature_info info;
+	int ret;
+
+	info.submap_idx = XENFEAT_writable_page_tables;
+
+	ret = HYPERVISOR_xen_version(XENVER_get_features, &info);
+	if (ret)
+		return ret;
+
+	return sprintf(buffer, "%d\n", info.submap);
+}
+
+HYPERVISOR_ATTR_RO(writable_pt);
+
+static struct attribute *xen_properties_attrs[] = {
+	&capabilities_attr.attr,
+	&changeset_attr.attr,
+	&virtual_start_attr.attr,
+	&pagesize_attr.attr,
+	&writable_pt_attr.attr,
+	NULL
+};
+
+static struct attribute_group xen_properties_group = {
+	.name = "properties",
+	.attrs = xen_properties_attrs,
+};
+
+static int __init xen_properties_init(void)
+{
+	return sysfs_create_group(hypervisor_kobj,
+				  &xen_properties_group);
+}
+
+static void xen_properties_destroy(void)
+{
+	sysfs_remove_group(hypervisor_kobj, &xen_properties_group);
+}
+
+int __init sys_hypervisor_init(void)
+{
+	int ret;
+
+	if (!is_running_on_xen())
+		return -ENODEV;
+
+	ret = xen_sysfs_type_init();
+	if (ret)
+		goto out;
+	ret = xen_sysfs_version_init();
+	if (ret)
+		goto version_out;
+	ret = xen_compilation_init();
+	if (ret)
+		goto comp_out;
+	ret = xen_sysfs_uuid_init();
+	if (ret)
+		goto uuid_out;
+	ret = xen_properties_init();
+	if (!ret)
+		goto out;
+
+	xen_sysfs_uuid_destroy();
+uuid_out:
+	xen_compilation_destroy();
+comp_out:
+	xen_sysfs_version_destroy();
+version_out:
+	xen_sysfs_type_destroy();
+out:
+	return ret;
+}
+
+void __exit sys_hypervisor_exit(void)
+{
+	xen_properties_destroy();
+	xen_compilation_destroy();
+	xen_sysfs_uuid_destroy();
+	xen_sysfs_version_destroy();
+	xen_sysfs_type_destroy();
+}
diff --git a/drivers/xen/xenctrl/xenctrl.h b/drivers/xen/xenctrl/xenctrl.h
index e585c4b..1afbdfb 100644
--- a/drivers/xen/xenctrl/xenctrl.h
+++ b/drivers/xen/xenctrl/xenctrl.h
@@ -49,3 +49,9 @@ void privcmd_remove_proc_entry(void) __exit;
  */
 int xenbus_create_proc_entry(void) __init;
 void xenbus_remove_proc_entry(void) __exit;
+
+/*
+ * sysfs.c
+ */
+int sys_hypervisor_init(void) __init;
+void sys_hypervisor_exit(void) __exit;
diff --git a/include/xen/interface/version.h b/include/xen/interface/version.h
index 453235e..dd58cf5 100644
--- a/include/xen/interface/version.h
+++ b/include/xen/interface/version.h
@@ -57,4 +57,10 @@ struct xen_feature_info {
 /* Declares the features reported by XENVER_get_features. */
 #include "features.h"
 
+/* arg == NULL; returns host memory page size. */
+#define XENVER_pagesize 7
+
+/* arg == xen_domain_handle_t. */
+#define XENVER_guest_handle 8
+
 #endif /* __XEN_PUBLIC_VERSION_H__ */
-- 
1.5.4.1


linux-2.6-xen-0017-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch:

--- NEW FILE linux-2.6-xen-0017-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch ---
>From 77d15e86acc349ce5e61dce2cfcf256ba4c0ca66 Mon Sep 17 00:00:00 2001
From: Stephen Tweedie <sct at redhat.com>
Date: Wed, 21 Nov 2007 18:40:31 +0000
Subject: [PATCH] xen debug: Add xprintk to log directly via hypercall

For early debugging, it is useful to have a way of doing debugging output
direct to the hypervisor without having to rely on console being fully
initialised.

Signed-off-by: Stephen Tweedie <sct at redhat.com>
---
 arch/x86/xen/enlighten.c  |   32 ++++++++++++++++++++++++++++++++
 include/xen/hvc-console.h |    1 +
 2 files changed, 33 insertions(+), 0 deletions(-)

diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index 75daa55..6e70522 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -33,6 +33,7 @@
 #include <xen/interface/sched.h>
 #include <xen/features.h>
 #include <xen/page.h>
+#include <xen/hvc-console.h>
 
 #include <asm/paravirt.h>
 #include <asm/page.h>
@@ -142,6 +143,37 @@ static void __init xen_banner(void)
 	printk(KERN_INFO "Hypervisor signature: %s\n", xen_start_info->magic);
 }
 
+static void kcons_write_dom0(const char *s, unsigned int count)
+{
+       int rc;
+
+       while ((count > 0) &&
+              ((rc = HYPERVISOR_console_io(
+                       CONSOLEIO_write, count, (char *)s)) > 0)) {
+               count -= rc;
+               s += rc;
+       }
+}
+
+
+/*** Useful function for console debugging -- goes straight to Xen. ***/
+asmlinkage int xprintk(const char *fmt, ...)
+{
+       va_list args;
+       int printk_len;
+       static char printk_buf[1024];
+
+       /* Emit the output into the temporary buffer */
+       va_start(args, fmt);
+       printk_len = vsnprintf(printk_buf, sizeof(printk_buf), fmt, args);
+       va_end(args);
+
+       /* Send the processed output directly to Xen. */
+       kcons_write_dom0(printk_buf, printk_len);
+
+       return 0;
+}
+
 static void xen_cpuid(unsigned int *ax, unsigned int *bx,
 		      unsigned int *cx, unsigned int *dx)
 {
diff --git a/include/xen/hvc-console.h b/include/xen/hvc-console.h
index 21c0ecf..cb7a3c9 100644
--- a/include/xen/hvc-console.h
+++ b/include/xen/hvc-console.h
@@ -2,5 +2,6 @@
 #define XEN_HVC_CONSOLE_H
 
 extern struct console xenboot_console;
+extern asmlinkage int xprintk(const char *fmt, ...);
 
 #endif	/* XEN_HVC_CONSOLE_H */
-- 
1.5.4.1


linux-2.6-xen-0018-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch:

--- NEW FILE linux-2.6-xen-0018-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch ---
>From 461a91a1927aaded2df4dbde682e1aa9f35022ec Mon Sep 17 00:00:00 2001
From: Mark McLoughlin <markmc at redhat.com>
Date: Tue, 4 Mar 2008 17:59:50 +0000
Subject: [PATCH] xen x86_64: Initial x86_64 support for Xen paravirt_ops

Signed-off-by: Eduardo Habkost <ehabkost at redhat.com>
Signed-off-by: Mark McLoughlin <markmc at redhat.com>
---
 arch/x86/Kconfig                     |    3 +-
 arch/x86/kernel/acpi/boot.c          |    4 +-
 arch/x86/kernel/apic_32.c            |    4 +-
 arch/x86/kernel/apic_64.c            |    2 +-
 arch/x86/kernel/asm-offsets_64.c     |   15 +
 arch/x86/kernel/early_printk.c       |    5 +-
 arch/x86/kernel/efi_64.c             |    4 +-
 arch/x86/kernel/entry_32.S           |   83 +-----
 arch/x86/kernel/entry_64.S           |   72 ++++-
 arch/x86/kernel/genapic_64.c         |   12 +
 arch/x86/kernel/head64.c             |    4 +
 arch/x86/kernel/head_64.S            |   23 ++
 arch/x86/kernel/hpet.c               |    4 +-
 arch/x86/kernel/io_apic_64.c         |    2 +-
 arch/x86/kernel/irq_64.c             |    5 +
 arch/x86/kernel/mpparse_32.c         |    4 +-
 arch/x86/kernel/mpparse_64.c         |    4 +-
 arch/x86/kernel/paravirt.c           |    3 +
 arch/x86/kernel/process_64.c         |    9 +
 arch/x86/kernel/setup64.c            |    5 +
 arch/x86/kernel/setup_64.c           |   41 +++-
 arch/x86/kernel/smpboot_64.c         |    4 +-
 arch/x86/kernel/vsyscall_64.c        |   31 ++-
 arch/x86/mach-visws/traps.c          |   10 +-
 arch/x86/mm/init_32.c                |    2 +-
 arch/x86/mm/init_64.c                |  558 ++++++++++++++++++++++++++++++++--
 arch/x86/mm/ioremap.c                |    4 +-
 arch/x86/mm/pgtable_32.c             |   25 ++-
 arch/x86/pci/mmconfig_32.c           |    2 +-
 arch/x86/vdso/vdso32-setup.c         |    6 +-
 arch/x86/xen/Kconfig                 |    1 -
 arch/x86/xen/Makefile                |    6 +
 arch/x86/xen/enlighten.c             |  268 +++++++++++-----
 arch/x86/xen/entry.S                 |    5 +
 arch/x86/xen/entry_32.S              |   81 +++++
 arch/x86/xen/entry_64.S              |   68 ++++
 arch/x86/xen/events.c                |   13 +-
 arch/x86/xen/genapic.c               |  190 ++++++++++++
 arch/x86/xen/init.h                  |   20 ++
 arch/x86/xen/init_32.c               |    3 +
 arch/x86/xen/init_64.c               |  181 +++++++++++
 arch/x86/xen/mmu.c                   |  407 ++++++++++++++++++-------
 arch/x86/xen/mmu.h                   |   46 ++--
 arch/x86/xen/multicalls.c            |    9 +-
 arch/x86/xen/setup.c                 |   22 ++
 arch/x86/xen/smp.c                   |   16 +
 arch/x86/xen/xen-asm.S               |  219 +++-----------
 arch/x86/xen/xen-asm_32.S            |  184 +++++++++++
 arch/x86/xen/xen-asm_64.S            |   75 +++++
 arch/x86/xen/xen-head.S              |   21 +-
 arch/x86/xen/xen-ops.h               |   11 +
 drivers/acpi/thermal.c               |    5 +
 drivers/char/hvc_xen.c               |    6 +
 drivers/ieee1394/init_ohci1394_dma.c |    2 +-
 drivers/serial/8250_early.c          |    2 +-
 include/asm-x86/asm-hack.h           |   27 ++
 include/asm-x86/cmpxchg_64.h         |   36 +++
 include/asm-x86/desc_defs.h          |    4 +
 include/asm-x86/fixmap_32.h          |   22 +-
 include/asm-x86/fixmap_64.h          |   31 ++-
 include/asm-x86/mmu_context_64.h     |    6 +-
 include/asm-x86/page_64.h            |    2 +-
 include/asm-x86/paravirt.h           |   46 ++-
 include/asm-x86/percpu.h             |   32 ++
 include/asm-x86/pgalloc_64.h         |   69 ++++-
 include/asm-x86/pgtable.h            |   15 +-
 include/asm-x86/pgtable_64.h         |    3 +-
 include/asm-x86/proto.h              |    1 +
 include/asm-x86/smp_64.h             |    3 +
 include/asm-x86/system.h             |    3 +-
 include/asm-x86/xen/hypercall.h      |  205 ++++++++++---
 include/asm-x86/xen/hypervisor.h     |    3 -
 include/asm-x86/xen/interface.h      |   35 ++-
 include/linux/dmi.h                  |    1 +
 include/linux/elfnote.h              |    2 +-
 include/xen/events.h                 |    2 +
 include/xen/interface/elfnote.h      |   16 +
 include/xen/page.h                   |   34 ++-
 init/main.c                          |   10 +
 mm/slab.c                            |    8 +-
 80 files changed, 2759 insertions(+), 668 deletions(-)
 create mode 100644 arch/x86/xen/entry.S
 create mode 100644 arch/x86/xen/entry_32.S
 create mode 100644 arch/x86/xen/entry_64.S
 create mode 100644 arch/x86/xen/genapic.c
 create mode 100644 arch/x86/xen/init.h
 create mode 100644 arch/x86/xen/init_32.c
 create mode 100644 arch/x86/xen/init_64.c
 create mode 100644 arch/x86/xen/xen-asm_32.S
 create mode 100644 arch/x86/xen/xen-asm_64.S
 create mode 100644 include/asm-x86/asm-hack.h

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index f41c953..6f466aa 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -92,7 +92,7 @@ config ARCH_MAY_HAVE_PC_FDC
 	def_bool y
 
 config DMI
-	def_bool y
+	def_bool !XEN
 
 config RWSEM_GENERIC_SPINLOCK
 	def_bool !X86_XADD
@@ -330,6 +330,7 @@ config X86_RDC321X
 
 config X86_VSMP
 	bool "Support for ScaleMP vSMP"
+	depends on !XEN
 	depends on X86_64 && PCI
 	 help
 	  Support for ScaleMP vSMP systems.  Say 'Y' here if this kernel is
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 2cdc9de..cfc79ac 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -141,7 +141,7 @@ char *__init __acpi_map_table(unsigned long phys, unsigned long size)
 
 	offset = phys & (PAGE_SIZE - 1);
 	mapped_size = PAGE_SIZE - offset;
-	set_fixmap(FIX_ACPI_END, phys);
+	set_fixmap_ma(FIX_ACPI_END, phys);
 	base = fix_to_virt(FIX_ACPI_END);
 
 	/*
@@ -152,7 +152,7 @@ char *__init __acpi_map_table(unsigned long phys, unsigned long size)
 		if (--idx < FIX_ACPI_BEGIN)
 			return NULL;	/* cannot handle this */
 		phys += PAGE_SIZE;
-		set_fixmap(idx, phys);
+		set_fixmap_ma(idx, phys);
 		mapped_size += PAGE_SIZE;
 	}
 
diff --git a/arch/x86/kernel/apic_32.c b/arch/x86/kernel/apic_32.c
index 35a568e..40fc1b3 100644
--- a/arch/x86/kernel/apic_32.c
+++ b/arch/x86/kernel/apic_32.c
@@ -1138,7 +1138,7 @@ void __init init_apic_mappings(void)
 	} else
 		apic_phys = mp_lapic_addr;
 
-	set_fixmap_nocache(FIX_APIC_BASE, apic_phys);
+	set_fixmap_ma_nocache(FIX_APIC_BASE, apic_phys);
 	printk(KERN_DEBUG "mapped APIC to %08lx (%08lx)\n", APIC_BASE,
 	       apic_phys);
 
@@ -1172,7 +1172,7 @@ fake_ioapic_page:
 					      alloc_bootmem_pages(PAGE_SIZE);
 				ioapic_phys = __pa(ioapic_phys);
 			}
-			set_fixmap_nocache(idx, ioapic_phys);
+			set_fixmap_ma_nocache(idx, ioapic_phys);
 			printk(KERN_DEBUG "mapped IOAPIC to %08lx (%08lx)\n",
 			       __fix_to_virt(idx), ioapic_phys);
 			idx++;
diff --git a/arch/x86/kernel/apic_64.c b/arch/x86/kernel/apic_64.c
index d8d03e0..a611520 100644
--- a/arch/x86/kernel/apic_64.c
+++ b/arch/x86/kernel/apic_64.c
@@ -877,7 +877,7 @@ void __init init_apic_mappings(void)
 	} else
 		apic_phys = mp_lapic_addr;
 
-	set_fixmap_nocache(FIX_APIC_BASE, apic_phys);
+	set_fixmap_ma_nocache(FIX_APIC_BASE, apic_phys);
 	apic_printk(APIC_VERBOSE, "mapped APIC to %16lx (%16lx)\n",
 				APIC_BASE, apic_phys);
 
diff --git a/arch/x86/kernel/asm-offsets_64.c b/arch/x86/kernel/asm-offsets_64.c
index 494e1e0..d0fabfd 100644
--- a/arch/x86/kernel/asm-offsets_64.c
+++ b/arch/x86/kernel/asm-offsets_64.c
@@ -25,6 +25,8 @@
 #define OFFSET(sym, str, mem) \
 	DEFINE(sym, offsetof(struct str, mem))
 
+#include <xen/interface/xen.h>
+
 #define __NO_STUBS 1
 #undef __SYSCALL
 #undef _ASM_X86_64_UNISTD_H_
@@ -92,6 +94,13 @@ int main(void)
 	       offsetof (struct rt_sigframe32, uc.uc_mcontext));
 	BLANK();
 #endif
+
+#ifdef CONFIG_XEN
+	BLANK();
+	OFFSET(XEN_vcpu_info_mask, vcpu_info, evtchn_upcall_mask);
[...5544 lines suppressed...]
-#define ELFNOTE(name, type, desc)		\
+#define ELFNOTE(name, type, desc...)		\
 	ELFNOTE_START(name, type, "")		\
 		desc			;	\
 	ELFNOTE_END
diff --git a/include/xen/events.h b/include/xen/events.h
index 2bde54d..c18d2bf 100644
--- a/include/xen/events.h
+++ b/include/xen/events.h
@@ -3,6 +3,8 @@
 
 #include <linux/interrupt.h>
 
+#include <asm/xen/interface.h>
+#include <xen/interface/xen.h>
 #include <xen/interface/event_channel.h>
 #include <asm/xen/hypercall.h>
 
diff --git a/include/xen/interface/elfnote.h b/include/xen/interface/elfnote.h
index a64d3df..ee5501d 100644
--- a/include/xen/interface/elfnote.h
+++ b/include/xen/interface/elfnote.h
@@ -120,6 +120,22 @@
  */
 #define XEN_ELFNOTE_BSD_SYMTAB    11
 
+/*
+ * The lowest address the hypervisor hole can begin at (numeric).
+ *
+ * This must not be set higher than HYPERVISOR_VIRT_START. Its presence
+ * also indicates to the hypervisor that the kernel can deal with the
+ * hole starting at a higher address.
+ */
+#define XEN_ELFNOTE_HV_START_LOW  12
+
+/*
+ * List of maddr_t-sized mask/value pairs describing how to recognize
+ * (non-present) L1 page table entries carrying valid MFNs (numeric).
+ */
+#define XEN_ELFNOTE_L1_MFN_VALID  13
+
+
 #endif /* __XEN_PUBLIC_ELFNOTE_H__ */
 
 /*
diff --git a/include/xen/page.h b/include/xen/page.h
index 031ef22..158fb60 100644
--- a/include/xen/page.h
+++ b/include/xen/page.h
@@ -8,6 +8,10 @@
 
 #include <xen/features.h>
 
+#include <asm/xen/interface.h>
+
+#include <xen/hvc-console.h>
+
 #ifdef CONFIG_X86_PAE
 /* Xen machine address */
 typedef struct xmaddr {
@@ -70,6 +74,8 @@ static inline unsigned long mfn_to_pfn(unsigned long mfn)
 #endif
 
 	pfn = 0;
+	//xprintk("mfn_to_pfn(%lx):\n", mfn);
+
 	/*
 	 * The array access can fail (e.g., device space beyond end of RAM).
 	 * In such cases it doesn't matter what we return (we return garbage),
@@ -77,6 +83,7 @@ static inline unsigned long mfn_to_pfn(unsigned long mfn)
 	 */
 	__get_user(pfn, &machine_to_phys_mapping[mfn]);
 
+	//xprintk("mfn_to_pfn(%lx) = %lx\n", mfn, pfn);
 	return pfn;
 }
 
@@ -143,34 +150,29 @@ static inline void set_phys_to_machine(unsigned long pfn, unsigned long mfn)
 
 static inline pte_t mfn_pte(unsigned long page_nr, pgprot_t pgprot)
 {
-	pte_t pte;
-
-	pte.pte_high = (page_nr >> (32 - PAGE_SHIFT)) |
-		(pgprot_val(pgprot) >> 32);
-	pte.pte_high &= (__supported_pte_mask >> 32);
-	pte.pte_low = ((page_nr << PAGE_SHIFT) | pgprot_val(pgprot));
-	pte.pte_low &= __supported_pte_mask;
-
-	return pte;
+	pteval_t val;
+	
+	val = (page_nr << PAGE_SHIFT) | pgprot_val(pgprot);
+	val &= __supported_pte_mask;
+	return native_make_pte(val);
 }
 
-static inline unsigned long long pte_val_ma(pte_t x)
+static inline pteval_t pte_val_ma(pte_t x)
 {
-	return x.pte;
+	return native_pte_val(x);
 }
-#define pmd_val_ma(v) ((v).pmd)
-#define pud_val_ma(v) ((v).pgd.pgd)
-#define __pte_ma(x)	((pte_t) { .pte = (x) })
+#define __pte_ma(x)	(native_make_pte(x))
 #define __pmd_ma(x)	((pmd_t) { (x) } )
 #else  /* !X86_PAE */
-#define pte_mfn(_pte) ((_pte).pte_low >> PAGE_SHIFT)
+#define pte_mfn(_pte) ((native_pte_val(_pte) & __PHYSICAL_MASK) >> PAGE_SHIFT)
 #define mfn_pte(pfn, prot)	__pte_ma(((pfn) << PAGE_SHIFT) | pgprot_val(prot))
 #define pte_val_ma(x)	((x).pte)
-#define pmd_val_ma(v)	((v).pud.pgd.pgd)
 #define __pte_ma(x)	((pte_t) { (x) } )
 #endif	/* CONFIG_X86_PAE */
 
 #define pgd_val_ma(x)	((x).pgd)
+#define pmd_val_ma(x)	(native_pmd_val((x)))
+#define pud_val_ma(x)	(native_pud_val((x)))
 
 
 xmaddr_t arbitrary_virt_to_machine(unsigned long address);
diff --git a/init/main.c b/init/main.c
index 80f5aaf..4a84f60 100644
--- a/init/main.c
+++ b/init/main.c
@@ -590,17 +590,25 @@ asmlinkage void __init start_kernel(void)
 	rcu_init();
 	init_IRQ();
 	pidhash_init();
+	printk("init_timers:\n");
 	init_timers();
 	hrtimers_init();
 	softirq_init();
+	printk("timekeeping:\n");
 	timekeeping_init();
+	printk("time:\n");
 	time_init();
+	printk("profile:\n");
 	profile_init();
+	printk("irqs_disabled:\n");
 	if (!irqs_disabled())
 		printk("start_kernel(): bug: interrupts were enabled early\n");
+	printk("early_boot_irqs_on:\n");
 	early_boot_irqs_on();
+	printk("local_irq_enable:\n");
 	local_irq_enable();
 
+	printk("console_init:\n");
 	/*
 	 * HACK ALERT! This is early. We're enabling the console before
 	 * we've done PCI setups etc, and console_init() must be aware of
@@ -637,7 +645,9 @@ asmlinkage void __init start_kernel(void)
 	numa_policy_init();
 	if (late_time_init)
 		late_time_init();
+	printk("calibrate_delay:\n");
 	calibrate_delay();
+	printk("pidmap_init:\n");
 	pidmap_init();
 	pgtable_cache_init();
 	prio_tree_init();
diff --git a/mm/slab.c b/mm/slab.c
index e499669..c18daa3 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -3202,6 +3202,8 @@ static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
 		STATS_INC_ALLOCHIT(cachep);
 		ac->touched = 1;
 		objp = ac->entry[--ac->avail];
+		if (!objp)
+			printk("really weird: avail objp for cache %s is null\n", cachep->name);
 	} else {
 		STATS_INC_ALLOCMISS(cachep);
 		objp = cache_alloc_refill(cachep, flags);
@@ -3464,8 +3466,10 @@ __cache_alloc(struct kmem_cache *cachep, gfp_t flags, void *caller)
 	unsigned long save_flags;
 	void *objp;
 
-	if (should_failslab(cachep, flags))
+	if (should_failslab(cachep, flags)) {
+		printk("cache %s should fail\n", cachep->name);
 		return NULL;
+	}
 
 	cache_alloc_debugcheck_before(cachep, flags);
 	local_irq_save(save_flags);
@@ -3477,6 +3481,8 @@ __cache_alloc(struct kmem_cache *cachep, gfp_t flags, void *caller)
 	if (unlikely((flags & __GFP_ZERO) && objp))
 		memset(objp, 0, obj_size(cachep));
 
+	if (!objp)
+		printk("allocation from cache %s failed!!!\n", cachep->name);
 	return objp;
 }
 
-- 
1.5.4.1







Index: kernel.spec
===================================================================
RCS file: /cvs/pkgs/rpms/kernel-xen-2.6/devel/kernel.spec,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -r1.18 -r1.19
--- kernel.spec	20 Mar 2008 09:56:37 -0000	1.18
+++ kernel.spec	25 Mar 2008 10:49:00 -0000	1.19
@@ -670,23 +670,24 @@
 Patch2502: linux-2.6-blkcipher-depend-on-chainiv.patch
 
 # kernel-xen patches start
-Patch5000: linux-2.6-xen-0001-Revert-linux-2.6-execshield.patch.patch
-Patch5001: linux-2.6-xen-0002-squashfs-Fix-build-without-CONFIG_SMP.patch
-Patch5002: linux-2.6-xen-0003-xen-Make-hvc0-the-preferred-console-in-domU.patch
-Patch5003: linux-2.6-xen-0004-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
-Patch5004: linux-2.6-xen-0005-fbdev-Make-deferred-I-O-work-as-advertized.patch
-Patch5005: linux-2.6-xen-0006-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
-Patch5006: linux-2.6-xen-0007-xen-Module-autoprobing-support-for-frontend-drivers.patch
-Patch5007: linux-2.6-xen-0008-xen-Add-compatibility-aliases-for-frontend-drivers.patch
-Patch5008: linux-2.6-xen-0009-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch
-Patch5009: linux-2.6-xen-0010-xen-Add-a-vmlinuz-target.patch
-Patch5010: linux-2.6-xen-0011-xen-Add-empty-xenctrl-module.patch
-Patch5011: linux-2.6-xen-0012-xen-Add-proc-xen-capabilities.patch
-Patch5012: linux-2.6-xen-0013-xen-Add-proc-xen-privcmd.patch
-Patch5013: linux-2.6-xen-0014-xen-Add-proc-xen-xenbus.patch
-Patch5014: linux-2.6-xen-0015-xen-Add-Xen-s-sys-hypervisor-interface.patch
-Patch5015: linux-2.6-xen-0016-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch
-Patch5016: linux-2.6-xen-0017-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch
+Patch5000: linux-2.6-xen-0001-squashfs-Fix-build-without-CONFIG_SMP.patch
+Patch5001: linux-2.6-xen-0002-xen-execshield-Add-xen-specific-load_user_cs_desc.patch
+Patch5002: linux-2.6-xen-0003-xen-execshield-fix-endless-GPF-fault-loop.patch
+Patch5003: linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch
+Patch5004: linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
+Patch5005: linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch
+Patch5006: linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
+Patch5007: linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch
+Patch5008: linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch
+Patch5009: linux-2.6-xen-0010-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch
+Patch5010: linux-2.6-xen-0011-xen-Add-a-vmlinuz-target.patch
+Patch5011: linux-2.6-xen-0012-xen-Add-empty-xenctrl-module.patch
+Patch5012: linux-2.6-xen-0013-xen-Add-proc-xen-capabilities.patch
+Patch5013: linux-2.6-xen-0014-xen-Add-proc-xen-privcmd.patch
+Patch5014: linux-2.6-xen-0015-xen-Add-proc-xen-xenbus.patch
+Patch5015: linux-2.6-xen-0016-xen-Add-Xen-s-sys-hypervisor-interface.patch
+Patch5016: linux-2.6-xen-0017-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch
+Patch5017: linux-2.6-xen-0018-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch
 # kernel-xen patches end
 
 # Xen hypervisor patches (20000+)
@@ -1233,24 +1234,25 @@
 # ---------- below all scheduled for 2.6.24 -----------------
 
 # kernel-xen apply start
-ApplyPatch linux-2.6-xen-0001-Revert-linux-2.6-execshield.patch.patch
-ApplyPatch linux-2.6-xen-0002-squashfs-Fix-build-without-CONFIG_SMP.patch
-ApplyPatch linux-2.6-xen-0003-xen-Make-hvc0-the-preferred-console-in-domU.patch
-ApplyPatch linux-2.6-xen-0004-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
-ApplyPatch linux-2.6-xen-0005-fbdev-Make-deferred-I-O-work-as-advertized.patch
-ApplyPatch linux-2.6-xen-0006-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
-ApplyPatch linux-2.6-xen-0007-xen-Module-autoprobing-support-for-frontend-drivers.patch
-ApplyPatch linux-2.6-xen-0008-xen-Add-compatibility-aliases-for-frontend-drivers.patch
-ApplyPatch linux-2.6-xen-0009-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch
-ApplyPatch linux-2.6-xen-0010-xen-Add-a-vmlinuz-target.patch
-ApplyPatch linux-2.6-xen-0011-xen-Add-empty-xenctrl-module.patch
-ApplyPatch linux-2.6-xen-0012-xen-Add-proc-xen-capabilities.patch
-ApplyPatch linux-2.6-xen-0013-xen-Add-proc-xen-privcmd.patch
-ApplyPatch linux-2.6-xen-0014-xen-Add-proc-xen-xenbus.patch
-ApplyPatch linux-2.6-xen-0015-xen-Add-Xen-s-sys-hypervisor-interface.patch
-ApplyPatch linux-2.6-xen-0016-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch
+ApplyPatch linux-2.6-xen-0001-squashfs-Fix-build-without-CONFIG_SMP.patch
+ApplyPatch linux-2.6-xen-0002-xen-execshield-Add-xen-specific-load_user_cs_desc.patch
+ApplyPatch linux-2.6-xen-0003-xen-execshield-fix-endless-GPF-fault-loop.patch
+ApplyPatch linux-2.6-xen-0004-xen-Make-hvc0-the-preferred-console-in-domU.patch
+ApplyPatch linux-2.6-xen-0005-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch
+ApplyPatch linux-2.6-xen-0006-fbdev-Make-deferred-I-O-work-as-advertized.patch
+ApplyPatch linux-2.6-xen-0007-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch
+ApplyPatch linux-2.6-xen-0008-xen-Module-autoprobing-support-for-frontend-drivers.patch
+ApplyPatch linux-2.6-xen-0009-xen-Add-compatibility-aliases-for-frontend-drivers.patch
+ApplyPatch linux-2.6-xen-0010-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch
+ApplyPatch linux-2.6-xen-0011-xen-Add-a-vmlinuz-target.patch
+ApplyPatch linux-2.6-xen-0012-xen-Add-empty-xenctrl-module.patch
+ApplyPatch linux-2.6-xen-0013-xen-Add-proc-xen-capabilities.patch
+ApplyPatch linux-2.6-xen-0014-xen-Add-proc-xen-privcmd.patch
+ApplyPatch linux-2.6-xen-0015-xen-Add-proc-xen-xenbus.patch
+ApplyPatch linux-2.6-xen-0016-xen-Add-Xen-s-sys-hypervisor-interface.patch
+ApplyPatch linux-2.6-xen-0017-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch
 %ifarch x86_64
-ApplyPatch linux-2.6-xen-0017-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch
+ApplyPatch linux-2.6-xen-0018-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch
 %endif
 # kernel-xen apply end
 
@@ -1852,6 +1854,9 @@
 %kernel_variant_files -a /%{image_install_path}/xen*-%{KVERREL}xen -e /etc/ld.so.conf.d/kernelcap-%{KVERREL}xen.conf %{with_xen} xen
 
 %changelog
+* Tue Mar 25 2008 Mark McLoughlin <markmc at redhat.com>
+- Re-enable execshield (bug #434759)
+
 * Thu Mar 20 2008 Mark McLoughlin <markmc at redhat.com>
 - Make xen-blkfront module load wait until backend is
   connected; fixes intermittent boot failure (bug #436493)


--- linux-2.6-xen-0001-Revert-linux-2.6-execshield.patch.patch DELETED ---


--- linux-2.6-xen-0002-squashfs-Fix-build-without-CONFIG_SMP.patch DELETED ---


--- linux-2.6-xen-0003-xen-Make-hvc0-the-preferred-console-in-domU.patch DELETED ---


--- linux-2.6-xen-0004-xen-Make-xen-blkfront-write-its-protocol-ABI-to-xen.patch DELETED ---


--- linux-2.6-xen-0005-fbdev-Make-deferred-I-O-work-as-advertized.patch DELETED ---


--- linux-2.6-xen-0006-xen-pvfb-Para-virtual-framebuffer-keyboard-and-poi.patch DELETED ---


--- linux-2.6-xen-0007-xen-Module-autoprobing-support-for-frontend-drivers.patch DELETED ---


--- linux-2.6-xen-0008-xen-Add-compatibility-aliases-for-frontend-drivers.patch DELETED ---


--- linux-2.6-xen-0009-xen-blkfront-Delay-wait-for-block-devices-until-aft.patch DELETED ---


--- linux-2.6-xen-0010-xen-Add-a-vmlinuz-target.patch DELETED ---


--- linux-2.6-xen-0011-xen-Add-empty-xenctrl-module.patch DELETED ---


--- linux-2.6-xen-0012-xen-Add-proc-xen-capabilities.patch DELETED ---


--- linux-2.6-xen-0013-xen-Add-proc-xen-privcmd.patch DELETED ---


--- linux-2.6-xen-0014-xen-Add-proc-xen-xenbus.patch DELETED ---


--- linux-2.6-xen-0015-xen-Add-Xen-s-sys-hypervisor-interface.patch DELETED ---


--- linux-2.6-xen-0016-xen-debug-Add-xprintk-to-log-directly-via-hypercall.patch DELETED ---


--- linux-2.6-xen-0017-xen-x86_64-Initial-x86_64-support-for-Xen-paravirt_.patch DELETED ---


