1.1 --- a/Config.mk	Mon Mar 05 12:49:12 2007 -0600
     1.2 +++ b/Config.mk	Thu Mar 08 14:39:52 2007 -0600
     1.3 @@ -73,9 +73,10 @@ ACM_SECURITY ?= n
     1.4  ACM_DEFAULT_SECURITY_POLICY ?= ACM_NULL_POLICY
     1.5  
     1.6  # Optional components
     1.7 -XENSTAT_XENTOP ?= y
     1.8 -VTPM_TOOLS ?= n
     1.9 +XENSTAT_XENTOP     ?= y
    1.10 +VTPM_TOOLS         ?= n
    1.11  LIBXENAPI_BINDINGS ?= n
    1.12 -XENFB_TOOLS ?= n
    1.13 +XENFB_TOOLS        ?= n
    1.14 +PYTHON_TOOLS       ?= y
    1.15  
    1.16  -include $(XEN_ROOT)/.config

     2.1 --- a/config/StdGNU.mk	Mon Mar 05 12:49:12 2007 -0600
     2.2 +++ b/config/StdGNU.mk	Thu Mar 08 14:39:52 2007 -0600
     2.3 @@ -12,9 +12,9 @@ OBJDUMP    = $(CROSS_COMPILE)objdump
     2.4  MSGFMT     = msgfmt
     2.5  
     2.6  INSTALL      = install
     2.7 -INSTALL_DIR  = $(INSTALL) -d -m0755
     2.8 -INSTALL_DATA = $(INSTALL) -m0644
     2.9 -INSTALL_PROG = $(INSTALL) -m0755
    2.10 +INSTALL_DIR  = $(INSTALL) -d -m0755 -p
    2.11 +INSTALL_DATA = $(INSTALL) -m0644 -p
    2.12 +INSTALL_PROG = $(INSTALL) -m0755 -p
    2.13  
    2.14  LIB64DIR = lib64
    2.15  

     3.1 --- a/config/SunOS.mk	Mon Mar 05 12:49:12 2007 -0600
     3.2 +++ b/config/SunOS.mk	Thu Mar 08 14:39:52 2007 -0600
     3.3 @@ -14,9 +14,9 @@ MSGFMT     = gmsgfmt
     3.4  SHELL      = bash
     3.5  
     3.6  INSTALL      = ginstall
     3.7 -INSTALL_DIR  = $(INSTALL) -d -m0755
     3.8 -INSTALL_DATA = $(INSTALL) -m0644
     3.9 -INSTALL_PROG = $(INSTALL) -m0755
    3.10 +INSTALL_DIR  = $(INSTALL) -d -m0755 -p
    3.11 +INSTALL_DATA = $(INSTALL) -m0644 -p
    3.12 +INSTALL_PROG = $(INSTALL) -m0755 -p
    3.13  
    3.14  LIB64DIR = lib/amd64
    3.15  

     4.1 --- a/docs/misc/dump-core-format.txt	Mon Mar 05 12:49:12 2007 -0600
     4.2 +++ b/docs/misc/dump-core-format.txt	Thu Mar 08 14:39:52 2007 -0600
     4.3 @@ -26,11 +26,12 @@ For xen related structure, please see th
     4.4  Elf header
     4.5  ----------
     4.6  The elf header members are set as follows
     4.7 +        e_ident[EI_CLASS] = ELFCLASS64 = 2
     4.8          e_ident[EI_OSABI] = ELFOSABI_SYSV = 0
     4.9          e_type = ET_CORE = 4
    4.10 -e_ident[EI_CLASS], e_ident[EI_DATA] and e_flags are set according
    4.11 -to an architecture which a file is created. Other members are set as usual.
    4.12 -
    4.13 +ELFCLASS64 is always used independent of architecture.
    4.14 +e_ident[EI_DATA] and e_flags are set according to the dumping system's
    4.15 +architecture. Other members are set as usual.
    4.16  
    4.17  Sections
    4.18  --------
    4.19 @@ -221,5 +222,10 @@ format_version descriptor
    4.20  
    4.21  Format version history
    4.22  ----------------------
    4.23 -The currently only (major, minor) = (0, 1) is used.
    4.24 +Currently only (major, minor) = (0, 1) is used.
    4.25  [When the format is changed, it would be described here.]
    4.26 +
    4.27 +(0, 1) update
    4.28 +- EI_CLASS member of elf header was changed to ELFCLASS64 independent of
    4.29 +  architecture. This is mainly for x86_32pae.
    4.30 +  The format version isn't bumped because analysis tools can distinguish it.

     5.1 --- a/linux-2.6-xen-sparse/arch/i386/Kconfig	Mon Mar 05 12:49:12 2007 -0600
     5.2 +++ b/linux-2.6-xen-sparse/arch/i386/Kconfig	Thu Mar 08 14:39:52 2007 -0600
     5.3 @@ -255,7 +255,6 @@ config NR_CPUS
     5.4  config SCHED_SMT
     5.5  	bool "SMT (Hyperthreading) scheduler support"
     5.6  	depends on X86_HT
     5.7 -	depends on !X86_XEN
     5.8  	help
     5.9  	  SMT scheduler support improves the CPU scheduler's decision making
    5.10  	  when dealing with Intel Pentium 4 chips with HyperThreading at a
    5.11 @@ -313,11 +312,6 @@ config X86_VISWS_APIC
    5.12  	depends on X86_VISWS
    5.13  	default y
    5.14  
    5.15 -config X86_TSC
    5.16 -	bool
    5.17 -	depends on (MWINCHIP3D || MWINCHIP2 || MCRUSOE || MEFFICEON || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMM || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2 || MGEODEGX1) && !X86_NUMAQ && !X86_XEN
    5.18 -	default y
    5.19 -
    5.20  config X86_MCE
    5.21  	bool "Machine Check Exception"
    5.22  	depends on !(X86_VOYAGER || X86_XEN)

     6.1 --- a/linux-2.6-xen-sparse/arch/i386/Kconfig.cpu	Mon Mar 05 12:49:12 2007 -0600
     6.2 +++ b/linux-2.6-xen-sparse/arch/i386/Kconfig.cpu	Thu Mar 08 14:39:52 2007 -0600
     6.3 @@ -311,5 +311,5 @@ config X86_OOSTORE
     6.4  
     6.5  config X86_TSC
     6.6  	bool
     6.7 -	depends on (MWINCHIP3D || MWINCHIP2 || MCRUSOE || MEFFICEON || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMM || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2 || MGEODEGX1 || MGEODE_LX) && !X86_NUMAQ
     6.8 +	depends on (MWINCHIP3D || MWINCHIP2 || MCRUSOE || MEFFICEON || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMM || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2 || MGEODEGX1 || MGEODE_LX) && !X86_NUMAQ && !X86_XEN
     6.9  	default y

     7.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/alternative-xen.c	Mon Mar 05 12:49:12 2007 -0600
     7.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.3 @@ -1,389 +0,0 @@
     7.4 -#include <linux/module.h>
     7.5 -#include <linux/spinlock.h>
     7.6 -#include <linux/list.h>
     7.7 -#include <asm/alternative.h>
     7.8 -#include <asm/sections.h>
     7.9 -
    7.10 -static int no_replacement    = 0;
    7.11 -static int smp_alt_once      = 0;
    7.12 -static int debug_alternative = 0;
    7.13 -
    7.14 -static int __init noreplacement_setup(char *s)
    7.15 -{
    7.16 -	no_replacement = 1;
    7.17 -	return 1;
    7.18 -}
    7.19 -static int __init bootonly(char *str)
    7.20 -{
    7.21 -	smp_alt_once = 1;
    7.22 -	return 1;
    7.23 -}
    7.24 -static int __init debug_alt(char *str)
    7.25 -{
    7.26 -	debug_alternative = 1;
    7.27 -	return 1;
    7.28 -}
    7.29 -
    7.30 -__setup("noreplacement", noreplacement_setup);
    7.31 -__setup("smp-alt-boot", bootonly);
    7.32 -__setup("debug-alternative", debug_alt);
    7.33 -
    7.34 -#define DPRINTK(fmt, args...) if (debug_alternative) \
    7.35 -	printk(KERN_DEBUG fmt, args)
    7.36 -
    7.37 -#ifdef GENERIC_NOP1
    7.38 -/* Use inline assembly to define this because the nops are defined
    7.39 -   as inline assembly strings in the include files and we cannot
    7.40 -   get them easily into strings. */
    7.41 -asm("\t.data\nintelnops: "
    7.42 -	GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
    7.43 -	GENERIC_NOP7 GENERIC_NOP8);
    7.44 -extern unsigned char intelnops[];
    7.45 -static unsigned char *intel_nops[ASM_NOP_MAX+1] = {
    7.46 -	NULL,
    7.47 -	intelnops,
    7.48 -	intelnops + 1,
    7.49 -	intelnops + 1 + 2,
    7.50 -	intelnops + 1 + 2 + 3,
    7.51 -	intelnops + 1 + 2 + 3 + 4,
    7.52 -	intelnops + 1 + 2 + 3 + 4 + 5,
    7.53 -	intelnops + 1 + 2 + 3 + 4 + 5 + 6,
    7.54 -	intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
    7.55 -};
    7.56 -#endif
    7.57 -
    7.58 -#ifdef K8_NOP1
    7.59 -asm("\t.data\nk8nops: "
    7.60 -	K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
    7.61 -	K8_NOP7 K8_NOP8);
    7.62 -extern unsigned char k8nops[];
    7.63 -static unsigned char *k8_nops[ASM_NOP_MAX+1] = {
    7.64 -	NULL,
    7.65 -	k8nops,
    7.66 -	k8nops + 1,
    7.67 -	k8nops + 1 + 2,
    7.68 -	k8nops + 1 + 2 + 3,
    7.69 -	k8nops + 1 + 2 + 3 + 4,
    7.70 -	k8nops + 1 + 2 + 3 + 4 + 5,
    7.71 -	k8nops + 1 + 2 + 3 + 4 + 5 + 6,
    7.72 -	k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
    7.73 -};
    7.74 -#endif
    7.75 -
    7.76 -#ifdef K7_NOP1
    7.77 -asm("\t.data\nk7nops: "
    7.78 -	K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
    7.79 -	K7_NOP7 K7_NOP8);
    7.80 -extern unsigned char k7nops[];
    7.81 -static unsigned char *k7_nops[ASM_NOP_MAX+1] = {
    7.82 -	NULL,
    7.83 -	k7nops,
    7.84 -	k7nops + 1,
    7.85 -	k7nops + 1 + 2,
    7.86 -	k7nops + 1 + 2 + 3,
    7.87 -	k7nops + 1 + 2 + 3 + 4,
    7.88 -	k7nops + 1 + 2 + 3 + 4 + 5,
    7.89 -	k7nops + 1 + 2 + 3 + 4 + 5 + 6,
    7.90 -	k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
    7.91 -};
    7.92 -#endif
    7.93 -
    7.94 -#ifdef CONFIG_X86_64
    7.95 -
    7.96 -extern char __vsyscall_0;
    7.97 -static inline unsigned char** find_nop_table(void)
    7.98 -{
    7.99 -	return k8_nops;
   7.100 -}
   7.101 -
   7.102 -#else /* CONFIG_X86_64 */
   7.103 -
   7.104 -static struct nop {
   7.105 -	int cpuid;
   7.106 -	unsigned char **noptable;
   7.107 -} noptypes[] = {
   7.108 -	{ X86_FEATURE_K8, k8_nops },
   7.109 -	{ X86_FEATURE_K7, k7_nops },
   7.110 -	{ -1, NULL }
   7.111 -};
   7.112 -
   7.113 -static unsigned char** find_nop_table(void)
   7.114 -{
   7.115 -	unsigned char **noptable = intel_nops;
   7.116 -	int i;
   7.117 -
   7.118 -	for (i = 0; noptypes[i].cpuid >= 0; i++) {
   7.119 -		if (boot_cpu_has(noptypes[i].cpuid)) {
   7.120 -			noptable = noptypes[i].noptable;
   7.121 -			break;
   7.122 -		}
   7.123 -	}
   7.124 -	return noptable;
   7.125 -}
   7.126 -
   7.127 -#endif /* CONFIG_X86_64 */
   7.128 -
   7.129 -extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
   7.130 -extern struct alt_instr __smp_alt_instructions[], __smp_alt_instructions_end[];
   7.131 -extern u8 *__smp_locks[], *__smp_locks_end[];
   7.132 -
   7.133 -extern u8 __smp_alt_begin[], __smp_alt_end[];
   7.134 -
   7.135 -/* Replace instructions with better alternatives for this CPU type.
   7.136 -   This runs before SMP is initialized to avoid SMP problems with
   7.137 -   self modifying code. This implies that assymetric systems where
   7.138 -   APs have less capabilities than the boot processor are not handled.
   7.139 -   Tough. Make sure you disable such features by hand. */
   7.140 -
   7.141 -void apply_alternatives(struct alt_instr *start, struct alt_instr *end)
   7.142 -{
   7.143 -	unsigned char **noptable = find_nop_table();
   7.144 -	struct alt_instr *a;
   7.145 -	u8 *instr;
   7.146 -	int diff, i, k;
   7.147 -
   7.148 -	DPRINTK("%s: alt table %p -> %p\n", __FUNCTION__, start, end);
   7.149 -	for (a = start; a < end; a++) {
   7.150 -		BUG_ON(a->replacementlen > a->instrlen);
   7.151 -		if (!boot_cpu_has(a->cpuid))
   7.152 -			continue;
   7.153 -		instr = a->instr;
   7.154 -#ifdef CONFIG_X86_64
   7.155 -		/* vsyscall code is not mapped yet. resolve it manually. */
   7.156 -		if (instr >= (u8 *)VSYSCALL_START && instr < (u8*)VSYSCALL_END) {
   7.157 -			instr -= VSYSCALL_START - (unsigned long)&__vsyscall_0;
   7.158 -			DPRINTK("%s: vsyscall fixup: %p => %p\n",
   7.159 -				__FUNCTION__, a->instr, instr);
   7.160 -		}
   7.161 -#endif
   7.162 -		memcpy(instr, a->replacement, a->replacementlen);
   7.163 -		diff = a->instrlen - a->replacementlen;
   7.164 -		/* Pad the rest with nops */
   7.165 -		for (i = a->replacementlen; diff > 0; diff -= k, i += k) {
   7.166 -			k = diff;
   7.167 -			if (k > ASM_NOP_MAX)
   7.168 -				k = ASM_NOP_MAX;
   7.169 -			memcpy(a->instr + i, noptable[k], k);
   7.170 -		}
   7.171 -	}
   7.172 -}
   7.173 -
   7.174 -#ifdef CONFIG_SMP
   7.175 -
   7.176 -static void alternatives_smp_save(struct alt_instr *start, struct alt_instr *end)
   7.177 -{
   7.178 -	struct alt_instr *a;
   7.179 -
   7.180 -	DPRINTK("%s: alt table %p-%p\n", __FUNCTION__, start, end);
   7.181 -	for (a = start; a < end; a++) {
   7.182 -		memcpy(a->replacement + a->replacementlen,
   7.183 -		       a->instr,
   7.184 -		       a->instrlen);
   7.185 -	}
   7.186 -}
   7.187 -
   7.188 -static void alternatives_smp_apply(struct alt_instr *start, struct alt_instr *end)
   7.189 -{
   7.190 -	struct alt_instr *a;
   7.191 -
   7.192 -	for (a = start; a < end; a++) {
   7.193 -		memcpy(a->instr,
   7.194 -		       a->replacement + a->replacementlen,
   7.195 -		       a->instrlen);
   7.196 -	}
   7.197 -}
   7.198 -
   7.199 -static void alternatives_smp_lock(u8 **start, u8 **end, u8 *text, u8 *text_end)
   7.200 -{
   7.201 -	u8 **ptr;
   7.202 -
   7.203 -	for (ptr = start; ptr < end; ptr++) {
   7.204 -		if (*ptr < text)
   7.205 -			continue;
   7.206 -		if (*ptr > text_end)
   7.207 -			continue;
   7.208 -		**ptr = 0xf0; /* lock prefix */
   7.209 -	};
   7.210 -}
   7.211 -
   7.212 -static void alternatives_smp_unlock(u8 **start, u8 **end, u8 *text, u8 *text_end)
   7.213 -{
   7.214 -	unsigned char **noptable = find_nop_table();
   7.215 -	u8 **ptr;
   7.216 -
   7.217 -	for (ptr = start; ptr < end; ptr++) {
   7.218 -		if (*ptr < text)
   7.219 -			continue;
   7.220 -		if (*ptr > text_end)
   7.221 -			continue;
   7.222 -		**ptr = noptable[1][0];
   7.223 -	};
   7.224 -}
   7.225 -
   7.226 -struct smp_alt_module {
   7.227 -	/* what is this ??? */
   7.228 -	struct module	*mod;
   7.229 -	char		*name;
   7.230 -
   7.231 -	/* ptrs to lock prefixes */
   7.232 -	u8		**locks;
   7.233 -	u8		**locks_end;
   7.234 -
   7.235 -	/* .text segment, needed to avoid patching init code ;) */
   7.236 -	u8		*text;
   7.237 -	u8		*text_end;
   7.238 -
   7.239 -	struct list_head next;
   7.240 -};
   7.241 -static LIST_HEAD(smp_alt_modules);
   7.242 -static DEFINE_SPINLOCK(smp_alt);
   7.243 -
   7.244 -void alternatives_smp_module_add(struct module *mod, char *name,
   7.245 -				 void *locks, void *locks_end,
   7.246 -				 void *text,  void *text_end)
   7.247 -{
   7.248 -	struct smp_alt_module *smp;
   7.249 -	unsigned long flags;
   7.250 -
   7.251 -	if (no_replacement)
   7.252 -		return;
   7.253 -
   7.254 -	if (smp_alt_once) {
   7.255 -		if (boot_cpu_has(X86_FEATURE_UP))
   7.256 -			alternatives_smp_unlock(locks, locks_end,
   7.257 -						text, text_end);
   7.258 -		return;
   7.259 -	}
   7.260 -
   7.261 -	smp = kzalloc(sizeof(*smp), GFP_KERNEL);
   7.262 -	if (NULL == smp)
   7.263 -		return; /* we'll run the (safe but slow) SMP code then ... */
   7.264 -
   7.265 -	smp->mod	= mod;
   7.266 -	smp->name	= name;
   7.267 -	smp->locks	= locks;
   7.268 -	smp->locks_end	= locks_end;
   7.269 -	smp->text	= text;
   7.270 -	smp->text_end	= text_end;
   7.271 -	DPRINTK("%s: locks %p -> %p, text %p -> %p, name %s\n",
   7.272 -		__FUNCTION__, smp->locks, smp->locks_end,
   7.273 -		smp->text, smp->text_end, smp->name);
   7.274 -
   7.275 -	spin_lock_irqsave(&smp_alt, flags);
   7.276 -	list_add_tail(&smp->next, &smp_alt_modules);
   7.277 -	if (boot_cpu_has(X86_FEATURE_UP))
   7.278 -		alternatives_smp_unlock(smp->locks, smp->locks_end,
   7.279 -					smp->text, smp->text_end);
   7.280 -	spin_unlock_irqrestore(&smp_alt, flags);
   7.281 -}
   7.282 -
   7.283 -void alternatives_smp_module_del(struct module *mod)
   7.284 -{
   7.285 -	struct smp_alt_module *item;
   7.286 -	unsigned long flags;
   7.287 -
   7.288 -	if (no_replacement || smp_alt_once)
   7.289 -		return;
   7.290 -
   7.291 -	spin_lock_irqsave(&smp_alt, flags);
   7.292 -	list_for_each_entry(item, &smp_alt_modules, next) {
   7.293 -		if (mod != item->mod)
   7.294 -			continue;
   7.295 -		list_del(&item->next);
   7.296 -		spin_unlock_irqrestore(&smp_alt, flags);
   7.297 -		DPRINTK("%s: %s\n", __FUNCTION__, item->name);
   7.298 -		kfree(item);
   7.299 -		return;
   7.300 -	}
   7.301 -	spin_unlock_irqrestore(&smp_alt, flags);
   7.302 -}
   7.303 -
   7.304 -void alternatives_smp_switch(int smp)
   7.305 -{
   7.306 -	struct smp_alt_module *mod;
   7.307 -	unsigned long flags;
   7.308 -
   7.309 -#ifdef CONFIG_LOCKDEP
   7.310 -	/*
   7.311 -	 * A not yet fixed binutils section handling bug prevents
   7.312 -	 * alternatives-replacement from working reliably, so turn
   7.313 -	 * it off:
   7.314 -	 */
   7.315 -	printk("lockdep: not fixing up alternatives.\n");
   7.316 -	return;
   7.317 -#endif
   7.318 -
   7.319 -	if (no_replacement || smp_alt_once)
   7.320 -		return;
   7.321 -	BUG_ON(!smp && (num_online_cpus() > 1));
   7.322 -
   7.323 -	spin_lock_irqsave(&smp_alt, flags);
   7.324 -	if (smp) {
   7.325 -		printk(KERN_INFO "SMP alternatives: switching to SMP code\n");
   7.326 -		clear_bit(X86_FEATURE_UP, boot_cpu_data.x86_capability);
   7.327 -		clear_bit(X86_FEATURE_UP, cpu_data[0].x86_capability);
   7.328 -		alternatives_smp_apply(__smp_alt_instructions,
   7.329 -				       __smp_alt_instructions_end);
   7.330 -		list_for_each_entry(mod, &smp_alt_modules, next)
   7.331 -			alternatives_smp_lock(mod->locks, mod->locks_end,
   7.332 -					      mod->text, mod->text_end);
   7.333 -	} else {
   7.334 -		printk(KERN_INFO "SMP alternatives: switching to UP code\n");
   7.335 -		set_bit(X86_FEATURE_UP, boot_cpu_data.x86_capability);
   7.336 -		set_bit(X86_FEATURE_UP, cpu_data[0].x86_capability);
   7.337 -		apply_alternatives(__smp_alt_instructions,
   7.338 -				   __smp_alt_instructions_end);
   7.339 -		list_for_each_entry(mod, &smp_alt_modules, next)
   7.340 -			alternatives_smp_unlock(mod->locks, mod->locks_end,
   7.341 -						mod->text, mod->text_end);
   7.342 -	}
   7.343 -	spin_unlock_irqrestore(&smp_alt, flags);
   7.344 -}
   7.345 -
   7.346 -#endif
   7.347 -
   7.348 -void __init alternative_instructions(void)
   7.349 -{
   7.350 -	if (no_replacement) {
   7.351 -		printk(KERN_INFO "(SMP-)alternatives turned off\n");
   7.352 -		free_init_pages("SMP alternatives",
   7.353 -				(unsigned long)__smp_alt_begin,
   7.354 -				(unsigned long)__smp_alt_end);
   7.355 -		return;
   7.356 -	}
   7.357 -	apply_alternatives(__alt_instructions, __alt_instructions_end);
   7.358 -
   7.359 -	/* switch to patch-once-at-boottime-only mode and free the
   7.360 -	 * tables in case we know the number of CPUs will never ever
   7.361 -	 * change */
   7.362 -#ifdef CONFIG_HOTPLUG_CPU
   7.363 -	if (num_possible_cpus() < 2)
   7.364 -		smp_alt_once = 1;
   7.365 -#else
   7.366 -	smp_alt_once = 1;
   7.367 -#endif
   7.368 -
   7.369 -#ifdef CONFIG_SMP
   7.370 -	if (smp_alt_once) {
   7.371 -		if (1 == num_possible_cpus()) {
   7.372 -			printk(KERN_INFO "SMP alternatives: switching to UP code\n");
   7.373 -			set_bit(X86_FEATURE_UP, boot_cpu_data.x86_capability);
   7.374 -			set_bit(X86_FEATURE_UP, cpu_data[0].x86_capability);
   7.375 -			apply_alternatives(__smp_alt_instructions,
   7.376 -					   __smp_alt_instructions_end);
   7.377 -			alternatives_smp_unlock(__smp_locks, __smp_locks_end,
   7.378 -						_text, _etext);
   7.379 -		}
   7.380 -		free_init_pages("SMP alternatives",
   7.381 -				(unsigned long)__smp_alt_begin,
   7.382 -				(unsigned long)__smp_alt_end);
   7.383 -	} else {
   7.384 -		alternatives_smp_save(__smp_alt_instructions,
   7.385 -				      __smp_alt_instructions_end);
   7.386 -		alternatives_smp_module_add(NULL, "core kernel",
   7.387 -					    __smp_locks, __smp_locks_end,
   7.388 -					    _text, _etext);
   7.389 -		alternatives_smp_switch(0);
   7.390 -	}
   7.391 -#endif
   7.392 -}

     8.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/cpu/intel_cacheinfo-xen.c	Mon Mar 05 12:49:12 2007 -0600
     8.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.3 @@ -1,774 +0,0 @@
     8.4 -/*
     8.5 - *      Routines to indentify caches on Intel CPU.
     8.6 - *
     8.7 - *      Changes:
     8.8 - *      Venkatesh Pallipadi	: Adding cache identification through cpuid(4)
     8.9 - *		Ashok Raj <ashok.raj@intel.com>: Work with CPU hotplug infrastructure.
    8.10 - *	Andi Kleen		: CPUID4 emulation on AMD.
    8.11 - */
    8.12 -
    8.13 -#include <linux/init.h>
    8.14 -#include <linux/slab.h>
    8.15 -#include <linux/device.h>
    8.16 -#include <linux/compiler.h>
    8.17 -#include <linux/cpu.h>
    8.18 -#include <linux/sched.h>
    8.19 -
    8.20 -#include <asm/processor.h>
    8.21 -#include <asm/smp.h>
    8.22 -
    8.23 -#define LVL_1_INST	1
    8.24 -#define LVL_1_DATA	2
    8.25 -#define LVL_2		3
    8.26 -#define LVL_3		4
    8.27 -#define LVL_TRACE	5
    8.28 -
    8.29 -struct _cache_table
    8.30 -{
    8.31 -	unsigned char descriptor;
    8.32 -	char cache_type;
    8.33 -	short size;
    8.34 -};
    8.35 -
    8.36 -/* all the cache descriptor types we care about (no TLB or trace cache entries) */
    8.37 -static struct _cache_table cache_table[] __cpuinitdata =
    8.38 -{
    8.39 -	{ 0x06, LVL_1_INST, 8 },	/* 4-way set assoc, 32 byte line size */
    8.40 -	{ 0x08, LVL_1_INST, 16 },	/* 4-way set assoc, 32 byte line size */
    8.41 -	{ 0x0a, LVL_1_DATA, 8 },	/* 2 way set assoc, 32 byte line size */
    8.42 -	{ 0x0c, LVL_1_DATA, 16 },	/* 4-way set assoc, 32 byte line size */
    8.43 -	{ 0x22, LVL_3,      512 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.44 -	{ 0x23, LVL_3,      1024 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.45 -	{ 0x25, LVL_3,      2048 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.46 -	{ 0x29, LVL_3,      4096 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.47 -	{ 0x2c, LVL_1_DATA, 32 },	/* 8-way set assoc, 64 byte line size */
    8.48 -	{ 0x30, LVL_1_INST, 32 },	/* 8-way set assoc, 64 byte line size */
    8.49 -	{ 0x39, LVL_2,      128 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.50 -	{ 0x3a, LVL_2,      192 },	/* 6-way set assoc, sectored cache, 64 byte line size */
    8.51 -	{ 0x3b, LVL_2,      128 },	/* 2-way set assoc, sectored cache, 64 byte line size */
    8.52 -	{ 0x3c, LVL_2,      256 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.53 -	{ 0x3d, LVL_2,      384 },	/* 6-way set assoc, sectored cache, 64 byte line size */
    8.54 -	{ 0x3e, LVL_2,      512 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.55 -	{ 0x41, LVL_2,      128 },	/* 4-way set assoc, 32 byte line size */
    8.56 -	{ 0x42, LVL_2,      256 },	/* 4-way set assoc, 32 byte line size */
    8.57 -	{ 0x43, LVL_2,      512 },	/* 4-way set assoc, 32 byte line size */
    8.58 -	{ 0x44, LVL_2,      1024 },	/* 4-way set assoc, 32 byte line size */
    8.59 -	{ 0x45, LVL_2,      2048 },	/* 4-way set assoc, 32 byte line size */
    8.60 -	{ 0x46, LVL_3,      4096 },	/* 4-way set assoc, 64 byte line size */
    8.61 -	{ 0x47, LVL_3,      8192 },	/* 8-way set assoc, 64 byte line size */
    8.62 -	{ 0x49, LVL_3,      4096 },	/* 16-way set assoc, 64 byte line size */
    8.63 -	{ 0x4a, LVL_3,      6144 },	/* 12-way set assoc, 64 byte line size */
    8.64 -	{ 0x4b, LVL_3,      8192 },	/* 16-way set assoc, 64 byte line size */
    8.65 -	{ 0x4c, LVL_3,     12288 },	/* 12-way set assoc, 64 byte line size */
    8.66 -	{ 0x4d, LVL_3,     16384 },	/* 16-way set assoc, 64 byte line size */
    8.67 -	{ 0x60, LVL_1_DATA, 16 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.68 -	{ 0x66, LVL_1_DATA, 8 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.69 -	{ 0x67, LVL_1_DATA, 16 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.70 -	{ 0x68, LVL_1_DATA, 32 },	/* 4-way set assoc, sectored cache, 64 byte line size */
    8.71 -	{ 0x70, LVL_TRACE,  12 },	/* 8-way set assoc */
    8.72 -	{ 0x71, LVL_TRACE,  16 },	/* 8-way set assoc */
    8.73 -	{ 0x72, LVL_TRACE,  32 },	/* 8-way set assoc */
    8.74 -	{ 0x73, LVL_TRACE,  64 },	/* 8-way set assoc */
    8.75 -	{ 0x78, LVL_2,    1024 },	/* 4-way set assoc, 64 byte line size */
    8.76 -	{ 0x79, LVL_2,     128 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.77 -	{ 0x7a, LVL_2,     256 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.78 -	{ 0x7b, LVL_2,     512 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.79 -	{ 0x7c, LVL_2,    1024 },	/* 8-way set assoc, sectored cache, 64 byte line size */
    8.80 -	{ 0x7d, LVL_2,    2048 },	/* 8-way set assoc, 64 byte line size */
    8.81 -	{ 0x7f, LVL_2,     512 },	/* 2-way set assoc, 64 byte line size */
    8.82 -	{ 0x82, LVL_2,     256 },	/* 8-way set assoc, 32 byte line size */
    8.83 -	{ 0x83, LVL_2,     512 },	/* 8-way set assoc, 32 byte line size */
    8.84 -	{ 0x84, LVL_2,    1024 },	/* 8-way set assoc, 32 byte line size */
    8.85 -	{ 0x85, LVL_2,    2048 },	/* 8-way set assoc, 32 byte line size */
    8.86 -	{ 0x86, LVL_2,     512 },	/* 4-way set assoc, 64 byte line size */
    8.87 -	{ 0x87, LVL_2,    1024 },	/* 8-way set assoc, 64 byte line size */
    8.88 -	{ 0x00, 0, 0}
    8.89 -};
    8.90 -
    8.91 -
    8.92 -enum _cache_type
    8.93 -{
    8.94 -	CACHE_TYPE_NULL	= 0,
    8.95 -	CACHE_TYPE_DATA = 1,
    8.96 -	CACHE_TYPE_INST = 2,
    8.97 -	CACHE_TYPE_UNIFIED = 3
    8.98 -};
    8.99 -
   8.100 -union _cpuid4_leaf_eax {
   8.101 -	struct {
   8.102 -		enum _cache_type	type:5;
   8.103 -		unsigned int		level:3;
   8.104 -		unsigned int		is_self_initializing:1;
   8.105 -		unsigned int		is_fully_associative:1;
   8.106 -		unsigned int		reserved:4;
   8.107 -		unsigned int		num_threads_sharing:12;
   8.108 -		unsigned int		num_cores_on_die:6;
   8.109 -	} split;
   8.110 -	u32 full;
   8.111 -};
   8.112 -
   8.113 -union _cpuid4_leaf_ebx {
   8.114 -	struct {
   8.115 -		unsigned int		coherency_line_size:12;
   8.116 -		unsigned int		physical_line_partition:10;
   8.117 -		unsigned int		ways_of_associativity:10;
   8.118 -	} split;
   8.119 -	u32 full;
   8.120 -};
   8.121 -
   8.122 -union _cpuid4_leaf_ecx {
   8.123 -	struct {
   8.124 -		unsigned int		number_of_sets:32;
   8.125 -	} split;
   8.126 -	u32 full;
   8.127 -};
   8.128 -
   8.129 -struct _cpuid4_info {
   8.130 -	union _cpuid4_leaf_eax eax;
   8.131 -	union _cpuid4_leaf_ebx ebx;
   8.132 -	union _cpuid4_leaf_ecx ecx;
   8.133 -	unsigned long size;
   8.134 -	cpumask_t shared_cpu_map;
   8.135 -};
   8.136 -
   8.137 -unsigned short			num_cache_leaves;
   8.138 -
   8.139 -/* AMD doesn't have CPUID4. Emulate it here to report the same
   8.140 -   information to the user.  This makes some assumptions about the machine:
   8.141 -   No L3, L2 not shared, no SMT etc. that is currently true on AMD CPUs.
   8.142 -
   8.143 -   In theory the TLBs could be reported as fake type (they are in "dummy").
   8.144 -   Maybe later */
   8.145 -union l1_cache {
   8.146 -	struct {
   8.147 -		unsigned line_size : 8;
   8.148 -		unsigned lines_per_tag : 8;
   8.149 -		unsigned assoc : 8;
   8.150 -		unsigned size_in_kb : 8;
   8.151 -	};
   8.152 -	unsigned val;
   8.153 -};
   8.154 -
   8.155 -union l2_cache {
   8.156 -	struct {
   8.157 -		unsigned line_size : 8;
   8.158 -		unsigned lines_per_tag : 4;
   8.159 -		unsigned assoc : 4;
   8.160 -		unsigned size_in_kb : 16;
   8.161 -	};
   8.162 -	unsigned val;
   8.163 -};
   8.164 -
   8.165 -static const unsigned short assocs[] = {
   8.166 -	[1] = 1, [2] = 2, [4] = 4, [6] = 8,
   8.167 -	[8] = 16,
   8.168 -	[0xf] = 0xffff // ??
   8.169 -	};
   8.170 -static const unsigned char levels[] = { 1, 1, 2 };
   8.171 -static const unsigned char types[] = { 1, 2, 3 };
   8.172 -
   8.173 -static void __cpuinit amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax,
   8.174 -		       union _cpuid4_leaf_ebx *ebx,
   8.175 -		       union _cpuid4_leaf_ecx *ecx)
   8.176 -{
   8.177 -	unsigned dummy;
   8.178 -	unsigned line_size, lines_per_tag, assoc, size_in_kb;
   8.179 -	union l1_cache l1i, l1d;
   8.180 -	union l2_cache l2;
   8.181 -
   8.182 -	eax->full = 0;
   8.183 -	ebx->full = 0;
   8.184 -	ecx->full = 0;
   8.185 -
   8.186 -	cpuid(0x80000005, &dummy, &dummy, &l1d.val, &l1i.val);
   8.187 -	cpuid(0x80000006, &dummy, &dummy, &l2.val, &dummy);
   8.188 -
   8.189 -	if (leaf > 2 || !l1d.val || !l1i.val || !l2.val)
   8.190 -		return;
   8.191 -
   8.192 -	eax->split.is_self_initializing = 1;
   8.193 -	eax->split.type = types[leaf];
   8.194 -	eax->split.level = levels[leaf];
   8.195 -	eax->split.num_threads_sharing = 0;
   8.196 -	eax->split.num_cores_on_die = current_cpu_data.x86_max_cores - 1;
   8.197 -
   8.198 -	if (leaf <= 1) {
   8.199 -		union l1_cache *l1 = leaf == 0 ? &l1d : &l1i;
   8.200 -		assoc = l1->assoc;
   8.201 -		line_size = l1->line_size;
   8.202 -		lines_per_tag = l1->lines_per_tag;
   8.203 -		size_in_kb = l1->size_in_kb;
   8.204 -	} else {
   8.205 -		assoc = l2.assoc;
   8.206 -		line_size = l2.line_size;
   8.207 -		lines_per_tag = l2.lines_per_tag;
   8.208 -		/* cpu_data has errata corrections for K7 applied */
   8.209 -		size_in_kb = current_cpu_data.x86_cache_size;
   8.210 -	}
   8.211 -
   8.212 -	if (assoc == 0xf)
   8.213 -		eax->split.is_fully_associative = 1;
   8.214 -	ebx->split.coherency_line_size = line_size - 1;
   8.215 -	ebx->split.ways_of_associativity = assocs[assoc] - 1;
   8.216 -	ebx->split.physical_line_partition = lines_per_tag - 1;
   8.217 -	ecx->split.number_of_sets = (size_in_kb * 1024) / line_size /
   8.218 -		(ebx->split.ways_of_associativity + 1) - 1;
   8.219 -}
   8.220 -
   8.221 -static int __cpuinit cpuid4_cache_lookup(int index, struct _cpuid4_info *this_leaf)
   8.222 -{
   8.223 -	union _cpuid4_leaf_eax 	eax;
   8.224 -	union _cpuid4_leaf_ebx 	ebx;
   8.225 -	union _cpuid4_leaf_ecx 	ecx;
   8.226 -	unsigned		edx;
   8.227 -
   8.228 -	if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
   8.229 -		amd_cpuid4(index, &eax, &ebx, &ecx);
   8.230 -	else
   8.231 -		cpuid_count(4, index, &eax.full, &ebx.full, &ecx.full,  &edx);
   8.232 -	if (eax.split.type == CACHE_TYPE_NULL)
   8.233 -		return -EIO; /* better error ? */
   8.234 -
   8.235 -	this_leaf->eax = eax;
   8.236 -	this_leaf->ebx = ebx;
   8.237 -	this_leaf->ecx = ecx;
   8.238 -	this_leaf->size = (ecx.split.number_of_sets + 1) *
   8.239 -		(ebx.split.coherency_line_size + 1) *
   8.240 -		(ebx.split.physical_line_partition + 1) *
   8.241 -		(ebx.split.ways_of_associativity + 1);
   8.242 -	return 0;
   8.243 -}
   8.244 -
   8.245 -/* will only be called once; __init is safe here */
   8.246 -static int __init find_num_cache_leaves(void)
   8.247 -{
   8.248 -	unsigned int		eax, ebx, ecx, edx;
   8.249 -	union _cpuid4_leaf_eax	cache_eax;
   8.250 -	int 			i = -1;
   8.251 -
   8.252 -	do {
   8.253 -		++i;
   8.254 -		/* Do cpuid(4) loop to find out num_cache_leaves */
   8.255 -		cpuid_count(4, i, &eax, &ebx, &ecx, &edx);
   8.256 -		cache_eax.full = eax;
   8.257 -	} while (cache_eax.split.type != CACHE_TYPE_NULL);
   8.258 -	return i;
   8.259 -}
   8.260 -
   8.261 -unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
   8.262 -{
   8.263 -	unsigned int trace = 0, l1i = 0, l1d = 0, l2 = 0, l3 = 0; /* Cache sizes */
   8.264 -	unsigned int new_l1d = 0, new_l1i = 0; /* Cache sizes from cpuid(4) */
   8.265 -	unsigned int new_l2 = 0, new_l3 = 0, i; /* Cache sizes from cpuid(4) */
   8.266 -	unsigned int l2_id = 0, l3_id = 0, num_threads_sharing, index_msb;
   8.267 -#ifdef CONFIG_X86_HT
   8.268 -	unsigned int cpu = (c == &boot_cpu_data) ? 0 : (c - cpu_data);
   8.269 -#endif
   8.270 -
   8.271 -	if (c->cpuid_level > 3) {
   8.272 -		static int is_initialized;
   8.273 -
   8.274 -		if (is_initialized == 0) {
   8.275 -			/* Init num_cache_leaves from boot CPU */
   8.276 -			num_cache_leaves = find_num_cache_leaves();
   8.277 -			is_initialized++;
   8.278 -		}
   8.279 -
   8.280 -		/*
   8.281 -		 * Whenever possible use cpuid(4), deterministic cache
   8.282 -		 * parameters cpuid leaf to find the cache details
   8.283 -		 */
   8.284 -		for (i = 0; i < num_cache_leaves; i++) {
   8.285 -			struct _cpuid4_info this_leaf;
   8.286 -
   8.287 -			int retval;
   8.288 -
   8.289 -			retval = cpuid4_cache_lookup(i, &this_leaf);
   8.290 -			if (retval >= 0) {
   8.291 -				switch(this_leaf.eax.split.level) {
   8.292 -				    case 1:
   8.293 -					if (this_leaf.eax.split.type ==
   8.294 -							CACHE_TYPE_DATA)
   8.295 -						new_l1d = this_leaf.size/1024;
   8.296 -					else if (this_leaf.eax.split.type ==
   8.297 -							CACHE_TYPE_INST)
   8.298 -						new_l1i = this_leaf.size/1024;
   8.299 -					break;
   8.300 -				    case 2:
   8.301 -					new_l2 = this_leaf.size/1024;
   8.302 -					num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
   8.303 -					index_msb = get_count_order(num_threads_sharing);
   8.304 -					l2_id = c->apicid >> index_msb;
   8.305 -					break;
   8.306 -				    case 3:
   8.307 -					new_l3 = this_leaf.size/1024;
   8.308 -					num_threads_sharing = 1 + this_leaf.eax.split.num_threads_sharing;
   8.309 -					index_msb = get_count_order(num_threads_sharing);
   8.310 -					l3_id = c->apicid >> index_msb;
   8.311 -					break;
   8.312 -				    default:
   8.313 -					break;
   8.314 -				}
   8.315 -			}
   8.316 -		}
   8.317 -	}
   8.318 -	/*
   8.319 -	 * Don't use cpuid2 if cpuid4 is supported. For P4, we use cpuid2 for
   8.320 -	 * trace cache
   8.321 -	 */
   8.322 -	if ((num_cache_leaves == 0 || c->x86 == 15) && c->cpuid_level > 1) {
   8.323 -		/* supports eax=2  call */
   8.324 -		int i, j, n;
   8.325 -		int regs[4];
   8.326 -		unsigned char *dp = (unsigned char *)regs;
   8.327 -		int only_trace = 0;
   8.328 -
   8.329 -		if (num_cache_leaves != 0 && c->x86 == 15)
   8.330 -			only_trace = 1;
   8.331 -
   8.332 -		/* Number of times to iterate */
   8.333 -		n = cpuid_eax(2) & 0xFF;
   8.334 -
   8.335 -		for ( i = 0 ; i < n ; i++ ) {
   8.336 -			cpuid(2, &regs[0], &regs[1], &regs[2], &regs[3]);
   8.337 -
   8.338 -			/* If bit 31 is set, this is an unknown format */
   8.339 -			for ( j = 0 ; j < 3 ; j++ ) {
   8.340 -				if ( regs[j] < 0 ) regs[j] = 0;
   8.341 -			}
   8.342 -
   8.343 -			/* Byte 0 is level count, not a descriptor */
   8.344 -			for ( j = 1 ; j < 16 ; j++ ) {
   8.345 -				unsigned char des = dp[j];
   8.346 -				unsigned char k = 0;
   8.347 -
   8.348 -				/* look up this descriptor in the table */
   8.349 -				while (cache_table[k].descriptor != 0)
   8.350 -				{
   8.351 -					if (cache_table[k].descriptor == des) {
   8.352 -						if (only_trace && cache_table[k].cache_type != LVL_TRACE)
   8.353 -							break;
   8.354 -						switch (cache_table[k].cache_type) {
   8.355 -						case LVL_1_INST:
   8.356 -							l1i += cache_table[k].size;
   8.357 -							break;
   8.358 -						case LVL_1_DATA:
   8.359 -							l1d += cache_table[k].size;
   8.360 -							break;
   8.361 -						case LVL_2:
   8.362 -							l2 += cache_table[k].size;
   8.363 -							break;
   8.364 -						case LVL_3:
   8.365 -							l3 += cache_table[k].size;
   8.366 -							break;
   8.367 -						case LVL_TRACE:
   8.368 -							trace += cache_table[k].size;
   8.369 -							break;
   8.370 -						}
   8.371 -
   8.372 -						break;
   8.373 -					}
   8.374 -
   8.375 -					k++;
   8.376 -				}
   8.377 -			}
   8.378 -		}
   8.379 -	}
   8.380 -
   8.381 -	if (new_l1d)
   8.382 -		l1d = new_l1d;
   8.383 -
   8.384 -	if (new_l1i)
   8.385 -		l1i = new_l1i;
   8.386 -
   8.387 -	if (new_l2) {
   8.388 -		l2 = new_l2;
   8.389 -#ifdef CONFIG_X86_HT
   8.390 -		cpu_llc_id[cpu] = l2_id;
   8.391 -#endif
   8.392 -	}
   8.393 -
   8.394 -	if (new_l3) {
   8.395 -		l3 = new_l3;
   8.396 -#ifdef CONFIG_X86_HT
   8.397 -		cpu_llc_id[cpu] = l3_id;
   8.398 -#endif
   8.399 -	}
   8.400 -
   8.401 -	if (trace)
   8.402 -		printk (KERN_INFO "CPU: Trace cache: %dK uops", trace);
   8.403 -	else if ( l1i )
   8.404 -		printk (KERN_INFO "CPU: L1 I cache: %dK", l1i);
   8.405 -
   8.406 -	if (l1d)
   8.407 -		printk(", L1 D cache: %dK\n", l1d);
   8.408 -	else
   8.409 -		printk("\n");
   8.410 -
   8.411 -	if (l2)
   8.412 -		printk(KERN_INFO "CPU: L2 cache: %dK\n", l2);
   8.413 -
   8.414 -	if (l3)
   8.415 -		printk(KERN_INFO "CPU: L3 cache: %dK\n", l3);
   8.416 -
   8.417 -	c->x86_cache_size = l3 ? l3 : (l2 ? l2 : (l1i+l1d));
   8.418 -
   8.419 -	return l2;
   8.420 -}
   8.421 -
   8.422 -/* pointer to _cpuid4_info array (for each cache leaf) */
   8.423 -static struct _cpuid4_info *cpuid4_info[NR_CPUS];
   8.424 -#define CPUID4_INFO_IDX(x,y)    (&((cpuid4_info[x])[y]))
   8.425 -
   8.426 -#ifdef CONFIG_SMP
   8.427 -static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
   8.428 -{
   8.429 -	struct _cpuid4_info	*this_leaf, *sibling_leaf;
   8.430 -	unsigned long num_threads_sharing;
   8.431 -	int index_msb, i;
   8.432 -	struct cpuinfo_x86 *c = cpu_data;
   8.433 -
   8.434 -	this_leaf = CPUID4_INFO_IDX(cpu, index);
   8.435 -	num_threads_sharing = 1 + this_leaf->eax.split.num_threads_sharing;
   8.436 -
   8.437 -	if (num_threads_sharing == 1)
   8.438 -		cpu_set(cpu, this_leaf->shared_cpu_map);
   8.439 -	else {
   8.440 -		index_msb = get_count_order(num_threads_sharing);
   8.441 -
   8.442 -		for_each_online_cpu(i) {
   8.443 -			if (c[i].apicid >> index_msb ==
   8.444 -			    c[cpu].apicid >> index_msb) {
   8.445 -				cpu_set(i, this_leaf->shared_cpu_map);
   8.446 -				if (i != cpu && cpuid4_info[i])  {
   8.447 -					sibling_leaf = CPUID4_INFO_IDX(i, index);
   8.448 -					cpu_set(cpu, sibling_leaf->shared_cpu_map);
   8.449 -				}
   8.450 -			}
   8.451 -		}
   8.452 -	}
   8.453 -}
   8.454 -static void __cpuinit cache_remove_shared_cpu_map(unsigned int cpu, int index)
   8.455 -{
   8.456 -	struct _cpuid4_info	*this_leaf, *sibling_leaf;
   8.457 -	int sibling;
   8.458 -
   8.459 -	this_leaf = CPUID4_INFO_IDX(cpu, index);
   8.460 -	for_each_cpu_mask(sibling, this_leaf->shared_cpu_map) {
   8.461 -		sibling_leaf = CPUID4_INFO_IDX(sibling, index);	
   8.462 -		cpu_clear(cpu, sibling_leaf->shared_cpu_map);
   8.463 -	}
   8.464 -}
   8.465 -#else
   8.466 -static void __init cache_shared_cpu_map_setup(unsigned int cpu, int index) {}
   8.467 -static void __init cache_remove_shared_cpu_map(unsigned int cpu, int index) {}
   8.468 -#endif
   8.469 -
   8.470 -static void free_cache_attributes(unsigned int cpu)
   8.471 -{
   8.472 -	kfree(cpuid4_info[cpu]);
   8.473 -	cpuid4_info[cpu] = NULL;
   8.474 -}
   8.475 -
   8.476 -static int __cpuinit detect_cache_attributes(unsigned int cpu)
   8.477 -{
   8.478 -	struct _cpuid4_info	*this_leaf;
   8.479 -	unsigned long 		j;
   8.480 -	int 			retval;
   8.481 -	cpumask_t		oldmask;
   8.482 -
   8.483 -	if (num_cache_leaves == 0)
   8.484 -		return -ENOENT;
   8.485 -
   8.486 -	cpuid4_info[cpu] = kmalloc(
   8.487 -	    sizeof(struct _cpuid4_info) * num_cache_leaves, GFP_KERNEL);
   8.488 -	if (unlikely(cpuid4_info[cpu] == NULL))
   8.489 -		return -ENOMEM;
   8.490 -	memset(cpuid4_info[cpu], 0,
   8.491 -	    sizeof(struct _cpuid4_info) * num_cache_leaves);
   8.492 -
   8.493 -	oldmask = current->cpus_allowed;
   8.494 -	retval = set_cpus_allowed(current, cpumask_of_cpu(cpu));
   8.495 -	if (retval)
   8.496 -		goto out;
   8.497 -
   8.498 -	/* Do cpuid and store the results */
   8.499 -	retval = 0;
   8.500 -	for (j = 0; j < num_cache_leaves; j++) {
   8.501 -		this_leaf = CPUID4_INFO_IDX(cpu, j);
   8.502 -		retval = cpuid4_cache_lookup(j, this_leaf);
   8.503 -		if (unlikely(retval < 0))
   8.504 -			break;
   8.505 -		cache_shared_cpu_map_setup(cpu, j);
   8.506 -	}
   8.507 -	set_cpus_allowed(current, oldmask);
   8.508 -
   8.509 -out:
   8.510 -	if (retval)
   8.511 -		free_cache_attributes(cpu);
   8.512 -	return retval;
   8.513 -}
   8.514 -
   8.515 -#ifdef CONFIG_SYSFS
   8.516 -
   8.517 -#include <linux/kobject.h>
   8.518 -#include <linux/sysfs.h>
   8.519 -
   8.520 -extern struct sysdev_class cpu_sysdev_class; /* from drivers/base/cpu.c */
   8.521 -
   8.522 -/* pointer to kobject for cpuX/cache */
   8.523 -static struct kobject * cache_kobject[NR_CPUS];
   8.524 -
   8.525 -struct _index_kobject {
   8.526 -	struct kobject kobj;
   8.527 -	unsigned int cpu;
   8.528 -	unsigned short index;
   8.529 -};
   8.530 -
   8.531 -/* pointer to array of kobjects for cpuX/cache/indexY */
   8.532 -static struct _index_kobject *index_kobject[NR_CPUS];
   8.533 -#define INDEX_KOBJECT_PTR(x,y)    (&((index_kobject[x])[y]))
   8.534 -
   8.535 -#define show_one_plus(file_name, object, val)				\
   8.536 -static ssize_t show_##file_name						\
   8.537 -			(struct _cpuid4_info *this_leaf, char *buf)	\
   8.538 -{									\
   8.539 -	return sprintf (buf, "%lu\n", (unsigned long)this_leaf->object + val); \
   8.540 -}
   8.541 -
   8.542 -show_one_plus(level, eax.split.level, 0);
   8.543 -show_one_plus(coherency_line_size, ebx.split.coherency_line_size, 1);
   8.544 -show_one_plus(physical_line_partition, ebx.split.physical_line_partition, 1);
   8.545 -show_one_plus(ways_of_associativity, ebx.split.ways_of_associativity, 1);
   8.546 -show_one_plus(number_of_sets, ecx.split.number_of_sets, 1);
   8.547 -
   8.548 -static ssize_t show_size(struct _cpuid4_info *this_leaf, char *buf)
   8.549 -{
   8.550 -	return sprintf (buf, "%luK\n", this_leaf->size / 1024);
   8.551 -}
   8.552 -
   8.553 -static ssize_t show_shared_cpu_map(struct _cpuid4_info *this_leaf, char *buf)
   8.554 -{
   8.555 -	char mask_str[NR_CPUS];
   8.556 -	cpumask_scnprintf(mask_str, NR_CPUS, this_leaf->shared_cpu_map);
   8.557 -	return sprintf(buf, "%s\n", mask_str);
   8.558 -}
   8.559 -
   8.560 -static ssize_t show_type(struct _cpuid4_info *this_leaf, char *buf) {
   8.561 -	switch(this_leaf->eax.split.type) {
   8.562 -	    case CACHE_TYPE_DATA:
   8.563 -		return sprintf(buf, "Data\n");
   8.564 -		break;
   8.565 -	    case CACHE_TYPE_INST:
   8.566 -		return sprintf(buf, "Instruction\n");
   8.567 -		break;
   8.568 -	    case CACHE_TYPE_UNIFIED:
   8.569 -		return sprintf(buf, "Unified\n");
   8.570 -		break;
   8.571 -	    default:
   8.572 -		return sprintf(buf, "Unknown\n");
   8.573 -		break;
   8.574 -	}
   8.575 -}
   8.576 -
   8.577 -struct _cache_attr {
   8.578 -	struct attribute attr;
   8.579 -	ssize_t (*show)(struct _cpuid4_info *, char *);
   8.580 -	ssize_t (*store)(struct _cpuid4_info *, const char *, size_t count);
   8.581 -};
   8.582 -
   8.583 -#define define_one_ro(_name) \
   8.584 -static struct _cache_attr _name = \
   8.585 -	__ATTR(_name, 0444, show_##_name, NULL)
   8.586 -
   8.587 -define_one_ro(level);
   8.588 -define_one_ro(type);
   8.589 -define_one_ro(coherency_line_size);
   8.590 -define_one_ro(physical_line_partition);
   8.591 -define_one_ro(ways_of_associativity);
   8.592 -define_one_ro(number_of_sets);
   8.593 -define_one_ro(size);
   8.594 -define_one_ro(shared_cpu_map);
   8.595 -
   8.596 -static struct attribute * default_attrs[] = {
   8.597 -	&type.attr,
   8.598 -	&level.attr,
   8.599 -	&coherency_line_size.attr,
   8.600 -	&physical_line_partition.attr,
   8.601 -	&ways_of_associativity.attr,
   8.602 -	&number_of_sets.attr,
   8.603 -	&size.attr,
   8.604 -	&shared_cpu_map.attr,
   8.605 -	NULL
   8.606 -};
   8.607 -
   8.608 -#define to_object(k) container_of(k, struct _index_kobject, kobj)
   8.609 -#define to_attr(a) container_of(a, struct _cache_attr, attr)
   8.610 -
   8.611 -static ssize_t show(struct kobject * kobj, struct attribute * attr, char * buf)
   8.612 -{
   8.613 -	struct _cache_attr *fattr = to_attr(attr);
   8.614 -	struct _index_kobject *this_leaf = to_object(kobj);
   8.615 -	ssize_t ret;
   8.616 -
   8.617 -	ret = fattr->show ?
   8.618 -		fattr->show(CPUID4_INFO_IDX(this_leaf->cpu, this_leaf->index),
   8.619 -			buf) :
   8.620 -	       	0;
   8.621 -	return ret;
   8.622 -}
   8.623 -
   8.624 -static ssize_t store(struct kobject * kobj, struct attribute * attr,
   8.625 -		     const char * buf, size_t count)
   8.626 -{
   8.627 -	return 0;
   8.628 -}
   8.629 -
   8.630 -static struct sysfs_ops sysfs_ops = {
   8.631 -	.show   = show,
   8.632 -	.store  = store,
   8.633 -};
   8.634 -
   8.635 -static struct kobj_type ktype_cache = {
   8.636 -	.sysfs_ops	= &sysfs_ops,
   8.637 -	.default_attrs	= default_attrs,
   8.638 -};
   8.639 -
   8.640 -static struct kobj_type ktype_percpu_entry = {
   8.641 -	.sysfs_ops	= &sysfs_ops,
   8.642 -};
   8.643 -
   8.644 -static void cpuid4_cache_sysfs_exit(unsigned int cpu)
   8.645 -{
   8.646 -	kfree(cache_kobject[cpu]);
   8.647 -	kfree(index_kobject[cpu]);
   8.648 -	cache_kobject[cpu] = NULL;
   8.649 -	index_kobject[cpu] = NULL;
   8.650 -	free_cache_attributes(cpu);
   8.651 -}
   8.652 -
   8.653 -static int __cpuinit cpuid4_cache_sysfs_init(unsigned int cpu)
   8.654 -{
   8.655 -
   8.656 -	if (num_cache_leaves == 0)
   8.657 -		return -ENOENT;
   8.658 -
   8.659 -	detect_cache_attributes(cpu);
   8.660 -	if (cpuid4_info[cpu] == NULL)
   8.661 -		return -ENOENT;
   8.662 -
   8.663 -	/* Allocate all required memory */
   8.664 -	cache_kobject[cpu] = kmalloc(sizeof(struct kobject), GFP_KERNEL);
   8.665 -	if (unlikely(cache_kobject[cpu] == NULL))
   8.666 -		goto err_out;
   8.667 -	memset(cache_kobject[cpu], 0, sizeof(struct kobject));
   8.668 -
   8.669 -	index_kobject[cpu] = kmalloc(
   8.670 -	    sizeof(struct _index_kobject ) * num_cache_leaves, GFP_KERNEL);
   8.671 -	if (unlikely(index_kobject[cpu] == NULL))
   8.672 -		goto err_out;
   8.673 -	memset(index_kobject[cpu], 0,
   8.674 -	    sizeof(struct _index_kobject) * num_cache_leaves);
   8.675 -
   8.676 -	return 0;
   8.677 -
   8.678 -err_out:
   8.679 -	cpuid4_cache_sysfs_exit(cpu);
   8.680 -	return -ENOMEM;
   8.681 -}
   8.682 -
   8.683 -/* Add/Remove cache interface for CPU device */
   8.684 -static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
   8.685 -{
   8.686 -	unsigned int cpu = sys_dev->id;
   8.687 -	unsigned long i, j;
   8.688 -	struct _index_kobject *this_object;
   8.689 -	int retval = 0;
   8.690 -
   8.691 -	retval = cpuid4_cache_sysfs_init(cpu);
   8.692 -	if (unlikely(retval < 0))
   8.693 -		return retval;
   8.694 -
   8.695 -	cache_kobject[cpu]->parent = &sys_dev->kobj;
   8.696 -	kobject_set_name(cache_kobject[cpu], "%s", "cache");
   8.697 -	cache_kobject[cpu]->ktype = &ktype_percpu_entry;
   8.698 -	retval = kobject_register(cache_kobject[cpu]);
   8.699 -
   8.700 -	for (i = 0; i < num_cache_leaves; i++) {
   8.701 -		this_object = INDEX_KOBJECT_PTR(cpu,i);
   8.702 -		this_object->cpu = cpu;
   8.703 -		this_object->index = i;
   8.704 -		this_object->kobj.parent = cache_kobject[cpu];
   8.705 -		kobject_set_name(&(this_object->kobj), "index%1lu", i);
   8.706 -		this_object->kobj.ktype = &ktype_cache;
   8.707 -		retval = kobject_register(&(this_object->kobj));
   8.708 -		if (unlikely(retval)) {
   8.709 -			for (j = 0; j < i; j++) {
   8.710 -				kobject_unregister(
   8.711 -					&(INDEX_KOBJECT_PTR(cpu,j)->kobj));
   8.712 -			}
   8.713 -			kobject_unregister(cache_kobject[cpu]);
   8.714 -			cpuid4_cache_sysfs_exit(cpu);
   8.715 -			break;
   8.716 -		}
   8.717 -	}
   8.718 -	return retval;
   8.719 -}
   8.720 -
   8.721 -static void __cpuexit cache_remove_dev(struct sys_device * sys_dev)
   8.722 -{
   8.723 -	unsigned int cpu = sys_dev->id;
   8.724 -	unsigned long i;
   8.725 -
   8.726 -	for (i = 0; i < num_cache_leaves; i++) {
   8.727 -		cache_remove_shared_cpu_map(cpu, i);
   8.728 -		kobject_unregister(&(INDEX_KOBJECT_PTR(cpu,i)->kobj));
   8.729 -	}
   8.730 -	kobject_unregister(cache_kobject[cpu]);
   8.731 -	cpuid4_cache_sysfs_exit(cpu);
   8.732 -	return;
   8.733 -}
   8.734 -
   8.735 -static int __cpuinit cacheinfo_cpu_callback(struct notifier_block *nfb,
   8.736 -					unsigned long action, void *hcpu)
   8.737 -{
   8.738 -	unsigned int cpu = (unsigned long)hcpu;
   8.739 -	struct sys_device *sys_dev;
   8.740 -
   8.741 -	sys_dev = get_cpu_sysdev(cpu);
   8.742 -	switch (action) {
   8.743 -	case CPU_ONLINE:
   8.744 -		cache_add_dev(sys_dev);
   8.745 -		break;
   8.746 -	case CPU_DEAD:
   8.747 -		cache_remove_dev(sys_dev);
   8.748 -		break;
   8.749 -	}
   8.750 -	return NOTIFY_OK;
   8.751 -}
   8.752 -
   8.753 -static struct notifier_block __cpuinitdata cacheinfo_cpu_notifier =
   8.754 -{
   8.755 -    .notifier_call = cacheinfo_cpu_callback,
   8.756 -};
   8.757 -
   8.758 -static int __cpuinit cache_sysfs_init(void)
   8.759 -{
   8.760 -	int i;
   8.761 -
   8.762 -	if (num_cache_leaves == 0)
   8.763 -		return 0;
   8.764 -
   8.765 -	register_hotcpu_notifier(&cacheinfo_cpu_notifier);
   8.766 -
   8.767 -	for_each_online_cpu(i) {
   8.768 -		cacheinfo_cpu_callback(&cacheinfo_cpu_notifier, CPU_ONLINE,
   8.769 -			(void *)(long)i);
   8.770 -	}
   8.771 -
   8.772 -	return 0;
   8.773 -}
   8.774 -
   8.775 -device_initcall(cache_sysfs_init);
   8.776 -
   8.777 -#endif

     9.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/entry-xen.S	Mon Mar 05 12:49:12 2007 -0600
     9.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/entry-xen.S	Thu Mar 08 14:39:52 2007 -0600
     9.3 @@ -368,6 +368,7 @@ sysexit_scrit:	/**** START OF SYSEXIT CR
     9.4  	movl ESI(%esp), %esi
     9.5  	sysexit
     9.6  14:	__DISABLE_INTERRUPTS
     9.7 +	TRACE_IRQS_OFF
     9.8  sysexit_ecrit:	/**** END OF SYSEXIT CRITICAL REGION ****/
     9.9  	push %esp
    9.10  	call evtchn_do_upcall
    9.11 @@ -427,11 +428,13 @@ restore_nocheck:
    9.12  restore_nocheck:
    9.13  	movl EFLAGS(%esp), %eax
    9.14  	testl $(VM_MASK|NMI_MASK), %eax
    9.15 +	CFI_REMEMBER_STATE
    9.16  	jnz hypervisor_iret
    9.17  	shr $9, %eax			# EAX[0] == IRET_EFLAGS.IF
    9.18  	GET_VCPU_INFO
    9.19  	andb evtchn_upcall_mask(%esi),%al
    9.20  	andb $1,%al			# EAX[0] == IRET_EFLAGS.IF & event_mask
    9.21 +	CFI_REMEMBER_STATE
    9.22  	jnz restore_all_enable_events	#        != 0 => enable event delivery
    9.23  #endif
    9.24  	TRACE_IRQS_IRET
    9.25 @@ -455,8 +458,8 @@ iret_exc:
    9.26  	.long 1b,iret_exc
    9.27  .previous
    9.28  
    9.29 +	CFI_RESTORE_STATE
    9.30  #ifndef CONFIG_XEN
    9.31 -	CFI_RESTORE_STATE
    9.32  ldt_ss:
    9.33  	larl OLDSS(%esp), %eax
    9.34  	jnz restore_nocheck
    9.35 @@ -485,14 +488,36 @@ 1:	iret
    9.36  	.align 4
    9.37  	.long 1b,iret_exc
    9.38  .previous
    9.39 -	CFI_ENDPROC
    9.40  #else
    9.41 +        ALIGN
    9.42 +restore_all_enable_events:
    9.43 +	TRACE_IRQS_ON
    9.44 +	__ENABLE_INTERRUPTS
    9.45 +scrit:	/**** START OF CRITICAL REGION ****/
    9.46 +	__TEST_PENDING
    9.47 +	jnz  14f			# process more events if necessary...
    9.48 +	RESTORE_REGS
    9.49 +	addl $4, %esp
    9.50 +	CFI_ADJUST_CFA_OFFSET -4
    9.51 +1:	iret
    9.52 +.section __ex_table,"a"
    9.53 +	.align 4
    9.54 +	.long 1b,iret_exc
    9.55 +.previous
    9.56 +14:	__DISABLE_INTERRUPTS
    9.57 +	TRACE_IRQS_OFF
    9.58 +	jmp  11f
    9.59 +ecrit:  /**** END OF CRITICAL REGION ****/
    9.60 +
    9.61 +	CFI_RESTORE_STATE
    9.62  hypervisor_iret:
    9.63  	andl $~NMI_MASK, EFLAGS(%esp)
    9.64  	RESTORE_REGS
    9.65  	addl $4, %esp
    9.66 +	CFI_ADJUST_CFA_OFFSET -4
    9.67  	jmp  hypercall_page + (__HYPERVISOR_iret * 32)
    9.68  #endif
    9.69 +	CFI_ENDPROC
    9.70  
    9.71  	# perform work that needs to be done immediately before resumption
    9.72  	ALIGN
    9.73 @@ -736,7 +761,9 @@ error_code:
    9.74  # critical region we know that the entire frame is present and correct
    9.75  # so we can simply throw away the new one.
    9.76  ENTRY(hypervisor_callback)
    9.77 +	RING0_INT_FRAME
    9.78  	pushl %eax
    9.79 +	CFI_ADJUST_CFA_OFFSET 4
    9.80  	SAVE_ALL
    9.81  	movl EIP(%esp),%eax
    9.82  	cmpl $scrit,%eax
    9.83 @@ -749,26 +776,13 @@ ENTRY(hypervisor_callback)
    9.84  	ja   11f
    9.85  	addl $OLDESP,%esp		# Remove eflags...ebx from stack frame.
    9.86  11:	push %esp
    9.87 +	CFI_ADJUST_CFA_OFFSET 4
    9.88  	call evtchn_do_upcall
    9.89  	add  $4,%esp
    9.90 +	CFI_ADJUST_CFA_OFFSET -4
    9.91  	jmp  ret_from_intr
    9.92 +	CFI_ENDPROC
    9.93  
    9.94 -        ALIGN
    9.95 -restore_all_enable_events:
    9.96 -	__ENABLE_INTERRUPTS
    9.97 -scrit:	/**** START OF CRITICAL REGION ****/
    9.98 -	__TEST_PENDING
    9.99 -	jnz  14f			# process more events if necessary...
   9.100 -	RESTORE_REGS
   9.101 -	addl $4, %esp
   9.102 -1:	iret
   9.103 -.section __ex_table,"a"
   9.104 -	.align 4
   9.105 -	.long 1b,iret_exc
   9.106 -.previous
   9.107 -14:	__DISABLE_INTERRUPTS
   9.108 -	jmp  11b
   9.109 -ecrit:  /**** END OF CRITICAL REGION ****/
   9.110  # [How we do the fixup]. We want to merge the current stack frame with the
   9.111  # just-interrupted frame. How we do this depends on where in the critical
   9.112  # region the interrupted handler was executing, and so how many saved
   9.113 @@ -835,6 +849,7 @@ 4:	mov 16(%esp),%gs
   9.114  	addl $16,%esp		# EAX != 0 => Category 2 (Bad IRET)
   9.115  	jmp iret_exc
   9.116  5:	addl $16,%esp		# EAX == 0 => Category 1 (Bad segment)
   9.117 +	RING0_INT_FRAME
   9.118  	pushl $0
   9.119  	SAVE_ALL
   9.120  	jmp ret_from_exception
   9.121 @@ -860,6 +875,7 @@ 9:	xorl %eax,%eax;		\
   9.122  	.long 4b,9b;		\
   9.123  .previous
   9.124  #endif
   9.125 +	CFI_ENDPROC
   9.126  
   9.127  ENTRY(coprocessor_error)
   9.128  	RING0_INT_FRAME
   9.129 @@ -1187,8 +1203,11 @@ ENDPROC(arch_unwind_init_running)
   9.130  #endif
   9.131  
   9.132  ENTRY(fixup_4gb_segment)
   9.133 +	RING0_EC_FRAME
   9.134  	pushl $do_fixup_4gb_segment
   9.135 +	CFI_ADJUST_CFA_OFFSET 4
   9.136  	jmp error_code
   9.137 +	CFI_ENDPROC
   9.138  
   9.139  .section .rodata,"a"
   9.140  .align 4

    10.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/head-xen.S	Mon Mar 05 12:49:12 2007 -0600
    10.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/head-xen.S	Thu Mar 08 14:39:52 2007 -0600
    10.3 @@ -9,11 +9,10 @@
    10.4  #include <asm/cache.h>
    10.5  #include <asm/thread_info.h>
    10.6  #include <asm/asm-offsets.h>
    10.7 +#include <asm/dwarf2.h>
    10.8  #include <xen/interface/xen.h>
    10.9  #include <xen/interface/elfnote.h>
   10.10  
   10.11 -#define _PAGE_PRESENT 0x1
   10.12 -
   10.13  /*
   10.14   * References to members of the new_cpu_data structure.
   10.15   */
   10.16 @@ -65,14 +64,13 @@ ENTRY(startup_32)
   10.17  
   10.18  	pushl %eax		# fake return address
   10.19  	jmp start_kernel
   10.20 -L6:
   10.21 -	jmp L6			# main should never return here, but
   10.22 -				# just in case, we know what happens.
   10.23  
   10.24  #define HYPERCALL_PAGE_OFFSET 0x1000
   10.25  .org HYPERCALL_PAGE_OFFSET
   10.26  ENTRY(hypercall_page)
   10.27 +	CFI_STARTPROC
   10.28  .skip 0x1000
   10.29 +	CFI_ENDPROC
   10.30  
   10.31  /*
   10.32   * Real beginning of normal "text" segment

    11.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/setup-xen.c	Mon Mar 05 12:49:12 2007 -0600
    11.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/setup-xen.c	Thu Mar 08 14:39:52 2007 -0600
    11.3 @@ -1847,6 +1847,9 @@ static __init int add_pcspkr(void)
    11.4  	struct platform_device *pd;
    11.5  	int ret;
    11.6  
    11.7 +	if (!is_initial_xendomain())
    11.8 +		return 0;
    11.9 +
   11.10  	pd = platform_device_alloc("pcspkr", -1);
   11.11  	if (!pd)
   11.12  		return -ENOMEM;

    12.1 --- a/linux-2.6-xen-sparse/arch/i386/kernel/time-xen.c	Mon Mar 05 12:49:12 2007 -0600
    12.2 +++ b/linux-2.6-xen-sparse/arch/i386/kernel/time-xen.c	Thu Mar 08 14:39:52 2007 -0600
    12.3 @@ -1022,16 +1022,21 @@ void halt(void)
    12.4  }
    12.5  EXPORT_SYMBOL(halt);
    12.6  
    12.7 -/* No locking required. We are only CPU running, and interrupts are off. */
    12.8 +/* No locking required. Interrupts are disabled on all CPUs. */
    12.9  void time_resume(void)
   12.10  {
   12.11 +	unsigned int cpu;
   12.12 +
   12.13  	init_cpu_khz();
   12.14  
   12.15 -	get_time_values_from_xen(0);
   12.16 +	for_each_online_cpu(cpu) {
   12.17 +		get_time_values_from_xen(cpu);
   12.18 +		per_cpu(processed_system_time, cpu) =
   12.19 +			per_cpu(shadow_time, 0).system_timestamp;
   12.20 +		init_missing_ticks_accounting(cpu);
   12.21 +	}
   12.22  
   12.23  	processed_system_time = per_cpu(shadow_time, 0).system_timestamp;
   12.24 -	per_cpu(processed_system_time, 0) = processed_system_time;
   12.25 -	init_missing_ticks_accounting(0);
   12.26  
   12.27  	update_wallclock();
   12.28  }

    13.1 --- a/linux-2.6-xen-sparse/arch/i386/mm/ioremap-xen.c	Mon Mar 05 12:49:12 2007 -0600
    13.2 +++ b/linux-2.6-xen-sparse/arch/i386/mm/ioremap-xen.c	Thu Mar 08 14:39:52 2007 -0600
    13.3 @@ -374,8 +374,6 @@ void iounmap(volatile void __iomem *addr
    13.4  }
    13.5  EXPORT_SYMBOL(iounmap);
    13.6  
    13.7 -#ifdef __i386__
    13.8 -
    13.9  void __init *bt_ioremap(unsigned long phys_addr, unsigned long size)
   13.10  {
   13.11  	unsigned long offset, last_addr;
   13.12 @@ -443,5 +441,3 @@ void __init bt_iounmap(void *addr, unsig
   13.13  		--nrpages;
   13.14  	}
   13.15  }
   13.16 -
   13.17 -#endif /* __i386__ */

    14.1 --- a/linux-2.6-xen-sparse/arch/i386/mm/pgtable-xen.c	Mon Mar 05 12:49:12 2007 -0600
    14.2 +++ b/linux-2.6-xen-sparse/arch/i386/mm/pgtable-xen.c	Thu Mar 08 14:39:52 2007 -0600
    14.3 @@ -573,64 +573,67 @@ void make_pages_writable(void *va, unsig
    14.4  	}
    14.5  }
    14.6  
    14.7 -static inline int pgd_walk_set_prot(struct page *page, pgprot_t flags)
    14.8 +static inline void pgd_walk_set_prot(struct page *page, pgprot_t flags)
    14.9  {
   14.10  	unsigned long pfn = page_to_pfn(page);
   14.11 -
   14.12 -	if (PageHighMem(page))
   14.13 -		return pgprot_val(flags) & _PAGE_RW
   14.14 -		       ? test_and_clear_bit(PG_pinned, &page->flags)
   14.15 -		       : !test_and_set_bit(PG_pinned, &page->flags);
   14.16 +	int rc;
   14.17  
   14.18 -	BUG_ON(HYPERVISOR_update_va_mapping(
   14.19 -		(unsigned long)__va(pfn << PAGE_SHIFT),
   14.20 -		pfn_pte(pfn, flags), 0));
   14.21 -
   14.22 -	return 0;
   14.23 +	if (PageHighMem(page)) {
   14.24 +		if (pgprot_val(flags) & _PAGE_RW)
   14.25 +			clear_bit(PG_pinned, &page->flags);
   14.26 +		else
   14.27 +			set_bit(PG_pinned, &page->flags);
   14.28 +	} else {
   14.29 +		rc = HYPERVISOR_update_va_mapping(
   14.30 +			(unsigned long)__va(pfn << PAGE_SHIFT),
   14.31 +			pfn_pte(pfn, flags), 0);
   14.32 +		if (rc)
   14.33 +			BUG();
   14.34 +	}
   14.35  }
   14.36  
   14.37 -static int pgd_walk(pgd_t *pgd_base, pgprot_t flags)
   14.38 +static void pgd_walk(pgd_t *pgd_base, pgprot_t flags)
   14.39  {
   14.40  	pgd_t *pgd = pgd_base;
   14.41  	pud_t *pud;
   14.42  	pmd_t *pmd;
   14.43 -	int    g, u, m, flush;
   14.44 +	int    g, u, m, rc;
   14.45  
   14.46  	if (xen_feature(XENFEAT_auto_translated_physmap))
   14.47  		return 0;
   14.48  
   14.49 -	for (g = 0, flush = 0; g < USER_PTRS_PER_PGD; g++, pgd++) {
   14.50 +	for (g = 0; g < USER_PTRS_PER_PGD; g++, pgd++) {
   14.51  		if (pgd_none(*pgd))
   14.52  			continue;
   14.53  		pud = pud_offset(pgd, 0);
   14.54  		if (PTRS_PER_PUD > 1) /* not folded */
   14.55 -			flush |= pgd_walk_set_prot(virt_to_page(pud),flags);
   14.56 +			pgd_walk_set_prot(virt_to_page(pud),flags);
   14.57  		for (u = 0; u < PTRS_PER_PUD; u++, pud++) {
   14.58  			if (pud_none(*pud))
   14.59  				continue;
   14.60  			pmd = pmd_offset(pud, 0);
   14.61  			if (PTRS_PER_PMD > 1) /* not folded */
   14.62 -				flush |= pgd_walk_set_prot(virt_to_page(pmd),flags);
   14.63 +				pgd_walk_set_prot(virt_to_page(pmd),flags);
   14.64  			for (m = 0; m < PTRS_PER_PMD; m++, pmd++) {
   14.65  				if (pmd_none(*pmd))
   14.66  					continue;
   14.67 -				flush |= pgd_walk_set_prot(pmd_page(*pmd),flags);
   14.68 +				pgd_walk_set_prot(pmd_page(*pmd),flags);
   14.69  			}
   14.70  		}
   14.71  	}
   14.72  
   14.73 -	BUG_ON(HYPERVISOR_update_va_mapping(
   14.74 +	rc = HYPERVISOR_update_va_mapping(
   14.75  		(unsigned long)pgd_base,
   14.76  		pfn_pte(virt_to_phys(pgd_base)>>PAGE_SHIFT, flags),
   14.77 -		UVMF_TLB_FLUSH));
   14.78 -
   14.79 -	return flush;
   14.80 +		UVMF_TLB_FLUSH);
   14.81 +	if (rc)
   14.82 +		BUG();
   14.83  }
   14.84  
   14.85  static void __pgd_pin(pgd_t *pgd)
   14.86  {
   14.87 -	if (pgd_walk(pgd, PAGE_KERNEL_RO))
   14.88 -		kmap_flush_unused();
   14.89 +	pgd_walk(pgd, PAGE_KERNEL_RO);
   14.90 +	kmap_flush_unused();
   14.91  	xen_pgd_pin(__pa(pgd));
   14.92  	set_bit(PG_pinned, &virt_to_page(pgd)->flags);
   14.93  }
   14.94 @@ -638,8 +641,7 @@ static void __pgd_pin(pgd_t *pgd)
   14.95  static void __pgd_unpin(pgd_t *pgd)
   14.96  {
   14.97  	xen_pgd_unpin(__pa(pgd));
   14.98 -	if (pgd_walk(pgd, PAGE_KERNEL))
   14.99 -		kmap_flush_unused();
  14.100 +	pgd_walk(pgd, PAGE_KERNEL);
  14.101  	clear_bit(PG_pinned, &virt_to_page(pgd)->flags);
  14.102  }
  14.103  

    15.1 --- a/linux-2.6-xen-sparse/arch/x86_64/Kconfig	Mon Mar 05 12:49:12 2007 -0600
    15.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/Kconfig	Thu Mar 08 14:39:52 2007 -0600
    15.3 @@ -450,7 +450,7 @@ config CALGARY_IOMMU
    15.4  	bool "IBM Calgary IOMMU support"
    15.5  	default y
    15.6  	select SWIOTLB
    15.7 -	depends on PCI && EXPERIMENTAL
    15.8 +	depends on PCI && !X86_64_XEN && EXPERIMENTAL
    15.9  	help
   15.10  	  Support for hardware IOMMUs in IBM's xSeries x366 and x460
   15.11  	  systems. Needed to run systems with more than 3GB of memory

    16.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/Makefile	Mon Mar 05 12:49:12 2007 -0600
    16.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/Makefile	Thu Mar 08 14:39:52 2007 -0600
    16.3 @@ -61,9 +61,7 @@ ifdef CONFIG_XEN
    16.4  time-y				+= ../../i386/kernel/time-xen.o
    16.5  pci-dma-y			+= ../../i386/kernel/pci-dma-xen.o
    16.6  microcode-$(subst m,y,$(CONFIG_MICROCODE))  := ../../i386/kernel/microcode-xen.o
    16.7 -intel_cacheinfo-y		:= ../../i386/kernel/cpu/intel_cacheinfo-xen.o
    16.8  quirks-y			:= ../../i386/kernel/quirks-xen.o
    16.9 -alternative-y			:= ../../i386/kernel/alternative-xen.o
   16.10  
   16.11  n-obj-xen := i8259.o reboot.o i8237.o smpboot.o trampoline.o
   16.12  

    17.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/entry-xen.S	Mon Mar 05 12:49:12 2007 -0600
    17.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/entry-xen.S	Thu Mar 08 14:39:52 2007 -0600
    17.3 @@ -116,19 +116,21 @@ NMI_MASK = 0x80000000
    17.4  	CFI_ADJUST_CFA_OFFSET	-(6*8)
    17.5  	.endm
    17.6  
    17.7 -	.macro	CFI_DEFAULT_STACK start=1
    17.8 +	.macro	CFI_DEFAULT_STACK start=1,adj=0
    17.9  	.if \start
   17.10  	CFI_STARTPROC	simple
   17.11 -	CFI_DEF_CFA	rsp,SS+8
   17.12 +	CFI_DEF_CFA	rsp,SS+8-(\adj*ARGOFFSET)
   17.13  	.else
   17.14 -	CFI_DEF_CFA_OFFSET SS+8
   17.15 +	CFI_DEF_CFA_OFFSET SS+8-(\adj*ARGOFFSET)
   17.16  	.endif
   17.17 +	.if \adj == 0
   17.18  	CFI_REL_OFFSET	r15,R15
   17.19  	CFI_REL_OFFSET	r14,R14
   17.20  	CFI_REL_OFFSET	r13,R13
   17.21  	CFI_REL_OFFSET	r12,R12
   17.22  	CFI_REL_OFFSET	rbp,RBP
   17.23  	CFI_REL_OFFSET	rbx,RBX
   17.24 +	.endif
   17.25  	CFI_REL_OFFSET	r11,R11
   17.26  	CFI_REL_OFFSET	r10,R10
   17.27  	CFI_REL_OFFSET	r9,R9
   17.28 @@ -363,8 +365,8 @@ ENTRY(int_ret_from_sys_call)
   17.29  	CFI_REL_OFFSET	r9,R9-ARGOFFSET
   17.30  	CFI_REL_OFFSET	r10,R10-ARGOFFSET
   17.31  	CFI_REL_OFFSET	r11,R11-ARGOFFSET
   17.32 +        XEN_BLOCK_EVENTS(%rsi)
   17.33  	TRACE_IRQS_OFF
   17.34 -        XEN_BLOCK_EVENTS(%rsi)
   17.35  	testb $3,CS-ARGOFFSET(%rsp)
   17.36          jnz 1f
   17.37          /* Need to set the proper %ss (not NULL) for ring 3 iretq */
   17.38 @@ -534,7 +536,7 @@ END(stub_rt_sigreturn)
   17.39   */ 
   17.40  
   17.41  retint_check:
   17.42 -	CFI_DEFAULT_STACK
   17.43 +	CFI_DEFAULT_STACK adj=1
   17.44  	movl threadinfo_flags(%rcx),%edx
   17.45  	andl %edi,%edx
   17.46  	CFI_REMEMBER_STATE
   17.47 @@ -838,6 +840,7 @@ ENTRY(error_entry)
   17.48  	CFI_REL_OFFSET	r15,R15
   17.49  #if 0        
   17.50  	cmpl $__KERNEL_CS,CS(%rsp)
   17.51 +	CFI_REMEMBER_STATE
   17.52  	je  error_kernelspace
   17.53  #endif        
   17.54  error_call_handler:
   17.55 @@ -864,7 +867,7 @@ error_exit:
   17.56  	TRACE_IRQS_IRETQ
   17.57  	jmp   retint_restore_args
   17.58  
   17.59 -error_kernelspace:
   17.60 +#if 0
   17.61           /*
   17.62           * We need to re-write the logic here because we don't do iretq to 
   17.63           * to return to user mode. It's still possible that we get trap/fault
   17.64 @@ -872,7 +875,8 @@ error_kernelspace:
   17.65           * for example).
   17.66           *
   17.67           */           
   17.68 -#if 0
   17.69 +	CFI_RESTORE_STATE
   17.70 +error_kernelspace:
   17.71  	incl %ebx
   17.72         /* There are two places in the kernel that can potentially fault with
   17.73            usergs. Handle them here. The exception handlers after
   17.74 @@ -888,11 +892,13 @@ error_kernelspace:
   17.75  	cmpq $gs_change,RIP(%rsp)
   17.76          je   error_swapgs
   17.77  	jmp  error_sti
   17.78 -#endif        
   17.79 +#endif
   17.80 +	CFI_ENDPROC
   17.81  END(error_entry)
   17.82  	
   17.83  ENTRY(hypervisor_callback)
   17.84  	zeroentry do_hypervisor_callback
   17.85 +END(hypervisor_callback)
   17.86          
   17.87  /*
   17.88   * Copied from arch/xen/i386/kernel/entry.S
   17.89 @@ -909,48 +915,66 @@ ENTRY(hypervisor_callback)
   17.90  # existing activation in its critical region -- if so, we pop the current
   17.91  # activation and restart the handler using the previous one.
   17.92  ENTRY(do_hypervisor_callback)   # do_hypervisor_callback(struct *pt_regs)
   17.93 +	CFI_STARTPROC
   17.94  # Since we don't modify %rdi, evtchn_do_upall(struct *pt_regs) will
   17.95  # see the correct pointer to the pt_regs
   17.96  	movq %rdi, %rsp            # we don't return, adjust the stack frame
   17.97 -11:	movq %gs:pda_irqstackptr,%rax
   17.98 -	incl %gs:pda_irqcount
   17.99 -	cmovzq %rax,%rsp
  17.100 -	pushq %rdi
  17.101 +	CFI_ENDPROC
  17.102 +	CFI_DEFAULT_STACK
  17.103 +11:	incl %gs:pda_irqcount
  17.104 +	movq %rsp,%rbp
  17.105 +	CFI_DEF_CFA_REGISTER rbp
  17.106 +	cmovzq %gs:pda_irqstackptr,%rsp
  17.107 +	pushq %rbp			# backlink for old unwinder
  17.108  	call evtchn_do_upcall
  17.109  	popq %rsp
  17.110 +	CFI_DEF_CFA_REGISTER rsp
  17.111  	decl %gs:pda_irqcount
  17.112  	jmp  error_exit
  17.113 +	CFI_ENDPROC
  17.114 +END(do_hypervisor_callback)
  17.115  
  17.116  #ifdef CONFIG_X86_LOCAL_APIC
  17.117  KPROBE_ENTRY(nmi)
  17.118  	zeroentry do_nmi_callback
  17.119  ENTRY(do_nmi_callback)
  17.120 +	CFI_STARTPROC
  17.121          addq $8, %rsp
  17.122 +	CFI_ENDPROC
  17.123 +	CFI_DEFAULT_STACK
  17.124          call do_nmi
  17.125          orl  $NMI_MASK,EFLAGS(%rsp)
  17.126          RESTORE_REST
  17.127          XEN_BLOCK_EVENTS(%rsi)
  17.128 +	TRACE_IRQS_OFF
  17.129          GET_THREAD_INFO(%rcx)
  17.130          jmp  retint_restore_args
  17.131 +	CFI_ENDPROC
  17.132  	.previous .text
  17.133 +END(nmi)
  17.134  #endif
  17.135  
  17.136          ALIGN
  17.137  restore_all_enable_events:  
  17.138 +	CFI_DEFAULT_STACK adj=1
  17.139 +	TRACE_IRQS_ON
  17.140  	XEN_UNBLOCK_EVENTS(%rsi)        # %rsi is already set up...
  17.141  
  17.142  scrit:	/**** START OF CRITICAL REGION ****/
  17.143  	XEN_TEST_PENDING(%rsi)
  17.144 +	CFI_REMEMBER_STATE
  17.145  	jnz  14f			# process more events if necessary...
  17.146  	XEN_PUT_VCPU_INFO(%rsi)
  17.147          RESTORE_ARGS 0,8,0
  17.148          HYPERVISOR_IRET 0
  17.149          
  17.150 +	CFI_RESTORE_STATE
  17.151  14:	XEN_LOCKED_BLOCK_EVENTS(%rsi)
  17.152  	XEN_PUT_VCPU_INFO(%rsi)
  17.153  	SAVE_REST
  17.154          movq %rsp,%rdi                  # set the argument again
  17.155  	jmp  11b
  17.156 +	CFI_ENDPROC
  17.157  ecrit:  /**** END OF CRITICAL REGION ****/
  17.158  # At this point, unlike on x86-32, we don't do the fixup to simplify the 
  17.159  # code and the stack frame is more complex on x86-64.
  17.160 @@ -970,8 +994,12 @@ ecrit:  /**** END OF CRITICAL REGION ***
  17.161  # We distinguish between categories by comparing each saved segment register
  17.162  # with its current contents: any discrepancy means we in category 1.
  17.163  ENTRY(failsafe_callback)
  17.164 +	_frame (RIP-0x30)
  17.165 +	CFI_REL_OFFSET rcx, 0
  17.166 +	CFI_REL_OFFSET r11, 8
  17.167  	movw %ds,%cx
  17.168  	cmpw %cx,0x10(%rsp)
  17.169 +	CFI_REMEMBER_STATE
  17.170  	jne 1f
  17.171  	movw %es,%cx
  17.172  	cmpw %cx,0x18(%rsp)
  17.173 @@ -984,17 +1012,26 @@ ENTRY(failsafe_callback)
  17.174  	jne 1f
  17.175  	/* All segments match their saved values => Category 2 (Bad IRET). */
  17.176  	movq (%rsp),%rcx
  17.177 +	CFI_RESTORE rcx
  17.178  	movq 8(%rsp),%r11
  17.179 +	CFI_RESTORE r11
  17.180  	addq $0x30,%rsp
  17.181 +	CFI_ADJUST_CFA_OFFSET -0x30
  17.182  	movq $11,%rdi	/* SIGSEGV */
  17.183  	jmp do_exit			
  17.184 +	CFI_RESTORE_STATE
  17.185  1:	/* Segment mismatch => Category 1 (Bad segment). Retry the IRET. */
  17.186  	movq (%rsp),%rcx
  17.187 +	CFI_RESTORE rcx
  17.188  	movq 8(%rsp),%r11
  17.189 +	CFI_RESTORE r11
  17.190  	addq $0x30,%rsp
  17.191 +	CFI_ADJUST_CFA_OFFSET -0x30
  17.192  	pushq $0
  17.193 +	CFI_ADJUST_CFA_OFFSET 8
  17.194  	SAVE_ALL
  17.195  	jmp error_exit
  17.196 +	CFI_ENDPROC
  17.197  #if 0	      
  17.198          .section __ex_table,"a"
  17.199          .align 8
  17.200 @@ -1117,12 +1154,12 @@ END(device_not_available)
  17.201  
  17.202  	/* runs on exception stack */
  17.203  KPROBE_ENTRY(debug)
  17.204 - 	INTR_FRAME
  17.205 -/*	pushq $0
  17.206 +/* 	INTR_FRAME
  17.207 +	pushq $0
  17.208  	CFI_ADJUST_CFA_OFFSET 8	*/
  17.209  	zeroentry do_debug
  17.210 -/*	paranoid_exit */
  17.211 -	CFI_ENDPROC
  17.212 +/*	paranoidexit
  17.213 +	CFI_ENDPROC */
  17.214  END(debug)
  17.215  	.previous .text
  17.216  
  17.217 @@ -1144,12 +1181,12 @@ END(nmi)
  17.218  #endif        
  17.219  
  17.220  KPROBE_ENTRY(int3)
  17.221 - 	INTR_FRAME
  17.222 -/* 	pushq $0
  17.223 +/* 	INTR_FRAME
  17.224 + 	pushq $0
  17.225   	CFI_ADJUST_CFA_OFFSET 8 */
  17.226   	zeroentry do_int3
  17.227 -/* 	jmp paranoid_exit1 */
  17.228 - 	CFI_ENDPROC
  17.229 +/* 	jmp paranoid_exit1
  17.230 + 	CFI_ENDPROC */
  17.231  END(int3)
  17.232  	.previous .text
  17.233  
  17.234 @@ -1193,9 +1230,11 @@ END(segment_not_present)
  17.235  
  17.236  	/* runs on exception stack */
  17.237  ENTRY(stack_segment)
  17.238 -	XCPT_FRAME
  17.239 +/*	XCPT_FRAME
  17.240 +	paranoidentry do_stack_segment */
  17.241  	errorentry do_stack_segment
  17.242 -	CFI_ENDPROC
  17.243 +/*	jmp paranoid_exit1
  17.244 +	CFI_ENDPROC */
  17.245  END(stack_segment)
  17.246  
  17.247  KPROBE_ENTRY(general_protection)

    18.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/head-xen.S	Mon Mar 05 12:49:12 2007 -0600
    18.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/head-xen.S	Thu Mar 08 14:39:52 2007 -0600
    18.3 @@ -22,11 +22,9 @@
    18.4  #include <asm/page.h>
    18.5  #include <asm/msr.h>
    18.6  #include <asm/cache.h>
    18.7 -
    18.8 +#include <asm/dwarf2.h>
    18.9  #include <xen/interface/elfnote.h>
   18.10  
   18.11 -#define _PAGE_PRESENT 0x1
   18.12 -
   18.13  	.section .bootstrap.text, "ax", @progbits
   18.14  	.code64
   18.15  #define VIRT_ENTRY_OFFSET 0x0
   18.16 @@ -42,6 +40,7 @@ ENTRY(_start)
   18.17  	/* rsi is pointer to startup info structure.
   18.18  	   pass it to C */
   18.19  	movq %rsi,%rdi
   18.20 +	pushq $0		# fake return address
   18.21  	jmp x86_64_start_kernel
   18.22  
   18.23  ENTRY(stext)
   18.24 @@ -82,7 +81,25 @@ NEXT_PAGE(level2_kernel_pgt)
   18.25  	.fill	512,8,0
   18.26  
   18.27  NEXT_PAGE(hypercall_page)
   18.28 -	.fill	512,8,0
   18.29 +	CFI_STARTPROC
   18.30 +	.rept 0x1000 / 0x20
   18.31 +	.skip 1 /* push %rcx */
   18.32 +	CFI_ADJUST_CFA_OFFSET	8
   18.33 +	CFI_REL_OFFSET	rcx,0
   18.34 +	.skip 2 /* push %r11 */
   18.35 +	CFI_ADJUST_CFA_OFFSET	8
   18.36 +	CFI_REL_OFFSET	rcx,0
   18.37 +	.skip 5 /* mov $#,%eax */
   18.38 +	.skip 2 /* syscall */
   18.39 +	.skip 2 /* pop %r11 */
   18.40 +	CFI_ADJUST_CFA_OFFSET -8
   18.41 +	CFI_RESTORE r11
   18.42 +	.skip 1 /* pop %rcx */
   18.43 +	CFI_ADJUST_CFA_OFFSET -8
   18.44 +	CFI_RESTORE rcx
   18.45 +	.align 0x20,0 /* ret */
   18.46 +	.endr
   18.47 +	CFI_ENDPROC
   18.48  
   18.49  #undef NEXT_PAGE
   18.50  

    19.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/init_task.c	Mon Mar 05 12:49:12 2007 -0600
    19.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/init_task.c	Thu Mar 08 14:39:52 2007 -0600
    19.3 @@ -47,11 +47,11 @@ EXPORT_SYMBOL(init_task);
    19.4   * on exact cacheline boundaries, to eliminate cacheline ping-pong.
    19.5   */ 
    19.6  DEFINE_PER_CPU(struct tss_struct, init_tss) ____cacheline_internodealigned_in_smp = INIT_TSS;
    19.7 -#endif
    19.8  
    19.9  /* Copies of the original ist values from the tss are only accessed during
   19.10   * debugging, no special alignment required.
   19.11   */
   19.12  DEFINE_PER_CPU(struct orig_ist, orig_ist);
   19.13 +#endif
   19.14  
   19.15  #define ALIGN_TO_4K __attribute__((section(".data.init_task")))

    20.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/setup-xen.c	Mon Mar 05 12:49:12 2007 -0600
    20.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/kernel/setup-xen.c	Thu Mar 08 14:39:52 2007 -0600
    20.3 @@ -676,7 +676,8 @@ void __init setup_arch(char **cmdline_p)
    20.4  
    20.5  	init_memory_mapping(0, (end_pfn_map << PAGE_SHIFT));
    20.6  
    20.7 -	/* dmi_scan_machine(); */
    20.8 +	if (is_initial_xendomain())
    20.9 +		dmi_scan_machine();
   20.10  
   20.11  #ifdef CONFIG_ACPI_NUMA
   20.12  	/*
   20.13 @@ -691,6 +692,14 @@ void __init setup_arch(char **cmdline_p)
   20.14  	contig_initmem_init(0, end_pfn);
   20.15  #endif
   20.16  
   20.17 +#ifdef CONFIG_XEN
   20.18 +	/*
   20.19 +	 * Reserve kernel, physmap, start info, initial page tables, and
   20.20 +	 * direct mapping.
   20.21 +	 */
   20.22 +	reserve_bootmem_generic(__pa_symbol(&_text),
   20.23 +	                        (table_end << PAGE_SHIFT) - __pa_symbol(&_text));
   20.24 +#else
   20.25  	/* Reserve direct mapping */
   20.26  	reserve_bootmem_generic(table_start << PAGE_SHIFT, 
   20.27  				(table_end - table_start) << PAGE_SHIFT);
   20.28 @@ -699,12 +708,6 @@ void __init setup_arch(char **cmdline_p)
   20.29  	reserve_bootmem_generic(__pa_symbol(&_text),
   20.30  				__pa_symbol(&_end) - __pa_symbol(&_text));
   20.31  
   20.32 -#ifdef CONFIG_XEN
   20.33 -	/* reserve physmap, start info and initial page tables */
   20.34 -	reserve_bootmem_generic(__pa_symbol(&_end),
   20.35 -				(table_start << PAGE_SHIFT) -
   20.36 -				__pa_symbol(&_end));
   20.37 -#else
   20.38  	/*
   20.39  	 * reserve physical page 0 - it's a special BIOS page on many boxes,
   20.40  	 * enabling clean reboots, SMP operation, laptop functions.
   20.41 @@ -1625,13 +1628,6 @@ struct seq_operations cpuinfo_op = {
   20.42  	.show =	show_cpuinfo,
   20.43  };
   20.44  
   20.45 -static int __init run_dmi_scan(void)
   20.46 -{
   20.47 -	dmi_scan_machine();
   20.48 -	return 0;
   20.49 -}
   20.50 -core_initcall(run_dmi_scan);
   20.51 -
   20.52  #if defined(CONFIG_INPUT_PCSPKR) || defined(CONFIG_INPUT_PCSPKR_MODULE)
   20.53  #include <linux/platform_device.h>
   20.54  static __init int add_pcspkr(void)
   20.55 @@ -1639,6 +1635,9 @@ static __init int add_pcspkr(void)
   20.56  	struct platform_device *pd;
   20.57  	int ret;
   20.58  
   20.59 +	if (!is_initial_xendomain())
   20.60 +		return 0;
   20.61 +
   20.62  	pd = platform_device_alloc("pcspkr", -1);
   20.63  	if (!pd)
   20.64  		return -ENOMEM;

    21.1 --- a/linux-2.6-xen-sparse/arch/x86_64/kernel/x8664_ksyms-xen.c	Mon Mar 05 12:49:12 2007 -0600
    21.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.3 @@ -1,59 +0,0 @@
    21.4 -/* Exports for assembly files.
    21.5 -   All C exports should go in the respective C files. */
    21.6 -
    21.7 -#include <linux/module.h>
    21.8 -#include <linux/smp.h>
    21.9 -
   21.10 -#include <asm/semaphore.h>
   21.11 -#include <asm/processor.h>
   21.12 -#include <asm/uaccess.h>
   21.13 -#include <asm/pgtable.h>
   21.14 -
   21.15 -EXPORT_SYMBOL(kernel_thread);
   21.16 -
   21.17 -EXPORT_SYMBOL(__down_failed);
   21.18 -EXPORT_SYMBOL(__down_failed_interruptible);
   21.19 -EXPORT_SYMBOL(__down_failed_trylock);
   21.20 -EXPORT_SYMBOL(__up_wakeup);
   21.21 -
   21.22 -EXPORT_SYMBOL(__get_user_1);
   21.23 -EXPORT_SYMBOL(__get_user_2);
   21.24 -EXPORT_SYMBOL(__get_user_4);
   21.25 -EXPORT_SYMBOL(__get_user_8);
   21.26 -EXPORT_SYMBOL(__put_user_1);
   21.27 -EXPORT_SYMBOL(__put_user_2);
   21.28 -EXPORT_SYMBOL(__put_user_4);
   21.29 -EXPORT_SYMBOL(__put_user_8);
   21.30 -
   21.31 -EXPORT_SYMBOL(copy_user_generic);
   21.32 -EXPORT_SYMBOL(copy_from_user);
   21.33 -EXPORT_SYMBOL(copy_to_user);
   21.34 -
   21.35 -EXPORT_SYMBOL(copy_page);
   21.36 -EXPORT_SYMBOL(clear_page);
   21.37 -
   21.38 -#ifdef CONFIG_SMP
   21.39 -extern void FASTCALL( __write_lock_failed(rwlock_t *rw));
   21.40 -extern void FASTCALL( __read_lock_failed(rwlock_t *rw));
   21.41 -EXPORT_SYMBOL(__write_lock_failed);
   21.42 -EXPORT_SYMBOL(__read_lock_failed);
   21.43 -#endif
   21.44 -
   21.45 -/* Export string functions. We normally rely on gcc builtin for most of these,
   21.46 -   but gcc sometimes decides not to inline them. */    
   21.47 -#undef memcpy
   21.48 -#undef memset
   21.49 -#undef memmove
   21.50 -
   21.51 -extern void * memset(void *,int,__kernel_size_t);
   21.52 -extern void * memcpy(void *,const void *,__kernel_size_t);
   21.53 -extern void * __memcpy(void *,const void *,__kernel_size_t);
   21.54 -
   21.55 -EXPORT_SYMBOL(memset);
   21.56 -EXPORT_SYMBOL(memcpy);
   21.57 -EXPORT_SYMBOL(__memcpy);
   21.58 -
   21.59 -EXPORT_SYMBOL(empty_zero_page);
   21.60 -
   21.61 -EXPORT_SYMBOL(load_gs_index);
   21.62 -

    22.1 --- a/linux-2.6-xen-sparse/arch/x86_64/mm/init-xen.c	Mon Mar 05 12:49:12 2007 -0600
    22.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/mm/init-xen.c	Thu Mar 08 14:39:52 2007 -0600
    22.3 @@ -102,14 +102,11 @@ static void __meminit early_make_page_re
    22.4  		BUG();
    22.5  }
    22.6  
    22.7 -void make_page_readonly(void *va, unsigned int feature)
    22.8 +static void __make_page_readonly(void *va)
    22.9  {
   22.10  	pgd_t *pgd; pud_t *pud; pmd_t *pmd; pte_t pte, *ptep;
   22.11  	unsigned long addr = (unsigned long) va;
   22.12  
   22.13 -	if (xen_feature(feature))
   22.14 -		return;
   22.15 -
   22.16  	pgd = pgd_offset_k(addr);
   22.17  	pud = pud_offset(pgd, addr);
   22.18  	pmd = pmd_offset(pud, addr);
   22.19 @@ -120,17 +117,14 @@ void make_page_readonly(void *va, unsign
   22.20  		xen_l1_entry_update(ptep, pte); /* fallback */
   22.21  
   22.22  	if ((addr >= VMALLOC_START) && (addr < VMALLOC_END))
   22.23 -		make_page_readonly(__va(pte_pfn(pte) << PAGE_SHIFT), feature);
   22.24 +		__make_page_readonly(__va(pte_pfn(pte) << PAGE_SHIFT));
   22.25  }
   22.26  
   22.27 -void make_page_writable(void *va, unsigned int feature)
   22.28 +static void __make_page_writable(void *va)
   22.29  {
   22.30  	pgd_t *pgd; pud_t *pud; pmd_t *pmd; pte_t pte, *ptep;
   22.31  	unsigned long addr = (unsigned long) va;
   22.32  
   22.33 -	if (xen_feature(feature))
   22.34 -		return;
   22.35 -
   22.36  	pgd = pgd_offset_k(addr);
   22.37  	pud = pud_offset(pgd, addr);
   22.38  	pmd = pmd_offset(pud, addr);
   22.39 @@ -141,7 +135,19 @@ void make_page_writable(void *va, unsign
   22.40  		xen_l1_entry_update(ptep, pte); /* fallback */
   22.41  
   22.42  	if ((addr >= VMALLOC_START) && (addr < VMALLOC_END))
   22.43 -		make_page_writable(__va(pte_pfn(pte) << PAGE_SHIFT), feature);
   22.44 +		__make_page_writable(__va(pte_pfn(pte) << PAGE_SHIFT));
   22.45 +}
   22.46 +
   22.47 +void make_page_readonly(void *va, unsigned int feature)
   22.48 +{
   22.49 +	if (!xen_feature(feature))
   22.50 +		__make_page_readonly(va);
   22.51 +}
   22.52 +
   22.53 +void make_page_writable(void *va, unsigned int feature)
   22.54 +{
   22.55 +	if (!xen_feature(feature))
   22.56 +		__make_page_writable(va);
   22.57  }
   22.58  
   22.59  void make_pages_readonly(void *va, unsigned nr, unsigned int feature)
   22.60 @@ -150,7 +156,7 @@ void make_pages_readonly(void *va, unsig
   22.61  		return;
   22.62  
   22.63  	while (nr-- != 0) {
   22.64 -		make_page_readonly(va, feature);
   22.65 +		__make_page_readonly(va);
   22.66  		va = (void*)((unsigned long)va + PAGE_SIZE);
   22.67  	}
   22.68  }
   22.69 @@ -161,7 +167,7 @@ void make_pages_writable(void *va, unsig
   22.70  		return;
   22.71  
   22.72  	while (nr-- != 0) {
   22.73 -		make_page_writable(va, feature);
   22.74 +		__make_page_writable(va);
   22.75  		va = (void*)((unsigned long)va + PAGE_SIZE);
   22.76  	}
   22.77  }
   22.78 @@ -208,7 +214,11 @@ static __init void *spp_getpage(void)
   22.79  	void *ptr;
   22.80  	if (after_bootmem)
   22.81  		ptr = (void *) get_zeroed_page(GFP_ATOMIC); 
   22.82 -	else
   22.83 +	else if (start_pfn < table_end) {
   22.84 +		ptr = __va(start_pfn << PAGE_SHIFT);
   22.85 +		start_pfn++;
   22.86 +		memset(ptr, 0, PAGE_SIZE);
   22.87 +	} else
   22.88  		ptr = alloc_bootmem_pages(PAGE_SIZE);
   22.89  	if (!ptr || ((unsigned long)ptr & ~PAGE_MASK))
   22.90  		panic("set_pte_phys: cannot allocate page data %s\n", after_bootmem?"after bootmem":"");
   22.91 @@ -299,36 +309,26 @@ static __init void set_pte_phys_ma(unsig
   22.92  
   22.93  		pmd = (pmd_t *) spp_getpage(); 
   22.94  		make_page_readonly(pmd, XENFEAT_writable_page_tables);
   22.95 -
   22.96  		set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE | _PAGE_USER));
   22.97 -
   22.98  		if (pmd != pmd_offset(pud, 0)) {
   22.99  			printk("PAGETABLE BUG #01! %p <-> %p\n", pmd, pmd_offset(pud,0));
  22.100  			return;
  22.101  		}
  22.102  	}
  22.103  	pmd = pmd_offset(pud, vaddr);
  22.104 -
  22.105  	if (pmd_none(*pmd)) {
  22.106  		pte = (pte_t *) spp_getpage();
  22.107  		make_page_readonly(pte, XENFEAT_writable_page_tables);
  22.108 -
  22.109  		set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE | _PAGE_USER));
  22.110  		if (pte != pte_offset_kernel(pmd, 0)) {
  22.111  			printk("PAGETABLE BUG #02!\n");
  22.112  			return;
  22.113  		}
  22.114  	}
  22.115 -
  22.116  	new_pte = pfn_pte_ma(phys >> PAGE_SHIFT, prot);
  22.117 -	pte = pte_offset_kernel(pmd, vaddr);
  22.118  
  22.119 -	/* 
  22.120 -	 * Note that the pte page is already RO, thus we want to use
  22.121 -	 * xen_l1_entry_update(), not set_pte().
  22.122 -	 */
  22.123 -	xen_l1_entry_update(pte, 
  22.124 -			    pfn_pte_ma(phys >> PAGE_SHIFT, prot));
  22.125 +	pte = pte_offset_kernel(pmd, vaddr);
  22.126 +	set_pte(pte, new_pte);
  22.127  
  22.128  	/*
  22.129  	 * It's enough to flush this one mapping.
  22.130 @@ -404,6 +404,7 @@ static inline void __set_pte(pte_t *dst,
  22.131  
  22.132  static inline int make_readonly(unsigned long paddr)
  22.133  {
  22.134 +	extern char __vsyscall_0;
  22.135  	int readonly = 0;
  22.136  
  22.137  	/* Make new page tables read-only. */
  22.138 @@ -420,25 +421,45 @@ static inline int make_readonly(unsigned
  22.139  	/*
  22.140  	 * No need for writable mapping of kernel image. This also ensures that
  22.141  	 * page and descriptor tables embedded inside don't have writable
  22.142 -	 * mappings. 
  22.143 +	 * mappings. Exclude the vsyscall area here, allowing alternative
  22.144 +	 * instruction patching to work.
  22.145  	 */
  22.146 -	if ((paddr >= __pa_symbol(&_text)) && (paddr < __pa_symbol(&_end)))
  22.147 +	if ((paddr >= __pa_symbol(&_text)) && (paddr < __pa_symbol(&_end))
  22.148 +	    && !(paddr >= __pa_symbol(&__vsyscall_0)
  22.149 +	         && paddr < __pa_symbol(&__vsyscall_0) + PAGE_SIZE))
  22.150  		readonly = 1;
  22.151  
  22.152  	return readonly;
  22.153  }
  22.154  
  22.155 +#ifndef CONFIG_XEN
  22.156  /* Must run before zap_low_mappings */
  22.157  __init void *early_ioremap(unsigned long addr, unsigned long size)
  22.158  {
  22.159 -	return ioremap(addr, size);
  22.160 +	unsigned long map = round_down(addr, LARGE_PAGE_SIZE);
  22.161 +
  22.162 +	/* actually usually some more */
  22.163 +	if (size >= LARGE_PAGE_SIZE) {
  22.164 +		printk("SMBIOS area too long %lu\n", size);
  22.165 +		return NULL;
  22.166 +	}
  22.167 +	set_pmd(temp_mappings[0].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
  22.168 +	map += LARGE_PAGE_SIZE;
  22.169 +	set_pmd(temp_mappings[1].pmd,  __pmd(map | _KERNPG_TABLE | _PAGE_PSE));
  22.170 +	__flush_tlb();
  22.171 +	return temp_mappings[0].address + (addr & (LARGE_PAGE_SIZE-1));
  22.172  }
  22.173  
  22.174  /* To avoid virtual aliases later */
  22.175  __init void early_iounmap(void *addr, unsigned long size)
  22.176  {
  22.177 -	iounmap(addr);
  22.178 +	if ((void *)round_down((unsigned long)addr, LARGE_PAGE_SIZE) != temp_mappings[0].address)
  22.179 +		printk("early_iounmap: bad address %p\n", addr);
  22.180 +	set_pmd(temp_mappings[0].pmd, __pmd(0));
  22.181 +	set_pmd(temp_mappings[1].pmd, __pmd(0));
  22.182 +	__flush_tlb();
  22.183  }
  22.184 +#endif
  22.185  
  22.186  static void __meminit
  22.187  phys_pmd_init(pmd_t *pmd, unsigned long address, unsigned long end)
  22.188 @@ -638,7 +659,7 @@ static void __init extend_init_mapping(u
  22.189  
  22.190  static void __init find_early_table_space(unsigned long end)
  22.191  {
  22.192 -	unsigned long puds, pmds, ptes, tables; 
  22.193 +	unsigned long puds, pmds, ptes, tables;
  22.194  
  22.195  	puds = (end + PUD_SIZE - 1) >> PUD_SHIFT;
  22.196  	pmds = (end + PMD_SIZE - 1) >> PMD_SHIFT;
  22.197 @@ -658,12 +679,70 @@ static void __init find_early_table_spac
  22.198  		(table_start << PAGE_SHIFT) + tables);
  22.199  }
  22.200  
  22.201 +static void xen_finish_init_mapping(void)
  22.202 +{
  22.203 +	unsigned long i, start, end;
  22.204 +
  22.205 +	/* Re-vector virtual addresses pointing into the initial
  22.206 +	   mapping to the just-established permanent ones. */
  22.207 +	xen_start_info = __va(__pa(xen_start_info));
  22.208 +	xen_start_info->pt_base = (unsigned long)
  22.209 +		__va(__pa(xen_start_info->pt_base));
  22.210 +	if (!xen_feature(XENFEAT_auto_translated_physmap)) {
  22.211 +		phys_to_machine_mapping =
  22.212 +			__va(__pa(xen_start_info->mfn_list));
  22.213 +		xen_start_info->mfn_list = (unsigned long)
  22.214 +			phys_to_machine_mapping;
  22.215 +	}
  22.216 +	if (xen_start_info->mod_start)
  22.217 +		xen_start_info->mod_start = (unsigned long)
  22.218 +			__va(__pa(xen_start_info->mod_start));
  22.219 +
  22.220 +	/* Destroy the Xen-created mappings beyond the kernel image as
  22.221 +	 * well as the temporary mappings created above. Prevents
  22.222 +	 * overlap with modules area (if init mapping is very big).
  22.223 +	 */
  22.224 +	start = PAGE_ALIGN((unsigned long)_end);
  22.225 +	end   = __START_KERNEL_map + (table_end << PAGE_SHIFT);
  22.226 +	for (; start < end; start += PAGE_SIZE)
  22.227 +		WARN_ON(HYPERVISOR_update_va_mapping(
  22.228 +			start, __pte_ma(0), 0));
  22.229 +
  22.230 +	/* Allocate pte's for initial fixmaps from 'start_pfn' allocator. */
  22.231 +	table_end = ~0UL;
  22.232 +
  22.233 +	/*
  22.234 +	 * Prefetch pte's for the bt_ioremap() area. It gets used before the
  22.235 +	 * boot-time allocator is online, so allocate-on-demand would fail.
  22.236 +	 */
  22.237 +	for (i = FIX_BTMAP_END; i <= FIX_BTMAP_BEGIN; i++)
  22.238 +		__set_fixmap(i, 0, __pgprot(0));
  22.239 +
  22.240 +	/* Switch to the real shared_info page, and clear the dummy page. */
  22.241 +	set_fixmap(FIX_SHARED_INFO, xen_start_info->shared_info);
  22.242 +	HYPERVISOR_shared_info = (shared_info_t *)fix_to_virt(FIX_SHARED_INFO);
  22.243 +	memset(empty_zero_page, 0, sizeof(empty_zero_page));
  22.244 +
  22.245 +	/* Set up mapping of lowest 1MB of physical memory. */
  22.246 +	for (i = 0; i < NR_FIX_ISAMAPS; i++)
  22.247 +		if (is_initial_xendomain())
  22.248 +			set_fixmap(FIX_ISAMAP_BEGIN - i, i * PAGE_SIZE);
  22.249 +		else
  22.250 +			__set_fixmap(FIX_ISAMAP_BEGIN - i,
  22.251 +				     virt_to_mfn(empty_zero_page)
  22.252 +				     << PAGE_SHIFT,
  22.253 +				     PAGE_KERNEL_RO);
  22.254 +
  22.255 +	/* Disable the 'start_pfn' allocator. */
  22.256 +	table_end = start_pfn;
  22.257 +}
  22.258 +
  22.259  /* Setup the direct mapping of the physical memory at PAGE_OFFSET.
  22.260     This runs before bootmem is initialized and gets pages directly from the 
  22.261     physical memory. To access them they are temporarily mapped. */
  22.262  void __meminit init_memory_mapping(unsigned long start, unsigned long end)
  22.263  { 
  22.264 -	unsigned long next; 
  22.265 +	unsigned long next;
  22.266  
  22.267  	Dprintk("init_memory_mapping\n");
  22.268  
  22.269 @@ -702,31 +781,7 @@ void __meminit init_memory_mapping(unsig
  22.270  
  22.271  	if (!after_bootmem) {
  22.272  		BUG_ON(start_pfn != table_end);
  22.273 -
  22.274 -		/* Re-vector virtual addresses pointing into the initial
  22.275 -		   mapping to the just-established permanent ones. */
  22.276 -		xen_start_info = __va(__pa(xen_start_info));
  22.277 -		xen_start_info->pt_base = (unsigned long)
  22.278 -			__va(__pa(xen_start_info->pt_base));
  22.279 -		if (!xen_feature(XENFEAT_auto_translated_physmap)) {
  22.280 -			phys_to_machine_mapping =
  22.281 -				__va(__pa(xen_start_info->mfn_list));
  22.282 -			xen_start_info->mfn_list = (unsigned long)
  22.283 -				phys_to_machine_mapping;
  22.284 -		}
  22.285 -		if (xen_start_info->mod_start)
  22.286 -			xen_start_info->mod_start = (unsigned long)
  22.287 -				__va(__pa(xen_start_info->mod_start));
  22.288 -
  22.289 -		/* Destroy the Xen-created mappings beyond the kernel image as
  22.290 -		 * well as the temporary mappings created above. Prevents
  22.291 -		 * overlap with modules area (if init mapping is very big).
  22.292 -		 */
  22.293 -		start = PAGE_ALIGN((unsigned long)_end);
  22.294 -		end   = __START_KERNEL_map + (table_end << PAGE_SHIFT);
  22.295 -		for (; start < end; start += PAGE_SIZE)
  22.296 -			WARN_ON(HYPERVISOR_update_va_mapping(
  22.297 -				start, __pte_ma(0), 0));
  22.298 +		xen_finish_init_mapping();
  22.299  	}
  22.300  
  22.301  	__flush_tlb_all();
  22.302 @@ -805,7 +860,6 @@ size_zones(unsigned long *z, unsigned lo
  22.303  void __init paging_init(void)
  22.304  {
  22.305  	unsigned long zones[MAX_NR_ZONES], holes[MAX_NR_ZONES];
  22.306 -	int i;
  22.307  
  22.308  	memory_present(0, 0, end_pfn);
  22.309  	sparse_init();
  22.310 @@ -813,22 +867,7 @@ void __init paging_init(void)
  22.311  	free_area_init_node(0, NODE_DATA(0), zones,
  22.312  			    __pa(PAGE_OFFSET) >> PAGE_SHIFT, holes);
  22.313  
  22.314 -	/* Switch to the real shared_info page, and clear the
  22.315 -	 * dummy page. */
  22.316 -	set_fixmap(FIX_SHARED_INFO, xen_start_info->shared_info);
  22.317 -	HYPERVISOR_shared_info = (shared_info_t *)fix_to_virt(FIX_SHARED_INFO);
  22.318 -	memset(empty_zero_page, 0, sizeof(empty_zero_page));
  22.319 -
  22.320  	init_mm.context.pinned = 1;
  22.321 -
  22.322 -	/* Setup mapping of lower 1st MB */
  22.323 -	for (i = 0; i < NR_FIX_ISAMAPS; i++)
  22.324 -		if (is_initial_xendomain())
  22.325 -			set_fixmap(FIX_ISAMAP_BEGIN - i, i * PAGE_SIZE);
  22.326 -		else
  22.327 -			__set_fixmap(FIX_ISAMAP_BEGIN - i,
  22.328 -				     virt_to_mfn(empty_zero_page) << PAGE_SHIFT,
  22.329 -				     PAGE_KERNEL_RO);
  22.330  }
  22.331  #endif
  22.332  
  22.333 @@ -1028,11 +1067,6 @@ void __init mem_init(void)
  22.334  
  22.335  void free_init_pages(char *what, unsigned long begin, unsigned long end)
  22.336  {
  22.337 -#ifdef __DO_LATER__
  22.338 -	/*
  22.339 -	 * Some pages can be pinned, but some are not. Unpinning such pages 
  22.340 -	 * triggers BUG(). 
  22.341 -	 */
  22.342  	unsigned long addr;
  22.343  
  22.344  	if (begin >= end)
  22.345 @@ -1044,25 +1078,27 @@ void free_init_pages(char *what, unsigne
  22.346  		init_page_count(virt_to_page(addr));
  22.347  		memset((void *)(addr & ~(PAGE_SIZE-1)),
  22.348  		       POISON_FREE_INITMEM, PAGE_SIZE); 
  22.349 -		make_page_writable(
  22.350 -			__va(__pa(addr)), XENFEAT_writable_page_tables);
  22.351 -		/*
  22.352 -		 * Make pages from __PAGE_OFFSET address as well
  22.353 -		 */
  22.354 -		make_page_writable(
  22.355 -			(void *)addr, XENFEAT_writable_page_tables);
  22.356 +		if (addr >= __START_KERNEL_map) {
  22.357 +			/* make_readonly() reports all kernel addresses. */
  22.358 +			__make_page_writable(__va(__pa(addr)));
  22.359 +			if (HYPERVISOR_update_va_mapping(addr, __pte(0), 0)) {
  22.360 +				pgd_t *pgd = pgd_offset_k(addr);
  22.361 +				pud_t *pud = pud_offset(pgd, addr);
  22.362 +				pmd_t *pmd = pmd_offset(pud, addr);
  22.363 +				pte_t *pte = pte_offset_kernel(pmd, addr);
  22.364 +
  22.365 +				xen_l1_entry_update(pte, __pte(0)); /* fallback */
  22.366 +			}
  22.367 +		}
  22.368  		free_page(addr);
  22.369  		totalram_pages++;
  22.370  	}
  22.371 -#endif
  22.372  }
  22.373  
  22.374  void free_initmem(void)
  22.375  {
  22.376 -#ifdef __DO_LATER__
  22.377  	memset(__initdata_begin, POISON_FREE_INITDATA,
  22.378  		__initdata_end - __initdata_begin);
  22.379 -#endif
  22.380  	free_init_pages("unused kernel memory",
  22.381  			(unsigned long)(&__init_begin),
  22.382  			(unsigned long)(&__init_end));
  22.383 @@ -1125,7 +1161,7 @@ int kern_addr_valid(unsigned long addr)
  22.384  	if (pgd_none(*pgd))
  22.385  		return 0;
  22.386  
  22.387 -	pud = pud_offset_k(pgd, addr);
  22.388 +	pud = pud_offset(pgd, addr);
  22.389  	if (pud_none(*pud))
  22.390  		return 0; 
  22.391  

    23.1 --- a/linux-2.6-xen-sparse/arch/x86_64/mm/pageattr-xen.c	Mon Mar 05 12:49:12 2007 -0600
    23.2 +++ b/linux-2.6-xen-sparse/arch/x86_64/mm/pageattr-xen.c	Thu Mar 08 14:39:52 2007 -0600
    23.3 @@ -24,10 +24,13 @@ static inline void mm_walk_set_prot(void
    23.4  {
    23.5  	struct page *page = virt_to_page(pt);
    23.6  	unsigned long pfn = page_to_pfn(page);
    23.7 +	int rc;
    23.8  
    23.9 -	BUG_ON(HYPERVISOR_update_va_mapping(
   23.10 -		       (unsigned long)__va(pfn << PAGE_SHIFT),
   23.11 -		       pfn_pte(pfn, flags), 0));
   23.12 +	rc = HYPERVISOR_update_va_mapping(
   23.13 +		(unsigned long)__va(pfn << PAGE_SHIFT),
   23.14 +		pfn_pte(pfn, flags), 0);
   23.15 +	if (rc)
   23.16 +		BUG();
   23.17  }
   23.18  
   23.19  static void mm_walk(struct mm_struct *mm, pgprot_t flags)

    24.1 --- a/linux-2.6-xen-sparse/drivers/char/mem.c	Mon Mar 05 12:49:12 2007 -0600
    24.2 +++ b/linux-2.6-xen-sparse/drivers/char/mem.c	Thu Mar 08 14:39:52 2007 -0600
    24.3 @@ -787,7 +787,7 @@ static const struct file_operations mem_
    24.4  	.open		= open_mem,
    24.5  };
    24.6  #else
    24.7 -extern struct file_operations mem_fops;
    24.8 +extern const struct file_operations mem_fops;
    24.9  #endif
   24.10  
   24.11  static const struct file_operations kmem_fops = {

    25.1 --- a/linux-2.6-xen-sparse/drivers/char/tpm/tpm_xen.c	Mon Mar 05 12:49:12 2007 -0600
    25.2 +++ b/linux-2.6-xen-sparse/drivers/char/tpm/tpm_xen.c	Thu Mar 08 14:39:52 2007 -0600
    25.3 @@ -113,14 +113,13 @@ void __exit tpmif_exit(void);
    25.4  
    25.5  
    25.6  static inline int
    25.7 -tx_buffer_copy(struct tx_buffer *txb, const u8 * src, int len,
    25.8 +tx_buffer_copy(struct tx_buffer *txb, const u8 *src, int len,
    25.9                 int isuserbuffer)
   25.10  {
   25.11  	int copied = len;
   25.12  
   25.13 -	if (len > txb->size) {
   25.14 +	if (len > txb->size)
   25.15  		copied = txb->size;
   25.16 -	}
   25.17  	if (isuserbuffer) {
   25.18  		if (copy_from_user(txb->data, src, copied))
   25.19  			return -EFAULT;
   25.20 @@ -133,18 +132,20 @@ tx_buffer_copy(struct tx_buffer *txb, co
   25.21  
   25.22  static inline struct tx_buffer *tx_buffer_alloc(void)
   25.23  {
   25.24 -	struct tx_buffer *txb = kzalloc(sizeof (struct tx_buffer),
   25.25 -					GFP_KERNEL);
   25.26 +	struct tx_buffer *txb;
   25.27 +
   25.28 +	txb = kzalloc(sizeof(struct tx_buffer), GFP_KERNEL);
   25.29 +	if (!txb)
   25.30 +		return NULL;
   25.31  
   25.32 -	if (txb) {
   25.33 -		txb->len = 0;
   25.34 -		txb->size = PAGE_SIZE;
   25.35 -		txb->data = (unsigned char *)__get_free_page(GFP_KERNEL);
   25.36 -		if (txb->data == NULL) {
   25.37 -			kfree(txb);
   25.38 -			txb = NULL;
   25.39 -		}
   25.40 +	txb->len = 0;
   25.41 +	txb->size = PAGE_SIZE;
   25.42 +	txb->data = (unsigned char *)__get_free_page(GFP_KERNEL);
   25.43 +	if (txb->data == NULL) {
   25.44 +		kfree(txb);
   25.45 +		txb = NULL;
   25.46  	}
   25.47 +
   25.48  	return txb;
   25.49  }
   25.50  
   25.51 @@ -160,37 +161,41 @@ static inline void tx_buffer_free(struct
   25.52  /**************************************************************
   25.53   Utility function for the tpm_private structure
   25.54  **************************************************************/
   25.55 -static inline void tpm_private_init(struct tpm_private *tp)
   25.56 +static void tpm_private_init(struct tpm_private *tp)
   25.57  {
   25.58  	spin_lock_init(&tp->tx_lock);
   25.59  	init_waitqueue_head(&tp->wait_q);
   25.60  	atomic_set(&tp->refcnt, 1);
   25.61  }
   25.62  
   25.63 -static inline void tpm_private_put(void)
   25.64 +static void tpm_private_put(void)
   25.65  {
   25.66 -	if ( atomic_dec_and_test(&my_priv->refcnt)) {
   25.67 -		tpmif_free_tx_buffers(my_priv);
   25.68 -		kfree(my_priv);
   25.69 -		my_priv = NULL;
   25.70 -	}
   25.71 +	if (!atomic_dec_and_test(&my_priv->refcnt))
   25.72 +		return;
   25.73 +
   25.74 +	tpmif_free_tx_buffers(my_priv);
   25.75 +	kfree(my_priv);
   25.76 +	my_priv = NULL;
   25.77  }
   25.78  
   25.79  static struct tpm_private *tpm_private_get(void)
   25.80  {
   25.81  	int err;
   25.82 -	if (!my_priv) {
   25.83 -		my_priv = kzalloc(sizeof(struct tpm_private), GFP_KERNEL);
   25.84 -		if (my_priv) {
   25.85 -			tpm_private_init(my_priv);
   25.86 -			err = tpmif_allocate_tx_buffers(my_priv);
   25.87 -			if (err < 0) {
   25.88 -				tpm_private_put();
   25.89 -			}
   25.90 -		}
   25.91 -	} else {
   25.92 +
   25.93 +	if (my_priv) {
   25.94  		atomic_inc(&my_priv->refcnt);
   25.95 +		return my_priv;
   25.96  	}
   25.97 +
   25.98 +	my_priv = kzalloc(sizeof(struct tpm_private), GFP_KERNEL);
   25.99 +	if (!my_priv)
  25.100 +		return NULL;
  25.101 +
  25.102 +	tpm_private_init(my_priv);
  25.103 +	err = tpmif_allocate_tx_buffers(my_priv);
  25.104 +	if (err < 0)
  25.105 +		tpm_private_put();
  25.106 +
  25.107  	return my_priv;
  25.108  }
  25.109  
  25.110 @@ -379,10 +384,8 @@ static int tpmfront_probe(struct xenbus_
  25.111  		return -ENOMEM;
  25.112  
  25.113  	tp->chip = init_vtpm(&dev->dev, &tvd, tp);
  25.114 -
  25.115 -	if (IS_ERR(tp->chip)) {
  25.116 +	if (IS_ERR(tp->chip))
  25.117  		return PTR_ERR(tp->chip);
  25.118 -	}
  25.119  
  25.120  	err = xenbus_scanf(XBT_NIL, dev->nodename,
  25.121  	                   "handle", "%i", &handle);
  25.122 @@ -401,6 +404,7 @@ static int tpmfront_probe(struct xenbus_
  25.123  		tpm_private_put();
  25.124  		return err;
  25.125  	}
  25.126 +
  25.127  	return 0;
  25.128  }
  25.129  
  25.130 @@ -417,32 +421,36 @@ static int tpmfront_suspend(struct xenbu
  25.131  {
  25.132  	struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
  25.133  	u32 ctr;
  25.134 -	/* lock, so no app can send */
  25.135 +
  25.136 +	/* Take the lock, preventing any application from sending. */
  25.137  	mutex_lock(&suspend_lock);
  25.138  	tp->is_suspended = 1;
  25.139  
  25.140 -	for (ctr = 0; atomic_read(&tp->tx_busy) && ctr <= 300; ctr++) {
  25.141 +	for (ctr = 0; atomic_read(&tp->tx_busy); ctr++) {
  25.142  		if ((ctr % 10) == 0)
  25.143  			printk("TPM-FE [INFO]: Waiting for outstanding "
  25.144  			       "request.\n");
  25.145 -		/*
  25.146 -		 * Wait for a request to be responded to.
  25.147 -		 */
  25.148 +		/* Wait for a request to be responded to. */
  25.149  		interruptible_sleep_on_timeout(&tp->wait_q, 100);
  25.150  	}
  25.151 -	xenbus_switch_state(dev, XenbusStateClosing);
  25.152 -
  25.153 -	if (atomic_read(&tp->tx_busy)) {
  25.154 -		/*
  25.155 -		 * A temporary work-around.
  25.156 -		 */
  25.157 -		printk("TPM-FE [WARNING]: Resetting busy flag.");
  25.158 -		atomic_set(&tp->tx_busy, 0);
  25.159 -	}
  25.160  
  25.161  	return 0;
  25.162  }
  25.163  
  25.164 +static int tpmfront_suspend_finish(struct tpm_private *tp)
  25.165 +{
  25.166 +	tp->is_suspended = 0;
  25.167 +	/* Allow applications to send again. */
  25.168 +	mutex_unlock(&suspend_lock);
  25.169 +	return 0;
  25.170 +}
  25.171 +
  25.172 +static int tpmfront_suspend_cancel(struct xenbus_device *dev)
  25.173 +{
  25.174 +	struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
  25.175 +	return tpmfront_suspend_finish(tp);
  25.176 +}
  25.177 +
  25.178  static int tpmfront_resume(struct xenbus_device *dev)
  25.179  {
  25.180  	struct tpm_private *tp = tpm_private_from_dev(&dev->dev);
  25.181 @@ -484,6 +492,7 @@ static struct xenbus_driver tpmfront = {
  25.182  	.resume = tpmfront_resume,
  25.183  	.otherend_changed = backend_changed,
  25.184  	.suspend = tpmfront_suspend,
  25.185 +	.suspend_cancel = tpmfront_suspend_cancel,
  25.186  };
  25.187  
  25.188  static void __init init_tpm_xenbus(void)
  25.189 @@ -514,9 +523,8 @@ static void tpmif_free_tx_buffers(struct
  25.190  {
  25.191  	unsigned int i;
  25.192  
  25.193 -	for (i = 0; i < TPMIF_TX_RING_SIZE; i++) {
  25.194 +	for (i = 0; i < TPMIF_TX_RING_SIZE; i++)
  25.195  		tx_buffer_free(tp->tx_buffers[i]);
  25.196 -	}
  25.197  }
  25.198  
  25.199  static void tpmif_rx_action(unsigned long priv)
  25.200 @@ -536,9 +544,8 @@ static void tpmif_rx_action(unsigned lon
  25.201  	received = tx->size;
  25.202  
  25.203  	buffer = kmalloc(received, GFP_ATOMIC);
  25.204 -	if (NULL == buffer) {
  25.205 +	if (!buffer)
  25.206  		goto exit;
  25.207 -	}
  25.208  
  25.209  	for (i = 0; i < TPMIF_TX_RING_SIZE && offset < received; i++) {
  25.210  		struct tx_buffer *txb = tp->tx_buffers[i];
  25.211 @@ -547,9 +554,8 @@ static void tpmif_rx_action(unsigned lon
  25.212  
  25.213  		tx = &tp->tx->ring[i].req;
  25.214  		tocopy = tx->size;
  25.215 -		if (tocopy > PAGE_SIZE) {
  25.216 +		if (tocopy > PAGE_SIZE)
  25.217  			tocopy = PAGE_SIZE;
  25.218 -		}
  25.219  
  25.220  		memcpy(&buffer[offset], txb->data, tocopy);
  25.221  
  25.222 @@ -607,12 +613,13 @@ static int tpm_xmit(struct tpm_private *
  25.223  		struct tx_buffer *txb = tp->tx_buffers[i];
  25.224  		int copied;
  25.225  
  25.226 -		if (NULL == txb) {
  25.227 +		if (!txb) {
  25.228  			DPRINTK("txb (i=%d) is NULL. buffers initilized?\n"
  25.229  				"Not transmitting anything!\n", i);
  25.230  			spin_unlock_irq(&tp->tx_lock);
  25.231  			return -EFAULT;
  25.232  		}
  25.233 +
  25.234  		copied = tx_buffer_copy(txb, &buf[offset], count,
  25.235  		                        isuserbuffer);
  25.236  		if (copied < 0) {
  25.237 @@ -624,25 +631,26 @@ static int tpm_xmit(struct tpm_private *
  25.238  		offset += copied;
  25.239  
  25.240  		tx = &tp->tx->ring[i].req;
  25.241 -
  25.242  		tx->addr = virt_to_machine(txb->data);
  25.243  		tx->size = txb->len;
  25.244  
  25.245 -		DPRINTK("First 4 characters sent by TPM-FE are 0x%02x 0x%02x 0x%02x 0x%02x\n",
  25.246 +		DPRINTK("First 4 characters sent by TPM-FE are "
  25.247 +			"0x%02x 0x%02x 0x%02x 0x%02x\n",
  25.248  		        txb->data[0],txb->data[1],txb->data[2],txb->data[3]);
  25.249  
  25.250 -		/* get the granttable reference for this page */
  25.251 +		/* Get the granttable reference for this page. */
  25.252  		tx->ref = gnttab_claim_grant_reference(&gref_head);
  25.253 -
  25.254 -		if (-ENOSPC == tx->ref) {
  25.255 +		if (tx->ref == -ENOSPC) {
  25.256  			spin_unlock_irq(&tp->tx_lock);
  25.257 -			DPRINTK(" Grant table claim reference failed in func:%s line:%d file:%s\n", __FUNCTION__, __LINE__, __FILE__);
  25.258 +			DPRINTK("Grant table claim reference failed in "
  25.259 +				"func:%s line:%d file:%s\n",
  25.260 +				__FUNCTION__, __LINE__, __FILE__);
  25.261  			return -ENOSPC;
  25.262  		}
  25.263 -		gnttab_grant_foreign_access_ref( tx->ref,
  25.264 -		                                 tp->backend_id,
  25.265 -		                                 virt_to_mfn(txb->data),
  25.266 -		                                 0 /*RW*/);
  25.267 +		gnttab_grant_foreign_access_ref(tx->ref,
  25.268 +						tp->backend_id,
  25.269 +						virt_to_mfn(txb->data),
  25.270 +						0 /*RW*/);
  25.271  		wmb();
  25.272  	}
  25.273  
  25.274 @@ -660,15 +668,10 @@ static int tpm_xmit(struct tpm_private *
  25.275  
  25.276  static void tpmif_notify_upperlayer(struct tpm_private *tp)
  25.277  {
  25.278 -	/*
  25.279 -	 * Notify upper layer about the state of the connection
  25.280 -	 * to the BE.
  25.281 -	 */
  25.282 -	if (tp->is_connected) {
  25.283 -		vtpm_vd_status(tp->chip, TPM_VD_STATUS_CONNECTED);
  25.284 -	} else {
  25.285 -		vtpm_vd_status(tp->chip, TPM_VD_STATUS_DISCONNECTED);
  25.286 -	}
  25.287 +	/* Notify upper layer about the state of the connection to the BE. */
  25.288 +	vtpm_vd_status(tp->chip, (tp->is_connected
  25.289 +				  ? TPM_VD_STATUS_CONNECTED
  25.290 +				  : TPM_VD_STATUS_DISCONNECTED));
  25.291  }
  25.292  
  25.293  
  25.294 @@ -679,20 +682,16 @@ static void tpmif_set_connected_state(st
  25.295  	 * should disconnect - assumption is that we will resume
  25.296  	 * The mutex keeps apps from sending.
  25.297  	 */
  25.298 -	if (is_connected == 0 && tp->is_suspended == 1) {
  25.299 +	if (is_connected == 0 && tp->is_suspended == 1)
  25.300  		return;
  25.301 -	}
  25.302  
  25.303  	/*
  25.304  	 * Unlock the mutex if we are connected again
  25.305  	 * after being suspended - now resuming.
  25.306  	 * This also removes the suspend state.
  25.307  	 */
  25.308 -	if (is_connected == 1 && tp->is_suspended == 1) {
  25.309 -		tp->is_suspended = 0;
  25.310 -		/* unlock, so apps can resume sending */
  25.311 -		mutex_unlock(&suspend_lock);
  25.312 -	}
  25.313 +	if (is_connected == 1 && tp->is_suspended == 1)
  25.314 +		tpmfront_suspend_finish(tp);
  25.315  
  25.316  	if (is_connected != tp->is_connected) {
  25.317  		tp->is_connected = is_connected;
  25.318 @@ -710,33 +709,24 @@ static void tpmif_set_connected_state(st
  25.319  
  25.320  static int __init tpmif_init(void)
  25.321  {
  25.322 -	long rc = 0;
  25.323  	struct tpm_private *tp;
  25.324  
  25.325  	if (is_initial_xendomain())
  25.326  		return -EPERM;
  25.327  
  25.328  	tp = tpm_private_get();
  25.329 -	if (!tp) {
  25.330 -		rc = -ENOMEM;
  25.331 -		goto failexit;
  25.332 -	}
  25.333 +	if (!tp)
  25.334 +		return -ENOMEM;
  25.335  
  25.336  	IPRINTK("Initialising the vTPM driver.\n");
  25.337 -	if ( gnttab_alloc_grant_references ( TPMIF_TX_RING_SIZE,
  25.338 -	                                     &gref_head ) < 0) {
  25.339 -		rc = -EFAULT;
  25.340 -		goto gnttab_alloc_failed;
  25.341 +	if (gnttab_alloc_grant_references(TPMIF_TX_RING_SIZE,
  25.342 +					  &gref_head) < 0) {
  25.343 +		tpm_private_put();
  25.344 +		return -EFAULT;
  25.345  	}
  25.346  
  25.347  	init_tpm_xenbus();
  25.348  	return 0;
  25.349 -
  25.350 -gnttab_alloc_failed:
  25.351 -	tpm_private_put();
  25.352 -failexit:
  25.353 -
  25.354 -	return (int)rc;
  25.355  }
  25.356  
  25.357  

    26.1 --- a/linux-2.6-xen-sparse/drivers/xen/blktap/blktap.c	Mon Mar 05 12:49:12 2007 -0600
    26.2 +++ b/linux-2.6-xen-sparse/drivers/xen/blktap/blktap.c	Thu Mar 08 14:39:52 2007 -0600
    26.3 @@ -335,7 +335,7 @@ static int blktap_ioctl(struct inode *in
    26.4                          unsigned int cmd, unsigned long arg);
    26.5  static unsigned int blktap_poll(struct file *file, poll_table *wait);
    26.6  
    26.7 -static struct file_operations blktap_fops = {
    26.8 +static const struct file_operations blktap_fops = {
    26.9  	.owner   = THIS_MODULE,
   26.10  	.poll    = blktap_poll,
   26.11  	.ioctl   = blktap_ioctl,

    27.1 --- a/linux-2.6-xen-sparse/drivers/xen/char/mem.c	Mon Mar 05 12:49:12 2007 -0600
    27.2 +++ b/linux-2.6-xen-sparse/drivers/xen/char/mem.c	Thu Mar 08 14:39:52 2007 -0600
    27.3 @@ -194,7 +194,7 @@ static int open_mem(struct inode * inode
    27.4  	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
    27.5  }
    27.6  
    27.7 -struct file_operations mem_fops = {
    27.8 +const struct file_operations mem_fops = {
    27.9  	.llseek		= memory_lseek,
   27.10  	.read		= read_mem,
   27.11  	.write		= write_mem,

    28.1 --- a/linux-2.6-xen-sparse/drivers/xen/core/machine_reboot.c	Mon Mar 05 12:49:12 2007 -0600
    28.2 +++ b/linux-2.6-xen-sparse/drivers/xen/core/machine_reboot.c	Thu Mar 08 14:39:52 2007 -0600
    28.3 @@ -59,27 +59,11 @@ EXPORT_SYMBOL(machine_restart);
    28.4  EXPORT_SYMBOL(machine_halt);
    28.5  EXPORT_SYMBOL(machine_power_off);
    28.6  
    28.7 -/* Ensure we run on the idle task page tables so that we will
    28.8 -   switch page tables before running user space. This is needed
    28.9 -   on architectures with separate kernel and user page tables
   28.10 -   because the user page table pointer is not saved/restored. */
   28.11 -static void switch_idle_mm(void)
   28.12 -{
   28.13 -	struct mm_struct *mm = current->active_mm;
   28.14 -
   28.15 -	if (mm == &init_mm)
   28.16 -		return;
   28.17 -
   28.18 -	atomic_inc(&init_mm.mm_count);
   28.19 -	switch_mm(mm, &init_mm, current);
   28.20 -	current->active_mm = &init_mm;
   28.21 -	mmdrop(mm);
   28.22 -}
   28.23 -
   28.24  static void pre_suspend(void)
   28.25  {
   28.26  	HYPERVISOR_shared_info = (shared_info_t *)empty_zero_page;
   28.27 -	clear_fixmap(FIX_SHARED_INFO);
   28.28 +	HYPERVISOR_update_va_mapping(fix_to_virt(FIX_SHARED_INFO),
   28.29 +				     __pte_ma(0), 0);
   28.30  
   28.31  	xen_start_info->store_mfn = mfn_to_pfn(xen_start_info->store_mfn);
   28.32  	xen_start_info->console.domU.mfn =
   28.33 @@ -89,6 +73,7 @@ static void pre_suspend(void)
   28.34  static void post_suspend(int suspend_cancelled)
   28.35  {
   28.36  	int i, j, k, fpp;
   28.37 +	unsigned long shinfo_mfn;
   28.38  	extern unsigned long max_pfn;
   28.39  	extern unsigned long *pfn_to_mfn_frame_list_list;
   28.40  	extern unsigned long *pfn_to_mfn_frame_list[];
   28.41 @@ -99,11 +84,14 @@ static void post_suspend(int suspend_can
   28.42  		xen_start_info->console.domU.mfn =
   28.43  			pfn_to_mfn(xen_start_info->console.domU.mfn);
   28.44  	} else {
   28.45 +#ifdef CONFIG_SMP
   28.46  		cpu_initialized_map = cpumask_of_cpu(0);
   28.47 +#endif
   28.48  	}
   28.49 -	
   28.50 -	set_fixmap(FIX_SHARED_INFO, xen_start_info->shared_info);
   28.51  
   28.52 +	shinfo_mfn = xen_start_info->shared_info >> PAGE_SHIFT;
   28.53 +	HYPERVISOR_update_va_mapping(fix_to_virt(FIX_SHARED_INFO),
   28.54 +				     pfn_pte_ma(shinfo_mfn, PAGE_KERNEL), 0);
   28.55  	HYPERVISOR_shared_info = (shared_info_t *)fix_to_virt(FIX_SHARED_INFO);
   28.56  
   28.57  	memset(empty_zero_page, 0, PAGE_SIZE);
   28.58 @@ -172,10 +160,25 @@ static int take_machine_down(void *p_fas
   28.59  
   28.60  	post_suspend(suspend_cancelled);
   28.61  	gnttab_resume();
   28.62 -	if (!suspend_cancelled)
   28.63 +	if (!suspend_cancelled) {
   28.64  		irq_resume();
   28.65 +#ifdef __x86_64__
   28.66 +		/*
   28.67 +		 * Older versions of Xen do not save/restore the user %cr3.
   28.68 +		 * We do it here just in case, but there's no need if we are
   28.69 +		 * in fast-suspend mode as that implies a new enough Xen.
   28.70 +		 */
   28.71 +		if (!fast_suspend) {
   28.72 +			struct mmuext_op op;
   28.73 +			op.cmd = MMUEXT_NEW_USER_BASEPTR;
   28.74 +			op.arg1.mfn = pfn_to_mfn(__pa(__user_pgd(
   28.75 +				current->active_mm->pgd)) >> PAGE_SHIFT);
   28.76 +			if (HYPERVISOR_mmuext_op(&op, 1, NULL, DOMID_SELF))
   28.77 +				BUG();
   28.78 +		}
   28.79 +#endif
   28.80 +	}
   28.81  	time_resume();
   28.82 -	switch_idle_mm();
   28.83  	local_irq_enable();
   28.84  
   28.85  	if (fast_suspend && !suspend_cancelled) {
   28.86 @@ -210,6 +213,10 @@ int __xen_suspend(int fast_suspend)
   28.87  	}
   28.88  #endif
   28.89  
   28.90 +	/* If we are definitely UP then 'slow mode' is actually faster. */
   28.91 +	if (num_possible_cpus() == 1)
   28.92 +		fast_suspend = 0;
   28.93 +
   28.94  	if (fast_suspend) {
   28.95  		xenbus_suspend();
   28.96  		err = stop_machine_run(take_machine_down, &fast_suspend, 0);

    29.1 --- a/linux-2.6-xen-sparse/drivers/xen/evtchn/evtchn.c	Mon Mar 05 12:49:12 2007 -0600
    29.2 +++ b/linux-2.6-xen-sparse/drivers/xen/evtchn/evtchn.c	Thu Mar 08 14:39:52 2007 -0600
    29.3 @@ -406,7 +406,7 @@ static int evtchn_release(struct inode *
    29.4  	return 0;
    29.5  }
    29.6  
    29.7 -static struct file_operations evtchn_fops = {
    29.8 +static const struct file_operations evtchn_fops = {
    29.9  	.owner   = THIS_MODULE,
   29.10  	.read    = evtchn_read,
   29.11  	.write   = evtchn_write,

    30.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/common.h	Mon Mar 05 12:49:12 2007 -0600
    30.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/common.h	Thu Mar 08 14:39:52 2007 -0600
    30.3 @@ -99,9 +99,21 @@ typedef struct netif_st {
    30.4  	struct net_device *dev;
    30.5  	struct net_device_stats stats;
    30.6  
    30.7 +	unsigned int carrier;
    30.8 +
    30.9  	wait_queue_head_t waiting_to_free;
   30.10  } netif_t;
   30.11  
   30.12 +/*
   30.13 + * Implement our own carrier flag: the network stack's version causes delays
   30.14 + * when the carrier is re-enabled (in particular, dev_activate() may not
   30.15 + * immediately be called, which can cause packet loss; also the etherbridge
   30.16 + * can be rather lazy in activating its port).
   30.17 + */
   30.18 +#define netback_carrier_on(netif)	((netif)->carrier = 1)
   30.19 +#define netback_carrier_off(netif)	((netif)->carrier = 0)
   30.20 +#define netback_carrier_ok(netif)	((netif)->carrier)
   30.21 +
   30.22  #define NET_TX_RING_SIZE __RING_SIZE((netif_tx_sring_t *)0, PAGE_SIZE)
   30.23  #define NET_RX_RING_SIZE __RING_SIZE((netif_rx_sring_t *)0, PAGE_SIZE)
   30.24  
   30.25 @@ -120,7 +132,8 @@ int netif_map(netif_t *netif, unsigned l
   30.26  
   30.27  void netif_xenbus_init(void);
   30.28  
   30.29 -#define netif_schedulable(dev) (netif_running(dev) && netif_carrier_ok(dev))
   30.30 +#define netif_schedulable(netif)				\
   30.31 +	(netif_running((netif)->dev) && netback_carrier_ok(netif))
   30.32  
   30.33  void netif_schedule_work(netif_t *netif);
   30.34  void netif_deschedule_work(netif_t *netif);

    31.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/interface.c	Mon Mar 05 12:49:12 2007 -0600
    31.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/interface.c	Thu Mar 08 14:39:52 2007 -0600
    31.3 @@ -66,16 +66,19 @@ static void __netif_down(netif_t *netif)
    31.4  static int net_open(struct net_device *dev)
    31.5  {
    31.6  	netif_t *netif = netdev_priv(dev);
    31.7 -	if (netif_carrier_ok(dev))
    31.8 +	if (netback_carrier_ok(netif)) {
    31.9  		__netif_up(netif);
   31.10 +		netif_start_queue(dev);
   31.11 +	}
   31.12  	return 0;
   31.13  }
   31.14  
   31.15  static int net_close(struct net_device *dev)
   31.16  {
   31.17  	netif_t *netif = netdev_priv(dev);
   31.18 -	if (netif_carrier_ok(dev))
   31.19 +	if (netback_carrier_ok(netif))
   31.20  		__netif_down(netif);
   31.21 +	netif_stop_queue(dev);
   31.22  	return 0;
   31.23  }
   31.24  
   31.25 @@ -138,8 +141,6 @@ netif_t *netif_alloc(domid_t domid, unsi
   31.26  		return ERR_PTR(-ENOMEM);
   31.27  	}
   31.28  
   31.29 -	netif_carrier_off(dev);
   31.30 -
   31.31  	netif = netdev_priv(dev);
   31.32  	memset(netif, 0, sizeof(*netif));
   31.33  	netif->domid  = domid;
   31.34 @@ -148,6 +149,8 @@ netif_t *netif_alloc(domid_t domid, unsi
   31.35  	init_waitqueue_head(&netif->waiting_to_free);
   31.36  	netif->dev = dev;
   31.37  
   31.38 +	netback_carrier_off(netif);
   31.39 +
   31.40  	netif->credit_bytes = netif->remaining_credit = ~0UL;
   31.41  	netif->credit_usec  = 0UL;
   31.42  	init_timer(&netif->credit_timeout);
   31.43 @@ -285,7 +288,7 @@ int netif_map(netif_t *netif, unsigned l
   31.44  	netif_get(netif);
   31.45  
   31.46  	rtnl_lock();
   31.47 -	netif_carrier_on(netif->dev);
   31.48 +	netback_carrier_on(netif);
   31.49  	if (netif_running(netif->dev))
   31.50  		__netif_up(netif);
   31.51  	rtnl_unlock();
   31.52 @@ -302,9 +305,10 @@ err_rx:
   31.53  
   31.54  void netif_disconnect(netif_t *netif)
   31.55  {
   31.56 -	if (netif_carrier_ok(netif->dev)) {
   31.57 +	if (netback_carrier_ok(netif)) {
   31.58  		rtnl_lock();
   31.59 -		netif_carrier_off(netif->dev);
   31.60 +		netback_carrier_off(netif);
   31.61 +		netif_carrier_off(netif->dev); /* discard queued packets */
   31.62  		if (netif_running(netif->dev))
   31.63  			__netif_down(netif);
   31.64  		rtnl_unlock();

    32.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/netback.c	Mon Mar 05 12:49:12 2007 -0600
    32.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/netback.c	Thu Mar 08 14:39:52 2007 -0600
    32.3 @@ -38,7 +38,10 @@
    32.4  #include <xen/balloon.h>
    32.5  #include <xen/interface/memory.h>
    32.6  
    32.7 -/*#define NETBE_DEBUG_INTERRUPT*/
    32.8 +/*define NETBE_DEBUG_INTERRUPT*/
    32.9 +
   32.10 +/* extra field used in struct page */
   32.11 +#define netif_page_index(pg) (*(long *)&(pg)->mapping)
   32.12  
   32.13  struct netbk_rx_meta {
   32.14  	skb_frag_t frag;
   32.15 @@ -231,7 +234,7 @@ static inline int netbk_queue_full(netif
   32.16  static void tx_queue_callback(unsigned long data)
   32.17  {
   32.18  	netif_t *netif = (netif_t *)data;
   32.19 -	if (netif_schedulable(netif->dev))
   32.20 +	if (netif_schedulable(netif))
   32.21  		netif_wake_queue(netif->dev);
   32.22  }
   32.23  
   32.24 @@ -242,7 +245,7 @@ int netif_be_start_xmit(struct sk_buff *
   32.25  	BUG_ON(skb->dev != dev);
   32.26  
   32.27  	/* Drop the packet if the target domain has no receive buffers. */
   32.28 -	if (unlikely(!netif_schedulable(dev) || netbk_queue_full(netif)))
   32.29 +	if (unlikely(!netif_schedulable(netif) || netbk_queue_full(netif)))
   32.30  		goto drop;
   32.31  
   32.32  	/*
   32.33 @@ -352,7 +355,7 @@ static u16 netbk_gop_frag(netif_t *netif
   32.34  		copy_gop->flags = GNTCOPY_dest_gref;
   32.35  		if (PageForeign(page)) {
   32.36  			struct pending_tx_info *src_pend =
   32.37 -				&pending_tx_info[page->index];
   32.38 +				&pending_tx_info[netif_page_index(page)];
   32.39  			copy_gop->source.domid = src_pend->netif->domid;
   32.40  			copy_gop->source.u.ref = src_pend->req.gref;
   32.41  			copy_gop->flags |= GNTCOPY_source_gref;
   32.42 @@ -681,7 +684,7 @@ static void net_rx_action(unsigned long 
   32.43  		}
   32.44  
   32.45  		if (netif_queue_stopped(netif->dev) &&
   32.46 -		    netif_schedulable(netif->dev) &&
   32.47 +		    netif_schedulable(netif) &&
   32.48  		    !netbk_queue_full(netif))
   32.49  			netif_wake_queue(netif->dev);
   32.50  
   32.51 @@ -739,7 +742,7 @@ static void add_to_net_schedule_list_tai
   32.52  
   32.53  	spin_lock_irq(&net_schedule_list_lock);
   32.54  	if (!__on_net_schedule_list(netif) &&
   32.55 -	    likely(netif_schedulable(netif->dev))) {
   32.56 +	    likely(netif_schedulable(netif))) {
   32.57  		list_add_tail(&netif->list, &net_schedule_list);
   32.58  		netif_get(netif);
   32.59  	}
   32.60 @@ -1327,7 +1330,7 @@ static void netif_page_release(struct pa
   32.61  	/* Ready for next use. */
   32.62  	init_page_count(page);
   32.63  
   32.64 -	netif_idx_release(page->index);
   32.65 +	netif_idx_release(netif_page_index(page));
   32.66  }
   32.67  
   32.68  irqreturn_t netif_be_int(int irq, void *dev_id, struct pt_regs *regs)
   32.69 @@ -1337,7 +1340,7 @@ irqreturn_t netif_be_int(int irq, void *
   32.70  	add_to_net_schedule_list_tail(netif);
   32.71  	maybe_schedule_tx_action();
   32.72  
   32.73 -	if (netif_schedulable(netif->dev) && !netbk_queue_full(netif))
   32.74 +	if (netif_schedulable(netif) && !netbk_queue_full(netif))
   32.75  		netif_wake_queue(netif->dev);
   32.76  
   32.77  	return IRQ_HANDLED;
   32.78 @@ -1457,7 +1460,7 @@ static int __init netback_init(void)
   32.79  	for (i = 0; i < MAX_PENDING_REQS; i++) {
   32.80  		page = mmap_pages[i];
   32.81  		SetPageForeign(page, netif_page_release);
   32.82 -		page->index = i;
   32.83 +		netif_page_index(page) = i;
   32.84  	}
   32.85  
   32.86  	pending_cons = 0;

    33.1 --- a/linux-2.6-xen-sparse/drivers/xen/netback/xenbus.c	Mon Mar 05 12:49:12 2007 -0600
    33.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netback/xenbus.c	Thu Mar 08 14:39:52 2007 -0600
    33.3 @@ -338,9 +338,7 @@ static void connect(struct backend_info 
    33.4  
    33.5  	xenbus_switch_state(dev, XenbusStateConnected);
    33.6  
    33.7 -	/* May not get a kick from the frontend, so start the tx_queue now. */
    33.8 -	if (!netbk_can_queue(be->netif->dev))
    33.9 -		netif_wake_queue(be->netif->dev);
   33.10 +	netif_wake_queue(be->netif->dev);
   33.11  }
   33.12  
   33.13  

    34.1 --- a/linux-2.6-xen-sparse/drivers/xen/netfront/netfront.c	Mon Mar 05 12:49:12 2007 -0600
    34.2 +++ b/linux-2.6-xen-sparse/drivers/xen/netfront/netfront.c	Thu Mar 08 14:39:52 2007 -0600
    34.3 @@ -154,6 +154,7 @@ struct netfront_info {
    34.4  
    34.5  	unsigned int irq;
    34.6  	unsigned int copying_receiver;
    34.7 +	unsigned int carrier;
    34.8  
    34.9  	/* Receive-ring batched refills. */
   34.10  #define RX_MIN_TARGET 8
   34.11 @@ -193,6 +194,15 @@ struct netfront_rx_info {
   34.12  };
   34.13  
   34.14  /*
   34.15 + * Implement our own carrier flag: the network stack's version causes delays
   34.16 + * when the carrier is re-enabled (in particular, dev_activate() may not
   34.17 + * immediately be called, which can cause packet loss).
   34.18 + */
   34.19 +#define netfront_carrier_on(netif)	((netif)->carrier = 1)
   34.20 +#define netfront_carrier_off(netif)	((netif)->carrier = 0)
   34.21 +#define netfront_carrier_ok(netif)	((netif)->carrier)
   34.22 +
   34.23 +/*
   34.24   * Access macros for acquiring freeing slots in tx_skbs[].
   34.25   */
   34.26  
   34.27 @@ -590,26 +600,6 @@ static int send_fake_arp(struct net_devi
   34.28  	return dev_queue_xmit(skb);
   34.29  }
   34.30  
   34.31 -static int network_open(struct net_device *dev)
   34.32 -{
   34.33 -	struct netfront_info *np = netdev_priv(dev);
   34.34 -
   34.35 -	memset(&np->stats, 0, sizeof(np->stats));
   34.36 -
   34.37 -	spin_lock(&np->rx_lock);
   34.38 -	if (netif_carrier_ok(dev)) {
   34.39 -		network_alloc_rx_buffers(dev);
   34.40 -		np->rx.sring->rsp_event = np->rx.rsp_cons + 1;
   34.41 -		if (RING_HAS_UNCONSUMED_RESPONSES(&np->rx))
   34.42 -			netif_rx_schedule(dev);
   34.43 -	}
   34.44 -	spin_unlock(&np->rx_lock);
   34.45 -
   34.46 -	netif_start_queue(dev);
   34.47 -
   34.48 -	return 0;
   34.49 -}
   34.50 -
   34.51  static inline int netfront_tx_slot_available(struct netfront_info *np)
   34.52  {
   34.53  	return ((np->tx.req_prod_pvt - np->tx.rsp_cons) <
   34.54 @@ -626,6 +616,26 @@ static inline void network_maybe_wake_tx
   34.55  		netif_wake_queue(dev);
   34.56  }
   34.57  
   34.58 +static int network_open(struct net_device *dev)
   34.59 +{
   34.60 +	struct netfront_info *np = netdev_priv(dev);
   34.61 +
   34.62 +	memset(&np->stats, 0, sizeof(np->stats));
   34.63 +
   34.64 +	spin_lock(&np->rx_lock);
   34.65 +	if (netfront_carrier_ok(np)) {
   34.66 +		network_alloc_rx_buffers(dev);
   34.67 +		np->rx.sring->rsp_event = np->rx.rsp_cons + 1;
   34.68 +		if (RING_HAS_UNCONSUMED_RESPONSES(&np->rx))
   34.69 +			netif_rx_schedule(dev);
   34.70 +	}
   34.71 +	spin_unlock(&np->rx_lock);
   34.72 +
   34.73 +	network_maybe_wake_tx(dev);
   34.74 +
   34.75 +	return 0;
   34.76 +}
   34.77 +
   34.78  static void network_tx_buf_gc(struct net_device *dev)
   34.79  {
   34.80  	RING_IDX cons, prod;
   34.81 @@ -633,7 +643,7 @@ static void network_tx_buf_gc(struct net
   34.82  	struct netfront_info *np = netdev_priv(dev);
   34.83  	struct sk_buff *skb;
   34.84  
   34.85 -	BUG_ON(!netif_carrier_ok(dev));
   34.86 +	BUG_ON(!netfront_carrier_ok(np));
   34.87  
   34.88  	do {
   34.89  		prod = np->tx.sring->rsp_prod;
   34.90 @@ -703,7 +713,7 @@ static void network_alloc_rx_buffers(str
   34.91  	int nr_flips;
   34.92  	netif_rx_request_t *req;
   34.93  
   34.94 -	if (unlikely(!netif_carrier_ok(dev)))
   34.95 +	if (unlikely(!netfront_carrier_ok(np)))
   34.96  		return;
   34.97  
   34.98  	/*
   34.99 @@ -934,7 +944,7 @@ static int network_start_xmit(struct sk_
  34.100  
  34.101  	spin_lock_irq(&np->tx_lock);
  34.102  
  34.103 -	if (unlikely(!netif_carrier_ok(dev) ||
  34.104 +	if (unlikely(!netfront_carrier_ok(np) ||
  34.105  		     (frags > 1 && !xennet_can_sg(dev)) ||
  34.106  		     netif_needs_gso(dev, skb))) {
  34.107  		spin_unlock_irq(&np->tx_lock);
  34.108 @@ -1024,7 +1034,7 @@ static irqreturn_t netif_int(int irq, vo
  34.109  
  34.110  	spin_lock_irqsave(&np->tx_lock, flags);
  34.111  
  34.112 -	if (likely(netif_carrier_ok(dev))) {
  34.113 +	if (likely(netfront_carrier_ok(np))) {
  34.114  		network_tx_buf_gc(dev);
  34.115  		/* Under tx_lock: protects access to rx shared-ring indexes. */
  34.116  		if (RING_HAS_UNCONSUMED_RESPONSES(&np->rx))
  34.117 @@ -1299,7 +1309,7 @@ static int netif_poll(struct net_device 
  34.118  
  34.119  	spin_lock(&np->rx_lock);
  34.120  
  34.121 -	if (unlikely(!netif_carrier_ok(dev))) {
  34.122 +	if (unlikely(!netfront_carrier_ok(np))) {
  34.123  		spin_unlock(&np->rx_lock);
  34.124  		return 0;
  34.125  	}
  34.126 @@ -1317,7 +1327,7 @@ static int netif_poll(struct net_device 
  34.127  	work_done = 0;
  34.128  	while ((i != rp) && (work_done < budget)) {
  34.129  		memcpy(rx, RING_GET_RESPONSE(&np->rx, i), sizeof(*rx));
  34.130 -		memset(extras, 0, sizeof(extras));
  34.131 +		memset(extras, 0, sizeof(rinfo.extras));
  34.132  
  34.133  		err = xennet_get_responses(np, &rinfo, rp, &tmpq,
  34.134  					   &pages_flipped);
  34.135 @@ -1744,7 +1754,7 @@ static int network_connect(struct net_de
  34.136  	 * domain a kick because we've probably just requeued some
  34.137  	 * packets.
  34.138  	 */
  34.139 -	netif_carrier_on(dev);
  34.140 +	netfront_carrier_on(np);
  34.141  	notify_remote_via_irq(np->irq);
  34.142  	network_tx_buf_gc(dev);
  34.143  	network_alloc_rx_buffers(dev);
  34.144 @@ -1989,7 +1999,7 @@ static struct net_device * __devinit cre
  34.145  
  34.146  	np->netdev = netdev;
  34.147  
  34.148 -	netif_carrier_off(netdev);
  34.149 +	netfront_carrier_off(np);
  34.150  
  34.151  	return netdev;
  34.152  
  34.153 @@ -2023,7 +2033,7 @@ static void netif_disconnect_backend(str
  34.154  	/* Stop old i/f to prevent errors whilst we rebuild the state. */
  34.155  	spin_lock_irq(&info->tx_lock);
  34.156  	spin_lock(&info->rx_lock);
  34.157 -	netif_carrier_off(info->netdev);
  34.158 +	netfront_carrier_off(info);
  34.159  	spin_unlock(&info->rx_lock);
  34.160  	spin_unlock_irq(&info->tx_lock);
  34.161  

    35.1 --- a/linux-2.6-xen-sparse/drivers/xen/pcifront/pci_op.c	Mon Mar 05 12:49:12 2007 -0600
    35.2 +++ b/linux-2.6-xen-sparse/drivers/xen/pcifront/pci_op.c	Thu Mar 08 14:39:52 2007 -0600
    35.3 @@ -239,17 +239,12 @@ static void free_root_bus_devs(struct pc
    35.4  {
    35.5  	struct pci_dev *dev;
    35.6  
    35.7 -	down_write(&pci_bus_sem);
    35.8  	while (!list_empty(&bus->devices)) {
    35.9 -		dev = container_of(bus->devices.next, struct pci_dev, bus_list);
   35.10 -		up_write(&pci_bus_sem);
   35.11 -
   35.12 +		dev = container_of(bus->devices.next, struct pci_dev,
   35.13 +				   bus_list);
   35.14  		dev_dbg(&dev->dev, "removing device\n");
   35.15  		pci_remove_bus_device(dev);
   35.16 -
   35.17 -		down_write(&pci_bus_sem);
   35.18  	}
   35.19 -	up_write(&pci_bus_sem);
   35.20  }
   35.21  
   35.22  void pcifront_free_roots(struct pcifront_device *pdev)

    36.1 --- a/linux-2.6-xen-sparse/drivers/xen/privcmd/privcmd.c	Mon Mar 05 12:49:12 2007 -0600
    36.2 +++ b/linux-2.6-xen-sparse/drivers/xen/privcmd/privcmd.c	Thu Mar 08 14:39:52 2007 -0600
    36.3 @@ -248,7 +248,7 @@ static int privcmd_enforce_singleshot_ma
    36.4  }
    36.5  #endif
    36.6  
    36.7 -static struct file_operations privcmd_file_ops = {
    36.8 +static const struct file_operations privcmd_file_ops = {
    36.9  	.ioctl = privcmd_ioctl,
   36.10  	.mmap  = privcmd_mmap,
   36.11  };

    37.1 --- a/linux-2.6-xen-sparse/drivers/xen/tpmback/tpmback.c	Mon Mar 05 12:49:12 2007 -0600
    37.2 +++ b/linux-2.6-xen-sparse/drivers/xen/tpmback/tpmback.c	Thu Mar 08 14:39:52 2007 -0600
    37.3 @@ -629,7 +629,7 @@ static unsigned int vtpm_op_poll(struct 
    37.4  	return flags;
    37.5  }
    37.6  
    37.7 -static struct file_operations vtpm_ops = {
    37.8 +static const struct file_operations vtpm_ops = {
    37.9  	.owner = THIS_MODULE,
   37.10  	.llseek = no_llseek,
   37.11  	.open = vtpm_op_open,

    38.1 --- a/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_dev.c	Mon Mar 05 12:49:12 2007 -0600
    38.2 +++ b/linux-2.6-xen-sparse/drivers/xen/xenbus/xenbus_dev.c	Thu Mar 08 14:39:52 2007 -0600
    38.3 @@ -173,17 +173,22 @@ static ssize_t xenbus_dev_write(struct f
    38.4  	void *reply;
    38.5  	char *path, *token;
    38.6  	struct watch_adapter *watch, *tmp_watch;
    38.7 -	int err;
    38.8 +	int err, rc = len;
    38.9  
   38.10 -	if ((len + u->len) > sizeof(u->u.buffer))
   38.11 -		return -EINVAL;
   38.12 +	if ((len + u->len) > sizeof(u->u.buffer)) {
   38.13 +		rc = -EINVAL;
   38.14 +		goto out;
   38.15 +	}
   38.16  
   38.17 -	if (copy_from_user(u->u.buffer + u->len, ubuf, len) != 0)
   38.18 -		return -EFAULT;
   38.19 +	if (copy_from_user(u->u.buffer + u->len, ubuf, len) != 0) {
   38.20 +		rc = -EFAULT;
   38.21 +		goto out;
   38.22 +	}
   38.23  
   38.24  	u->len += len;
   38.25 -	if (u->len < (sizeof(u->u.msg) + u->u.msg.len))
   38.26 -		return len;
   38.27 +	if ((u->len < sizeof(u->u.msg)) ||
   38.28 +	    (u->len < (sizeof(u->u.msg) + u->u.msg.len)))
   38.29 +		return rc;
   38.30  
   38.31  	msg_type = u->u.msg.type;
   38.32  
   38.33 @@ -201,14 +206,17 @@ static ssize_t xenbus_dev_write(struct f
   38.34  	case XS_SET_PERMS:
   38.35  		if (msg_type == XS_TRANSACTION_START) {
   38.36  			trans = kmalloc(sizeof(*trans), GFP_KERNEL);
   38.37 -			if (!trans)
   38.38 -				return -ENOMEM;
   38.39 +			if (!trans) {
   38.40 +				rc = -ENOMEM;
   38.41 +				goto out;
   38.42 +			}
   38.43  		}
   38.44  
   38.45  		reply = xenbus_dev_request_and_reply(&u->u.msg);
   38.46  		if (IS_ERR(reply)) {
   38.47  			kfree(trans);
   38.48 -			return PTR_ERR(reply);
   38.49 +			rc = PTR_ERR(reply);
   38.50 +			goto out;
   38.51  		}
   38.52  
   38.53  		if (msg_type == XS_TRANSACTION_START) {
   38.54 @@ -231,8 +239,10 @@ static ssize_t xenbus_dev_write(struct f
   38.55  	case XS_UNWATCH:
   38.56  		path = u->u.buffer + sizeof(u->u.msg);
   38.57  		token = memchr(path, 0, u->u.msg.len);
   38.58 -		if (token == NULL)
   38.59 -			return -EILSEQ;
   38.60 +		if (token == NULL) {
   38.61 +			rc = -EILSEQ;
   38.62 +			goto out;
   38.63 +		}
   38.64  		token++;
   38.65  
   38.66  		if (msg_type == XS_WATCH) {
   38.67 @@ -251,7 +261,8 @@ static ssize_t xenbus_dev_write(struct f
   38.68  			err = register_xenbus_watch(&watch->watch);
   38.69  			if (err) {
   38.70  				free_watch_adapter(watch);
   38.71 -				return err;
   38.72 +				rc = err;
   38.73 +				goto out;
   38.74  			}
   38.75  			
   38.76  			list_add(&watch->list, &u->watches);
   38.77 @@ -265,7 +276,6 @@ static ssize_t xenbus_dev_write(struct f
   38.78                                                   &u->watches, list) {
   38.79  				if (!strcmp(watch->token, token) &&
   38.80  				    !strcmp(watch->watch.node, path))
   38.81 -					break;
   38.82  				{
   38.83  					unregister_xenbus_watch(&watch->watch);
   38.84  					list_del(&watch->list);
   38.85 @@ -278,11 +288,13 @@ static ssize_t xenbus_dev_write(struct f
   38.86  		break;
   38.87  
   38.88  	default:
   38.89 -		return -EINVAL;
   38.90 +		rc = -EINVAL;
   38.91 +		break;
   38.92  	}
   38.93  
   38.94 + out:
   38.95  	u->len = 0;
   38.96 -	return len;
   38.97 +	return rc;
   38.98  }
   38.99  
  38.100  static int xenbus_dev_open(struct inode *inode, struct file *filp)
  38.101 @@ -342,7 +354,7 @@ static unsigned int xenbus_dev_poll(stru
  38.102  	return 0;
  38.103  }
  38.104  
  38.105 -static struct file_operations xenbus_dev_file_ops = {
  38.106 +static const struct file_operations xenbus_dev_file_ops = {
  38.107  	.read = xenbus_dev_read,
  38.108  	.write = xenbus_dev_write,
  38.109  	.open = xenbus_dev_open,

    39.1 --- a/linux-2.6-xen-sparse/include/asm-i386/mach-xen/asm/page.h	Mon Mar 05 12:49:12 2007 -0600
    39.2 +++ b/linux-2.6-xen-sparse/include/asm-i386/mach-xen/asm/page.h	Thu Mar 08 14:39:52 2007 -0600
    39.3 @@ -20,6 +20,14 @@
    39.4  #define LARGE_PAGE_SIZE (1UL << PMD_SHIFT)
    39.5  
    39.6  #ifdef __KERNEL__
    39.7 +
    39.8 +/*
    39.9 + * Need to repeat this here in order to not include pgtable.h (which in turn
   39.10 + * depends on definitions made here), but to be able to use the symbolic
   39.11 + * below. The preprocessor will warn if the two definitions aren't identical.
   39.12 + */
   39.13 +#define _PAGE_PRESENT	0x001
   39.14 +
   39.15  #ifndef __ASSEMBLY__
   39.16  
   39.17  #include <linux/string.h>
   39.18 @@ -29,13 +37,6 @@
   39.19  #include <xen/interface/xen.h>
   39.20  #include <xen/features.h>
   39.21  
   39.22 -/*
   39.23 - * Need to repeat this here in order to not include pgtable.h (which in turn
   39.24 - * depends on definitions made here), but to be able to use the symbolic
   39.25 - * below. The preprocessor will warn if the two definitions aren't identical.
   39.26 - */
   39.27 -#define _PAGE_PRESENT	0x001
   39.28 -
   39.29  #define arch_free_page(_page,_order)		\
   39.30  ({	int foreign = PageForeign(_page);	\
   39.31  	if (foreign)				\
   39.32 @@ -225,8 +226,6 @@ extern int page_is_ram(unsigned long pag
   39.33  	((current->personality & READ_IMPLIES_EXEC) ? VM_EXEC : 0 ) | \
   39.34  		 VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
   39.35  
   39.36 -#define __HAVE_ARCH_GATE_AREA 1
   39.37 -
   39.38  #include <asm-generic/memory_model.h>
   39.39  #include <asm-generic/page.h>
   39.40  

    40.1 --- a/linux-2.6-xen-sparse/include/asm-i386/mach-xen/asm/system.h	Mon Mar 05 12:49:12 2007 -0600
    40.2 +++ b/linux-2.6-xen-sparse/include/asm-i386/mach-xen/asm/system.h	Thu Mar 08 14:39:52 2007 -0600
    40.3 @@ -137,7 +137,7 @@ extern struct task_struct * FASTCALL(__s
    40.4  })
    40.5  
    40.6  #define write_cr4(x) \
    40.7 -	__asm__ __volatile__("movl %0,%%cr4": :"r" (x));
    40.8 +	__asm__ __volatile__("movl %0,%%cr4": :"r" (x))
    40.9  
   40.10  /*
   40.11   * Clear and set 'TS' bit respectively

    41.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/fixmap.h	Mon Mar 05 12:49:12 2007 -0600
    41.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/fixmap.h	Thu Mar 08 14:39:52 2007 -0600
    41.3 @@ -53,6 +53,11 @@ enum fixed_addresses {
    41.4  #define NR_FIX_ISAMAPS	256
    41.5  	FIX_ISAMAP_END,
    41.6  	FIX_ISAMAP_BEGIN = FIX_ISAMAP_END + NR_FIX_ISAMAPS - 1,
    41.7 +	__end_of_permanent_fixed_addresses,
    41.8 +	/* temporary boot-time mappings, used before ioremap() is functional */
    41.9 +#define NR_FIX_BTMAPS	16
   41.10 +	FIX_BTMAP_END = __end_of_permanent_fixed_addresses,
   41.11 +	FIX_BTMAP_BEGIN = FIX_BTMAP_END + NR_FIX_BTMAPS - 1,
   41.12  	__end_of_fixed_addresses
   41.13  };
   41.14  

    42.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/io.h	Mon Mar 05 12:49:12 2007 -0600
    42.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/io.h	Thu Mar 08 14:39:52 2007 -0600
    42.3 @@ -150,8 +150,10 @@ static inline void __iomem * ioremap (un
    42.4  	return __ioremap(offset, size, 0);
    42.5  }
    42.6  
    42.7 -extern void *early_ioremap(unsigned long addr, unsigned long size);
    42.8 -extern void early_iounmap(void *addr, unsigned long size);
    42.9 +extern void *bt_ioremap(unsigned long addr, unsigned long size);
   42.10 +extern void bt_iounmap(void *addr, unsigned long size);
   42.11 +#define early_ioremap bt_ioremap
   42.12 +#define early_iounmap bt_iounmap
   42.13  
   42.14  /*
   42.15   * This one maps high address device memory and turns off caching for that area.

    43.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/pgtable.h	Mon Mar 05 12:49:12 2007 -0600
    43.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/pgtable.h	Thu Mar 08 14:39:52 2007 -0600
    43.3 @@ -403,19 +403,6 @@ static inline int pmd_large(pmd_t pte) {
    43.4  /* to find an entry in a page-table-directory. */
    43.5  #define pud_index(address) (((address) >> PUD_SHIFT) & (PTRS_PER_PUD-1))
    43.6  #define pud_offset(pgd, address) ((pud_t *) pgd_page(*(pgd)) + pud_index(address))
    43.7 -static inline pud_t *__pud_offset_k(pud_t *pud, unsigned long address)
    43.8 -{ 
    43.9 -	return pud + pud_index(address);
   43.10 -} 
   43.11 -
   43.12 -/* Find correct pud via the hidden fourth level page level: */
   43.13 -
   43.14 -/* This accesses the reference page table of the boot cpu. 
   43.15 -   Other CPUs get synced lazily via the page fault handler. */
   43.16 -static inline pud_t *pud_offset_k(pgd_t *pgd, unsigned long address)
   43.17 -{
   43.18 -	return pud_offset(pgd_offset_k(address), address);
   43.19 -}
   43.20  
   43.21  /* PMD  - Level 2 access */
   43.22  #define pmd_page_kernel(pmd) ((unsigned long) __va(pmd_val(pmd) & PTE_MASK))

    44.1 --- a/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/processor.h	Mon Mar 05 12:49:12 2007 -0600
    44.2 +++ b/linux-2.6-xen-sparse/include/asm-x86_64/mach-xen/asm/processor.h	Thu Mar 08 14:39:52 2007 -0600
    44.3 @@ -246,11 +246,13 @@ DECLARE_PER_CPU(struct tss_struct,init_t
    44.4  
    44.5  
    44.6  extern struct cpuinfo_x86 boot_cpu_data;
    44.7 +#ifndef CONFIG_X86_NO_TSS
    44.8  /* Save the original ist values for checking stack pointers during debugging */
    44.9  struct orig_ist {
   44.10  	unsigned long ist[7];
   44.11  };
   44.12  DECLARE_PER_CPU(struct orig_ist, orig_ist);
   44.13 +#endif
   44.14  
   44.15  #ifdef CONFIG_X86_VSMP
   44.16  #define ARCH_MIN_TASKALIGN	(1 << INTERNODE_CACHE_SHIFT)

    45.1 --- a/linux-2.6-xen-sparse/include/linux/page-flags.h	Mon Mar 05 12:49:12 2007 -0600
    45.2 +++ b/linux-2.6-xen-sparse/include/linux/page-flags.h	Thu Mar 08 14:39:52 2007 -0600
    45.3 @@ -252,14 +252,14 @@
    45.4  #define PageForeign(page)	test_bit(PG_foreign, &(page)->flags)
    45.5  #define SetPageForeign(page, dtor) do {		\
    45.6  	set_bit(PG_foreign, &(page)->flags);	\
    45.7 -	(page)->mapping = (void *)dtor;		\
    45.8 +	(page)->index = (long)(dtor);		\
    45.9  } while (0)
   45.10  #define ClearPageForeign(page) do {		\
   45.11  	clear_bit(PG_foreign, &(page)->flags);	\
   45.12 -	(page)->mapping = NULL;			\
   45.13 +	(page)->index = 0;			\
   45.14  } while (0)
   45.15  #define PageForeignDestructor(page)		\
   45.16 -	( (void (*) (struct page *)) (page)->mapping )(page)
   45.17 +	( (void (*) (struct page *)) (page)->index )(page)
   45.18  
   45.19  struct page;	/* forward declaration */
   45.20  

    46.1 --- a/linux-2.6-xen-sparse/include/xen/cpu_hotplug.h	Mon Mar 05 12:49:12 2007 -0600
    46.2 +++ b/linux-2.6-xen-sparse/include/xen/cpu_hotplug.h	Thu Mar 08 14:39:52 2007 -0600
    46.3 @@ -4,7 +4,7 @@
    46.4  #include <linux/kernel.h>
    46.5  #include <linux/cpumask.h>
    46.6  
    46.7 -#if defined(CONFIG_X86)
    46.8 +#if defined(CONFIG_X86) && defined(CONFIG_SMP)
    46.9  extern cpumask_t cpu_initialized_map;
   46.10  #define cpu_set_initialized(cpu) cpu_set(cpu, cpu_initialized_map)
   46.11  #else

    47.1 --- a/linux-2.6-xen-sparse/mm/Kconfig	Mon Mar 05 12:49:12 2007 -0600
    47.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    47.3 @@ -1,157 +0,0 @@
    47.4 -config SELECT_MEMORY_MODEL
    47.5 -	def_bool y
    47.6 -	depends on EXPERIMENTAL || ARCH_SELECT_MEMORY_MODEL
    47.7 -
    47.8 -choice
    47.9 -	prompt "Memory model"
   47.10 -	depends on SELECT_MEMORY_MODEL
   47.11 -	default DISCONTIGMEM_MANUAL if ARCH_DISCONTIGMEM_DEFAULT
   47.12 -	default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
   47.13 -	default FLATMEM_MANUAL
   47.14 -
   47.15 -config FLATMEM_MANUAL
   47.16 -	bool "Flat Memory"
   47.17 -	depends on !(ARCH_DISCONTIGMEM_ENABLE || ARCH_SPARSEMEM_ENABLE) || ARCH_FLATMEM_ENABLE
   47.18 -	help
   47.19 -	  This option allows you to change some of the ways that
   47.20 -	  Linux manages its memory internally.  Most users will
   47.21 -	  only have one option here: FLATMEM.  This is normal
   47.22 -	  and a correct option.
   47.23 -
   47.24 -	  Some users of more advanced features like NUMA and
   47.25 -	  memory hotplug may have different options here.
   47.26 -	  DISCONTIGMEM is an more mature, better tested system,
   47.27 -	  but is incompatible with memory hotplug and may suffer
   47.28 -	  decreased performance over SPARSEMEM.  If unsure between
   47.29 -	  "Sparse Memory" and "Discontiguous Memory", choose
   47.30 -	  "Discontiguous Memory".
   47.31 -
   47.32 -	  If unsure, choose this option (Flat Memory) over any other.
   47.33 -
   47.34 -config DISCONTIGMEM_MANUAL
   47.35 -	bool "Discontiguous Memory"
   47.36 -	depends on ARCH_DISCONTIGMEM_ENABLE
   47.37 -	help
   47.38 -	  This option provides enhanced support for discontiguous
   47.39 -	  memory systems, over FLATMEM.  These systems have holes
   47.40 -	  in their physical address spaces, and this option provides
   47.41 -	  more efficient handling of these holes.  However, the vast
   47.42 -	  majority of hardware has quite flat address spaces, and
   47.43 -	  can have degraded performance from extra overhead that
   47.44 -	  this option imposes.
   47.45 -
   47.46 -	  Many NUMA configurations will have this as the only option.
   47.47 -
   47.48 -	  If unsure, choose "Flat Memory" over this option.
   47.49 -
   47.50 -config SPARSEMEM_MANUAL
   47.51 -	bool "Sparse Memory"
   47.52 -	depends on ARCH_SPARSEMEM_ENABLE
   47.53 -	help
   47.54 -	  This will be the only option for some systems, including
   47.55 -	  memory hotplug systems.  This is normal.
   47.56 -
   47.57 -	  For many other systems, this will be an alternative to
   47.58 -	  "Discontiguous Memory".  This option provides some potential
   47.59 -	  performance benefits, along with decreased code complexity,
   47.60 -	  but it is newer, and more experimental.
   47.61 -
   47.62 -	  If unsure, choose "Discontiguous Memory" or "Flat Memory"
   47.63 -	  over this option.
   47.64 -
   47.65 -endchoice
   47.66 -
   47.67 -config DISCONTIGMEM
   47.68 -	def_bool y
   47.69 -	depends on (!SELECT_MEMORY_MODEL && ARCH_DISCONTIGMEM_ENABLE) || DISCONTIGMEM_MANUAL
   47.70 -
   47.71 -config SPARSEMEM
   47.72 -	def_bool y
   47.73 -	depends on SPARSEMEM_MANUAL
   47.74 -
   47.75 -config FLATMEM
   47.76 -	def_bool y
   47.77 -	depends on (!DISCONTIGMEM && !SPARSEMEM) || FLATMEM_MANUAL
   47.78 -
   47.79 -config FLAT_NODE_MEM_MAP
   47.80 -	def_bool y
   47.81 -	depends on !SPARSEMEM
   47.82 -
   47.83 -#
   47.84 -# Both the NUMA code and DISCONTIGMEM use arrays of pg_data_t's
   47.85 -# to represent different areas of memory.  This variable allows
   47.86 -# those dependencies to exist individually.
   47.87 -#
   47.88 -config NEED_MULTIPLE_NODES
   47.89 -	def_bool y
   47.90 -	depends on DISCONTIGMEM || NUMA
   47.91 -
   47.92 -config HAVE_MEMORY_PRESENT
   47.93 -	def_bool y
   47.94 -	depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM
   47.95 -
   47.96 -#
   47.97 -# SPARSEMEM_EXTREME (which is the default) does some bootmem
   47.98 -# allocations when memory_present() is called.  If this can not
   47.99 -# be done on your architecture, select this option.  However,
  47.100 -# statically allocating the mem_section[] array can potentially
  47.101 -# consume vast quantities of .bss, so be careful.
  47.102 -#
  47.103 -# This option will also potentially produce smaller runtime code
  47.104 -# with gcc 3.4 and later.
  47.105 -#
  47.106 -config SPARSEMEM_STATIC
  47.107 -	def_bool n
  47.108 -
  47.109 -#
  47.110 -# Architectecture platforms which require a two level mem_section in SPARSEMEM
  47.111 -# must select this option. This is usually for architecture platforms with
  47.112 -# an extremely sparse physical address space.
  47.113 -#
  47.114 -config SPARSEMEM_EXTREME
  47.115 -	def_bool y
  47.116 -	depends on SPARSEMEM && !SPARSEMEM_STATIC
  47.117 -
  47.118 -# eventually, we can have this option just 'select SPARSEMEM'
  47.119 -config MEMORY_HOTPLUG
  47.120 -	bool "Allow for memory hot-add"
  47.121 -	depends on SPARSEMEM && HOTPLUG && !SOFTWARE_SUSPEND && ARCH_ENABLE_MEMORY_HOTPLUG
  47.122 -	depends on (IA64 || X86 || PPC64)
  47.123 -
  47.124 -comment "Memory hotplug is currently incompatible with Software Suspend"
  47.125 -	depends on SPARSEMEM && HOTPLUG && SOFTWARE_SUSPEND
  47.126 -
  47.127 -# Heavily threaded applications may benefit from splitting the mm-wide
  47.128 -# page_table_lock, so that faults on different parts of the user address
  47.129 -# space can be handled with less contention: split it at this NR_CPUS.
  47.130 -# Default to 4 for wider testing, though 8 might be more appropriate.
  47.131 -# ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock.
  47.132 -# PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes.
  47.133 -# XEN on x86 architecture uses the mapping field on pagetable pages to store a
  47.134 -# pointer to the destructor. This conflicts with pte_lock_deinit().
  47.135 -#
  47.136 -config SPLIT_PTLOCK_CPUS
  47.137 -	int
  47.138 -	default "4096" if ARM && !CPU_CACHE_VIPT
  47.139 -	default "4096" if PARISC && !PA20
  47.140 -	default "4096" if X86_XEN || X86_64_XEN
  47.141 -	default "4"
  47.142 -
  47.143 -#
  47.144 -# support for page migration
  47.145 -#
  47.146 -config MIGRATION
  47.147 -	bool "Page migration"
  47.148 -	def_bool y
  47.149 -	depends on NUMA
  47.150 -	help
  47.151 -	  Allows the migration of the physical location of pages of processes
  47.152 -	  while the virtual addresses are not changed. This is useful for
  47.153 -	  example on NUMA systems to put pages nearer to the processors accessing
  47.154 -	  the page.
  47.155 -
  47.156 -config RESOURCES_64BIT
  47.157 -	bool "64 bit Memory and IO resources (EXPERIMENTAL)" if (!64BIT && EXPERIMENTAL)
  47.158 -	default 64BIT
  47.159 -	help
  47.160 -	  This option allows memory and IO resources to be 64 bit.

    48.1 --- a/patches/linux-2.6.18/blktap-aio-16_03_06.patch	Mon Mar 05 12:49:12 2007 -0600
    48.2 +++ b/patches/linux-2.6.18/blktap-aio-16_03_06.patch	Thu Mar 08 14:39:52 2007 -0600
    48.3 @@ -106,7 +106,7 @@ diff -pruN ../orig-linux-2.6.18/fs/aio.c
    48.4  +	return pollflags;
    48.5  +}
    48.6  +
    48.7 -+static struct file_operations aioq_fops = {
    48.8 ++static const struct file_operations aioq_fops = {
    48.9  +	.release	= aio_queue_fd_close,
   48.10  +	.poll		= aio_queue_fd_poll
   48.11  +};
   48.12 @@ -201,7 +201,7 @@ diff -pruN ../orig-linux-2.6.18/fs/event
   48.13   		   int maxevents, long timeout);
   48.14   static int eventpollfs_delete_dentry(struct dentry *dentry);
   48.15  -static struct inode *ep_eventpoll_inode(void);
   48.16 -+static struct inode *ep_eventpoll_inode(struct file_operations *fops);
   48.17 ++static struct inode *ep_eventpoll_inode(const struct file_operations *fops);
   48.18   static int eventpollfs_get_sb(struct file_system_type *fs_type,
   48.19   			      int flags, const char *dev_name,
   48.20   			      void *data, struct vfsmount *mnt);
   48.21 @@ -221,7 +221,7 @@ diff -pruN ../orig-linux-2.6.18/fs/event
   48.22  -static int ep_getfd(int *efd, struct inode **einode, struct file **efile,
   48.23  -		    struct eventpoll *ep)
   48.24  +int ep_getfd(int *efd, struct inode **einode, struct file **efile,
   48.25 -+		    struct eventpoll *ep, struct file_operations *fops)
   48.26 ++		    struct eventpoll *ep, const struct file_operations *fops)
   48.27   {
   48.28   	struct qstr this;
   48.29   	char name[32];
   48.30 @@ -248,7 +248,7 @@ diff -pruN ../orig-linux-2.6.18/fs/event
   48.31   
   48.32   
   48.33  -static struct inode *ep_eventpoll_inode(void)
   48.34 -+static struct inode *ep_eventpoll_inode(struct file_operations *fops)
   48.35 ++static struct inode *ep_eventpoll_inode(const struct file_operations *fops)
   48.36   {
   48.37   	int error = -ENOMEM;
   48.38   	struct inode *inode = new_inode(eventpoll_mnt->mnt_sb);
   48.39 @@ -288,7 +288,7 @@ diff -pruN ../orig-linux-2.6.18/include/
   48.40  + */
   48.41  +struct eventpoll;
   48.42  +int ep_getfd(int *efd, struct inode **einode, struct file **efile,
   48.43 -+             struct eventpoll *ep, struct file_operations *fops);
   48.44 ++             struct eventpoll *ep, const struct file_operations *fops);
   48.45   #else
   48.46   
   48.47   static inline void eventpoll_init_file(struct file *file) {}

    49.1 --- a/tools/Makefile	Mon Mar 05 12:49:12 2007 -0600
    49.2 +++ b/tools/Makefile	Thu Mar 08 14:39:52 2007 -0600
    49.3 @@ -24,9 +24,8 @@ SUBDIRS-$(LIBXENAPI_BINDINGS) += libxen
    49.4  
    49.5  # These don't cross-compile
    49.6  ifeq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH))
    49.7 -SUBDIRS-y += python
    49.8 -SUBDIRS-y += pygrub
    49.9 -SUBDIRS-y += ptsname
   49.10 +SUBDIRS-$(PYTHON_TOOLS) += python
   49.11 +SUBDIRS-$(PYTHON_TOOLS) += pygrub
   49.12  endif
   49.13  
   49.14  .PHONY: all
   49.15 @@ -42,8 +41,8 @@ install: check
   49.16  		$(MAKE) -C $$subdir $@; \
   49.17  	done
   49.18  	$(MAKE) ioemuinstall
   49.19 -	$(INSTALL_DIR) -p $(DESTDIR)/var/xen/dump
   49.20 -	$(INSTALL_DIR) -p $(DESTDIR)/var/log/xen
   49.21 +	$(INSTALL_DIR) $(DESTDIR)/var/xen/dump
   49.22 +	$(INSTALL_DIR) $(DESTDIR)/var/log/xen
   49.23  
   49.24  .PHONY: clean
   49.25  clean: check_clean

    50.1 --- a/tools/blktap/lib/Makefile	Mon Mar 05 12:49:12 2007 -0600
    50.2 +++ b/tools/blktap/lib/Makefile	Thu Mar 08 14:39:52 2007 -0600
    50.3 @@ -40,8 +40,8 @@ build: libblktap.a
    50.4  libblktap: libblktap.a
    50.5  
    50.6  install: all
    50.7 -	$(INSTALL_DIR) -p $(DESTDIR)/usr/$(LIBDIR)
    50.8 -	$(INSTALL_DIR) -p $(DESTDIR)/usr/include
    50.9 +	$(INSTALL_DIR) $(DESTDIR)/usr/$(LIBDIR)
   50.10 +	$(INSTALL_DIR) $(DESTDIR)/usr/include
   50.11  	$(INSTALL_PROG) $(LIB) $(DESTDIR)/usr/$(LIBDIR)
   50.12  	ln -sf libblktap.so.$(MAJOR).$(MINOR) $(DESTDIR)/usr/$(LIBDIR)/libblktap.so.$(MAJOR)
   50.13  	ln -sf libblktap.so.$(MAJOR) $(DESTDIR)/usr/$(LIBDIR)/libblktap.so

    51.1 --- a/tools/console/Makefile	Mon Mar 05 12:49:12 2007 -0600
    51.2 +++ b/tools/console/Makefile	Thu Mar 08 14:39:52 2007 -0600
    51.3 @@ -30,7 +30,7 @@ xenconsole: $(patsubst %.c,%.o,$(wildcar
    51.4  
    51.5  .PHONY: install
    51.6  install: $(BIN)
    51.7 -	$(INSTALL_DIR) -p $(DESTDIR)/$(DAEMON_INSTALL_DIR)
    51.8 +	$(INSTALL_DIR) $(DESTDIR)/$(DAEMON_INSTALL_DIR)
    51.9  	$(INSTALL_PROG) xenconsoled $(DESTDIR)/$(DAEMON_INSTALL_DIR)
   51.10 -	$(INSTALL_DIR) -p $(DESTDIR)/$(CLIENT_INSTALL_DIR)
   51.11 +	$(INSTALL_DIR) $(DESTDIR)/$(CLIENT_INSTALL_DIR)
   51.12  	$(INSTALL_PROG) xenconsole $(DESTDIR)/$(CLIENT_INSTALL_DIR)

    52.1 --- a/tools/firmware/rombios/rombios.c	Mon Mar 05 12:49:12 2007 -0600
    52.2 +++ b/tools/firmware/rombios/rombios.c	Thu Mar 08 14:39:52 2007 -0600
    52.3 @@ -890,7 +890,7 @@ static void           int14_function();
    52.4  static void           int15_function();
    52.5  static void           int16_function();
    52.6  static void           int17_function();
    52.7 -static void           int19_function();
    52.8 +static void           int18_function();
    52.9  static void           int1a_function();
   52.10  static void           int70_function();
   52.11  static void           int74_function();
   52.12 @@ -1837,6 +1837,38 @@ keyboard_panic(status)
   52.13  }
   52.14  
   52.15  //--------------------------------------------------------------------------
   52.16 +// machine_reset
   52.17 +//--------------------------------------------------------------------------
   52.18 +  void
   52.19 +machine_reset()
   52.20 +{
   52.21 +  /* Frob the keyboard reset line to reset the processor */
   52.22 +  outb(0x64, 0x60); /* Map the flags register at data port (0x60) */
   52.23 +  outb(0x60, 0x14); /* Set the flags to system|disable */
   52.24 +  outb(0x64, 0xfe); /* Pulse output 0 (system reset) low */
   52.25 +  BX_PANIC("Couldn't reset the machine\n");
   52.26 +}
   52.27 +
   52.28 +//--------------------------------------------------------------------------
   52.29 +// clobber_entry_point
   52.30 +//    Because PV drivers in HVM guests detach some of the emulated devices, 
   52.31 +//    it is not safe to do a soft reboot by just dropping to real mode and
   52.32 +//    jumping at ffff:0000. -- the boot drives might have disappeared!
   52.33 +//    This rather foul function overwrites(!) the BIOS entry point 
   52.34 +//    to point at machine-reset, which will cause the Xen tools to
   52.35 +//    rebuild the whole machine from scratch.
   52.36 +//--------------------------------------------------------------------------
   52.37 +  void 
   52.38 +clobber_entry_point() 
   52.39 +{
   52.40 +    /* The instruction at the entry point is one byte (0xea) for the
   52.41 +     * jump opcode, then two bytes of address, then two of segment. 
   52.42 +     * Overwrite the address bytes.*/
   52.43 +    write_word(0xffff, 0x0001, machine_reset); 
   52.44 +}
   52.45 +
   52.46 +
   52.47 +//--------------------------------------------------------------------------
   52.48  // shutdown_status_panic
   52.49  //   called when the shutdown statsu is not implemented, displays the status
   52.50  //--------------------------------------------------------------------------
   52.51 @@ -7626,7 +7658,7 @@ int17_function(regs, ds, iret_addr)
   52.52  }
   52.53  
   52.54  void
   52.55 -int19_function(seq_nr)
   52.56 +int18_function(seq_nr)
   52.57  Bit16u seq_nr;
   52.58  {
   52.59    Bit16u ebda_seg=read_word(0x0040,0x000E);
   52.60 @@ -7702,8 +7734,8 @@ ASM_START
   52.61      push cx
   52.62      push dx
   52.63  
   52.64 -    mov  dl, _int19_function.bootdrv + 2[bp]
   52.65 -    mov  ax, _int19_function.bootseg + 2[bp]
   52.66 +    mov  dl, _int18_function.bootdrv + 2[bp]
   52.67 +    mov  ax, _int18_function.bootseg + 2[bp]
   52.68      mov  es, ax         ;; segment
   52.69      mov  bx, #0x0000    ;; offset
   52.70      mov  ah, #0x02      ;; function 2, read diskette sector
   52.71 @@ -7714,7 +7746,7 @@ ASM_START
   52.72      int  #0x13          ;; read sector
   52.73      jnc  int19_load_done
   52.74      mov  ax, #0x0001
   52.75 -    mov  _int19_function.status + 2[bp], ax
   52.76 +    mov  _int18_function.status + 2[bp], ax
   52.77  
   52.78  int19_load_done:
   52.79      pop  dx
   52.80 @@ -7789,13 +7821,13 @@ ASM_START
   52.81      ;; Build an iret stack frame that will take us to the boot vector.
   52.82      ;; iret pops ip, then cs, then flags, so push them in the opposite order.
   52.83      pushf
   52.84 -    mov  ax, _int19_function.bootseg + 0[bp] 
   52.85 +    mov  ax, _int18_function.bootseg + 0[bp] 
   52.86      push ax
   52.87 -    mov  ax, _int19_function.bootip + 0[bp] 
   52.88 +    mov  ax, _int18_function.bootip + 0[bp] 
   52.89      push ax
   52.90      ;; Set the magic number in ax and the boot drive in dl.
   52.91      mov  ax, #0xaa55
   52.92 -    mov  dl, _int19_function.bootdrv + 0[bp]
   52.93 +    mov  dl, _int18_function.bootdrv + 0[bp]
   52.94      ;; Zero some of the other registers.
   52.95      xor  bx, bx
   52.96      mov  ds, bx
   52.97 @@ -8272,6 +8304,8 @@ int18_handler: ;; Boot Failure recovery:
   52.98    mov  ss, ax
   52.99  
  52.100    ;; Get the boot sequence number out of the IPL memory
  52.101 +  ;; The first time we do this it will have been set to -1 so 
  52.102 +  ;; we will start from device 0.
  52.103    mov  bx, #IPL_SEG 
  52.104    mov  ds, bx                     ;; Set segment
  52.105    mov  bx, IPL_SEQUENCE_OFFSET    ;; BX is now the sequence number
  52.106 @@ -8279,43 +8313,33 @@ int18_handler: ;; Boot Failure recovery:
  52.107    mov  IPL_SEQUENCE_OFFSET, bx    ;; Write it back
  52.108    mov  ds, ax                     ;; and reset the segment to zero. 
  52.109  
  52.110 -  ;; Carry on in the INT 19h handler, using the new sequence number
  52.111 +  ;; Call the C code for the next boot device
  52.112    push bx
  52.113 -
  52.114 -  jmp  int19_next_boot
  52.115 +  call _int18_function
  52.116 +
  52.117 +  ;; Boot failed: invoke the boot recovery function...
  52.118 +  int  #0x18
  52.119  
  52.120  ;----------
  52.121  ;- INT19h -
  52.122  ;----------
  52.123  int19_relocated: ;; Boot function, relocated
  52.124 -
  52.125 -  ;; int19 was beginning to be really complex, so now it
  52.126 -  ;; just calls a C function that does the work
  52.127 -
  52.128 -  push bp
  52.129 -  mov  bp, sp
  52.130 -  
  52.131 -  ;; Reset SS and SP
  52.132 +  ;;
  52.133 +  ;; *** Warning: INT 19h resets the whole machine *** 
  52.134 +  ;;
  52.135 +  ;; Because PV drivers in HVM guests detach some of the emulated devices, 
  52.136 +  ;; it is not safe to do a soft reboot by just dropping to real mode and
  52.137 +  ;; invoking INT 19h -- the boot drives might have disappeared!
  52.138 +  ;; If the user asks for a soft reboot, the only thing we can do is 
  52.139 +  ;; reset the whole machine.  When it comes back up, the normal BIOS 
  52.140 +  ;; boot sequence will start, which is more or less the required behaviour.
  52.141 +  ;; 
  52.142 +  ;; Reset SP and SS
  52.143    mov  ax, #0xfffe
  52.144    mov  sp, ax
  52.145    xor  ax, ax
  52.146    mov  ss, ax
  52.147 -
  52.148 -  ;; Start from the first boot device (0, in AX)
  52.149 -  mov  bx, #IPL_SEG 
  52.150 -  mov  ds, bx                     ;; Set segment to write to the IPL memory
  52.151 -  mov  IPL_SEQUENCE_OFFSET, ax    ;; Save the sequence number 
  52.152 -  mov  ds, ax                     ;; and reset the segment.
  52.153 -
  52.154 -  push ax
  52.155 -
  52.156 -int19_next_boot:
  52.157 -
  52.158 -  ;; Call the C code for the next boot device
  52.159 -  call _int19_function
  52.160 -
  52.161 -  ;; Boot failed: invoke the boot recovery function
  52.162 -  int  #0x18
  52.163 +  call _machine_reset
  52.164  
  52.165  ;----------
  52.166  ;- INT1Ch -
  52.167 @@ -9609,6 +9633,8 @@ normal_post:
  52.168  
  52.169    call _log_bios_start
  52.170  
  52.171 +  call _clobber_entry_point
  52.172 +
  52.173    ;; set all interrupts to default handler
  52.174    mov  bx, #0x0000    ;; offset index
  52.175    mov  cx, #0x0100    ;; counter (256 interrupts)
  52.176 @@ -9857,8 +9883,10 @@ post_default_ints:
  52.177    call _tcpa_calling_int19h          /* specs: 8.2.3 step 1 */
  52.178    call _tcpa_add_event_separators    /* specs: 8.2.3 step 2 */
  52.179  #endif
  52.180 -  int  #0x19
  52.181 -  //JMP_EP(0x0064) ; INT 19h location
  52.182 +
  52.183 +  ;; Start the boot sequence.   See the comments in int19_relocated 
  52.184 +  ;; for why we use INT 18h instead of INT 19h here.
  52.185 +  int  #0x18
  52.186  
  52.187  #if BX_TCGBIOS
  52.188    call _tcpa_returned_int19h         /* specs: 8.2.3 step 3/7 */

    53.1 --- a/tools/guest-headers/Makefile	Mon Mar 05 12:49:12 2007 -0600
    53.2 +++ b/tools/guest-headers/Makefile	Thu Mar 08 14:39:52 2007 -0600
    53.3 @@ -13,7 +13,7 @@ check:
    53.4  
    53.5  install-Linux:
    53.6  	mkdir -p $(DESTDIR)/usr/include/xen/linux
    53.7 -	install -m0644 $(linuxsparsetree)/include/xen/public/*.h $(DESTDIR)/usr/include/xen/linux
    53.8 +	$(INSTALL_DATA) $(linuxsparsetree)/include/xen/public/*.h $(DESTDIR)/usr/include/xen/linux
    53.9  
   53.10  install-SunOS:
   53.11  

    54.1 --- a/tools/ioemu/Makefile	Mon Mar 05 12:49:12 2007 -0600
    54.2 +++ b/tools/ioemu/Makefile	Thu Mar 08 14:39:52 2007 -0600
    54.3 @@ -65,10 +65,10 @@ common  de-ch  es     fo  fr-ca  hu     
    54.4  
    54.5  install-doc: $(DOCS)
    54.6  	mkdir -p "$(DESTDIR)$(docdir)"
    54.7 -	$(INSTALL) -m 644 qemu-doc.html  qemu-tech.html "$(DESTDIR)$(docdir)"
    54.8 +	$(INSTALL_DATA) qemu-doc.html  qemu-tech.html "$(DESTDIR)$(docdir)"
    54.9  ifndef CONFIG_WIN32
   54.10  	mkdir -p "$(DESTDIR)$(mandir)/man1"
   54.11 -	$(INSTALL) qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1"
   54.12 +	$(INSTALL_DATA) qemu.1 qemu-img.1 "$(DESTDIR)$(mandir)/man1"
   54.13  endif
   54.14  
   54.15  install: all $(if $(BUILD_DOCS),install-doc)
   54.16 @@ -77,12 +77,12 @@ install: all $(if $(BUILD_DOCS),install-
   54.17  #	mkdir -p "$(DESTDIR)$(datadir)"
   54.18  #	for x in bios.bin vgabios.bin vgabios-cirrus.bin ppc_rom.bin \
   54.19  #			video.x openbios-sparc32 linux_boot.bin; do \
   54.20 -#		$(INSTALL) -m 644 $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(datadir)"; \
   54.21 +#		$(INSTALL_DATA) $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(datadir)"; \
   54.22  #	done
   54.23  ifndef CONFIG_WIN32
   54.24  	mkdir -p "$(DESTDIR)$(datadir)/keymaps"
   54.25  	for x in $(KEYMAPS); do \
   54.26 -		$(INSTALL) -m 644 $(SRC_PATH)/keymaps/$$x "$(DESTDIR)$(datadir)/keymaps"; \
   54.27 +		$(INSTALL_DATA) $(SRC_PATH)/keymaps/$$x "$(DESTDIR)$(datadir)/keymaps"; \
   54.28  	done
   54.29  endif
   54.30  	for d in $(TARGET_DIRS); do \

    55.1 --- a/tools/ioemu/hw/ide.c	Mon Mar 05 12:49:12 2007 -0600
    55.2 +++ b/tools/ioemu/hw/ide.c	Thu Mar 08 14:39:52 2007 -0600
    55.3 @@ -2602,6 +2602,120 @@ void pci_cmd646_ide_init(PCIBus *bus, Bl
    55.4  #endif /* DMA_MULTI_THREAD */
    55.5  }
    55.6  
    55.7 +static void pci_ide_save(QEMUFile* f, void *opaque)
    55.8 +{
    55.9 +    PCIIDEState *d = opaque;
   55.10 +    int i;
   55.11 +
   55.12 +    for(i = 0; i < 2; i++) {
   55.13 +        BMDMAState *bm = &d->bmdma[i];
   55.14 +        qemu_put_8s(f, &bm->cmd);
   55.15 +        qemu_put_8s(f, &bm->status);
   55.16 +        qemu_put_be32s(f, &bm->addr);
   55.17 +        /* XXX: if a transfer is pending, we do not save it yet */
   55.18 +    }
   55.19 +
   55.20 +    /* per IDE interface data */
   55.21 +    for(i = 0; i < 2; i++) {
   55.22 +        IDEState *s = &d->ide_if[i * 2];
   55.23 +        uint8_t drive1_selected;
   55.24 +        qemu_put_8s(f, &s->cmd);
   55.25 +        drive1_selected = (s->cur_drive != s);
   55.26 +        qemu_put_8s(f, &drive1_selected);
   55.27 +    }
   55.28 +
   55.29 +    /* per IDE drive data */
   55.30 +    for(i = 0; i < 4; i++) {
   55.31 +        IDEState *s = &d->ide_if[i];
   55.32 +        qemu_put_be32s(f, &s->mult_sectors);
   55.33 +        qemu_put_be32s(f, &s->identify_set);
   55.34 +        if (s->identify_set) {
   55.35 +            qemu_put_buffer(f, (const uint8_t *)s->identify_data, 512);
   55.36 +        }
   55.37 +        qemu_put_8s(f, &s->write_cache);
   55.38 +        qemu_put_8s(f, &s->feature);
   55.39 +        qemu_put_8s(f, &s->error);
   55.40 +        qemu_put_be32s(f, &s->nsector);
   55.41 +        qemu_put_8s(f, &s->sector);
   55.42 +        qemu_put_8s(f, &s->lcyl);
   55.43 +        qemu_put_8s(f, &s->hcyl);
   55.44 +        qemu_put_8s(f, &s->hob_feature);
   55.45 +        qemu_put_8s(f, &s->hob_nsector);
   55.46 +        qemu_put_8s(f, &s->hob_sector);
   55.47 +        qemu_put_8s(f, &s->hob_lcyl);
   55.48 +        qemu_put_8s(f, &s->hob_hcyl);
   55.49 +        qemu_put_8s(f, &s->select);
   55.50 +        qemu_put_8s(f, &s->status);
   55.51 +        qemu_put_8s(f, &s->lba48);
   55.52 +
   55.53 +        qemu_put_8s(f, &s->sense_key);
   55.54 +        qemu_put_8s(f, &s->asc);
   55.55 +        /* XXX: if a transfer is pending, we do not save it yet */
   55.56 +    }
   55.57 +}
   55.58 +
   55.59 +static int pci_ide_load(QEMUFile* f, void *opaque, int version_id)
   55.60 +{
   55.61 +    PCIIDEState *d = opaque;
   55.62 +    int ret, i;
   55.63 +
   55.64 +    if (version_id != 1)
   55.65 +        return -EINVAL;
   55.66 +
   55.67 +    for(i = 0; i < 2; i++) {
   55.68 +        BMDMAState *bm = &d->bmdma[i];
   55.69 +        qemu_get_8s(f, &bm->cmd);
   55.70 +        qemu_get_8s(f, &bm->status);
   55.71 +        qemu_get_be32s(f, &bm->addr);
   55.72 +        /* XXX: if a transfer is pending, we do not save it yet */
   55.73 +    }
   55.74 +
   55.75 +    /* per IDE interface data */
   55.76 +    for(i = 0; i < 2; i++) {
   55.77 +        IDEState *s = &d->ide_if[i * 2];
   55.78 +        uint8_t drive1_selected;
   55.79 +        qemu_get_8s(f, &s->cmd);
   55.80 +        qemu_get_8s(f, &drive1_selected);
   55.81 +        s->cur_drive = &d->ide_if[i * 2 + (drive1_selected != 0)];
   55.82 +    }
   55.83 +
   55.84 +    /* per IDE drive data */
   55.85 +    for(i = 0; i < 4; i++) {
   55.86 +        IDEState *s = &d->ide_if[i];
   55.87 +        qemu_get_be32s(f, &s->mult_sectors);
   55.88 +        qemu_get_be32s(f, &s->identify_set);
   55.89 +        if (s->identify_set) {
   55.90 +            qemu_get_buffer(f, (uint8_t *)s->identify_data, 512);
   55.91 +        }
   55.92 +        qemu_get_8s(f, &s->write_cache);
   55.93 +        qemu_get_8s(f, &s->feature);
   55.94 +        qemu_get_8s(f, &s->error);
   55.95 +        qemu_get_be32s(f, &s->nsector);
   55.96 +        qemu_get_8s(f, &s->sector);
   55.97 +        qemu_get_8s(f, &s->lcyl);
   55.98 +        qemu_get_8s(f, &s->hcyl);
   55.99 +        qemu_get_8s(f, &s->hob_feature);
  55.100 +        qemu_get_8s(f, &s->hob_nsector);
  55.101 +        qemu_get_8s(f, &s->hob_sector);
  55.102 +        qemu_get_8s(f, &s->hob_lcyl);
  55.103 +        qemu_get_8s(f, &s->hob_hcyl);
  55.104 +        qemu_get_8s(f, &s->select);
  55.105 +        qemu_get_8s(f, &s->status);
  55.106 +        qemu_get_8s(f, &s->lba48);
  55.107 +
  55.108 +        qemu_get_8s(f, &s->sense_key);
  55.109 +        qemu_get_8s(f, &s->asc);
  55.110 +        /* XXX: if a transfer is pending, we do not save it yet */
  55.111 +        if (s->status & (DRQ_STAT|BUSY_STAT)) {
  55.112 +            /* Tell the guest that its transfer has gone away */
  55.113 +            ide_abort_command(s);
  55.114 +            ide_set_irq(s);
  55.115 +        }
  55.116 +    }
  55.117 +    return 0;
  55.118 +}
  55.119 +
  55.120 +
  55.121  /* hd_table must contain 4 block drivers */
  55.122  /* NOTE: for the PIIX3, the IRQs and IOports are hardcoded */
  55.123  void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn)
  55.124 @@ -2643,6 +2757,7 @@ void pci_piix3_ide_init(PCIBus *bus, Blo
  55.125      buffered_pio_init();
  55.126  
  55.127      register_savevm("ide_pci", 0, 1, generic_pci_save, generic_pci_load, d);
  55.128 +    register_savevm("ide", 0, 1, pci_ide_save, pci_ide_load, d);
  55.129  
  55.130  #ifdef DMA_MULTI_THREAD    
  55.131      dma_create_thread();

    56.1 --- a/tools/ioemu/target-i386-dm/qemu-ifup	Mon Mar 05 12:49:12 2007 -0600
    56.2 +++ b/tools/ioemu/target-i386-dm/qemu-ifup	Thu Mar 08 14:39:52 2007 -0600
    56.3 @@ -3,8 +3,7 @@
    56.4  #. /etc/rc.d/init.d/functions
    56.5  #ulimit -c unlimited
    56.6  
    56.7 -echo -c 'config qemu network with xen bridge for '
    56.8 -echo $*
    56.9 +echo 'config qemu network with xen bridge for ' $*
   56.10  
   56.11  ifconfig $1 0.0.0.0 up
   56.12  brctl addif $2 $1

    57.1 --- a/tools/ioemu/vl.c	Mon Mar 05 12:49:12 2007 -0600
    57.2 +++ b/tools/ioemu/vl.c	Thu Mar 08 14:39:52 2007 -0600
    57.3 @@ -3250,6 +3250,14 @@ static int net_tap_init(VLANState *vlan,
    57.4          pid = fork();
    57.5          if (pid >= 0) {
    57.6              if (pid == 0) {
    57.7 +                int open_max = sysconf(_SC_OPEN_MAX), i;
    57.8 +                for (i = 0; i < open_max; i++)
    57.9 +                    if (i != STDIN_FILENO &&
   57.10 +                        i != STDOUT_FILENO &&
   57.11 +                        i != STDERR_FILENO &&
   57.12 +                        i != fd)
   57.13 +                        close(i);
   57.14 +
   57.15                  parg = args;
   57.16                  *parg++ = (char *)setup_script;
   57.17                  *parg++ = ifname;

    58.1 --- a/tools/ioemu/vnc.c	Mon Mar 05 12:49:12 2007 -0600
    58.2 +++ b/tools/ioemu/vnc.c	Thu Mar 08 14:39:52 2007 -0600
    58.3 @@ -1445,7 +1445,7 @@ int vnc_display_init(DisplayState *ds, i
    58.4  
    58.5  int vnc_start_viewer(int port)
    58.6  {
    58.7 -    int pid;
    58.8 +    int pid, i, open_max;
    58.9      char s[16];
   58.10  
   58.11      sprintf(s, ":%d", port);
   58.12 @@ -1456,6 +1456,12 @@ int vnc_start_viewer(int port)
   58.13  	exit(1);
   58.14  
   58.15      case 0:	/* child */
   58.16 +	open_max = sysconf(_SC_OPEN_MAX);
   58.17 +	for (i = 0; i < open_max; i++)
   58.18 +	    if (i != STDIN_FILENO &&
   58.19 +		i != STDOUT_FILENO &&
   58.20 +		i != STDERR_FILENO)
   58.21 +		close(i);
   58.22  	execlp("vncviewer", "vncviewer", s, NULL);
   58.23  	fprintf(stderr, "vncviewer execlp failed\n");
   58.24  	exit(1);

    59.1 --- a/tools/libxc/xc_core.c	Mon Mar 05 12:49:12 2007 -0600
    59.2 +++ b/tools/libxc/xc_core.c	Thu Mar 08 14:39:52 2007 -0600
    59.3 @@ -153,7 +153,7 @@ struct xc_core_section_headers {
    59.4      uint16_t    num;
    59.5      uint16_t    num_max;
    59.6  
    59.7 -    Elf_Shdr   *shdrs;
    59.8 +    Elf64_Shdr  *shdrs;
    59.9  };
   59.10  #define SHDR_INIT       16
   59.11  #define SHDR_INC        4
   59.12 @@ -184,14 +184,14 @@ xc_core_shdr_free(struct xc_core_section
   59.13      free(sheaders);
   59.14  }
   59.15  
   59.16 -Elf_Shdr*
   59.17 +Elf64_Shdr*
   59.18  xc_core_shdr_get(struct xc_core_section_headers *sheaders)
   59.19  {
   59.20 -    Elf_Shdr *shdr;
   59.21 +    Elf64_Shdr *shdr;
   59.22  
   59.23      if ( sheaders->num == sheaders->num_max )
   59.24      {
   59.25 -        Elf_Shdr *shdrs;
   59.26 +        Elf64_Shdr *shdrs;
   59.27          if ( sheaders->num_max + SHDR_INC < sheaders->num_max )
   59.28          {
   59.29              errno = E2BIG;
   59.30 @@ -212,7 +212,7 @@ xc_core_shdr_get(struct xc_core_section_
   59.31  }
   59.32  
   59.33  int
   59.34 -xc_core_shdr_set(Elf_Shdr *shdr,
   59.35 +xc_core_shdr_set(Elf64_Shdr *shdr,
   59.36                   struct xc_core_strtab *strtab,
   59.37                   const char *name, uint32_t type,
   59.38                   uint64_t offset, uint64_t size,
   59.39 @@ -317,15 +317,15 @@ xc_domain_dumpcore_via_callback(int xc_h
   59.40  
   59.41      uint64_t *pfn_array = NULL;
   59.42  
   59.43 -    Elf_Ehdr ehdr;
   59.44 -    unsigned long filesz;
   59.45 -    unsigned long offset;
   59.46 -    unsigned long fixup;
   59.47 +    Elf64_Ehdr ehdr;
   59.48 +    uint64_t filesz;
   59.49 +    uint64_t offset;
   59.50 +    uint64_t fixup;
   59.51  
   59.52      struct xc_core_strtab *strtab = NULL;
   59.53      uint16_t strtab_idx;
   59.54      struct xc_core_section_headers *sheaders = NULL;
   59.55 -    Elf_Shdr *shdr;
   59.56 +    Elf64_Shdr *shdr;
   59.57  
   59.58      /* elf notes */
   59.59      struct elfnote elfnote;
   59.60 @@ -460,7 +460,7 @@ xc_domain_dumpcore_via_callback(int xc_h
   59.61      ehdr.e_ident[EI_MAG1] = ELFMAG1;
   59.62      ehdr.e_ident[EI_MAG2] = ELFMAG2;
   59.63      ehdr.e_ident[EI_MAG3] = ELFMAG3;
   59.64 -    ehdr.e_ident[EI_CLASS] = ELFCLASS;
   59.65 +    ehdr.e_ident[EI_CLASS] = ELFCLASS64;
   59.66      ehdr.e_ident[EI_DATA] = ELF_ARCH_DATA;
   59.67      ehdr.e_ident[EI_VERSION] = EV_CURRENT;
   59.68      ehdr.e_ident[EI_OSABI] = ELFOSABI_SYSV;
   59.69 @@ -474,9 +474,9 @@ xc_domain_dumpcore_via_callback(int xc_h
   59.70      ehdr.e_shoff = sizeof(ehdr);
   59.71      ehdr.e_flags = ELF_CORE_EFLAGS;
   59.72      ehdr.e_ehsize = sizeof(ehdr);
   59.73 -    ehdr.e_phentsize = sizeof(Elf_Phdr);
   59.74 +    ehdr.e_phentsize = sizeof(Elf64_Phdr);
   59.75      ehdr.e_phnum = 0;
   59.76 -    ehdr.e_shentsize = sizeof(Elf_Shdr);
   59.77 +    ehdr.e_shentsize = sizeof(Elf64_Shdr);
   59.78      /* ehdr.e_shnum and ehdr.e_shstrndx aren't known here yet. fill it later*/
   59.79  
   59.80      /* create section header */

    60.1 --- a/tools/libxc/xc_core.h	Mon Mar 05 12:49:12 2007 -0600
    60.2 +++ b/tools/libxc/xc_core.h	Thu Mar 08 14:39:52 2007 -0600
    60.3 @@ -116,10 +116,10 @@ struct xen_dumpcore_p2m {
    60.4  struct xc_core_strtab;
    60.5  struct xc_core_section_headers;
    60.6  
    60.7 -Elf_Shdr*
    60.8 +Elf64_Shdr*
    60.9  xc_core_shdr_get(struct xc_core_section_headers *sheaders);
   60.10  int
   60.11 -xc_core_shdr_set(Elf_Shdr *shdr,
   60.12 +xc_core_shdr_set(Elf64_Shdr *shdr,
   60.13                   struct xc_core_strtab *strtab,
   60.14                   const char *name, uint32_t type,
   60.15                   uint64_t offset, uint64_t size,

    61.1 --- a/tools/libxc/xc_core_ia64.c	Mon Mar 05 12:49:12 2007 -0600
    61.2 +++ b/tools/libxc/xc_core_ia64.c	Thu Mar 08 14:39:52 2007 -0600
    61.3 @@ -266,10 +266,10 @@ int
    61.4  xc_core_arch_context_get_shdr(struct xc_core_arch_context *arch_ctxt, 
    61.5                                struct xc_core_section_headers *sheaders,
    61.6                                struct xc_core_strtab *strtab,
    61.7 -                              unsigned long *filesz, unsigned long offset)
    61.8 +                              uint64_t *filesz, uint64_t offset)
    61.9  {
   61.10      int sts = -1;
   61.11 -    Elf_Shdr *shdr;
   61.12 +    Elf64_Shdr *shdr;
   61.13  
   61.14      /* mmapped priv regs */
   61.15      shdr = xc_core_shdr_get(sheaders);

    62.1 --- a/tools/libxc/xc_core_ia64.h	Mon Mar 05 12:49:12 2007 -0600
    62.2 +++ b/tools/libxc/xc_core_ia64.h	Thu Mar 08 14:39:52 2007 -0600
    62.3 @@ -42,7 +42,7 @@ int
    62.4  xc_core_arch_context_get_shdr(struct xc_core_arch_context* arch_ctxt, 
    62.5                                struct xc_core_section_headers *sheaders,
    62.6                                struct xc_core_strtab *strtab,
    62.7 -                              unsigned long *filesz, unsigned long offset);
    62.8 +                              uint64_t *filesz, uint64_t offset);
    62.9  int
   62.10  xc_core_arch_context_dump(struct xc_core_arch_context* arch_ctxt,
   62.11                            void* args, dumpcore_rtn_t dump_rtn);

    63.1 --- a/tools/libxc/xc_core_x86.h	Mon Mar 05 12:49:12 2007 -0600
    63.2 +++ b/tools/libxc/xc_core_x86.h	Thu Mar 08 14:39:52 2007 -0600
    63.3 @@ -45,7 +45,7 @@ static inline int
    63.4  xc_core_arch_context_get_shdr(struct xc_core_arch_context *arch_ctxt, 
    63.5                                struct xc_core_section_headers *sheaders,
    63.6                                struct xc_core_strtab *strtab,
    63.7 -                              unsigned long *filesz, unsigned long offset)
    63.8 +                              uint64_t *filesz, uint64_t offset)
    63.9  {
   63.10      *filesz = 0;
   63.11      return 0;

    64.1 --- a/tools/libxc/xc_dom_core.c	Mon Mar 05 12:49:12 2007 -0600
    64.2 +++ b/tools/libxc/xc_dom_core.c	Thu Mar 08 14:39:52 2007 -0600
    64.3 @@ -721,9 +721,6 @@ int xc_dom_build_image(struct xc_dom_ima
    64.4      }
    64.5      page_size = XC_DOM_PAGE_SIZE(dom);
    64.6  
    64.7 -    /* 4MB align virtual base address */
    64.8 -    dom->parms.virt_base &= ~(((uint64_t)1<<22)-1);
    64.9 -
   64.10      /* load kernel */
   64.11      if ( xc_dom_alloc_segment(dom, &dom->kernel_seg, "kernel",
   64.12                                dom->kernel_seg.vstart,

    65.1 --- a/tools/libxc/xc_linux_restore.c	Mon Mar 05 12:49:12 2007 -0600
    65.2 +++ b/tools/libxc/xc_linux_restore.c	Thu Mar 08 14:39:52 2007 -0600
    65.3 @@ -19,7 +19,7 @@ static unsigned long max_mfn;
    65.4  /* virtual starting address of the hypervisor */
    65.5  static unsigned long hvirt_start;
    65.6  
    65.7 -/* #levels of page tables used by the currrent guest */
    65.8 +/* #levels of page tables used by the current guest */
    65.9  static unsigned int pt_levels;
   65.10  
   65.11  /* total number of pages used by the current guest */
   65.12 @@ -857,6 +857,28 @@ int xc_linux_restore(int xc_handle, int 
   65.13  
   65.14          ctxt.ctrlreg[3] = xen_pfn_to_cr3(p2m[pfn]);
   65.15  
   65.16 +        /* Guest pagetable (x86/64) stored in otherwise-unused CR1. */
   65.17 +        if ( (pt_levels == 4) && ctxt.ctrlreg[1] )
   65.18 +        {
   65.19 +            pfn = xen_cr3_to_pfn(ctxt.ctrlreg[1]);
   65.20 +
   65.21 +            if (pfn >= max_pfn) {
   65.22 +                ERROR("User PT base is bad: pfn=%lu max_pfn=%lu type=%08lx",
   65.23 +                      pfn, max_pfn, pfn_type[pfn]);
   65.24 +                goto out;
   65.25 +            }
   65.26 +
   65.27 +            if ( (pfn_type[pfn] & XEN_DOMCTL_PFINFO_LTABTYPE_MASK) !=
   65.28 +                 ((unsigned long)pt_levels<<XEN_DOMCTL_PFINFO_LTAB_SHIFT) ) {
   65.29 +                ERROR("User PT base is bad. pfn=%lu nr=%lu type=%08lx %08lx",
   65.30 +                      pfn, max_pfn, pfn_type[pfn],
   65.31 +                      (unsigned long)pt_levels<<XEN_DOMCTL_PFINFO_LTAB_SHIFT);
   65.32 +                goto out;
   65.33 +            }
   65.34 +
   65.35 +            ctxt.ctrlreg[1] = xen_pfn_to_cr3(p2m[pfn]);
   65.36 +        }
   65.37 +
   65.38          domctl.cmd = XEN_DOMCTL_setvcpucontext;
   65.39          domctl.domain = (domid_t)dom;
   65.40          domctl.u.vcpucontext.vcpu = i;

    66.1 --- a/tools/libxc/xc_linux_save.c	Mon Mar 05 12:49:12 2007 -0600
    66.2 +++ b/tools/libxc/xc_linux_save.c	Thu Mar 08 14:39:52 2007 -0600
    66.3 @@ -34,7 +34,7 @@ static unsigned long max_mfn;
    66.4  /* virtual starting address of the hypervisor */
    66.5  static unsigned long hvirt_start;
    66.6  
    66.7 -/* #levels of page tables used by the currrent guest */
    66.8 +/* #levels of page tables used by the current guest */
    66.9  static unsigned int pt_levels;
   66.10  
   66.11  /* total number of pages used by the current guest */
   66.12 @@ -491,7 +491,7 @@ static int canonicalize_pagetable(unsign
   66.13      ** reserved hypervisor mappings. This depends on the current
   66.14      ** page table type as well as the number of paging levels.
   66.15      */
   66.16 -    xen_start = xen_end = pte_last = PAGE_SIZE / ((pt_levels == 2)? 4 : 8);
   66.17 +    xen_start = xen_end = pte_last = PAGE_SIZE / ((pt_levels == 2) ? 4 : 8);
   66.18  
   66.19      if (pt_levels == 2 && type == XEN_DOMCTL_PFINFO_L2TAB)
   66.20          xen_start = (hvirt_start >> L2_PAGETABLE_SHIFT);
   66.21 @@ -1279,6 +1279,18 @@ int xc_linux_save(int xc_handle, int io_
   66.22          ctxt.ctrlreg[3] = 
   66.23              xen_pfn_to_cr3(mfn_to_pfn(xen_cr3_to_pfn(ctxt.ctrlreg[3])));
   66.24  
   66.25 +        /* Guest pagetable (x86/64) stored in otherwise-unused CR1. */
   66.26 +        if ( (pt_levels == 4) && ctxt.ctrlreg[1] )
   66.27 +        {
   66.28 +            if ( !MFN_IS_IN_PSEUDOPHYS_MAP(xen_cr3_to_pfn(ctxt.ctrlreg[1])) ) {
   66.29 +                ERROR("PT base is not in range of pseudophys map");
   66.30 +                goto out;
   66.31 +            }
   66.32 +            /* Least-significant bit means 'valid PFN'. */
   66.33 +            ctxt.ctrlreg[1] = 1 |
   66.34 +                xen_pfn_to_cr3(mfn_to_pfn(xen_cr3_to_pfn(ctxt.ctrlreg[1])));
   66.35 +        }
   66.36 +
   66.37          if (!write_exact(io_fd, &ctxt, sizeof(ctxt))) {
   66.38              ERROR("Error when writing to state file (1) (errno %d)", errno);
   66.39              goto out;

    67.1 --- a/tools/libxc/xc_ptrace_core.c	Mon Mar 05 12:49:12 2007 -0600
    67.2 +++ b/tools/libxc/xc_ptrace_core.c	Thu Mar 08 14:39:52 2007 -0600
    67.3 @@ -192,7 +192,7 @@ pread_exact(int fd, void* buffer, size_t
    67.4  struct elf_core
    67.5  {
    67.6      int         domfd;
    67.7 -    Elf_Ehdr    ehdr;
    67.8 +    Elf64_Ehdr  ehdr;
    67.9  
   67.10      char*       shdr;
   67.11      
   67.12 @@ -242,6 +242,8 @@ elf_core_init(struct elf_core* ecore, in
   67.13      /* check elf header */
   67.14      if (!IS_ELF(ecore->ehdr) || ecore->ehdr.e_type != ET_CORE)
   67.15          goto out;
   67.16 +    if (ecore->ehdr.e_ident[EI_CLASS] != ELFCLASS64)
   67.17 +        goto out;
   67.18      /* check elf header more: EI_DATA, EI_VERSION, e_machine... */
   67.19  
   67.20      /* read section headers */
   67.21 @@ -294,7 +296,7 @@ elf_core_search_note(struct elf_core* ec
   67.22  }
   67.23  
   67.24  static int
   67.25 -elf_core_alloc_read_sec(struct elf_core* ecore, const Elf_Shdr* shdr,
   67.26 +elf_core_alloc_read_sec(struct elf_core* ecore, const Elf64_Shdr* shdr,
   67.27                          char** buf)
   67.28  {
   67.29      int ret;
   67.30 @@ -309,19 +311,19 @@ elf_core_alloc_read_sec(struct elf_core*
   67.31      return ret;
   67.32  }
   67.33  
   67.34 -static Elf_Shdr*
   67.35 +static Elf64_Shdr*
   67.36  elf_core_shdr_by_index(struct elf_core* ecore, uint16_t index)
   67.37  {
   67.38      if (index >= ecore->ehdr.e_shnum)
   67.39          return NULL;
   67.40 -    return (Elf_Shdr*)(ecore->shdr + ecore->ehdr.e_shentsize * index);
   67.41 +    return (Elf64_Shdr*)(ecore->shdr + ecore->ehdr.e_shentsize * index);
   67.42  }
   67.43  
   67.44  static int
   67.45  elf_core_alloc_read_sec_by_index(struct elf_core* ecore, uint16_t index,
   67.46                                   char** buf, uint64_t* size)
   67.47  {
   67.48 -    Elf_Shdr* shdr = elf_core_shdr_by_index(ecore, index);
   67.49 +    Elf64_Shdr* shdr = elf_core_shdr_by_index(ecore, index);
   67.50      if (shdr == NULL)
   67.51          return -1;
   67.52      if (size != NULL)
   67.53 @@ -329,14 +331,14 @@ elf_core_alloc_read_sec_by_index(struct 
   67.54      return elf_core_alloc_read_sec(ecore, shdr, buf);
   67.55  }
   67.56  
   67.57 -static Elf_Shdr*
   67.58 +static Elf64_Shdr*
   67.59  elf_core_shdr_by_name(struct elf_core* ecore, const char* name)
   67.60  {
   67.61      const char* s;
   67.62      for (s = ecore->shdr;
   67.63           s < ecore->shdr + ecore->ehdr.e_shentsize * ecore->ehdr.e_shnum;
   67.64           s += ecore->ehdr.e_shentsize) {
   67.65 -        Elf_Shdr* shdr = (Elf_Shdr*)s;
   67.66 +        Elf64_Shdr* shdr = (Elf64_Shdr*)s;
   67.67  
   67.68          if (strncmp(ecore->shstrtab + shdr->sh_name, name, strlen(name)) == 0)
   67.69              return shdr;
   67.70 @@ -348,7 +350,7 @@ elf_core_shdr_by_name(struct elf_core* e
   67.71  static int
   67.72  elf_core_read_sec_by_name(struct elf_core* ecore, const char* name, char* buf)
   67.73  {
   67.74 -    Elf_Shdr* shdr = elf_core_shdr_by_name(ecore, name);
   67.75 +    Elf64_Shdr* shdr = elf_core_shdr_by_name(ecore, name);
   67.76      return pread_exact(ecore->domfd, buf, shdr->sh_size, shdr->sh_offset);
   67.77      
   67.78  }
   67.79 @@ -357,7 +359,7 @@ static int
   67.80  elf_core_alloc_read_sec_by_name(struct elf_core* ecore, const char* name,
   67.81                                  char** buf, uint64_t* size)
   67.82  {
   67.83 -    Elf_Shdr* shdr = elf_core_shdr_by_name(ecore, name);
   67.84 +    Elf64_Shdr* shdr = elf_core_shdr_by_name(ecore, name);
   67.85      if (shdr == NULL)
   67.86          return -1;
   67.87      if (size != NULL)
   67.88 @@ -508,8 +510,8 @@ xc_waitdomain_core_elf(
   67.89      struct xen_dumpcore_elfnote_xen_version *xen_version;
   67.90      struct xen_dumpcore_elfnote_format_version *format_version;
   67.91  
   67.92 -    Elf_Shdr* table_shdr;
   67.93 -    Elf_Shdr* pages_shdr;
   67.94 +    Elf64_Shdr* table_shdr;
   67.95 +    Elf64_Shdr* pages_shdr;
   67.96  
   67.97      if (elf_core_init(&ecore, domfd) < 0)
   67.98          goto out;

    68.1 --- a/tools/libxen/Makefile	Mon Mar 05 12:49:12 2007 -0600
    68.2 +++ b/tools/libxen/Makefile	Thu Mar 08 14:39:52 2007 -0600
    68.3 @@ -57,8 +57,8 @@ test/test_hvm_bindings: test/test_hvm_bi
    68.4  
    68.5  .PHONY: install
    68.6  install: all
    68.7 -	$(INSTALL_DIR) -p $(DESTDIR)/usr/include/xen/api
    68.8 -	$(INSTALL_DIR) -p $(DESTDIR)/usr/$(LIBDIR)
    68.9 +	$(INSTALL_DIR) $(DESTDIR)/usr/include/xen/api
   68.10 +	$(INSTALL_DIR) $(DESTDIR)/usr/$(LIBDIR)
   68.11  	$(INSTALL_PROG) libxenapi.so.$(MAJOR).$(MINOR) $(DESTDIR)/usr/$(LIBDIR)
   68.12  	ln -sf libxenapi.so.$(MAJOR).$(MINOR) $(DESTDIR)/usr/$(LIBDIR)/libxenapi.so.$(MAJOR)
   68.13  	ln -sf libxenapi.so.$(MAJOR) $(DESTDIR)/usr/$(LIBDIR)/libxenapi.so

    69.1 --- a/tools/ptsname/Makefile	Mon Mar 05 12:49:12 2007 -0600
    69.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    69.3 @@ -1,22 +0,0 @@
    69.4 -
    69.5 -XEN_ROOT = ../..
    69.6 -include $(XEN_ROOT)/tools/Rules.mk
    69.7 -
    69.8 -.PHONY: all
    69.9 -all: build
   69.10 -.PHONY: build
   69.11 -build:
   69.12 -	CC="$(CC)" CFLAGS="$(CFLAGS)" python setup.py build
   69.13 -
   69.14 -.PHONY: install
   69.15 -ifndef XEN_PYTHON_NATIVE_INSTALL
   69.16 -install: all
   69.17 -	CC="$(CC)" CFLAGS="$(CFLAGS)" python setup.py install --home="$(DESTDIR)/usr" --prefix=""
   69.18 -else
   69.19 -install: all
   69.20 -	CC="$(CC)" CFLAGS="$(CFLAGS)" python setup.py install --root="$(DESTDIR)"
   69.21 -endif
   69.22 -
   69.23 -.PHONY: clean
   69.24 -clean:
   69.25 -	rm -rf build tmp *.pyc *.pyo *.o *.a *~ a.out

    70.1 --- a/tools/ptsname/ptsname.c	Mon Mar 05 12:49:12 2007 -0600
    70.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    70.3 @@ -1,44 +0,0 @@
    70.4 -/******************************************************************************
    70.5 - * ptsname.c
    70.6 - * 
    70.7 - * A python extension to expose the POSIX ptsname() function.
    70.8 - * 
    70.9 - * Copyright (C) 2007 XenSource Ltd
   70.10 - */
   70.11 -
   70.12 -#include <Python.h>
   70.13 -#include <stdlib.h>
   70.14 -
   70.15 -/* Needed for Python versions earlier than 2.3. */
   70.16 -#ifndef PyMODINIT_FUNC
   70.17 -#define PyMODINIT_FUNC DL_EXPORT(void)
   70.18 -#endif
   70.19 -
   70.20 -static PyObject *do_ptsname(PyObject *self, PyObject *args)
   70.21 -{
   70.22 -    int fd;
   70.23 -    char *path;
   70.24 -
   70.25 -    if (!PyArg_ParseTuple(args, "i", &fd))
   70.26 -        return NULL;
   70.27 -
   70.28 -    path = ptsname(fd);
   70.29 -
   70.30 -    if (!path)
   70.31 -    {
   70.32 -        PyErr_SetFromErrno(PyExc_IOError);
   70.33 -        return NULL;
   70.34 -    } 
   70.35 -
   70.36 -    return PyString_FromString(path);
   70.37 -}
   70.38 -
   70.39 -static PyMethodDef ptsname_methods[] = { 
   70.40 -    { "ptsname", do_ptsname, METH_VARARGS }, 
   70.41 -    { NULL }
   70.42 -};
   70.43 -
   70.44 -PyMODINIT_FUNC initptsname(void)
   70.45 -{
   70.46 -    Py_InitModule("ptsname", ptsname_methods);
   70.47 -}