]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/suse-2.6.27.31/patches.xen/xen3-patch-2.6.20
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add a patch to fix Intel E100 wake-on-lan problems.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.31 / patches.xen / xen3-patch-2.6.20
CommitLineData
2cb7cef9
BS		 1From: www.kernel.org
2Subject: Linux 2.6.20
3Patch-mainline: 2.6.20
4
5Automatically created from "patches.kernel.org/patch-2.6.20" by xen-port-patches.py
6
7Acked-by: jbeulich@novell.com
8
9--- sle11-2009-06-29.orig/arch/x86/Kconfig 2009-03-04 11:28:34.000000000 +0100
10+++ sle11-2009-06-29/arch/x86/Kconfig 2009-02-05 10:22:19.000000000 +0100
11@@ -1431,7 +1431,7 @@ config PHYSICAL_START
12
13 config RELOCATABLE
14 bool "Build a relocatable kernel (EXPERIMENTAL)"
15- depends on EXPERIMENTAL
16+ depends on EXPERIMENTAL && !X86_XEN
17 help
18 This builds a kernel image that retains relocation information
19 so it can be loaded someplace besides the default 1MB.
20--- sle11-2009-06-29.orig/arch/x86/kernel/asm-offsets_32.c 2008-11-25 12:35:53.000000000 +0100
21+++ sle11-2009-06-29/arch/x86/kernel/asm-offsets_32.c 2008-12-15 11:26:44.000000000 +0100
22@@ -54,6 +54,7 @@ void foo(void)
23 OFFSET(TI_exec_domain, thread_info, exec_domain);
24 OFFSET(TI_flags, thread_info, flags);
25 OFFSET(TI_status, thread_info, status);
26+ OFFSET(TI_cpu, thread_info, cpu);
27 OFFSET(TI_preempt_count, thread_info, preempt_count);
28 OFFSET(TI_addr_limit, thread_info, addr_limit);
29 OFFSET(TI_restart_block, thread_info, restart_block);
30@@ -108,6 +109,11 @@ void foo(void)
31
32 OFFSET(crypto_tfm_ctx_offset, crypto_tfm, __crt_ctx);
33
34+#ifdef CONFIG_XEN
35+ BLANK();
36+ OFFSET(XEN_START_mfn_list, start_info, mfn_list);
37+#endif
38+
39 #ifdef CONFIG_PARAVIRT
40 BLANK();
41 OFFSET(PARAVIRT_enabled, pv_info, paravirt_enabled);
42--- sle11-2009-06-29.orig/arch/x86/kernel/cpu/common-xen.c 2009-03-04 11:28:34.000000000 +0100
43+++ sle11-2009-06-29/arch/x86/kernel/cpu/common-xen.c 2008-12-15 11:26:44.000000000 +0100
44@@ -22,6 +22,7 @@
45 #define phys_pkg_id(a,b) a
46 #endif
47 #endif
48+#include <asm/pda.h>
49 #include <asm/hypervisor.h>
50
51 #include "cpu.h"
52@@ -29,10 +30,8 @@
53 DEFINE_PER_CPU(struct Xgt_desc_struct, cpu_gdt_descr);
54 EXPORT_PER_CPU_SYMBOL(cpu_gdt_descr);
55
56-#ifndef CONFIG_XEN
57-DEFINE_PER_CPU(unsigned char, cpu_16bit_stack[CPU_16BIT_STACK_SIZE]);
58-EXPORT_PER_CPU_SYMBOL(cpu_16bit_stack);
59-#endif
60+struct i386_pda *_cpu_pda[NR_CPUS] __read_mostly;
61+EXPORT_SYMBOL(_cpu_pda);
62
63 static int cachesize_override __cpuinitdata = -1;
64 static int disable_x86_fxsr __cpuinitdata;
65@@ -60,7 +59,7 @@ static struct cpu_dev __cpuinitdata defa
66 .c_init = default_init,
67 .c_vendor = "Unknown",
68 };
69-static struct cpu_dev * this_cpu = &default_cpu;
70+static struct cpu_dev * this_cpu __cpuinitdata = &default_cpu;
71
72 static int __init cachesize_setup(char *str)
73 {
74@@ -242,29 +241,14 @@ static int __cpuinit have_cpuid_p(void)
75 return flag_is_changeable_p(X86_EFLAGS_ID);
76 }
77
78-/* Do minimum CPU detection early.
79- Fields really needed: vendor, cpuid_level, family, model, mask, cache alignment.
80- The others are not touched to avoid unwanted side effects.
81-
82- WARNING: this function is only called on the BP. Don't add code here
83- that is supposed to run on all CPUs. */
84-static void __init early_cpu_detect(void)
85+void __init cpu_detect(struct cpuinfo_x86 *c)
86 {
87- struct cpuinfo_x86 *c = &boot_cpu_data;
88-
89- c->x86_cache_alignment = 32;
90-
91- if (!have_cpuid_p())
92- return;
93-
94 /* Get vendor name */
95 cpuid(0x00000000, &c->cpuid_level,
96 (int *)&c->x86_vendor_id[0],
97 (int *)&c->x86_vendor_id[8],
98 (int *)&c->x86_vendor_id[4]);
99
100- get_cpu_vendor(c, 1);
101-
102 c->x86 = 4;
103 if (c->cpuid_level >= 0x00000001) {
104 u32 junk, tfms, cap0, misc;
105@@ -281,6 +265,26 @@ static void __init early_cpu_detect(void
106 }
107 }
108
109+/* Do minimum CPU detection early.
110+ Fields really needed: vendor, cpuid_level, family, model, mask, cache alignment.
111+ The others are not touched to avoid unwanted side effects.
112+
113+ WARNING: this function is only called on the BP. Don't add code here
114+ that is supposed to run on all CPUs. */
115+static void __init early_cpu_detect(void)
116+{
117+ struct cpuinfo_x86 *c = &boot_cpu_data;
118+
119+ c->x86_cache_alignment = 32;
120+
121+ if (!have_cpuid_p())
122+ return;
123+
124+ cpu_detect(c);
125+
126+ get_cpu_vendor(c, 1);
127+}
128+
129 static void __cpuinit generic_identify(struct cpuinfo_x86 * c)
130 {
131 u32 tfms, xlvl;
132@@ -315,6 +319,8 @@ static void __cpuinit generic_identify(s
133 #else
134 c->apicid = (ebx >> 24) & 0xFF;
135 #endif
136+ if (c->x86_capability[0] & (1<<19))
137+ c->x86_clflush_size = ((ebx >> 8) & 0xff) * 8;
138 } else {
139 /* Have CPUID level 0 only - unheard of */
140 c->x86 = 4;
141@@ -379,6 +385,7 @@ void __cpuinit identify_cpu(struct cpuin
142 c->x86_vendor_id[0] = '\0'; /* Unset */
143 c->x86_model_id[0] = '\0'; /* Unset */
144 c->x86_max_cores = 1;
145+ c->x86_clflush_size = 32;
146 memset(&c->x86_capability, 0, sizeof c->x86_capability);
147
148 if (!have_cpuid_p()) {
149@@ -599,61 +606,23 @@ void __init early_cpu_init(void)
150 #endif
151 }
152
153-static void __cpuinit cpu_gdt_init(const struct Xgt_desc_struct *gdt_descr)
154+/* Make sure %gs is initialized properly in idle threads */
155+struct pt_regs * __devinit idle_regs(struct pt_regs *regs)
156 {
157- unsigned long frames[16];
158- unsigned long va;
159- int f;
160-
161- for (va = gdt_descr->address, f = 0;
162- va < gdt_descr->address + gdt_descr->size;
163- va += PAGE_SIZE, f++) {
164- frames[f] = virt_to_mfn(va);
165- make_lowmem_page_readonly(
166- (void *)va, XENFEAT_writable_descriptor_tables);
167- }
168- if (HYPERVISOR_set_gdt(frames, (gdt_descr->size + 1) / 8))
169- BUG();
170+ memset(regs, 0, sizeof(struct pt_regs));
171+ regs->xgs = __KERNEL_PDA;
172+ return regs;
173 }
174
175-/*
176- * cpu_init() initializes state that is per-CPU. Some data is already
177- * initialized (naturally) in the bootstrap process, such as the GDT
178- * and IDT. We reload them nevertheless, this function acts as a
179- * 'CPU state barrier', nothing should get across.
180- */
181-void __cpuinit cpu_init(void)
182+static __cpuinit int alloc_gdt(int cpu)
183 {
184- int cpu = smp_processor_id();
185-#ifndef CONFIG_X86_NO_TSS
186- struct tss_struct * t = &per_cpu(init_tss, cpu);
187-#endif
188- struct thread_struct *thread = &current->thread;
189- struct desc_struct *gdt;
190 struct Xgt_desc_struct *cpu_gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
191+ struct desc_struct *gdt;
192+ struct i386_pda *pda;
193
194- if (cpu_test_and_set(cpu, cpu_initialized)) {
195- printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
196- for (;;) local_irq_enable();
197- }
198- printk(KERN_INFO "Initializing CPU#%d\n", cpu);
199-
200- if (cpu_has_vme || cpu_has_de)
201- clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);
202- if (tsc_disable && cpu_has_tsc) {
203- printk(KERN_NOTICE "Disabling TSC...\n");
204- /**** FIX-HPA: DOES THIS REALLY BELONG HERE? ****/
205- clear_bit(X86_FEATURE_TSC, boot_cpu_data.x86_capability);
206- set_in_cr4(X86_CR4_TSD);
207- }
208+ gdt = (struct desc_struct *)cpu_gdt_descr->address;
209+ pda = cpu_pda(cpu);
210
211-#ifndef CONFIG_XEN
212- /* The CPU hotplug case */
213- if (cpu_gdt_descr->address) {
214- gdt = (struct desc_struct *)cpu_gdt_descr->address;
215- memset(gdt, 0, PAGE_SIZE);
216- goto old_gdt;
217- }
218 /*
219 * This is a horrible hack to allocate the GDT. The problem
220 * is that cpu_init() is called really early for the boot CPU
221@@ -661,54 +630,141 @@ void __cpuinit cpu_init(void)
222 * CPUs, when bootmem will have gone away
223 */
224 if (NODE_DATA(0)->bdata->node_bootmem_map) {
225- gdt = (struct desc_struct *)alloc_bootmem_pages(PAGE_SIZE);
226- /* alloc_bootmem_pages panics on failure, so no check */
227+ BUG_ON(gdt != NULL || pda != NULL);
228+
229+ gdt = alloc_bootmem_pages(PAGE_SIZE);
230+ pda = alloc_bootmem(sizeof(*pda));
231+ /* alloc_bootmem(_pages) panics on failure, so no check */
232+
233 memset(gdt, 0, PAGE_SIZE);
234+ memset(pda, 0, sizeof(*pda));
235 } else {
236- gdt = (struct desc_struct *)get_zeroed_page(GFP_KERNEL);
237- if (unlikely(!gdt)) {
238- printk(KERN_CRIT "CPU%d failed to allocate GDT\n", cpu);
239- for (;;)
240- local_irq_enable();
241+ /* GDT and PDA might already have been allocated if
242+ this is a CPU hotplug re-insertion. */
243+ if (gdt == NULL)
244+ gdt = (struct desc_struct *)get_zeroed_page(GFP_KERNEL);
245+
246+ if (pda == NULL)
247+ pda = kmalloc_node(sizeof(*pda), GFP_KERNEL, cpu_to_node(cpu));
248+
249+ if (unlikely(!gdt || !pda)) {
250+ free_pages((unsigned long)gdt, 0);
251+ kfree(pda);
252+ return 0;
253 }
254 }
255-old_gdt:
256+
257+ cpu_gdt_descr->address = (unsigned long)gdt;
258+ cpu_pda(cpu) = pda;
259+
260+ return 1;
261+}
262+
263+/* Initial PDA used by boot CPU */
264+struct i386_pda boot_pda = {
265+ ._pda = &boot_pda,
266+ .cpu_number = 0,
267+ .pcurrent = &init_task,
268+};
269+
270+static inline void set_kernel_gs(void)
271+{
272+ /* Set %gs for this CPU's PDA. Memory clobber is to create a
273+ barrier with respect to any PDA operations, so the compiler
274+ doesn't move any before here. */
275+ asm volatile ("mov %0, %%gs" : : "r" (__KERNEL_PDA) : "memory");
276+}
277+
278+/* Initialize the CPU's GDT and PDA. The boot CPU does this for
279+ itself, but secondaries find this done for them. */
280+__cpuinit int init_gdt(int cpu, struct task_struct *idle)
281+{
282+ struct Xgt_desc_struct *cpu_gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
283+ struct desc_struct *gdt;
284+ struct i386_pda *pda;
285+
286+ /* For non-boot CPUs, the GDT and PDA should already have been
287+ allocated. */
288+ if (!alloc_gdt(cpu)) {
289+ printk(KERN_CRIT "CPU%d failed to allocate GDT or PDA\n", cpu);
290+ return 0;
291+ }
292+
293+ gdt = (struct desc_struct *)cpu_gdt_descr->address;
294+ pda = cpu_pda(cpu);
295+
296+ BUG_ON(gdt == NULL || pda == NULL);
297+
298 /*
299 * Initialize the per-CPU GDT with the boot GDT,
300 * and set up the GDT descriptor:
301 */
302 memcpy(gdt, cpu_gdt_table, GDT_SIZE);
303+ cpu_gdt_descr->size = GDT_SIZE - 1;
304
305- /* Set up GDT entry for 16bit stack */
306- *(__u64 *)(&gdt[GDT_ENTRY_ESPFIX_SS]) |=
307- ((((__u64)stk16_off) << 16) & 0x000000ffffff0000ULL) |
308- ((((__u64)stk16_off) << 32) & 0xff00000000000000ULL) |
309- (CPU_16BIT_STACK_SIZE - 1);
310+ pack_descriptor((u32 *)&gdt[GDT_ENTRY_PDA].a,
311+ (u32 *)&gdt[GDT_ENTRY_PDA].b,
312+ (unsigned long)pda, sizeof(*pda) - 1,
313+ 0x80 | DESCTYPE_S | 0x2, 0); /* present read-write data segment */
314+
315+ memset(pda, 0, sizeof(*pda));
316+ pda->_pda = pda;
317+ pda->cpu_number = cpu;
318+ pda->pcurrent = idle;
319
320- cpu_gdt_descr->size = GDT_SIZE - 1;
321- cpu_gdt_descr->address = (unsigned long)gdt;
322-#else
323- if (cpu == 0 && cpu_gdt_descr->address == 0) {
324- gdt = (struct desc_struct *)alloc_bootmem_pages(PAGE_SIZE);
325- /* alloc_bootmem_pages panics on failure, so no check */
326- memset(gdt, 0, PAGE_SIZE);
327+ return 1;
328+}
329
330- memcpy(gdt, cpu_gdt_table, GDT_SIZE);
331-
332- cpu_gdt_descr->size = GDT_SIZE;
333- cpu_gdt_descr->address = (unsigned long)gdt;
334+void __cpuinit cpu_set_gdt(int cpu)
335+{
336+ struct Xgt_desc_struct *cpu_gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
337+ unsigned long va, frames[16];
338+ int f;
339+
340+ for (va = cpu_gdt_descr->address, f = 0;
341+ va < cpu_gdt_descr->address + cpu_gdt_descr->size;
342+ va += PAGE_SIZE, f++) {
343+ frames[f] = virt_to_mfn(va);
344+ make_lowmem_page_readonly(
345+ (void *)va, XENFEAT_writable_descriptor_tables);
346 }
347+ BUG_ON(HYPERVISOR_set_gdt(frames, (cpu_gdt_descr->size + 1) / 8));
348+
349+ set_kernel_gs();
350+}
351+
352+/* Common CPU init for both boot and secondary CPUs */
353+static void __cpuinit _cpu_init(int cpu, struct task_struct *curr)
354+{
355+#ifndef CONFIG_X86_NO_TSS
356+ struct tss_struct * t = &per_cpu(init_tss, cpu);
357 #endif
358+ struct thread_struct *thread = &curr->thread;
359+
360+ if (cpu_test_and_set(cpu, cpu_initialized)) {
361+ printk(KERN_WARNING "CPU#%d already initialized!\n", cpu);
362+ for (;;) local_irq_enable();
363+ }
364
365- cpu_gdt_init(cpu_gdt_descr);
366+ printk(KERN_INFO "Initializing CPU#%d\n", cpu);
367+
368+ if (cpu_has_vme || cpu_has_de)
369+ clear_in_cr4(X86_CR4_VME|X86_CR4_PVI|X86_CR4_TSD|X86_CR4_DE);
370+ if (tsc_disable && cpu_has_tsc) {
371+ printk(KERN_NOTICE "Disabling TSC...\n");
372+ /**** FIX-HPA: DOES THIS REALLY BELONG HERE? ****/
373+ clear_bit(X86_FEATURE_TSC, boot_cpu_data.x86_capability);
374+ set_in_cr4(X86_CR4_TSD);
375+ }
376
377 /*
378 * Set up and load the per-CPU TSS and LDT
379 */
380 atomic_inc(&init_mm.mm_count);
381- current->active_mm = &init_mm;
382- BUG_ON(current->mm);
383- enter_lazy_tlb(&init_mm, current);
384+ curr->active_mm = &init_mm;
385+ if (curr->mm)
386+ BUG();
387+ enter_lazy_tlb(&init_mm, curr);
388
389 load_esp0(t, thread);
390
391@@ -719,8 +775,8 @@ old_gdt:
392 __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss);
393 #endif
394
395- /* Clear %fs and %gs. */
396- asm volatile ("movl %0, %%fs; movl %0, %%gs" : : "r" (0));
397+ /* Clear %fs. */
398+ asm volatile ("mov %0, %%fs" : : "r" (0));
399
400 /* Clear all 6 debug registers: */
401 set_debugreg(0, 0);
402@@ -738,6 +794,38 @@ old_gdt:
403 mxcsr_feature_mask_init();
404 }
405
406+/* Entrypoint to initialize secondary CPU */
407+void __cpuinit secondary_cpu_init(void)
408+{
409+ int cpu = smp_processor_id();
410+ struct task_struct *curr = current;
411+
412+ _cpu_init(cpu, curr);
413+}
414+
415+/*
416+ * cpu_init() initializes state that is per-CPU. Some data is already
417+ * initialized (naturally) in the bootstrap process, such as the GDT
418+ * and IDT. We reload them nevertheless, this function acts as a
419+ * 'CPU state barrier', nothing should get across.
420+ */
421+void __cpuinit cpu_init(void)
422+{
423+ int cpu = smp_processor_id();
424+ struct task_struct *curr = current;
425+
426+ /* Set up the real GDT and PDA, so we can transition from the
427+ boot versions. */
428+ if (!init_gdt(cpu, curr)) {
429+ /* failed to allocate something; not much we can do... */
430+ for (;;)
431+ local_irq_enable();
432+ }
433+
434+ cpu_set_gdt(cpu);
435+ _cpu_init(cpu, curr);
436+}
437+
438 #ifdef CONFIG_HOTPLUG_CPU
439 void __cpuinit cpu_uninit(void)
440 {
441--- sle11-2009-06-29.orig/arch/x86/kernel/cpu/mtrr/main-xen.c 2009-06-29 15:14:52.000000000 +0200
442+++ sle11-2009-06-29/arch/x86/kernel/cpu/mtrr/main-xen.c 2008-12-15 11:26:44.000000000 +0100
443@@ -12,7 +12,7 @@
444 static DEFINE_MUTEX(mtrr_mutex);
445
446 void generic_get_mtrr(unsigned int reg, unsigned long *base,
447- unsigned int *size, mtrr_type * type)
448+ unsigned long *size, mtrr_type * type)
449 {
450 struct xen_platform_op op;
451
452@@ -115,8 +115,7 @@ int mtrr_del_page(int reg, unsigned long
453 {
454 unsigned i;
455 mtrr_type ltype;
456- unsigned long lbase;
457- unsigned int lsize;
458+ unsigned long lbase, lsize;
459 int error = -EINVAL;
460 struct xen_platform_op op;
461
462--- /dev/null 1970-01-01 00:00:00.000000000 +0000
463+++ sle11-2009-06-29/arch/x86/kernel/e820_32-xen.c 2008-12-15 11:26:44.000000000 +0100
464@@ -0,0 +1,1015 @@
465+#include <linux/kernel.h>
466+#include <linux/types.h>
467+#include <linux/init.h>
468+#include <linux/bootmem.h>
469+#include <linux/ioport.h>
470+#include <linux/string.h>
471+#include <linux/kexec.h>
472+#include <linux/module.h>
473+#include <linux/mm.h>
474+#include <linux/efi.h>
475+#include <linux/pfn.h>
476+#include <linux/uaccess.h>
477+
478+#include <asm/pgtable.h>
479+#include <asm/page.h>
480+#include <asm/e820.h>
481+#include <xen/interface/memory.h>
482+
483+#ifdef CONFIG_EFI
484+int efi_enabled = 0;
485+EXPORT_SYMBOL(efi_enabled);
486+#endif
487+
488+struct e820map e820;
489+struct change_member {
490+ struct e820entry *pbios; /* pointer to original bios entry */
491+ unsigned long long addr; /* address for this change point */
492+};
493+static struct change_member change_point_list[2*E820MAX] __initdata;
494+static struct change_member *change_point[2*E820MAX] __initdata;
495+static struct e820entry *overlap_list[E820MAX] __initdata;
496+static struct e820entry new_bios[E820MAX] __initdata;
497+/* For PCI or other memory-mapped resources */
498+unsigned long pci_mem_start = 0x10000000;
499+#ifdef CONFIG_PCI
500+EXPORT_SYMBOL(pci_mem_start);
501+#endif
502+extern int user_defined_memmap;
503+struct resource data_resource = {
504+ .name = "Kernel data",
505+ .start = 0,
506+ .end = 0,
507+ .flags = IORESOURCE_BUSY | IORESOURCE_MEM
508+};
509+
510+struct resource code_resource = {
511+ .name = "Kernel code",
512+ .start = 0,
513+ .end = 0,
514+ .flags = IORESOURCE_BUSY | IORESOURCE_MEM
515+};
516+
517+static struct resource system_rom_resource = {
518+ .name = "System ROM",
519+ .start = 0xf0000,
520+ .end = 0xfffff,
521+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
522+};
523+
524+static struct resource extension_rom_resource = {
525+ .name = "Extension ROM",
526+ .start = 0xe0000,
527+ .end = 0xeffff,
528+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
529+};
530+
531+static struct resource adapter_rom_resources[] = { {
532+ .name = "Adapter ROM",
533+ .start = 0xc8000,
534+ .end = 0,
535+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
536+}, {
537+ .name = "Adapter ROM",
538+ .start = 0,
539+ .end = 0,
540+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
541+}, {
542+ .name = "Adapter ROM",
543+ .start = 0,
544+ .end = 0,
545+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
546+}, {
547+ .name = "Adapter ROM",
548+ .start = 0,
549+ .end = 0,
550+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
551+}, {
552+ .name = "Adapter ROM",
553+ .start = 0,
554+ .end = 0,
555+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
556+}, {
557+ .name = "Adapter ROM",
558+ .start = 0,
559+ .end = 0,
560+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
561+} };
562+
563+static struct resource video_rom_resource = {
564+ .name = "Video ROM",
565+ .start = 0xc0000,
566+ .end = 0xc7fff,
567+ .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
568+};
569+
570+static struct resource video_ram_resource = {
571+ .name = "Video RAM area",
572+ .start = 0xa0000,
573+ .end = 0xbffff,
574+ .flags = IORESOURCE_BUSY | IORESOURCE_MEM
575+};
576+
577+static struct resource standard_io_resources[] = { {
578+ .name = "dma1",
579+ .start = 0x0000,
580+ .end = 0x001f,
581+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
582+}, {
583+ .name = "pic1",
584+ .start = 0x0020,
585+ .end = 0x0021,
586+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
587+}, {
588+ .name = "timer0",
589+ .start = 0x0040,
590+ .end = 0x0043,
591+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
592+}, {
593+ .name = "timer1",
594+ .start = 0x0050,
595+ .end = 0x0053,
596+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
597+}, {
598+ .name = "keyboard",
599+ .start = 0x0060,
600+ .end = 0x006f,
601+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
602+}, {
603+ .name = "dma page reg",
604+ .start = 0x0080,
605+ .end = 0x008f,
606+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
607+}, {
608+ .name = "pic2",
609+ .start = 0x00a0,
610+ .end = 0x00a1,
611+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
612+}, {
613+ .name = "dma2",
614+ .start = 0x00c0,
615+ .end = 0x00df,
616+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
617+}, {
618+ .name = "fpu",
619+ .start = 0x00f0,
620+ .end = 0x00ff,
621+ .flags = IORESOURCE_BUSY | IORESOURCE_IO
622+} };
623+
624+static int romsignature(const unsigned char *x)
625+{
626+ unsigned short sig;
627+ int ret = 0;
628+ if (probe_kernel_address((const unsigned short *)x, sig) == 0)
629+ ret = (sig == 0xaa55);
630+ return ret;
631+}
632+
633+static int __init romchecksum(unsigned char *rom, unsigned long length)
634+{
635+ unsigned char *p, sum = 0;
636+
637+ for (p = rom; p < rom + length; p++)
638+ sum += *p;
639+ return sum == 0;
640+}
641+
642+static void __init probe_roms(void)
643+{
644+ unsigned long start, length, upper;
645+ unsigned char *rom;
646+ int i;
647+
648+#ifdef CONFIG_XEN
649+ /* Nothing to do if not running in dom0. */
650+ if (!is_initial_xendomain())
651+ return;
652+#endif
653+
654+ /* video rom */
655+ upper = adapter_rom_resources[0].start;
656+ for (start = video_rom_resource.start; start < upper; start += 2048) {
657+ rom = isa_bus_to_virt(start);
658+ if (!romsignature(rom))
659+ continue;
660+
661+ video_rom_resource.start = start;
662+
663+ /* 0 < length <= 0x7f * 512, historically */
664+ length = rom[2] * 512;
665+
666+ /* if checksum okay, trust length byte */
667+ if (length && romchecksum(rom, length))
668+ video_rom_resource.end = start + length - 1;
669+
670+ request_resource(&iomem_resource, &video_rom_resource);
671+ break;
672+ }
673+
674+ start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
675+ if (start < upper)
676+ start = upper;
677+
678+ /* system rom */
679+ request_resource(&iomem_resource, &system_rom_resource);
680+ upper = system_rom_resource.start;
681+
682+ /* check for extension rom (ignore length byte!) */
683+ rom = isa_bus_to_virt((unsigned long)extension_rom_resource.start);
684+ if (romsignature(rom)) {
685+ length = extension_rom_resource.end - extension_rom_resource.start + 1;
686+ if (romchecksum(rom, length)) {
687+ request_resource(&iomem_resource, &extension_rom_resource);
688+ upper = extension_rom_resource.start;
689+ }
690+ }
691+
692+ /* check for adapter roms on 2k boundaries */
693+ for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
694+ rom = isa_bus_to_virt(start);
695+ if (!romsignature(rom))
696+ continue;
697+
698+ /* 0 < length <= 0x7f * 512, historically */
699+ length = rom[2] * 512;
700+
701+ /* but accept any length that fits if checksum okay */
702+ if (!length || start + length > upper || !romchecksum(rom, length))
703+ continue;
704+
705+ adapter_rom_resources[i].start = start;
706+ adapter_rom_resources[i].end = start + length - 1;
707+ request_resource(&iomem_resource, &adapter_rom_resources[i]);
708+
709+ start = adapter_rom_resources[i++].end & ~2047UL;
710+ }
711+}
712+
713+#ifdef CONFIG_XEN
714+static struct e820map machine_e820 __initdata;
715+#define e820 machine_e820
716+#endif
717+
718+/*
719+ * Request address space for all standard RAM and ROM resources
720+ * and also for regions reported as reserved by the e820.
721+ */
722+static void __init
723+legacy_init_iomem_resources(struct resource *code_resource, struct resource *data_resource)
724+{
725+ int i;
726+
727+ probe_roms();
728+ for (i = 0; i < e820.nr_map; i++) {
729+ struct resource *res;
730+#ifndef CONFIG_RESOURCES_64BIT
731+ if (e820.map[i].addr + e820.map[i].size > 0x100000000ULL)
732+ continue;
733+#endif
734+ res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
735+ switch (e820.map[i].type) {
736+ case E820_RAM: res->name = "System RAM"; break;
737+ case E820_ACPI: res->name = "ACPI Tables"; break;
738+ case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
739+ default: res->name = "reserved";
740+ }
741+ res->start = e820.map[i].addr;
742+ res->end = res->start + e820.map[i].size - 1;
743+ res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
744+ if (request_resource(&iomem_resource, res)) {
745+ kfree(res);
746+ continue;
747+ }
748+ if (e820.map[i].type == E820_RAM) {
749+ /*
750+ * We don't know which RAM region contains kernel data,
751+ * so we try it repeatedly and let the resource manager
752+ * test it.
753+ */
754+#ifndef CONFIG_XEN
755+ request_resource(res, code_resource);
756+ request_resource(res, data_resource);
757+#endif
758+#ifdef CONFIG_KEXEC
759+ request_resource(res, &crashk_res);
760+#ifdef CONFIG_XEN
761+ xen_machine_kexec_register_resources(res);
762+#endif
763+#endif
764+ }
765+ }
766+}
767+
768+#undef e820
769+
770+/*
771+ * Request address space for all standard resources
772+ *
773+ * This is called just before pcibios_init(), which is also a
774+ * subsys_initcall, but is linked in later (in arch/i386/pci/common.c).
775+ */
776+static int __init request_standard_resources(void)
777+{
778+ int i;
779+
780+ /* Nothing to do if not running in dom0. */
781+ if (!is_initial_xendomain())
782+ return 0;
783+
784+ printk("Setting up standard PCI resources\n");
785+ if (efi_enabled)
786+ efi_initialize_iomem_resources(&code_resource, &data_resource);
787+ else
788+ legacy_init_iomem_resources(&code_resource, &data_resource);
789+
790+ /* EFI systems may still have VGA */
791+ request_resource(&iomem_resource, &video_ram_resource);
792+
793+ /* request I/O space for devices used on all i[345]86 PCs */
794+ for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
795+ request_resource(&ioport_resource, &standard_io_resources[i]);
796+ return 0;
797+}
798+
799+subsys_initcall(request_standard_resources);
800+
801+void __init add_memory_region(unsigned long long start,
802+ unsigned long long size, int type)
803+{
804+ int x;
805+
806+ if (!efi_enabled) {
807+ x = e820.nr_map;
808+
809+ if (x == E820MAX) {
810+ printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
811+ return;
812+ }
813+
814+ e820.map[x].addr = start;
815+ e820.map[x].size = size;
816+ e820.map[x].type = type;
817+ e820.nr_map++;
818+ }
819+} /* add_memory_region */
820+
821+/*
822+ * Sanitize the BIOS e820 map.
823+ *
824+ * Some e820 responses include overlapping entries. The following
825+ * replaces the original e820 map with a new one, removing overlaps.
826+ *
827+ */
828+int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
829+{
830+ struct change_member *change_tmp;
831+ unsigned long current_type, last_type;
832+ unsigned long long last_addr;
833+ int chgidx, still_changing;
834+ int overlap_entries;
835+ int new_bios_entry;
836+ int old_nr, new_nr, chg_nr;
837+ int i;
838+
839+ /*
840+ Visually we're performing the following (1,2,3,4 = memory types)...
841+
842+ Sample memory map (w/overlaps):
843+ ____22__________________
844+ ______________________4_
845+ ____1111________________
846+ _44_____________________
847+ 11111111________________
848+ ____________________33__
849+ ___________44___________
850+ __________33333_________
851+ ______________22________
852+ ___________________2222_
853+ _________111111111______
854+ _____________________11_
855+ _________________4______
856+
857+ Sanitized equivalent (no overlap):
858+ 1_______________________
859+ _44_____________________
860+ ___1____________________
861+ ____22__________________
862+ ______11________________
863+ _________1______________
864+ __________3_____________
865+ ___________44___________
866+ _____________33_________
867+ _______________2________
868+ ________________1_______
869+ _________________4______
870+ ___________________2____
871+ ____________________33__
872+ ______________________4_
873+ */
874+ printk("sanitize start\n");
875+ /* if there's only one memory region, don't bother */
876+ if (*pnr_map < 2) {
877+ printk("sanitize bail 0\n");
878+ return -1;
879+ }
880+
881+ old_nr = *pnr_map;
882+
883+ /* bail out if we find any unreasonable addresses in bios map */
884+ for (i=0; i<old_nr; i++)
885+ if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr) {
886+ printk("sanitize bail 1\n");
887+ return -1;
888+ }
889+
890+ /* create pointers for initial change-point information (for sorting) */
891+ for (i=0; i < 2*old_nr; i++)
892+ change_point[i] = &change_point_list[i];
893+
894+ /* record all known change-points (starting and ending addresses),
895+ omitting those that are for empty memory regions */
896+ chgidx = 0;
897+ for (i=0; i < old_nr; i++) {
898+ if (biosmap[i].size != 0) {
899+ change_point[chgidx]->addr = biosmap[i].addr;
900+ change_point[chgidx++]->pbios = &biosmap[i];
901+ change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
902+ change_point[chgidx++]->pbios = &biosmap[i];
903+ }
904+ }
905+ chg_nr = chgidx; /* true number of change-points */
906+
907+ /* sort change-point list by memory addresses (low -> high) */
908+ still_changing = 1;
909+ while (still_changing) {
910+ still_changing = 0;
911+ for (i=1; i < chg_nr; i++) {
912+ /* if <current_addr> > <last_addr>, swap */
913+ /* or, if current=<start_addr> & last=<end_addr>, swap */
914+ if ((change_point[i]->addr < change_point[i-1]->addr) ||
915+ ((change_point[i]->addr == change_point[i-1]->addr) &&
916+ (change_point[i]->addr == change_point[i]->pbios->addr) &&
917+ (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
918+ )
919+ {
920+ change_tmp = change_point[i];
921+ change_point[i] = change_point[i-1];
922+ change_point[i-1] = change_tmp;
923+ still_changing=1;
924+ }
925+ }
926+ }
927+
928+ /* create a new bios memory map, removing overlaps */
929+ overlap_entries=0; /* number of entries in the overlap table */
930+ new_bios_entry=0; /* index for creating new bios map entries */
931+ last_type = 0; /* start with undefined memory type */
932+ last_addr = 0; /* start with 0 as last starting address */
933+ /* loop through change-points, determining affect on the new bios map */
934+ for (chgidx=0; chgidx < chg_nr; chgidx++)
935+ {
936+ /* keep track of all overlapping bios entries */
937+ if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
938+ {
939+ /* add map entry to overlap list (> 1 entry implies an overlap) */
940+ overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
941+ }
942+ else
943+ {
944+ /* remove entry from list (order independent, so swap with last) */
945+ for (i=0; i<overlap_entries; i++)
946+ {
947+ if (overlap_list[i] == change_point[chgidx]->pbios)
948+ overlap_list[i] = overlap_list[overlap_entries-1];
949+ }
950+ overlap_entries--;
951+ }
952+ /* if there are overlapping entries, decide which "type" to use */
953+ /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
954+ current_type = 0;
955+ for (i=0; i<overlap_entries; i++)
956+ if (overlap_list[i]->type > current_type)
957+ current_type = overlap_list[i]->type;
958+ /* continue building up new bios map based on this information */
959+ if (current_type != last_type) {
960+ if (last_type != 0) {
961+ new_bios[new_bios_entry].size =
962+ change_point[chgidx]->addr - last_addr;
963+ /* move forward only if the new size was non-zero */
964+ if (new_bios[new_bios_entry].size != 0)
965+ if (++new_bios_entry >= E820MAX)
966+ break; /* no more space left for new bios entries */
967+ }
968+ if (current_type != 0) {
969+ new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
970+ new_bios[new_bios_entry].type = current_type;
971+ last_addr=change_point[chgidx]->addr;
972+ }
973+ last_type = current_type;
974+ }
975+ }
976+ new_nr = new_bios_entry; /* retain count for new bios entries */
977+
978+ /* copy new bios mapping into original location */
979+ memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
980+ *pnr_map = new_nr;
981+
982+ printk("sanitize end\n");
983+ return 0;
984+}
985+
986+/*
987+ * Copy the BIOS e820 map into a safe place.
988+ *
989+ * Sanity-check it while we're at it..
990+ *
991+ * If we're lucky and live on a modern system, the setup code
992+ * will have given us a memory map that we can use to properly
993+ * set up memory. If we aren't, we'll fake a memory map.
994+ *
995+ * We check to see that the memory map contains at least 2 elements
996+ * before we'll use it, because the detection code in setup.S may
997+ * not be perfect and most every PC known to man has two memory
998+ * regions: one from 0 to 640k, and one from 1mb up. (The IBM
999+ * thinkpad 560x, for example, does not cooperate with the memory
1000+ * detection code.)
1001+ */
1002+int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
1003+{
1004+#ifndef CONFIG_XEN
1005+ /* Only one memory region (or negative)? Ignore it */
1006+ if (nr_map < 2)
1007+ return -1;
1008+#else
1009+ BUG_ON(nr_map < 1);
1010+#endif
1011+
1012+ do {
1013+ unsigned long long start = biosmap->addr;
1014+ unsigned long long size = biosmap->size;
1015+ unsigned long long end = start + size;
1016+ unsigned long type = biosmap->type;
1017+ printk("copy_e820_map() start: %016Lx size: %016Lx end: %016Lx type: %ld\n", start, size, end, type);
1018+
1019+ /* Overflow in 64 bits? Ignore the memory map. */
1020+ if (start > end)
1021+ return -1;
1022+
1023+#ifndef CONFIG_XEN
1024+ /*
1025+ * Some BIOSes claim RAM in the 640k - 1M region.
1026+ * Not right. Fix it up.
1027+ */
1028+ if (type == E820_RAM) {
1029+ printk("copy_e820_map() type is E820_RAM\n");
1030+ if (start < 0x100000ULL && end > 0xA0000ULL) {
1031+ printk("copy_e820_map() lies in range...\n");
1032+ if (start < 0xA0000ULL) {
1033+ printk("copy_e820_map() start < 0xA0000ULL\n");
1034+ add_memory_region(start, 0xA0000ULL-start, type);
1035+ }
1036+ if (end <= 0x100000ULL) {
1037+ printk("copy_e820_map() end <= 0x100000ULL\n");
1038+ continue;
1039+ }
1040+ start = 0x100000ULL;
1041+ size = end - start;
1042+ }
1043+ }
1044+#endif
1045+ add_memory_region(start, size, type);
1046+ } while (biosmap++,--nr_map);
1047+
1048+#ifdef CONFIG_XEN
1049+ if (is_initial_xendomain()) {
1050+ struct xen_memory_map memmap;
1051+
1052+ memmap.nr_entries = E820MAX;
1053+ set_xen_guest_handle(memmap.buffer, machine_e820.map);
1054+
1055+ if (HYPERVISOR_memory_op(XENMEM_machine_memory_map, &memmap))
1056+ BUG();
1057+ machine_e820.nr_map = memmap.nr_entries;
1058+ } else
1059+ machine_e820 = e820;
1060+#endif
1061+
1062+ return 0;
1063+}
1064+
1065+/*
1066+ * Callback for efi_memory_walk.
1067+ */
1068+static int __init
1069+efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
1070+{
1071+ unsigned long *max_pfn = arg, pfn;
1072+
1073+ if (start < end) {
1074+ pfn = PFN_UP(end -1);
1075+ if (pfn > *max_pfn)
1076+ *max_pfn = pfn;
1077+ }
1078+ return 0;
1079+}
1080+
1081+static int __init
1082+efi_memory_present_wrapper(unsigned long start, unsigned long end, void *arg)
1083+{
1084+ memory_present(0, PFN_UP(start), PFN_DOWN(end));
1085+ return 0;
1086+}
1087+
1088+/*
1089+ * Find the highest page frame number we have available
1090+ */
1091+void __init find_max_pfn(void)
1092+{
1093+ int i;
1094+
1095+ max_pfn = 0;
1096+ if (efi_enabled) {
1097+ efi_memmap_walk(efi_find_max_pfn, &max_pfn);
1098+ efi_memmap_walk(efi_memory_present_wrapper, NULL);
1099+ return;
1100+ }
1101+
1102+ for (i = 0; i < e820.nr_map; i++) {
1103+ unsigned long start, end;
1104+ /* RAM? */
1105+ if (e820.map[i].type != E820_RAM)
1106+ continue;
1107+ start = PFN_UP(e820.map[i].addr);
1108+ end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1109+ if (start >= end)
1110+ continue;
1111+ if (end > max_pfn)
1112+ max_pfn = end;
1113+ memory_present(0, start, end);
1114+ }
1115+}
1116+
1117+/*
1118+ * Free all available memory for boot time allocation. Used
1119+ * as a callback function by efi_memory_walk()
1120+ */
1121+
1122+static int __init
1123+free_available_memory(unsigned long start, unsigned long end, void *arg)
1124+{
1125+ /* check max_low_pfn */
1126+ if (start >= (max_low_pfn << PAGE_SHIFT))
1127+ return 0;
1128+ if (end >= (max_low_pfn << PAGE_SHIFT))
1129+ end = max_low_pfn << PAGE_SHIFT;
1130+ if (start < end)
1131+ free_bootmem(start, end - start);
1132+
1133+ return 0;
1134+}
1135+/*
1136+ * Register fully available low RAM pages with the bootmem allocator.
1137+ */
1138+void __init register_bootmem_low_pages(unsigned long max_low_pfn)
1139+{
1140+ int i;
1141+
1142+ if (efi_enabled) {
1143+ efi_memmap_walk(free_available_memory, NULL);
1144+ return;
1145+ }
1146+ for (i = 0; i < e820.nr_map; i++) {
1147+ unsigned long curr_pfn, last_pfn, size;
1148+ /*
1149+ * Reserve usable low memory
1150+ */
1151+ if (e820.map[i].type != E820_RAM)
1152+ continue;
1153+ /*
1154+ * We are rounding up the start address of usable memory:
1155+ */
1156+ curr_pfn = PFN_UP(e820.map[i].addr);
1157+ if (curr_pfn >= max_low_pfn)
1158+ continue;
1159+ /*
1160+ * ... and at the end of the usable range downwards:
1161+ */
1162+ last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
1163+
1164+#ifdef CONFIG_XEN
1165+ /*
1166+ * Truncate to the number of actual pages currently
1167+ * present.
1168+ */
1169+ if (last_pfn > xen_start_info->nr_pages)
1170+ last_pfn = xen_start_info->nr_pages;
1171+#endif
1172+
1173+ if (last_pfn > max_low_pfn)
1174+ last_pfn = max_low_pfn;
1175+
1176+ /*
1177+ * .. finally, did all the rounding and playing
1178+ * around just make the area go away?
1179+ */
1180+ if (last_pfn <= curr_pfn)
1181+ continue;
1182+
1183+ size = last_pfn - curr_pfn;
1184+ free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
1185+ }
1186+}
1187+
1188+void __init e820_register_memory(void)
1189+{
1190+ unsigned long gapstart, gapsize, round;
1191+ unsigned long long last;
1192+ int i;
1193+
1194+#ifdef CONFIG_XEN
1195+ if (is_initial_xendomain()) {
1196+ struct xen_memory_map memmap;
1197+
1198+ memmap.nr_entries = E820MAX;
1199+ set_xen_guest_handle(memmap.buffer, machine_e820.map);
1200+
1201+ if (HYPERVISOR_memory_op(XENMEM_machine_memory_map, &memmap))
1202+ BUG();
1203+ machine_e820.nr_map = memmap.nr_entries;
1204+ }
1205+ else
1206+ machine_e820 = e820;
1207+#define e820 machine_e820
1208+#endif
1209+
1210+ /*
1211+ * Search for the bigest gap in the low 32 bits of the e820
1212+ * memory space.
1213+ */
1214+ last = 0x100000000ull;
1215+ gapstart = 0x10000000;
1216+ gapsize = 0x400000;
1217+ i = e820.nr_map;
1218+ while (--i >= 0) {
1219+ unsigned long long start = e820.map[i].addr;
1220+ unsigned long long end = start + e820.map[i].size;
1221+
1222+ /*
1223+ * Since "last" is at most 4GB, we know we'll
1224+ * fit in 32 bits if this condition is true
1225+ */
1226+ if (last > end) {
1227+ unsigned long gap = last - end;
1228+
1229+ if (gap > gapsize) {
1230+ gapsize = gap;
1231+ gapstart = end;
1232+ }
1233+ }
1234+ if (start < last)
1235+ last = start;
1236+ }
1237+#undef e820
1238+
1239+ /*
1240+ * See how much we want to round up: start off with
1241+ * rounding to the next 1MB area.
1242+ */
1243+ round = 0x100000;
1244+ while ((gapsize >> 4) > round)
1245+ round += round;
1246+ /* Fun with two's complement */
1247+ pci_mem_start = (gapstart + round) & -round;
1248+
1249+ printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
1250+ pci_mem_start, gapstart, gapsize);
1251+}
1252+
1253+void __init print_memory_map(char *who)
1254+{
1255+ int i;
1256+
1257+ for (i = 0; i < e820.nr_map; i++) {
1258+ printk(" %s: %016Lx - %016Lx ", who,
1259+ e820.map[i].addr,
1260+ e820.map[i].addr + e820.map[i].size);
1261+ switch (e820.map[i].type) {
1262+ case E820_RAM: printk("(usable)\n");
1263+ break;
1264+ case E820_RESERVED:
1265+ printk("(reserved)\n");
1266+ break;
1267+ case E820_ACPI:
1268+ printk("(ACPI data)\n");
1269+ break;
1270+ case E820_NVS:
1271+ printk("(ACPI NVS)\n");
1272+ break;
1273+ default: printk("type %lu\n", e820.map[i].type);
1274+ break;
1275+ }
1276+ }
1277+}
1278+
1279+static __init __always_inline void efi_limit_regions(unsigned long long size)
1280+{
1281+ unsigned long long current_addr = 0;
1282+ efi_memory_desc_t *md, *next_md;
1283+ void *p, *p1;
1284+ int i, j;
1285+
1286+ j = 0;
1287+ p1 = memmap.map;
1288+ for (p = p1, i = 0; p < memmap.map_end; p += memmap.desc_size, i++) {
1289+ md = p;
1290+ next_md = p1;
1291+ current_addr = md->phys_addr +
1292+ PFN_PHYS(md->num_pages);
1293+ if (is_available_memory(md)) {
1294+ if (md->phys_addr >= size) continue;
1295+ memcpy(next_md, md, memmap.desc_size);
1296+ if (current_addr >= size) {
1297+ next_md->num_pages -=
1298+ PFN_UP(current_addr-size);
1299+ }
1300+ p1 += memmap.desc_size;
1301+ next_md = p1;
1302+ j++;
1303+ } else if ((md->attribute & EFI_MEMORY_RUNTIME) ==
1304+ EFI_MEMORY_RUNTIME) {
1305+ /* In order to make runtime services
1306+ * available we have to include runtime
1307+ * memory regions in memory map */
1308+ memcpy(next_md, md, memmap.desc_size);
1309+ p1 += memmap.desc_size;
1310+ next_md = p1;
1311+ j++;
1312+ }
1313+ }
1314+ memmap.nr_map = j;
1315+ memmap.map_end = memmap.map +
1316+ (memmap.nr_map * memmap.desc_size);
1317+}
1318+
1319+void __init limit_regions(unsigned long long size)
1320+{
1321+ unsigned long long current_addr = 0;
1322+ int i;
1323+
1324+ print_memory_map("limit_regions start");
1325+ if (efi_enabled) {
1326+ efi_limit_regions(size);
1327+ return;
1328+ }
1329+ for (i = 0; i < e820.nr_map; i++) {
1330+ current_addr = e820.map[i].addr + e820.map[i].size;
1331+ if (current_addr < size)
1332+ continue;
1333+
1334+ if (e820.map[i].type != E820_RAM)
1335+ continue;
1336+
1337+ if (e820.map[i].addr >= size) {
1338+ /*
1339+ * This region starts past the end of the
1340+ * requested size, skip it completely.
1341+ */
1342+ e820.nr_map = i;
1343+ } else {
1344+ e820.nr_map = i + 1;
1345+ e820.map[i].size -= current_addr - size;
1346+ }
1347+ print_memory_map("limit_regions endfor");
1348+ return;
1349+ }
1350+#ifdef CONFIG_XEN
1351+ if (current_addr < size) {
1352+ /*
1353+ * The e820 map finished before our requested size so
1354+ * extend the final entry to the requested address.
1355+ */
1356+ --i;
1357+ if (e820.map[i].type == E820_RAM)
1358+ e820.map[i].size -= current_addr - size;
1359+ else
1360+ add_memory_region(current_addr, size - current_addr, E820_RAM);
1361+ }
1362+#endif
1363+ print_memory_map("limit_regions endfunc");
1364+}
1365+
1366+/*
1367+ * This function checks if any part of the range <start,end> is mapped
1368+ * with type.
1369+ */
1370+int
1371+e820_any_mapped(u64 start, u64 end, unsigned type)
1372+{
1373+ int i;
1374+
1375+#ifndef CONFIG_XEN
1376+ for (i = 0; i < e820.nr_map; i++) {
1377+ const struct e820entry *ei = &e820.map[i];
1378+#else
1379+ if (!is_initial_xendomain())
1380+ return 0;
1381+ for (i = 0; i < machine_e820.nr_map; ++i) {
1382+ const struct e820entry *ei = &machine_e820.map[i];
1383+#endif
1384+
1385+ if (type && ei->type != type)
1386+ continue;
1387+ if (ei->addr >= end || ei->addr + ei->size <= start)
1388+ continue;
1389+ return 1;
1390+ }
1391+ return 0;
1392+}
1393+EXPORT_SYMBOL_GPL(e820_any_mapped);
1394+
1395+ /*
1396+ * This function checks if the entire range <start,end> is mapped with type.
1397+ *
1398+ * Note: this function only works correct if the e820 table is sorted and
1399+ * not-overlapping, which is the case
1400+ */
1401+int __init
1402+e820_all_mapped(unsigned long s, unsigned long e, unsigned type)
1403+{
1404+ u64 start = s;
1405+ u64 end = e;
1406+ int i;
1407+
1408+#ifndef CONFIG_XEN
1409+ for (i = 0; i < e820.nr_map; i++) {
1410+ struct e820entry *ei = &e820.map[i];
1411+#else
1412+ if (!is_initial_xendomain())
1413+ return 0;
1414+ for (i = 0; i < machine_e820.nr_map; ++i) {
1415+ const struct e820entry *ei = &machine_e820.map[i];
1416+#endif
1417+
1418+ if (type && ei->type != type)
1419+ continue;
1420+ /* is the region (part) in overlap with the current region ?*/
1421+ if (ei->addr >= end || ei->addr + ei->size <= start)
1422+ continue;
1423+ /* if the region is at the beginning of <start,end> we move
1424+ * start to the end of the region since it's ok until there
1425+ */
1426+ if (ei->addr <= start)
1427+ start = ei->addr + ei->size;
1428+ /* if start is now at or beyond end, we're done, full
1429+ * coverage */
1430+ if (start >= end)
1431+ return 1; /* we're done */
1432+ }
1433+ return 0;
1434+}
1435+
1436+static int __init parse_memmap(char *arg)
1437+{
1438+ if (!arg)
1439+ return -EINVAL;
1440+
1441+ if (strcmp(arg, "exactmap") == 0) {
1442+#ifdef CONFIG_CRASH_DUMP
1443+ /* If we are doing a crash dump, we
1444+ * still need to know the real mem
1445+ * size before original memory map is
1446+ * reset.
1447+ */
1448+ find_max_pfn();
1449+ saved_max_pfn = max_pfn;
1450+#endif
1451+ e820.nr_map = 0;
1452+ user_defined_memmap = 1;
1453+ } else {
1454+ /* If the user specifies memory size, we
1455+ * limit the BIOS-provided memory map to
1456+ * that size. exactmap can be used to specify
1457+ * the exact map. mem=number can be used to
1458+ * trim the existing memory map.
1459+ */
1460+ unsigned long long start_at, mem_size;
1461+
1462+ mem_size = memparse(arg, &arg);
1463+ if (*arg == '@') {
1464+ start_at = memparse(arg+1, &arg);
1465+ add_memory_region(start_at, mem_size, E820_RAM);
1466+ } else if (*arg == '#') {
1467+ start_at = memparse(arg+1, &arg);
1468+ add_memory_region(start_at, mem_size, E820_ACPI);
1469+ } else if (*arg == '$') {
1470+ start_at = memparse(arg+1, &arg);
1471+ add_memory_region(start_at, mem_size, E820_RESERVED);
1472+ } else {
1473+ limit_regions(mem_size);
1474+ user_defined_memmap = 1;
1475+ }
1476+ }
1477+ return 0;
1478+}
1479+early_param("memmap", parse_memmap);
1480--- sle11-2009-06-29.orig/arch/x86/kernel/entry_32-xen.S 2009-05-14 11:07:47.000000000 +0200
1481+++ sle11-2009-06-29/arch/x86/kernel/entry_32-xen.S 2009-05-14 11:08:06.000000000 +0200
1482@@ -30,12 +30,13 @@
1483 * 18(%esp) - %eax
1484 * 1C(%esp) - %ds
1485 * 20(%esp) - %es
1486- * 24(%esp) - orig_eax
1487- * 28(%esp) - %eip
1488- * 2C(%esp) - %cs
1489- * 30(%esp) - %eflags
1490- * 34(%esp) - %oldesp
1491- * 38(%esp) - %oldss
1492+ * 24(%esp) - %gs
1493+ * 28(%esp) - orig_eax
1494+ * 2C(%esp) - %eip
1495+ * 30(%esp) - %cs
1496+ * 34(%esp) - %eflags
1497+ * 38(%esp) - %oldesp
1498+ * 3C(%esp) - %oldss
1499 *
1500 * "current" is in register %ebx during any slow entries.
1501 */
1502@@ -48,27 +49,25 @@
1503 #include <asm/smp.h>
1504 #include <asm/page.h>
1505 #include <asm/desc.h>
1506+#include <asm/percpu.h>
1507 #include <asm/dwarf2.h>
1508 #include "irq_vectors.h"
1509 #include <xen/interface/xen.h>
1510
1511-#define nr_syscalls ((syscall_table_size)/4)
1512+/*
1513+ * We use macros for low-level operations which need to be overridden
1514+ * for paravirtualization. The following will never clobber any registers:
1515+ * INTERRUPT_RETURN (aka. "iret")
1516+ * GET_CR0_INTO_EAX (aka. "movl %cr0, %eax")
1517+ * ENABLE_INTERRUPTS_SYSEXIT (aka "sti; sysexit").
1518+ *
1519+ * For DISABLE_INTERRUPTS/ENABLE_INTERRUPTS (aka "cli"/"sti"), you must
1520+ * specify what registers can be overwritten (CLBR_NONE, CLBR_EAX/EDX/ECX/ANY).
1521+ * Allowing a register to be clobbered can shrink the paravirt replacement
1522+ * enough to patch inline, increasing performance.
1523+ */
1524
1525-EBX = 0x00
1526-ECX = 0x04
1527-EDX = 0x08
1528-ESI = 0x0C
1529-EDI = 0x10
1530-EBP = 0x14
1531-EAX = 0x18
1532-DS = 0x1C
1533-ES = 0x20
1534-ORIG_EAX = 0x24
1535-EIP = 0x28
1536-CS = 0x2C
1537-EFLAGS = 0x30
1538-OLDESP = 0x34
1539-OLDSS = 0x38
1540+#define nr_syscalls ((syscall_table_size)/4)
1541
1542 CF_MASK = 0x00000001
1543 TF_MASK = 0x00000100
1544@@ -79,61 +78,16 @@ VM_MASK = 0x00020000
1545 /* Pseudo-eflags. */
1546 NMI_MASK = 0x80000000
1547
1548-#ifndef CONFIG_XEN
1549-/* These are replaces for paravirtualization */
1550-#define DISABLE_INTERRUPTS cli
1551-#define ENABLE_INTERRUPTS sti
1552-#define ENABLE_INTERRUPTS_SYSEXIT sti; sysexit
1553-#define INTERRUPT_RETURN iret
1554-#define GET_CR0_INTO_EAX movl %cr0, %eax
1555-#else
1556-/* Offsets into shared_info_t. */
1557-#define evtchn_upcall_pending /* 0 */
1558-#define evtchn_upcall_mask 1
1559-
1560-#define sizeof_vcpu_shift 6
1561-
1562-#ifdef CONFIG_SMP
1563-#define GET_VCPU_INFO movl TI_cpu(%ebp),%esi ; \
1564- shl $sizeof_vcpu_shift,%esi ; \
1565- addl HYPERVISOR_shared_info,%esi
1566-#else
1567-#define GET_VCPU_INFO movl HYPERVISOR_shared_info,%esi
1568-#endif
1569-
1570-#define __DISABLE_INTERRUPTS movb $1,evtchn_upcall_mask(%esi)
1571-#define __ENABLE_INTERRUPTS movb $0,evtchn_upcall_mask(%esi)
1572-#define __TEST_PENDING testb $0xFF,evtchn_upcall_pending(%esi)
1573-#define DISABLE_INTERRUPTS GET_VCPU_INFO ; \
1574- __DISABLE_INTERRUPTS
1575-#define ENABLE_INTERRUPTS GET_VCPU_INFO ; \
1576- __ENABLE_INTERRUPTS
1577-#define ENABLE_INTERRUPTS_SYSEXIT __ENABLE_INTERRUPTS ; \
1578-sysexit_scrit: /**** START OF SYSEXIT CRITICAL REGION ****/ ; \
1579- __TEST_PENDING ; \
1580- jnz 14f # process more events if necessary... ; \
1581- movl ESI(%esp), %esi ; \
1582- sysexit ; \
1583-14: __DISABLE_INTERRUPTS ; \
1584- TRACE_IRQS_OFF ; \
1585-sysexit_ecrit: /**** END OF SYSEXIT CRITICAL REGION ****/ ; \
1586- push %esp ; \
1587- call evtchn_do_upcall ; \
1588- add $4,%esp ; \
1589- jmp ret_from_intr
1590-#define INTERRUPT_RETURN iret
1591-#endif
1592-
1593 #ifdef CONFIG_PREEMPT
1594-#define preempt_stop DISABLE_INTERRUPTS; TRACE_IRQS_OFF
1595+#define preempt_stop(clobbers) DISABLE_INTERRUPTS(clobbers); TRACE_IRQS_OFF
1596 #else
1597-#define preempt_stop
1598+#define preempt_stop(clobbers)
1599 #define resume_kernel restore_nocheck
1600 #endif
1601
1602 .macro TRACE_IRQS_IRET
1603 #ifdef CONFIG_TRACE_IRQFLAGS
1604- testl $IF_MASK,EFLAGS(%esp) # interrupts off?
1605+ testl $IF_MASK,PT_EFLAGS(%esp) # interrupts off?
1606 jz 1f
1607 TRACE_IRQS_ON
1608 1:
1609@@ -148,6 +102,9 @@ sysexit_ecrit: /**** END OF SYSEXIT CRIT
1610
1611 #define SAVE_ALL \
1612 cld; \
1613+ pushl %gs; \
1614+ CFI_ADJUST_CFA_OFFSET 4;\
1615+ /*CFI_REL_OFFSET gs, 0;*/\
1616 pushl %es; \
1617 CFI_ADJUST_CFA_OFFSET 4;\
1618 /*CFI_REL_OFFSET es, 0;*/\
1619@@ -177,7 +134,9 @@ sysexit_ecrit: /**** END OF SYSEXIT CRIT
1620 CFI_REL_OFFSET ebx, 0;\
1621 movl $(__USER_DS), %edx; \
1622 movl %edx, %ds; \
1623- movl %edx, %es;
1624+ movl %edx, %es; \
1625+ movl $(__KERNEL_PDA), %edx; \
1626+ movl %edx, %gs
1627
1628 #define RESTORE_INT_REGS \
1629 popl %ebx; \
1630@@ -210,17 +169,22 @@ sysexit_ecrit: /**** END OF SYSEXIT CRIT
1631 2: popl %es; \
1632 CFI_ADJUST_CFA_OFFSET -4;\
1633 /*CFI_RESTORE es;*/\
1634-.section .fixup,"ax"; \
1635-3: movl $0,(%esp); \
1636- jmp 1b; \
1637+3: popl %gs; \
1638+ CFI_ADJUST_CFA_OFFSET -4;\
1639+ /*CFI_RESTORE gs;*/\
1640+.pushsection .fixup,"ax"; \
1641 4: movl $0,(%esp); \
1642+ jmp 1b; \
1643+5: movl $0,(%esp); \
1644 jmp 2b; \
1645-.previous; \
1646+6: movl $0,(%esp); \
1647+ jmp 3b; \
1648 .section __ex_table,"a";\
1649 .align 4; \
1650- .long 1b,3b; \
1651- .long 2b,4b; \
1652-.previous
1653+ .long 1b,4b; \
1654+ .long 2b,5b; \
1655+ .long 3b,6b; \
1656+.popsection
1657
1658 #define RING0_INT_FRAME \
1659 CFI_STARTPROC simple;\
1660@@ -239,18 +203,18 @@ sysexit_ecrit: /**** END OF SYSEXIT CRIT
1661 #define RING0_PTREGS_FRAME \
1662 CFI_STARTPROC simple;\
1663 CFI_SIGNAL_FRAME;\
1664- CFI_DEF_CFA esp, OLDESP-EBX;\
1665- /*CFI_OFFSET cs, CS-OLDESP;*/\
1666- CFI_OFFSET eip, EIP-OLDESP;\
1667- /*CFI_OFFSET es, ES-OLDESP;*/\
1668- /*CFI_OFFSET ds, DS-OLDESP;*/\
1669- CFI_OFFSET eax, EAX-OLDESP;\
1670- CFI_OFFSET ebp, EBP-OLDESP;\
1671- CFI_OFFSET edi, EDI-OLDESP;\
1672- CFI_OFFSET esi, ESI-OLDESP;\
1673- CFI_OFFSET edx, EDX-OLDESP;\
1674- CFI_OFFSET ecx, ECX-OLDESP;\
1675- CFI_OFFSET ebx, EBX-OLDESP
1676+ CFI_DEF_CFA esp, PT_OLDESP-PT_EBX;\
1677+ /*CFI_OFFSET cs, PT_CS-PT_OLDESP;*/\
1678+ CFI_OFFSET eip, PT_EIP-PT_OLDESP;\
1679+ /*CFI_OFFSET es, PT_ES-PT_OLDESP;*/\
1680+ /*CFI_OFFSET ds, PT_DS-PT_OLDESP;*/\
1681+ CFI_OFFSET eax, PT_EAX-PT_OLDESP;\
1682+ CFI_OFFSET ebp, PT_EBP-PT_OLDESP;\
1683+ CFI_OFFSET edi, PT_EDI-PT_OLDESP;\
1684+ CFI_OFFSET esi, PT_ESI-PT_OLDESP;\
1685+ CFI_OFFSET edx, PT_EDX-PT_OLDESP;\
1686+ CFI_OFFSET ecx, PT_ECX-PT_OLDESP;\
1687+ CFI_OFFSET ebx, PT_EBX-PT_OLDESP
1688
1689 ENTRY(ret_from_fork)
1690 CFI_STARTPROC
1691@@ -278,17 +242,18 @@ ENTRY(ret_from_fork)
1692 ALIGN
1693 RING0_PTREGS_FRAME
1694 ret_from_exception:
1695- preempt_stop
1696+ preempt_stop(CLBR_ANY)
1697 ret_from_intr:
1698 GET_THREAD_INFO(%ebp)
1699 check_userspace:
1700- movl EFLAGS(%esp), %eax # mix EFLAGS and CS
1701- movb CS(%esp), %al
1702+ movl PT_EFLAGS(%esp), %eax # mix EFLAGS and CS
1703+ movb PT_CS(%esp), %al
1704 andl $(VM_MASK | SEGMENT_RPL_MASK), %eax
1705 cmpl $USER_RPL, %eax
1706 jb resume_kernel # not returning to v8086 or userspace
1707+
1708 ENTRY(resume_userspace)
1709- DISABLE_INTERRUPTS # make sure we don't miss an interrupt
1710+ DISABLE_INTERRUPTS(CLBR_ANY) # make sure we don't miss an interrupt
1711 # setting need_resched or sigpending
1712 # between sampling and the iret
1713 movl TI_flags(%ebp), %ecx
1714@@ -299,14 +264,14 @@ ENTRY(resume_userspace)
1715
1716 #ifdef CONFIG_PREEMPT
1717 ENTRY(resume_kernel)
1718- DISABLE_INTERRUPTS
1719+ DISABLE_INTERRUPTS(CLBR_ANY)
1720 cmpl $0,TI_preempt_count(%ebp) # non-zero preempt_count ?
1721 jnz restore_nocheck
1722 need_resched:
1723 movl TI_flags(%ebp), %ecx # need_resched set ?
1724 testb $_TIF_NEED_RESCHED, %cl
1725 jz restore_all
1726- testl $IF_MASK,EFLAGS(%esp) # interrupts off (exception path) ?
1727+ testl $IF_MASK,PT_EFLAGS(%esp) # interrupts off (exception path) ?
1728 jz restore_all
1729 call preempt_schedule_irq
1730 jmp need_resched
1731@@ -328,7 +293,7 @@ sysenter_past_esp:
1732 * No need to follow this irqs on/off section: the syscall
1733 * disabled irqs and here we enable it straight after entry:
1734 */
1735- ENABLE_INTERRUPTS
1736+ ENABLE_INTERRUPTS(CLBR_NONE)
1737 pushl $(__USER_DS)
1738 CFI_ADJUST_CFA_OFFSET 4
1739 /*CFI_REL_OFFSET ss, 0*/
1740@@ -340,12 +305,16 @@ sysenter_past_esp:
1741 pushl $(__USER_CS)
1742 CFI_ADJUST_CFA_OFFSET 4
1743 /*CFI_REL_OFFSET cs, 0*/
1744+#ifndef CONFIG_COMPAT_VDSO
1745 /*
1746 * Push current_thread_info()->sysenter_return to the stack.
1747 * A tiny bit of offset fixup is necessary - 4*4 means the 4 words
1748 * pushed above; +8 corresponds to copy_thread's esp0 setting.
1749 */
1750 pushl (TI_sysenter_return-THREAD_SIZE+8+4*4)(%esp)
1751+#else
1752+ pushl $SYSENTER_RETURN
1753+#endif
1754 CFI_ADJUST_CFA_OFFSET 4
1755 CFI_REL_OFFSET eip, 0
1756
1757@@ -372,19 +341,27 @@ sysenter_past_esp:
1758 cmpl $(nr_syscalls), %eax
1759 jae syscall_badsys
1760 call *sys_call_table(,%eax,4)
1761- movl %eax,EAX(%esp)
1762- DISABLE_INTERRUPTS
1763+ movl %eax,PT_EAX(%esp)
1764+ DISABLE_INTERRUPTS(CLBR_ECX|CLBR_EDX)
1765 TRACE_IRQS_OFF
1766 movl TI_flags(%ebp), %ecx
1767 testw $_TIF_ALLWORK_MASK, %cx
1768 jne syscall_exit_work
1769 /* if something modifies registers it must also disable sysexit */
1770- movl EIP(%esp), %edx
1771- movl OLDESP(%esp), %ecx
1772+ movl PT_EIP(%esp), %edx
1773+ movl PT_OLDESP(%esp), %ecx
1774 xorl %ebp,%ebp
1775 TRACE_IRQS_ON
1776+1: mov PT_GS(%esp), %gs
1777 ENABLE_INTERRUPTS_SYSEXIT
1778 CFI_ENDPROC
1779+.pushsection .fixup,"ax"
1780+2: movl $0,PT_GS(%esp)
1781+ jmp 1b
1782+.section __ex_table,"a"
1783+ .align 4
1784+ .long 1b,2b
1785+.popsection
1786
1787 # pv sysenter call handler stub
1788 ENTRY(sysenter_entry_pv)
1789@@ -419,7 +396,7 @@ ENTRY(system_call)
1790 CFI_ADJUST_CFA_OFFSET 4
1791 SAVE_ALL
1792 GET_THREAD_INFO(%ebp)
1793- testl $TF_MASK,EFLAGS(%esp)
1794+ testl $TF_MASK,PT_EFLAGS(%esp)
1795 jz no_singlestep
1796 orl $_TIF_SINGLESTEP,TI_flags(%ebp)
1797 no_singlestep:
1798@@ -431,9 +408,9 @@ no_singlestep:
1799 jae syscall_badsys
1800 syscall_call:
1801 call *sys_call_table(,%eax,4)
1802- movl %eax,EAX(%esp) # store the return value
1803+ movl %eax,PT_EAX(%esp) # store the return value
1804 syscall_exit:
1805- DISABLE_INTERRUPTS # make sure we don't miss an interrupt
1806+ DISABLE_INTERRUPTS(CLBR_ANY) # make sure we don't miss an interrupt
1807 # setting need_resched or sigpending
1808 # between sampling and the iret
1809 TRACE_IRQS_OFF
1810@@ -443,12 +420,12 @@ syscall_exit:
1811
1812 restore_all:
1813 #ifndef CONFIG_XEN
1814- movl EFLAGS(%esp), %eax # mix EFLAGS, SS and CS
1815- # Warning: OLDSS(%esp) contains the wrong/random values if we
1816+ movl PT_EFLAGS(%esp), %eax # mix EFLAGS, SS and CS
1817+ # Warning: PT_OLDSS(%esp) contains the wrong/random values if we
1818 # are returning to the kernel.
1819 # See comments in process.c:copy_thread() for details.
1820- movb OLDSS(%esp), %ah
1821- movb CS(%esp), %al
1822+ movb PT_OLDSS(%esp), %ah
1823+ movb PT_CS(%esp), %al
1824 andl $(VM_MASK | (SEGMENT_TI_MASK << 8) | SEGMENT_RPL_MASK), %eax
1825 cmpl $((SEGMENT_LDT << 8) | USER_RPL), %eax
1826 CFI_REMEMBER_STATE
1827@@ -456,7 +433,7 @@ restore_all:
1828 restore_nocheck:
1829 #else
1830 restore_nocheck:
1831- movl EFLAGS(%esp), %eax
1832+ movl PT_EFLAGS(%esp), %eax
1833 testl $(VM_MASK|NMI_MASK), %eax
1834 CFI_REMEMBER_STATE
1835 jnz hypervisor_iret
1836@@ -470,13 +447,13 @@ restore_nocheck:
1837 TRACE_IRQS_IRET
1838 restore_nocheck_notrace:
1839 RESTORE_REGS
1840- addl $4, %esp
1841+ addl $4, %esp # skip orig_eax/error_code
1842 CFI_ADJUST_CFA_OFFSET -4
1843 1: INTERRUPT_RETURN
1844 .section .fixup,"ax"
1845 iret_exc:
1846 #ifndef CONFIG_XEN
1847- ENABLE_INTERRUPTS
1848+ ENABLE_INTERRUPTS(CLBR_NONE)
1849 #endif
1850 pushl $0 # no error code
1851 pushl $do_iret_error
1852@@ -490,33 +467,42 @@ iret_exc:
1853 CFI_RESTORE_STATE
1854 #ifndef CONFIG_XEN
1855 ldt_ss:
1856- larl OLDSS(%esp), %eax
1857+ larl PT_OLDSS(%esp), %eax
1858 jnz restore_nocheck
1859 testl $0x00400000, %eax # returning to 32bit stack?
1860 jnz restore_nocheck # allright, normal return
1861+
1862+#ifdef CONFIG_PARAVIRT
1863+ /*
1864+ * The kernel can't run on a non-flat stack if paravirt mode
1865+ * is active. Rather than try to fixup the high bits of
1866+ * ESP, bypass this code entirely. This may break DOSemu
1867+ * and/or Wine support in a paravirt VM, although the option
1868+ * is still available to implement the setting of the high
1869+ * 16-bits in the INTERRUPT_RETURN paravirt-op.
1870+ */
1871+ cmpl $0, paravirt_ops+PARAVIRT_enabled
1872+ jne restore_nocheck
1873+#endif
1874+
1875 /* If returning to userspace with 16bit stack,
1876 * try to fix the higher word of ESP, as the CPU
1877 * won't restore it.
1878 * This is an "official" bug of all the x86-compatible
1879 * CPUs, which we can try to work around to make
1880 * dosemu and wine happy. */
1881- subl $8, %esp # reserve space for switch16 pointer
1882- CFI_ADJUST_CFA_OFFSET 8
1883- DISABLE_INTERRUPTS
1884+ movl PT_OLDESP(%esp), %eax
1885+ movl %esp, %edx
1886+ call patch_espfix_desc
1887+ pushl $__ESPFIX_SS
1888+ CFI_ADJUST_CFA_OFFSET 4
1889+ pushl %eax
1890+ CFI_ADJUST_CFA_OFFSET 4
1891+ DISABLE_INTERRUPTS(CLBR_EAX)
1892 TRACE_IRQS_OFF
1893- movl %esp, %eax
1894- /* Set up the 16bit stack frame with switch32 pointer on top,
1895- * and a switch16 pointer on top of the current frame. */
1896- call setup_x86_bogus_stack
1897- CFI_ADJUST_CFA_OFFSET -8 # frame has moved
1898- TRACE_IRQS_IRET
1899- RESTORE_REGS
1900- lss 20+4(%esp), %esp # switch to 16bit stack
1901-1: INTERRUPT_RETURN
1902-.section __ex_table,"a"
1903- .align 4
1904- .long 1b,iret_exc
1905-.previous
1906+ lss (%esp), %esp
1907+ CFI_ADJUST_CFA_OFFSET -8
1908+ jmp restore_nocheck
1909 #else
1910 ALIGN
1911 restore_all_enable_events:
1912@@ -540,7 +526,7 @@ ecrit: /**** END OF CRITICAL REGION ***
1913
1914 CFI_RESTORE_STATE
1915 hypervisor_iret:
1916- andl $~NMI_MASK, EFLAGS(%esp)
1917+ andl $~NMI_MASK, PT_EFLAGS(%esp)
1918 RESTORE_REGS
1919 addl $4, %esp
1920 CFI_ADJUST_CFA_OFFSET -4
1921@@ -556,7 +542,7 @@ work_pending:
1922 jz work_notifysig
1923 work_resched:
1924 call schedule
1925- DISABLE_INTERRUPTS # make sure we don't miss an interrupt
1926+ DISABLE_INTERRUPTS(CLBR_ANY) # make sure we don't miss an interrupt
1927 # setting need_resched or sigpending
1928 # between sampling and the iret
1929 TRACE_IRQS_OFF
1930@@ -569,7 +555,8 @@ work_resched:
1931
1932 work_notifysig: # deal with pending signals and
1933 # notify-resume requests
1934- testl $VM_MASK, EFLAGS(%esp)
1935+#ifdef CONFIG_VM86
1936+ testl $VM_MASK, PT_EFLAGS(%esp)
1937 movl %esp, %eax
1938 jne work_notifysig_v86 # returning to kernel-space or
1939 # vm86-space
1940@@ -579,29 +566,30 @@ work_notifysig: # deal with pending s
1941
1942 ALIGN
1943 work_notifysig_v86:
1944-#ifdef CONFIG_VM86
1945 pushl %ecx # save ti_flags for do_notify_resume
1946 CFI_ADJUST_CFA_OFFSET 4
1947 call save_v86_state # %eax contains pt_regs pointer
1948 popl %ecx
1949 CFI_ADJUST_CFA_OFFSET -4
1950 movl %eax, %esp
1951+#else
1952+ movl %esp, %eax
1953+#endif
1954 xorl %edx, %edx
1955 call do_notify_resume
1956 jmp resume_userspace_sig
1957-#endif
1958
1959 # perform syscall exit tracing
1960 ALIGN
1961 syscall_trace_entry:
1962- movl $-ENOSYS,EAX(%esp)
1963+ movl $-ENOSYS,PT_EAX(%esp)
1964 movl %esp, %eax
1965 xorl %edx,%edx
1966 call do_syscall_trace
1967 cmpl $0, %eax
1968 jne resume_userspace # ret != 0 -> running under PTRACE_SYSEMU,
1969 # so must skip actual syscall
1970- movl ORIG_EAX(%esp), %eax
1971+ movl PT_ORIG_EAX(%esp), %eax
1972 cmpl $(nr_syscalls), %eax
1973 jnae syscall_call
1974 jmp syscall_exit
1975@@ -612,7 +600,7 @@ syscall_exit_work:
1976 testb $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP), %cl
1977 jz work_pending
1978 TRACE_IRQS_ON
1979- ENABLE_INTERRUPTS # could let do_syscall_trace() call
1980+ ENABLE_INTERRUPTS(CLBR_ANY) # could let do_syscall_trace() call
1981 # schedule() instead
1982 movl %esp, %eax
1983 movl $1, %edx
1984@@ -626,40 +614,39 @@ syscall_fault:
1985 CFI_ADJUST_CFA_OFFSET 4
1986 SAVE_ALL
1987 GET_THREAD_INFO(%ebp)
1988- movl $-EFAULT,EAX(%esp)
1989+ movl $-EFAULT,PT_EAX(%esp)
1990 jmp resume_userspace
1991
1992 syscall_badsys:
1993- movl $-ENOSYS,EAX(%esp)
1994+ movl $-ENOSYS,PT_EAX(%esp)
1995 jmp resume_userspace
1996 CFI_ENDPROC
1997
1998 #ifndef CONFIG_XEN
1999 #define FIXUP_ESPFIX_STACK \
2000- movl %esp, %eax; \
2001- /* switch to 32bit stack using the pointer on top of 16bit stack */ \
2002- lss %ss:CPU_16BIT_STACK_SIZE-8, %esp; \
2003- /* copy data from 16bit stack to 32bit stack */ \
2004- call fixup_x86_bogus_stack; \
2005- /* put ESP to the proper location */ \
2006- movl %eax, %esp;
2007-#define UNWIND_ESPFIX_STACK \
2008+ /* since we are on a wrong stack, we cant make it a C code :( */ \
2009+ movl %gs:PDA_cpu, %ebx; \
2010+ PER_CPU(cpu_gdt_descr, %ebx); \
2011+ movl GDS_address(%ebx), %ebx; \
2012+ GET_DESC_BASE(GDT_ENTRY_ESPFIX_SS, %ebx, %eax, %ax, %al, %ah); \
2013+ addl %esp, %eax; \
2014+ pushl $__KERNEL_DS; \
2015+ CFI_ADJUST_CFA_OFFSET 4; \
2016 pushl %eax; \
2017 CFI_ADJUST_CFA_OFFSET 4; \
2018+ lss (%esp), %esp; \
2019+ CFI_ADJUST_CFA_OFFSET -8;
2020+#define UNWIND_ESPFIX_STACK \
2021 movl %ss, %eax; \
2022- /* see if on 16bit stack */ \
2023+ /* see if on espfix stack */ \
2024 cmpw $__ESPFIX_SS, %ax; \
2025- je 28f; \
2026-27: popl %eax; \
2027- CFI_ADJUST_CFA_OFFSET -4; \
2028-.section .fixup,"ax"; \
2029-28: movl $__KERNEL_DS, %eax; \
2030+ jne 27f; \
2031+ movl $__KERNEL_DS, %eax; \
2032 movl %eax, %ds; \
2033 movl %eax, %es; \
2034- /* switch to 32bit stack */ \
2035+ /* switch to normal stack */ \
2036 FIXUP_ESPFIX_STACK; \
2037- jmp 27b; \
2038-.previous
2039+27:;
2040
2041 /*
2042 * Build the entry stubs and pointer table with
2043@@ -723,13 +710,16 @@ KPROBE_ENTRY(page_fault)
2044 CFI_ADJUST_CFA_OFFSET 4
2045 ALIGN
2046 error_code:
2047+ /* the function address is in %gs's slot on the stack */
2048+ pushl %es
2049+ CFI_ADJUST_CFA_OFFSET 4
2050+ /*CFI_REL_OFFSET es, 0*/
2051 pushl %ds
2052 CFI_ADJUST_CFA_OFFSET 4
2053 /*CFI_REL_OFFSET ds, 0*/
2054 pushl %eax
2055 CFI_ADJUST_CFA_OFFSET 4
2056 CFI_REL_OFFSET eax, 0
2057- xorl %eax, %eax
2058 pushl %ebp
2059 CFI_ADJUST_CFA_OFFSET 4
2060 CFI_REL_OFFSET ebp, 0
2061@@ -742,7 +732,6 @@ error_code:
2062 pushl %edx
2063 CFI_ADJUST_CFA_OFFSET 4
2064 CFI_REL_OFFSET edx, 0
2065- decl %eax # eax = -1
2066 pushl %ecx
2067 CFI_ADJUST_CFA_OFFSET 4
2068 CFI_REL_OFFSET ecx, 0
2069@@ -750,18 +739,20 @@ error_code:
2070 CFI_ADJUST_CFA_OFFSET 4
2071 CFI_REL_OFFSET ebx, 0
2072 cld
2073- pushl %es
2074+ pushl %gs
2075 CFI_ADJUST_CFA_OFFSET 4
2076- /*CFI_REL_OFFSET es, 0*/
2077+ /*CFI_REL_OFFSET gs, 0*/
2078+ movl $(__KERNEL_PDA), %ecx
2079+ movl %ecx, %gs
2080 UNWIND_ESPFIX_STACK
2081 popl %ecx
2082 CFI_ADJUST_CFA_OFFSET -4
2083 /*CFI_REGISTER es, ecx*/
2084- movl ES(%esp), %edi # get the function address
2085- movl ORIG_EAX(%esp), %edx # get the error code
2086- movl %eax, ORIG_EAX(%esp)
2087- movl %ecx, ES(%esp)
2088- /*CFI_REL_OFFSET es, ES*/
2089+ movl PT_GS(%esp), %edi # get the function address
2090+ movl PT_ORIG_EAX(%esp), %edx # get the error code
2091+ movl $-1, PT_ORIG_EAX(%esp) # no syscall to restart
2092+ mov %ecx, PT_GS(%esp)
2093+ /*CFI_REL_OFFSET gs, ES*/
2094 movl $(__USER_DS), %ecx
2095 movl %ecx, %ds
2096 movl %ecx, %es
2097@@ -793,8 +784,8 @@ ENTRY(hypervisor_callback)
2098 pushl %eax
2099 CFI_ADJUST_CFA_OFFSET 4
2100 SAVE_ALL
2101- movl CS(%esp),%ecx
2102- movl EIP(%esp),%eax
2103+ movl PT_CS(%esp),%ecx
2104+ movl PT_EIP(%esp),%eax
2105 andl $SEGMENT_RPL_MASK,%ecx
2106 cmpl $USER_RPL,%ecx
2107 jae .Ldo_upcall
2108@@ -808,7 +799,7 @@ ENTRY(hypervisor_callback)
2109 jb .Ldo_upcall
2110 cmpl $sysexit_ecrit,%eax
2111 ja .Ldo_upcall
2112- addl $OLDESP,%esp # Remove eflags...ebx from stack frame.
2113+ addl $PT_OLDESP,%esp # Remove eflags...ebx from stack frame.
2114 #endif
2115 .Ldo_upcall:
2116 push %esp
2117@@ -830,7 +821,7 @@ critical_region_fixup:
2118 movsbl critical_fixup_table-scrit(%eax),%ecx # %ecx contains num slots popped
2119 testl %ecx,%ecx
2120 leal (%esp,%ecx,4),%esi # %esi points at end of src region
2121- leal OLDESP(%esp),%edi # %edi points at end of dst region
2122+ leal PT_OLDESP(%esp),%edi # %edi points at end of dst region
2123 jle 17f # skip loop if nothing to copy
2124 16: subl $4,%esi # pre-decrementing copy loop
2125 subl $4,%edi
2126@@ -853,8 +844,9 @@ critical_fixup_table:
2127 .byte 6 # pop %eax
2128 .byte 7 # pop %ds
2129 .byte 8 # pop %es
2130- .byte 9,9,9 # add $4,%esp
2131- .byte 10 # iret
2132+ .byte 9,9 # pop %gs
2133+ .byte 10,10,10 # add $4,%esp
2134+ .byte 11 # iret
2135 .byte -1,-1,-1,-1 # movb $1,1(%esi) = __DISABLE_INTERRUPTS
2136 .previous
2137
2138@@ -944,7 +936,7 @@ ENTRY(device_not_available)
2139 jmp ret_from_exception
2140 device_available_emulate:
2141 #endif
2142- preempt_stop
2143+ preempt_stop(CLBR_ANY)
2144 call math_state_restore
2145 jmp ret_from_exception
2146 CFI_ENDPROC
2147@@ -1014,7 +1006,7 @@ KPROBE_ENTRY(nmi)
2148 cmpw $__ESPFIX_SS, %ax
2149 popl %eax
2150 CFI_ADJUST_CFA_OFFSET -4
2151- je nmi_16bit_stack
2152+ je nmi_espfix_stack
2153 cmpl $sysenter_entry,(%esp)
2154 je nmi_stack_fixup
2155 pushl %eax
2156@@ -1057,7 +1049,7 @@ nmi_debug_stack_check:
2157 FIX_STACK(24,nmi_stack_correct, 1)
2158 jmp nmi_stack_correct
2159
2160-nmi_16bit_stack:
2161+nmi_espfix_stack:
2162 /* We have a RING0_INT_FRAME here.
2163 *
2164 * create the pointer to lss back
2165@@ -1066,7 +1058,6 @@ nmi_16bit_stack:
2166 CFI_ADJUST_CFA_OFFSET 4
2167 pushl %esp
2168 CFI_ADJUST_CFA_OFFSET 4
2169- movzwl %sp, %esp
2170 addw $4, (%esp)
2171 /* copy the iret frame of 12 bytes */
2172 .rept 3
2173@@ -1077,11 +1068,11 @@ nmi_16bit_stack:
2174 CFI_ADJUST_CFA_OFFSET 4
2175 SAVE_ALL
2176 FIXUP_ESPFIX_STACK # %eax == %esp
2177- CFI_ADJUST_CFA_OFFSET -20 # the frame has now moved
2178 xorl %edx,%edx # zero error code
2179 call do_nmi
2180 RESTORE_REGS
2181- lss 12+4(%esp), %esp # back to 16bit stack
2182+ lss 12+4(%esp), %esp # back to espfix stack
2183+ CFI_ADJUST_CFA_OFFSET -24
2184 1: INTERRUPT_RETURN
2185 CFI_ENDPROC
2186 .section __ex_table,"a"
2187@@ -1097,12 +1088,25 @@ KPROBE_ENTRY(nmi)
2188 xorl %edx,%edx # zero error code
2189 movl %esp,%eax # pt_regs pointer
2190 call do_nmi
2191- orl $NMI_MASK, EFLAGS(%esp)
2192+ orl $NMI_MASK, PT_EFLAGS(%esp)
2193 jmp restore_all
2194 CFI_ENDPROC
2195 #endif
2196 KPROBE_END(nmi)
2197
2198+#ifdef CONFIG_PARAVIRT
2199+ENTRY(native_iret)
2200+1: iret
2201+.section __ex_table,"a"
2202+ .align 4
2203+ .long 1b,iret_exc
2204+.previous
2205+
2206+ENTRY(native_irq_enable_sysexit)
2207+ sti
2208+ sysexit
2209+#endif
2210+
2211 KPROBE_ENTRY(int3)
2212 RING0_INT_FRAME
2213 pushl $-1 # mark this as an int
2214@@ -1218,37 +1222,6 @@ ENTRY(spurious_interrupt_bug)
2215 CFI_ENDPROC
2216 #endif /* !CONFIG_XEN */
2217
2218-#ifdef CONFIG_STACK_UNWIND
2219-ENTRY(arch_unwind_init_running)
2220- CFI_STARTPROC
2221- movl 4(%esp), %edx
2222- movl (%esp), %ecx
2223- leal 4(%esp), %eax
2224- movl %ebx, EBX(%edx)
2225- xorl %ebx, %ebx
2226- movl %ebx, ECX(%edx)
2227- movl %ebx, EDX(%edx)
2228- movl %esi, ESI(%edx)
2229- movl %edi, EDI(%edx)
2230- movl %ebp, EBP(%edx)
2231- movl %ebx, EAX(%edx)
2232- movl $__USER_DS, DS(%edx)
2233- movl $__USER_DS, ES(%edx)
2234- movl %ebx, ORIG_EAX(%edx)
2235- movl %ecx, EIP(%edx)
2236- movl 12(%esp), %ecx
2237- movl $__KERNEL_CS, CS(%edx)
2238- movl %ebx, EFLAGS(%edx)
2239- movl %eax, OLDESP(%edx)
2240- movl 8(%esp), %eax
2241- movl %ecx, 8(%esp)
2242- movl EBX(%edx), %ebx
2243- movl $__KERNEL_DS, OLDSS(%edx)
2244- jmpl *%eax
2245- CFI_ENDPROC
2246-ENDPROC(arch_unwind_init_running)
2247-#endif
2248-
2249 ENTRY(fixup_4gb_segment)
2250 RING0_EC_FRAME
2251 pushl $do_fixup_4gb_segment
2252--- sle11-2009-06-29.orig/arch/x86/kernel/head_32-xen.S 2009-03-04 11:28:34.000000000 +0100
2253+++ sle11-2009-06-29/arch/x86/kernel/head_32-xen.S 2008-12-15 11:26:44.000000000 +0100
2254@@ -9,6 +9,7 @@
2255 #include <asm/cache.h>
2256 #include <asm/thread_info.h>
2257 #include <asm/asm-offsets.h>
2258+#include <asm/boot.h>
2259 #include <asm/dwarf2.h>
2260 #include <xen/interface/xen.h>
2261 #include <xen/interface/elfnote.h>
2262@@ -35,6 +36,8 @@ ENTRY(startup_32)
2263 /* Set up the stack pointer */
2264 movl $(init_thread_union+THREAD_SIZE),%esp
2265
2266+ call setup_pda
2267+
2268 /* get vendor info */
2269 xorl %eax,%eax # call CPUID with 0 -> return vendor ID
2270 XEN_CPUID
2271@@ -57,14 +60,58 @@ ENTRY(startup_32)
2272
2273 movb $1,X86_HARD_MATH
2274
2275- xorl %eax,%eax # Clear FS/GS and LDT
2276+ xorl %eax,%eax # Clear FS
2277 movl %eax,%fs
2278- movl %eax,%gs
2279+
2280+ movl $(__KERNEL_PDA),%eax
2281+ mov %eax,%gs
2282+
2283 cld # gcc2 wants the direction flag cleared at all times
2284
2285 pushl $0 # fake return address for unwinder
2286 jmp start_kernel
2287
2288+/*
2289+ * Point the GDT at this CPU's PDA. This will be
2290+ * cpu_gdt_table and boot_pda.
2291+ */
2292+setup_pda:
2293+ /* get the PDA pointer */
2294+ movl $boot_pda, %eax
2295+
2296+ /* slot the PDA address into the GDT */
2297+ mov $cpu_gdt_table, %ecx
2298+ mov %ax, (__KERNEL_PDA+0+2)(%ecx) /* base & 0x0000ffff */
2299+ shr $16, %eax
2300+ mov %al, (__KERNEL_PDA+4+0)(%ecx) /* base & 0x00ff0000 */
2301+ mov %ah, (__KERNEL_PDA+4+3)(%ecx) /* base & 0xff000000 */
2302+
2303+ # %esi still points to start_info, and no registers
2304+ # need to be preserved.
2305+
2306+ movl XEN_START_mfn_list(%esi), %ebx
2307+ movl $(cpu_gdt_table - __PAGE_OFFSET), %eax
2308+ shrl $PAGE_SHIFT, %eax
2309+ movl (%ebx,%eax,4), %ecx
2310+ pushl %ecx # frame number for set_gdt below
2311+
2312+ xorl %esi, %esi
2313+ xorl %edx, %edx
2314+ shldl $PAGE_SHIFT, %ecx, %edx
2315+ shll $PAGE_SHIFT, %ecx
2316+ orl $0x61, %ecx
2317+ movl $cpu_gdt_table, %ebx
2318+ movl $__HYPERVISOR_update_va_mapping, %eax
2319+ int $0x82
2320+
2321+ movl $(PAGE_SIZE_asm / 8), %ecx
2322+ movl %esp, %ebx
2323+ movl $__HYPERVISOR_set_gdt, %eax
2324+ int $0x82
2325+
2326+ popl %ecx
2327+ ret
2328+
2329 #define HYPERCALL_PAGE_OFFSET 0x1000
2330 .org HYPERCALL_PAGE_OFFSET
2331 ENTRY(hypercall_page)
2332@@ -93,7 +140,8 @@ ENTRY(empty_zero_page)
2333 /*
2334 * The Global Descriptor Table contains 28 quadwords, per-CPU.
2335 */
2336- .align L1_CACHE_BYTES
2337+ .section .data.page_aligned, "aw"
2338+ .align PAGE_SIZE_asm
2339 ENTRY(cpu_gdt_table)
2340 .quad 0x0000000000000000 /* NULL descriptor */
2341 .quad 0x0000000000000000 /* 0x0b reserved */
2342@@ -135,12 +183,13 @@ ENTRY(cpu_gdt_table)
2343 .quad 0x0000000000000000 /* 0xc0 APM CS 16 code (16 bit) */
2344 .quad 0x0000000000000000 /* 0xc8 APM DS data */
2345
2346- .quad 0x0000000000000000 /* 0xd0 - ESPFIX 16-bit SS */
2347- .quad 0x0000000000000000 /* 0xd8 - unused */
2348+ .quad 0x0000000000000000 /* 0xd0 - ESPFIX SS */
2349+ .quad 0x00cf92000000ffff /* 0xd8 - PDA */
2350 .quad 0x0000000000000000 /* 0xe0 - unused */
2351 .quad 0x0000000000000000 /* 0xe8 - unused */
2352 .quad 0x0000000000000000 /* 0xf0 - unused */
2353 .quad 0x0000000000000000 /* 0xf8 - GDT entry 31: double-fault TSS */
2354+ .align PAGE_SIZE_asm
2355
2356 #if CONFIG_XEN_COMPAT <= 0x030002
2357 /*
2358@@ -165,9 +214,9 @@ ENTRY(cpu_gdt_table)
2359 .ascii ",ELF_PADDR_OFFSET=0x"
2360 utoa __PAGE_OFFSET
2361 .ascii ",VIRT_ENTRY=0x"
2362- utoa (__PAGE_OFFSET + __PHYSICAL_START + VIRT_ENTRY_OFFSET)
2363+ utoa (__PAGE_OFFSET + LOAD_PHYSICAL_ADDR + VIRT_ENTRY_OFFSET)
2364 .ascii ",HYPERCALL_PAGE=0x"
2365- utoa ((__PHYSICAL_START+HYPERCALL_PAGE_OFFSET)>>PAGE_SHIFT)
2366+ utoa ((LOAD_PHYSICAL_ADDR+HYPERCALL_PAGE_OFFSET)>>PAGE_SHIFT)
2367 .ascii ",FEATURES=writable_page_tables"
2368 .ascii "|writable_descriptor_tables"
2369 .ascii "|auto_translated_physmap"
2370--- sle11-2009-06-29.orig/arch/x86/kernel/io_apic_32-xen.c 2009-03-04 11:28:34.000000000 +0100
2371+++ sle11-2009-06-29/arch/x86/kernel/io_apic_32-xen.c 2008-12-15 11:26:44.000000000 +0100
2372@@ -34,6 +34,7 @@
2373 #include <linux/pci.h>
2374 #include <linux/msi.h>
2375 #include <linux/htirq.h>
2376+#include <linux/freezer.h>
2377
2378 #include <asm/io.h>
2379 #include <asm/smp.h>
2380@@ -199,14 +200,20 @@ static struct IO_APIC_route_entry ioapic
2381 * the interrupt, and we need to make sure the entry is fully populated
2382 * before that happens.
2383 */
2384-static void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
2385+static void
2386+__ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
2387 {
2388- unsigned long flags;
2389 union entry_union eu;
2390 eu.entry = e;
2391- spin_lock_irqsave(&ioapic_lock, flags);
2392 io_apic_write(apic, 0x11 + 2*pin, eu.w2);
2393 io_apic_write(apic, 0x10 + 2*pin, eu.w1);
2394+}
2395+
2396+static void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
2397+{
2398+ unsigned long flags;
2399+ spin_lock_irqsave(&ioapic_lock, flags);
2400+ __ioapic_write_entry(apic, pin, e);
2401 spin_unlock_irqrestore(&ioapic_lock, flags);
2402 }
2403
2404@@ -889,8 +896,7 @@ static int __init find_isa_irq_pin(int i
2405
2406 if ((mp_bus_id_to_type[lbus] == MP_BUS_ISA ||
2407 mp_bus_id_to_type[lbus] == MP_BUS_EISA ||
2408- mp_bus_id_to_type[lbus] == MP_BUS_MCA ||
2409- mp_bus_id_to_type[lbus] == MP_BUS_NEC98
2410+ mp_bus_id_to_type[lbus] == MP_BUS_MCA
2411 ) &&
2412 (mp_irqs[i].mpc_irqtype == type) &&
2413 (mp_irqs[i].mpc_srcbusirq == irq))
2414@@ -909,8 +915,7 @@ static int __init find_isa_irq_apic(int
2415
2416 if ((mp_bus_id_to_type[lbus] == MP_BUS_ISA ||
2417 mp_bus_id_to_type[lbus] == MP_BUS_EISA ||
2418- mp_bus_id_to_type[lbus] == MP_BUS_MCA ||
2419- mp_bus_id_to_type[lbus] == MP_BUS_NEC98
2420+ mp_bus_id_to_type[lbus] == MP_BUS_MCA
2421 ) &&
2422 (mp_irqs[i].mpc_irqtype == type) &&
2423 (mp_irqs[i].mpc_srcbusirq == irq))
2424@@ -1043,12 +1048,6 @@ static int EISA_ELCR(unsigned int irq)
2425 #define default_MCA_trigger(idx) (1)
2426 #define default_MCA_polarity(idx) (0)
2427
2428-/* NEC98 interrupts are always polarity zero edge triggered,
2429- * when listed as conforming in the MP table. */
2430-
2431-#define default_NEC98_trigger(idx) (0)
2432-#define default_NEC98_polarity(idx) (0)
2433-
2434 static int __init MPBIOS_polarity(int idx)
2435 {
2436 int bus = mp_irqs[idx].mpc_srcbus;
2437@@ -1083,11 +1082,6 @@ static int __init MPBIOS_polarity(int id
2438 polarity = default_MCA_polarity(idx);
2439 break;
2440 }
2441- case MP_BUS_NEC98: /* NEC 98 pin */
2442- {
2443- polarity = default_NEC98_polarity(idx);
2444- break;
2445- }
2446 default:
2447 {
2448 printk(KERN_WARNING "broken BIOS!!\n");
2449@@ -1157,11 +1151,6 @@ static int MPBIOS_trigger(int idx)
2450 trigger = default_MCA_trigger(idx);
2451 break;
2452 }
2453- case MP_BUS_NEC98: /* NEC 98 pin */
2454- {
2455- trigger = default_NEC98_trigger(idx);
2456- break;
2457- }
2458 default:
2459 {
2460 printk(KERN_WARNING "broken BIOS!!\n");
2461@@ -1223,7 +1212,6 @@ static int pin_2_irq(int idx, int apic,
2462 case MP_BUS_ISA: /* ISA pin */
2463 case MP_BUS_EISA:
2464 case MP_BUS_MCA:
2465- case MP_BUS_NEC98:
2466 {
2467 irq = mp_irqs[idx].mpc_srcbusirq;
2468 break;
2469@@ -1291,7 +1279,7 @@ static inline int IO_APIC_irq_trigger(in
2470 }
2471
2472 /* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */
2473-u8 irq_vector[NR_IRQ_VECTORS] __read_mostly; /* = { FIRST_DEVICE_VECTOR , 0 }; */
2474+static u8 irq_vector[NR_IRQ_VECTORS] __read_mostly; /* = { FIRST_DEVICE_VECTOR , 0 }; */
2475
2476 static int __assign_irq_vector(int irq)
2477 {
2478@@ -1417,8 +1405,8 @@ static void __init setup_IO_APIC_irqs(vo
2479 if (!apic && (irq < 16))
2480 disable_8259A_irq(irq);
2481 }
2482- ioapic_write_entry(apic, pin, entry);
2483 spin_lock_irqsave(&ioapic_lock, flags);
2484+ __ioapic_write_entry(apic, pin, entry);
2485 set_native_irq_info(irq, TARGET_CPUS);
2486 spin_unlock_irqrestore(&ioapic_lock, flags);
2487 }
2488@@ -1988,6 +1976,15 @@ static void __init setup_ioapic_ids_from
2489 #endif
2490
2491 #ifndef CONFIG_XEN
2492+static int no_timer_check __initdata;
2493+
2494+static int __init notimercheck(char *s)
2495+{
2496+ no_timer_check = 1;
2497+ return 1;
2498+}
2499+__setup("no_timer_check", notimercheck);
2500+
2501 /*
2502 * There is a nasty bug in some older SMP boards, their mptable lies
2503 * about the timer IRQ. We do the following to work around the situation:
2504@@ -1996,10 +1993,13 @@ static void __init setup_ioapic_ids_from
2505 * - if this function detects that timer IRQs are defunct, then we fall
2506 * back to ISA timer IRQs
2507 */
2508-static int __init timer_irq_works(void)
2509+int __init timer_irq_works(void)
2510 {
2511 unsigned long t1 = jiffies;
2512
2513+ if (no_timer_check)
2514+ return 1;
2515+
2516 local_irq_enable();
2517 /* Let ten ticks pass... */
2518 mdelay((10 * 1000) / HZ);
2519@@ -2226,9 +2226,15 @@ static inline void unlock_ExtINT_logic(v
2520 unsigned char save_control, save_freq_select;
2521
2522 pin = find_isa_irq_pin(8, mp_INT);
2523+ if (pin == -1) {
2524+ WARN_ON_ONCE(1);
2525+ return;
2526+ }
2527 apic = find_isa_irq_apic(8, mp_INT);
2528- if (pin == -1)
2529+ if (apic == -1) {
2530+ WARN_ON_ONCE(1);
2531 return;
2532+ }
2533
2534 entry0 = ioapic_read_entry(apic, pin);
2535 clear_IO_APIC_pin(apic, pin);
2536@@ -2273,7 +2279,7 @@ int timer_uses_ioapic_pin_0;
2537 * is so screwy. Thanks to Brian Perkins for testing/hacking this beast
2538 * fanatically on his truly buggy board.
2539 */
2540-static inline void check_timer(void)
2541+static inline void __init check_timer(void)
2542 {
2543 int apic1, pin1, apic2, pin2;
2544 int vector;
2545@@ -2558,7 +2564,7 @@ device_initcall(ioapic_init_sysfs);
2546 int create_irq(void)
2547 {
2548 /* Allocate an unused irq */
2549- int irq, new, vector;
2550+ int irq, new, vector = 0;
2551 unsigned long flags;
2552
2553 irq = -ENOSPC;
2554@@ -2939,8 +2945,8 @@ int io_apic_set_pci_routing (int ioapic,
2555 if (!ioapic && (irq < 16))
2556 disable_8259A_irq(irq);
2557
2558- ioapic_write_entry(ioapic, pin, entry);
2559 spin_lock_irqsave(&ioapic_lock, flags);
2560+ __ioapic_write_entry(ioapic, pin, entry);
2561 set_native_irq_info(irq, TARGET_CPUS);
2562 spin_unlock_irqrestore(&ioapic_lock, flags);
2563
2564--- sle11-2009-06-29.orig/arch/x86/kernel/ldt_32-xen.c 2009-03-04 11:28:34.000000000 +0100
2565+++ sle11-2009-06-29/arch/x86/kernel/ldt_32-xen.c 2008-12-15 11:26:44.000000000 +0100
2566@@ -177,16 +177,14 @@ static int read_default_ldt(void __user
2567 {
2568 int err;
2569 unsigned long size;
2570- void *address;
2571
2572 err = 0;
2573- address = &default_ldt[0];
2574 size = 5*sizeof(struct desc_struct);
2575 if (size > bytecount)
2576 size = bytecount;
2577
2578 err = size;
2579- if (copy_to_user(ptr, address, size))
2580+ if (clear_user(ptr, size))
2581 err = -EFAULT;
2582
2583 return err;
2584--- sle11-2009-06-29.orig/arch/x86/kernel/microcode-xen.c 2009-03-04 11:28:34.000000000 +0100
2585+++ sle11-2009-06-29/arch/x86/kernel/microcode-xen.c 2008-12-15 11:26:44.000000000 +0100
2586@@ -1,7 +1,7 @@
2587 /*
2588 * Intel CPU Microcode Update Driver for Linux
2589 *
2590- * Copyright (C) 2000-2004 Tigran Aivazian
2591+ * Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
2592 * 2006 Shaohua Li <shaohua.li@intel.com>
2593 *
2594 * This driver allows to upgrade microcode on Intel processors
2595@@ -43,7 +43,7 @@
2596 #include <asm/processor.h>
2597
2598 MODULE_DESCRIPTION("Intel CPU (IA-32) Microcode Update Driver");
2599-MODULE_AUTHOR("Tigran Aivazian <tigran@veritas.com>");
2600+MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
2601 MODULE_LICENSE("GPL");
2602
2603 static int verbose;
2604@@ -195,7 +195,7 @@ static int __init microcode_init (void)
2605 request_microcode();
2606
2607 printk(KERN_INFO
2608- "IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@veritas.com>\n");
2609+ "IA-32 Microcode Update Driver: v" MICROCODE_VERSION " <tigran@aivazian.fsnet.co.uk>\n");
2610 return 0;
2611 }
2612
2613--- sle11-2009-06-29.orig/arch/x86/kernel/mpparse_32-xen.c 2009-03-04 11:28:34.000000000 +0100
2614+++ sle11-2009-06-29/arch/x86/kernel/mpparse_32-xen.c 2008-12-15 11:26:44.000000000 +0100
2615@@ -36,7 +36,7 @@
2616
2617 /* Have we found an MP table */
2618 int smp_found_config;
2619-unsigned int __initdata maxcpus = NR_CPUS;
2620+unsigned int __cpuinitdata maxcpus = NR_CPUS;
2621
2622 /*
2623 * Various Linux-internal data structures created from the
2624@@ -102,10 +102,10 @@ static int __init mpf_checksum(unsigned
2625 */
2626
2627 static int mpc_record;
2628-static struct mpc_config_translation *translation_table[MAX_MPC_ENTRY] __initdata;
2629+static struct mpc_config_translation *translation_table[MAX_MPC_ENTRY] __cpuinitdata;
2630
2631 #ifndef CONFIG_XEN
2632-static void __devinit MP_processor_info (struct mpc_config_processor *m)
2633+static void __cpuinit MP_processor_info (struct mpc_config_processor *m)
2634 {
2635 int ver, apicid;
2636 physid_mask_t phys_cpu;
2637@@ -221,7 +221,7 @@ static void __devinit MP_processor_info
2638 bios_cpu_apicid[num_processors - 1] = m->mpc_apicid;
2639 }
2640 #else
2641-void __init MP_processor_info (struct mpc_config_processor *m)
2642+static void __cpuinit MP_processor_info (struct mpc_config_processor *m)
2643 {
2644 num_processors++;
2645 }
2646@@ -256,8 +256,6 @@ static void __init MP_bus_info (struct m
2647 mp_current_pci_id++;
2648 } else if (strncmp(str, BUSTYPE_MCA, sizeof(BUSTYPE_MCA)-1) == 0) {
2649 mp_bus_id_to_type[m->mpc_busid] = MP_BUS_MCA;
2650- } else if (strncmp(str, BUSTYPE_NEC98, sizeof(BUSTYPE_NEC98)-1) == 0) {
2651- mp_bus_id_to_type[m->mpc_busid] = MP_BUS_NEC98;
2652 } else {
2653 printk(KERN_WARNING "Unknown bustype %s - ignoring\n", str);
2654 }
2655@@ -842,7 +840,7 @@ void __init mp_register_lapic_address(u6
2656 #endif
2657 }
2658
2659-void __devinit mp_register_lapic (u8 id, u8 enabled)
2660+void __cpuinit mp_register_lapic (u8 id, u8 enabled)
2661 {
2662 struct mpc_config_processor processor;
2663 int boot_cpu = 0;
2664--- sle11-2009-06-29.orig/arch/x86/kernel/pci-dma-xen.c 2009-03-04 11:28:34.000000000 +0100
2665+++ sle11-2009-06-29/arch/x86/kernel/pci-dma-xen.c 2008-12-15 11:26:44.000000000 +0100
2666@@ -276,7 +276,7 @@ EXPORT_SYMBOL(dma_free_coherent);
2667 int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
2668 dma_addr_t device_addr, size_t size, int flags)
2669 {
2670- void __iomem *mem_base;
2671+ void __iomem *mem_base = NULL;
2672 int pages = size >> PAGE_SHIFT;
2673 int bitmap_size = (pages + 31)/32;
2674
2675@@ -293,14 +293,12 @@ int dma_declare_coherent_memory(struct d
2676 if (!mem_base)
2677 goto out;
2678
2679- dev->dma_mem = kmalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
2680+ dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
2681 if (!dev->dma_mem)
2682 goto out;
2683- memset(dev->dma_mem, 0, sizeof(struct dma_coherent_mem));
2684- dev->dma_mem->bitmap = kmalloc(bitmap_size, GFP_KERNEL);
2685+ dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
2686 if (!dev->dma_mem->bitmap)
2687 goto free1_out;
2688- memset(dev->dma_mem->bitmap, 0, bitmap_size);
2689
2690 dev->dma_mem->virt_base = mem_base;
2691 dev->dma_mem->device_base = device_addr;
2692@@ -315,6 +313,8 @@ int dma_declare_coherent_memory(struct d
2693 free1_out:
2694 kfree(dev->dma_mem->bitmap);
2695 out:
2696+ if (mem_base)
2697+ iounmap(mem_base);
2698 return 0;
2699 }
2700 EXPORT_SYMBOL(dma_declare_coherent_memory);
2701--- sle11-2009-06-29.orig/arch/x86/kernel/process_32-xen.c 2009-03-04 11:28:34.000000000 +0100
2702+++ sle11-2009-06-29/arch/x86/kernel/process_32-xen.c 2008-12-15 11:26:44.000000000 +0100
2703@@ -60,6 +60,7 @@
2704
2705 #include <asm/tlbflush.h>
2706 #include <asm/cpu.h>
2707+#include <asm/pda.h>
2708
2709 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
2710
2711@@ -104,28 +105,24 @@ EXPORT_SYMBOL(enable_hlt);
2712 */
2713 static void poll_idle (void)
2714 {
2715- local_irq_enable();
2716-
2717- asm volatile(
2718- "2:"
2719- "testl %0, %1;"
2720- "rep; nop;"
2721- "je 2b;"
2722- : : "i"(_TIF_NEED_RESCHED), "m" (current_thread_info()->flags));
2723+ cpu_relax();
2724 }
2725
2726 static void xen_idle(void)
2727 {
2728- local_irq_disable();
2729+ current_thread_info()->status &= ~TS_POLLING;
2730+ /*
2731+ * TS_POLLING-cleared state must be visible before we
2732+ * test NEED_RESCHED:
2733+ */
2734+ smp_mb();
2735
2736- if (need_resched())
2737+ local_irq_disable();
2738+ if (!need_resched())
2739+ safe_halt(); /* enables interrupts racelessly */
2740+ else
2741 local_irq_enable();
2742- else {
2743- current_thread_info()->status &= ~TS_POLLING;
2744- smp_mb__after_clear_bit();
2745- safe_halt();
2746- current_thread_info()->status |= TS_POLLING;
2747- }
2748+ current_thread_info()->status |= TS_POLLING;
2749 }
2750 #ifdef CONFIG_APM_MODULE
2751 EXPORT_SYMBOL(default_idle);
2752@@ -250,8 +247,8 @@ void show_regs(struct pt_regs * regs)
2753 regs->eax,regs->ebx,regs->ecx,regs->edx);
2754 printk("ESI: %08lx EDI: %08lx EBP: %08lx",
2755 regs->esi, regs->edi, regs->ebp);
2756- printk(" DS: %04x ES: %04x\n",
2757- 0xffff & regs->xds,0xffff & regs->xes);
2758+ printk(" DS: %04x ES: %04x GS: %04x\n",
2759+ 0xffff & regs->xds,0xffff & regs->xes, 0xffff & regs->xgs);
2760
2761 cr0 = read_cr0();
2762 cr2 = read_cr2();
2763@@ -282,6 +279,7 @@ int kernel_thread(int (*fn)(void *), voi
2764
2765 regs.xds = __USER_DS;
2766 regs.xes = __USER_DS;
2767+ regs.xgs = __KERNEL_PDA;
2768 regs.orig_eax = -1;
2769 regs.eip = (unsigned long) kernel_thread_helper;
2770 regs.xcs = __KERNEL_CS | get_kernel_rpl();
2771@@ -359,7 +357,6 @@ int copy_thread(int nr, unsigned long cl
2772 p->thread.eip = (unsigned long) ret_from_fork;
2773
2774 savesegment(fs,p->thread.fs);
2775- savesegment(gs,p->thread.gs);
2776
2777 tsk = current;
2778 if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
2779@@ -438,7 +435,7 @@ void dump_thread(struct pt_regs * regs,
2780 dump->regs.ds = regs->xds;
2781 dump->regs.es = regs->xes;
2782 savesegment(fs,dump->regs.fs);
2783- savesegment(gs,dump->regs.gs);
2784+ dump->regs.gs = regs->xgs;
2785 dump->regs.orig_eax = regs->orig_eax;
2786 dump->regs.eip = regs->eip;
2787 dump->regs.cs = regs->xcs;
2788@@ -635,17 +632,19 @@ struct task_struct fastcall * __switch_t
2789 if (unlikely(HYPERVISOR_multicall_check(_mcl, mcl - _mcl, NULL)))
2790 BUG();
2791
2792+ /* we're going to use this soon, after a few expensive things */
2793+ if (next_p->fpu_counter > 5)
2794+ prefetch(&next->i387.fxsave);
2795+
2796 /*
2797- * Restore %fs and %gs if needed.
2798+ * Restore %fs if needed.
2799 *
2800- * Glibc normally makes %fs be zero, and %gs is one of
2801- * the TLS segments.
2802+ * Glibc normally makes %fs be zero.
2803 */
2804 if (unlikely(next->fs))
2805 loadsegment(fs, next->fs);
2806
2807- if (next->gs)
2808- loadsegment(gs, next->gs);
2809+ write_pda(pcurrent, next_p);
2810
2811 /*
2812 * Now maybe handle debug registers
2813@@ -655,6 +654,13 @@ struct task_struct fastcall * __switch_t
2814
2815 disable_tsc(prev_p, next_p);
2816
2817+ /* If the task has used fpu the last 5 timeslices, just do a full
2818+ * restore of the math state immediately to avoid the trap; the
2819+ * chances of needing FPU soon are obviously high now
2820+ */
2821+ if (next_p->fpu_counter > 5)
2822+ math_state_restore();
2823+
2824 return prev_p;
2825 }
2826
2827--- sle11-2009-06-29.orig/arch/x86/kernel/quirks-xen.c 2009-06-29 15:14:52.000000000 +0200
2828+++ sle11-2009-06-29/arch/x86/kernel/quirks-xen.c 2008-12-15 11:26:44.000000000 +0100
2829@@ -3,10 +3,12 @@
2830 */
2831 #include <linux/pci.h>
2832 #include <linux/irq.h>
2833+#include <asm/pci-direct.h>
2834+#include <asm/genapic.h>
2835+#include <asm/cpu.h>
2836
2837 #if defined(CONFIG_X86_IO_APIC) && (defined(CONFIG_SMP) || defined(CONFIG_XEN)) && defined(CONFIG_PCI)
2838-
2839-static void __devinit quirk_intel_irqbalance(struct pci_dev *dev)
2840+static void __devinit verify_quirk_intel_irqbalance(struct pci_dev *dev)
2841 {
2842 u8 config, rev;
2843 u32 word;
2844@@ -14,14 +16,12 @@ static void __devinit quirk_intel_irqbal
2845 /* BIOS may enable hardware IRQ balancing for
2846 * E7520/E7320/E7525(revision ID 0x9 and below)
2847 * based platforms.
2848- * Disable SW irqbalance/affinity on those platforms.
2849+ * For those platforms, make sure that the genapic is set to 'flat'
2850 */
2851 pci_read_config_byte(dev, PCI_CLASS_REVISION, &rev);
2852 if (rev > 0x9)
2853 return;
2854
2855- printk(KERN_INFO "Intel E7520/7320/7525 detected.");
2856-
2857 /* enable access to config space*/
2858 pci_read_config_byte(dev, 0xf4, &config);
2859 pci_write_config_byte(dev, 0xf4, config|0x2);
2860@@ -30,6 +30,46 @@ static void __devinit quirk_intel_irqbal
2861 raw_pci_ops->read(0, 0, 0x40, 0x4c, 2, &word);
2862
2863 if (!(word & (1 << 13))) {
2864+#ifndef CONFIG_XEN
2865+#ifdef CONFIG_X86_64
2866+ if (genapic != &apic_flat)
2867+ panic("APIC mode must be flat on this system\n");
2868+#elif defined(CONFIG_X86_GENERICARCH)
2869+ if (genapic != &apic_default)
2870+ panic("APIC mode must be default(flat) on this system. Use apic=default\n");
2871+#endif
2872+#endif
2873+ }
2874+
2875+ /* put back the original value for config space*/
2876+ if (!(config & 0x2))
2877+ pci_write_config_byte(dev, 0xf4, config);
2878+}
2879+
2880+void __init quirk_intel_irqbalance(void)
2881+{
2882+ u8 config, rev;
2883+ u32 word;
2884+
2885+ /* BIOS may enable hardware IRQ balancing for
2886+ * E7520/E7320/E7525(revision ID 0x9 and below)
2887+ * based platforms.
2888+ * Disable SW irqbalance/affinity on those platforms.
2889+ */
2890+ rev = read_pci_config_byte(0, 0, 0, PCI_CLASS_REVISION);
2891+ if (rev > 0x9)
2892+ return;
2893+
2894+ printk(KERN_INFO "Intel E7520/7320/7525 detected.");
2895+
2896+ /* enable access to config space */
2897+ config = read_pci_config_byte(0, 0, 0, 0xf4);
2898+ write_pci_config_byte(0, 0, 0, 0xf4, config|0x2);
2899+
2900+ /* read xTPR register */
2901+ word = read_pci_config_16(0, 0, 0x40, 0x4c);
2902+
2903+ if (!(word & (1 << 13))) {
2904 struct xen_platform_op op;
2905 printk(KERN_INFO "Disabling irq balancing and affinity\n");
2906 op.cmd = XENPF_platform_quirk;
2907@@ -37,11 +77,12 @@ static void __devinit quirk_intel_irqbal
2908 WARN_ON(HYPERVISOR_platform_op(&op));
2909 }
2910
2911- /* put back the original value for config space*/
2912+ /* put back the original value for config space */
2913 if (!(config & 0x2))
2914- pci_write_config_byte(dev, 0xf4, config);
2915+ write_pci_config_byte(0, 0, 0, 0xf4, config);
2916 }
2917-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7320_MCH, quirk_intel_irqbalance);
2918-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7525_MCH, quirk_intel_irqbalance);
2919-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7520_MCH, quirk_intel_irqbalance);
2920+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7320_MCH, verify_quirk_intel_irqbalance);
2921+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7525_MCH, verify_quirk_intel_irqbalance);
2922+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_E7520_MCH, verify_quirk_intel_irqbalance);
2923+
2924 #endif
2925--- sle11-2009-06-29.orig/arch/x86/kernel/setup_32-xen.c 2009-03-04 11:28:34.000000000 +0100
2926+++ sle11-2009-06-29/arch/x86/kernel/setup_32-xen.c 2008-12-15 11:26:44.000000000 +0100
2927@@ -76,9 +76,6 @@
2928 #include <xen/interface/kexec.h>
2929 #endif
2930
2931-/* Forward Declaration. */
2932-void __init find_max_pfn(void);
2933-
2934 static int xen_panic_event(struct notifier_block *, unsigned long, void *);
2935 static struct notifier_block xen_panic_block = {
2936 xen_panic_event, NULL, 0 /* try to go last */
2937@@ -89,14 +86,11 @@ int disable_pse __devinitdata = 0;
2938 /*
2939 * Machine setup..
2940 */
2941-
2942-#ifdef CONFIG_EFI
2943-int efi_enabled = 0;
2944-EXPORT_SYMBOL(efi_enabled);
2945-#endif
2946+extern struct resource code_resource;
2947+extern struct resource data_resource;
2948
2949 /* cpu data as detected by the assembly code in head.S */
2950-struct cpuinfo_x86 new_cpu_data __initdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
2951+struct cpuinfo_x86 new_cpu_data __cpuinitdata = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
2952 /* common cpu data for all cpus */
2953 struct cpuinfo_x86 boot_cpu_data __read_mostly = { 0, 0, 0, 0, -1, 1, 0, 0, -1 };
2954 EXPORT_SYMBOL(boot_cpu_data);
2955@@ -112,12 +106,6 @@ unsigned int machine_submodel_id;
2956 unsigned int BIOS_revision;
2957 unsigned int mca_pentium_flag;
2958
2959-/* For PCI or other memory-mapped resources */
2960-unsigned long pci_mem_start = 0x10000000;
2961-#ifdef CONFIG_PCI
2962-EXPORT_SYMBOL(pci_mem_start);
2963-#endif
2964-
2965 /* Boot loader ID as an integer, for the benefit of proc_dointvec */
2966 int bootloader_type;
2967
2968@@ -150,10 +138,6 @@ struct ist_info ist_info;
2969 defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
2970 EXPORT_SYMBOL(ist_info);
2971 #endif
2972-struct e820map e820;
2973-#ifdef CONFIG_XEN
2974-struct e820map machine_e820;
2975-#endif
2976
2977 extern void early_cpu_init(void);
2978 extern int root_mountflags;
2979@@ -168,209 +152,6 @@ static char command_line[COMMAND_LINE_SI
2980
2981 unsigned char __initdata boot_params[PARAM_SIZE];
2982
2983-static struct resource data_resource = {
2984- .name = "Kernel data",
2985- .start = 0,
2986- .end = 0,
2987- .flags = IORESOURCE_BUSY | IORESOURCE_MEM
2988-};
2989-
2990-static struct resource code_resource = {
2991- .name = "Kernel code",
2992- .start = 0,
2993- .end = 0,
2994- .flags = IORESOURCE_BUSY | IORESOURCE_MEM
2995-};
2996-
2997-static struct resource system_rom_resource = {
2998- .name = "System ROM",
2999- .start = 0xf0000,
3000- .end = 0xfffff,
3001- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3002-};
3003-
3004-static struct resource extension_rom_resource = {
3005- .name = "Extension ROM",
3006- .start = 0xe0000,
3007- .end = 0xeffff,
3008- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3009-};
3010-
3011-static struct resource adapter_rom_resources[] = { {
3012- .name = "Adapter ROM",
3013- .start = 0xc8000,
3014- .end = 0,
3015- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3016-}, {
3017- .name = "Adapter ROM",
3018- .start = 0,
3019- .end = 0,
3020- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3021-}, {
3022- .name = "Adapter ROM",
3023- .start = 0,
3024- .end = 0,
3025- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3026-}, {
3027- .name = "Adapter ROM",
3028- .start = 0,
3029- .end = 0,
3030- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3031-}, {
3032- .name = "Adapter ROM",
3033- .start = 0,
3034- .end = 0,
3035- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3036-}, {
3037- .name = "Adapter ROM",
3038- .start = 0,
3039- .end = 0,
3040- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3041-} };
3042-
3043-static struct resource video_rom_resource = {
3044- .name = "Video ROM",
3045- .start = 0xc0000,
3046- .end = 0xc7fff,
3047- .flags = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
3048-};
3049-
3050-static struct resource video_ram_resource = {
3051- .name = "Video RAM area",
3052- .start = 0xa0000,
3053- .end = 0xbffff,
3054- .flags = IORESOURCE_BUSY | IORESOURCE_MEM
3055-};
3056-
3057-static struct resource standard_io_resources[] = { {
3058- .name = "dma1",
3059- .start = 0x0000,
3060- .end = 0x001f,
3061- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3062-}, {
3063- .name = "pic1",
3064- .start = 0x0020,
3065- .end = 0x0021,
3066- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3067-}, {
3068- .name = "timer0",
3069- .start = 0x0040,
3070- .end = 0x0043,
3071- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3072-}, {
3073- .name = "timer1",
3074- .start = 0x0050,
3075- .end = 0x0053,
3076- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3077-}, {
3078- .name = "keyboard",
3079- .start = 0x0060,
3080- .end = 0x006f,
3081- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3082-}, {
3083- .name = "dma page reg",
3084- .start = 0x0080,
3085- .end = 0x008f,
3086- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3087-}, {
3088- .name = "pic2",
3089- .start = 0x00a0,
3090- .end = 0x00a1,
3091- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3092-}, {
3093- .name = "dma2",
3094- .start = 0x00c0,
3095- .end = 0x00df,
3096- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3097-}, {
3098- .name = "fpu",
3099- .start = 0x00f0,
3100- .end = 0x00ff,
3101- .flags = IORESOURCE_BUSY | IORESOURCE_IO
3102-} };
3103-
3104-#define romsignature(x) (*(unsigned short *)(x) == 0xaa55)
3105-
3106-static int __init romchecksum(unsigned char *rom, unsigned long length)
3107-{
3108- unsigned char *p, sum = 0;
3109-
3110- for (p = rom; p < rom + length; p++)
3111- sum += *p;
3112- return sum == 0;
3113-}
3114-
3115-static void __init probe_roms(void)
3116-{
3117- unsigned long start, length, upper;
3118- unsigned char *rom;
3119- int i;
3120-
3121-#ifdef CONFIG_XEN
3122- /* Nothing to do if not running in dom0. */
3123- if (!is_initial_xendomain())
3124- return;
3125-#endif
3126-
3127- /* video rom */
3128- upper = adapter_rom_resources[0].start;
3129- for (start = video_rom_resource.start; start < upper; start += 2048) {
3130- rom = isa_bus_to_virt(start);
3131- if (!romsignature(rom))
3132- continue;
3133-
3134- video_rom_resource.start = start;
3135-
3136- /* 0 < length <= 0x7f * 512, historically */
3137- length = rom[2] * 512;
3138-
3139- /* if checksum okay, trust length byte */
3140- if (length && romchecksum(rom, length))
3141- video_rom_resource.end = start + length - 1;
3142-
3143- request_resource(&iomem_resource, &video_rom_resource);
3144- break;
3145- }
3146-
3147- start = (video_rom_resource.end + 1 + 2047) & ~2047UL;
3148- if (start < upper)
3149- start = upper;
3150-
3151- /* system rom */
3152- request_resource(&iomem_resource, &system_rom_resource);
3153- upper = system_rom_resource.start;
3154-
3155- /* check for extension rom (ignore length byte!) */
3156- rom = isa_bus_to_virt(extension_rom_resource.start);
3157- if (romsignature(rom)) {
3158- length = extension_rom_resource.end - extension_rom_resource.start + 1;
3159- if (romchecksum(rom, length)) {
3160- request_resource(&iomem_resource, &extension_rom_resource);
3161- upper = extension_rom_resource.start;
3162- }
3163- }
3164-
3165- /* check for adapter roms on 2k boundaries */
3166- for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; start += 2048) {
3167- rom = isa_bus_to_virt(start);
3168- if (!romsignature(rom))
3169- continue;
3170-
3171- /* 0 < length <= 0x7f * 512, historically */
3172- length = rom[2] * 512;
3173-
3174- /* but accept any length that fits if checksum okay */
3175- if (!length || start + length > upper || !romchecksum(rom, length))
3176- continue;
3177-
3178- adapter_rom_resources[i].start = start;
3179- adapter_rom_resources[i].end = start + length - 1;
3180- request_resource(&iomem_resource, &adapter_rom_resources[i]);
3181-
3182- start = adapter_rom_resources[i++].end & ~2047UL;
3183- }
3184-}
3185-
3186 /*
3187 * Point at the empty zero page to start with. We map the real shared_info
3188 * page as soon as fixmap is up and running.
3189@@ -386,353 +167,6 @@ EXPORT_SYMBOL(phys_to_machine_mapping);
3190 start_info_t *xen_start_info;
3191 EXPORT_SYMBOL(xen_start_info);
3192
3193-void __init add_memory_region(unsigned long long start,
3194- unsigned long long size, int type)
3195-{
3196- int x;
3197-
3198- if (!efi_enabled) {
3199- x = e820.nr_map;
3200-
3201- if (x == E820MAX) {
3202- printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
3203- return;
3204- }
3205-
3206- e820.map[x].addr = start;
3207- e820.map[x].size = size;
3208- e820.map[x].type = type;
3209- e820.nr_map++;
3210- }
3211-} /* add_memory_region */
3212-
3213-static void __init limit_regions(unsigned long long size)
3214-{
3215- unsigned long long current_addr = 0;
3216- int i;
3217-
3218- if (efi_enabled) {
3219- efi_memory_desc_t *md;
3220- void *p;
3221-
3222- for (p = memmap.map, i = 0; p < memmap.map_end;
3223- p += memmap.desc_size, i++) {
3224- md = p;
3225- current_addr = md->phys_addr + (md->num_pages << 12);
3226- if (md->type == EFI_CONVENTIONAL_MEMORY) {
3227- if (current_addr >= size) {
3228- md->num_pages -=
3229- (((current_addr-size) + PAGE_SIZE-1) >> PAGE_SHIFT);
3230- memmap.nr_map = i + 1;
3231- return;
3232- }
3233- }
3234- }
3235- }
3236- for (i = 0; i < e820.nr_map; i++) {
3237- current_addr = e820.map[i].addr + e820.map[i].size;
3238- if (current_addr < size)
3239- continue;
3240-
3241- if (e820.map[i].type != E820_RAM)
3242- continue;
3243-
3244- if (e820.map[i].addr >= size) {
3245- /*
3246- * This region starts past the end of the
3247- * requested size, skip it completely.
3248- */
3249- e820.nr_map = i;
3250- } else {
3251- e820.nr_map = i + 1;
3252- e820.map[i].size -= current_addr - size;
3253- }
3254- return;
3255- }
3256-#ifdef CONFIG_XEN
3257- if (i==e820.nr_map && current_addr < size) {
3258- /*
3259- * The e820 map finished before our requested size so
3260- * extend the final entry to the requested address.
3261- */
3262- --i;
3263- if (e820.map[i].type == E820_RAM)
3264- e820.map[i].size -= current_addr - size;
3265- else
3266- add_memory_region(current_addr, size - current_addr, E820_RAM);
3267- }
3268-#endif
3269-}
3270-
3271-#define E820_DEBUG 1
3272-
3273-static void __init print_memory_map(char *who)
3274-{
3275- int i;
3276-
3277- for (i = 0; i < e820.nr_map; i++) {
3278- printk(" %s: %016Lx - %016Lx ", who,
3279- e820.map[i].addr,
3280- e820.map[i].addr + e820.map[i].size);
3281- switch (e820.map[i].type) {
3282- case E820_RAM: printk("(usable)\n");
3283- break;
3284- case E820_RESERVED:
3285- printk("(reserved)\n");
3286- break;
3287- case E820_ACPI:
3288- printk("(ACPI data)\n");
3289- break;
3290- case E820_NVS:
3291- printk("(ACPI NVS)\n");
3292- break;
3293- default: printk("type %lu\n", e820.map[i].type);
3294- break;
3295- }
3296- }
3297-}
3298-
3299-/*
3300- * Sanitize the BIOS e820 map.
3301- *
3302- * Some e820 responses include overlapping entries. The following
3303- * replaces the original e820 map with a new one, removing overlaps.
3304- *
3305- */
3306-struct change_member {
3307- struct e820entry *pbios; /* pointer to original bios entry */
3308- unsigned long long addr; /* address for this change point */
3309-};
3310-static struct change_member change_point_list[2*E820MAX] __initdata;
3311-static struct change_member *change_point[2*E820MAX] __initdata;
3312-static struct e820entry *overlap_list[E820MAX] __initdata;
3313-static struct e820entry new_bios[E820MAX] __initdata;
3314-
3315-int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
3316-{
3317- struct change_member *change_tmp;
3318- unsigned long current_type, last_type;
3319- unsigned long long last_addr;
3320- int chgidx, still_changing;
3321- int overlap_entries;
3322- int new_bios_entry;
3323- int old_nr, new_nr, chg_nr;
3324- int i;
3325-
3326- /*
3327- Visually we're performing the following (1,2,3,4 = memory types)...
3328-
3329- Sample memory map (w/overlaps):
3330- ____22__________________
3331- ______________________4_
3332- ____1111________________
3333- _44_____________________
3334- 11111111________________
3335- ____________________33__
3336- ___________44___________
3337- __________33333_________
3338- ______________22________
3339- ___________________2222_
3340- _________111111111______
3341- _____________________11_
3342- _________________4______
3343-
3344- Sanitized equivalent (no overlap):
3345- 1_______________________
3346- _44_____________________
3347- ___1____________________
3348- ____22__________________
3349- ______11________________
3350- _________1______________
3351- __________3_____________
3352- ___________44___________
3353- _____________33_________
3354- _______________2________
3355- ________________1_______
3356- _________________4______
3357- ___________________2____
3358- ____________________33__
3359- ______________________4_
3360- */
3361-
3362- /* if there's only one memory region, don't bother */
3363- if (*pnr_map < 2)
3364- return -1;
3365-
3366- old_nr = *pnr_map;
3367-
3368- /* bail out if we find any unreasonable addresses in bios map */
3369- for (i=0; i<old_nr; i++)
3370- if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
3371- return -1;
3372-
3373- /* create pointers for initial change-point information (for sorting) */
3374- for (i=0; i < 2*old_nr; i++)
3375- change_point[i] = &change_point_list[i];
3376-
3377- /* record all known change-points (starting and ending addresses),
3378- omitting those that are for empty memory regions */
3379- chgidx = 0;
3380- for (i=0; i < old_nr; i++) {
3381- if (biosmap[i].size != 0) {
3382- change_point[chgidx]->addr = biosmap[i].addr;
3383- change_point[chgidx++]->pbios = &biosmap[i];
3384- change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size;
3385- change_point[chgidx++]->pbios = &biosmap[i];
3386- }
3387- }
3388- chg_nr = chgidx; /* true number of change-points */
3389-
3390- /* sort change-point list by memory addresses (low -> high) */
3391- still_changing = 1;
3392- while (still_changing) {
3393- still_changing = 0;
3394- for (i=1; i < chg_nr; i++) {
3395- /* if <current_addr> > <last_addr>, swap */
3396- /* or, if current=<start_addr> & last=<end_addr>, swap */
3397- if ((change_point[i]->addr < change_point[i-1]->addr) ||
3398- ((change_point[i]->addr == change_point[i-1]->addr) &&
3399- (change_point[i]->addr == change_point[i]->pbios->addr) &&
3400- (change_point[i-1]->addr != change_point[i-1]->pbios->addr))
3401- )
3402- {
3403- change_tmp = change_point[i];
3404- change_point[i] = change_point[i-1];
3405- change_point[i-1] = change_tmp;
3406- still_changing=1;
3407- }
3408- }
3409- }
3410-
3411- /* create a new bios memory map, removing overlaps */
3412- overlap_entries=0; /* number of entries in the overlap table */
3413- new_bios_entry=0; /* index for creating new bios map entries */
3414- last_type = 0; /* start with undefined memory type */
3415- last_addr = 0; /* start with 0 as last starting address */
3416- /* loop through change-points, determining affect on the new bios map */
3417- for (chgidx=0; chgidx < chg_nr; chgidx++)
3418- {
3419- /* keep track of all overlapping bios entries */
3420- if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr)
3421- {
3422- /* add map entry to overlap list (> 1 entry implies an overlap) */
3423- overlap_list[overlap_entries++]=change_point[chgidx]->pbios;
3424- }
3425- else
3426- {
3427- /* remove entry from list (order independent, so swap with last) */
3428- for (i=0; i<overlap_entries; i++)
3429- {
3430- if (overlap_list[i] == change_point[chgidx]->pbios)
3431- overlap_list[i] = overlap_list[overlap_entries-1];
3432- }
3433- overlap_entries--;
3434- }
3435- /* if there are overlapping entries, decide which "type" to use */
3436- /* (larger value takes precedence -- 1=usable, 2,3,4,4+=unusable) */
3437- current_type = 0;
3438- for (i=0; i<overlap_entries; i++)
3439- if (overlap_list[i]->type > current_type)
3440- current_type = overlap_list[i]->type;
3441- /* continue building up new bios map based on this information */
3442- if (current_type != last_type) {
3443- if (last_type != 0) {
3444- new_bios[new_bios_entry].size =
3445- change_point[chgidx]->addr - last_addr;
3446- /* move forward only if the new size was non-zero */
3447- if (new_bios[new_bios_entry].size != 0)
3448- if (++new_bios_entry >= E820MAX)
3449- break; /* no more space left for new bios entries */
3450- }
3451- if (current_type != 0) {
3452- new_bios[new_bios_entry].addr = change_point[chgidx]->addr;
3453- new_bios[new_bios_entry].type = current_type;
3454- last_addr=change_point[chgidx]->addr;
3455- }
3456- last_type = current_type;
3457- }
3458- }
3459- new_nr = new_bios_entry; /* retain count for new bios entries */
3460-
3461- /* copy new bios mapping into original location */
3462- memcpy(biosmap, new_bios, new_nr*sizeof(struct e820entry));
3463- *pnr_map = new_nr;
3464-
3465- return 0;
3466-}
3467-
3468-/*
3469- * Copy the BIOS e820 map into a safe place.
3470- *
3471- * Sanity-check it while we're at it..
3472- *
3473- * If we're lucky and live on a modern system, the setup code
3474- * will have given us a memory map that we can use to properly
3475- * set up memory. If we aren't, we'll fake a memory map.
3476- *
3477- * We check to see that the memory map contains at least 2 elements
3478- * before we'll use it, because the detection code in setup.S may
3479- * not be perfect and most every PC known to man has two memory
3480- * regions: one from 0 to 640k, and one from 1mb up. (The IBM
3481- * thinkpad 560x, for example, does not cooperate with the memory
3482- * detection code.)
3483- */
3484-int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
3485-{
3486-#ifndef CONFIG_XEN
3487- /* Only one memory region (or negative)? Ignore it */
3488- if (nr_map < 2)
3489- return -1;
3490-#else
3491- BUG_ON(nr_map < 1);
3492-#endif
3493-
3494- do {
3495- unsigned long long start = biosmap->addr;
3496- unsigned long long size = biosmap->size;
3497- unsigned long long end = start + size;
3498- unsigned long type = biosmap->type;
3499-
3500- /* Overflow in 64 bits? Ignore the memory map. */
3501- if (start > end)
3502- return -1;
3503-
3504-#ifndef CONFIG_XEN
3505- /*
3506- * Some BIOSes claim RAM in the 640k - 1M region.
3507- * Not right. Fix it up.
3508- */
3509- if (type == E820_RAM) {
3510- if (start < 0x100000ULL && end > 0xA0000ULL) {
3511- if (start < 0xA0000ULL)
3512- add_memory_region(start, 0xA0000ULL-start, type);
3513- if (end <= 0x100000ULL)
3514- continue;
3515- start = 0x100000ULL;
3516- size = end - start;
3517- }
3518- }
3519-#endif
3520- add_memory_region(start, size, type);
3521- } while (biosmap++,--nr_map);
3522-
3523-#ifdef CONFIG_XEN
3524- if (is_initial_xendomain()) {
3525- struct xen_memory_map memmap;
3526-
3527- memmap.nr_entries = E820MAX;
3528- set_xen_guest_handle(memmap.buffer, machine_e820.map);
3529-
3530- if (HYPERVISOR_memory_op(XENMEM_machine_memory_map, &memmap))
3531- BUG();
3532- machine_e820.nr_map = memmap.nr_entries;
3533- } else
3534- machine_e820 = e820;
3535-#endif
3536-
3537- return 0;
3538-}
3539-
3540 #if defined(CONFIG_EDD) || defined(CONFIG_EDD_MODULE)
3541 struct edd edd;
3542 #ifdef CONFIG_EDD_MODULE
3543@@ -758,7 +192,7 @@ static inline void copy_edd(void)
3544 }
3545 #endif
3546
3547-static int __initdata user_defined_memmap = 0;
3548+int __initdata user_defined_memmap = 0;
3549
3550 /*
3551 * "mem=nopentium" disables the 4MB page tables.
3552@@ -795,51 +229,6 @@ static int __init parse_mem(char *arg)
3553 }
3554 early_param("mem", parse_mem);
3555
3556-static int __init parse_memmap(char *arg)
3557-{
3558- if (!arg)
3559- return -EINVAL;
3560-
3561- if (strcmp(arg, "exactmap") == 0) {
3562-#ifdef CONFIG_CRASH_DUMP
3563- /* If we are doing a crash dump, we
3564- * still need to know the real mem
3565- * size before original memory map is
3566- * reset.
3567- */
3568- find_max_pfn();
3569- saved_max_pfn = max_pfn;
3570-#endif
3571- e820.nr_map = 0;
3572- user_defined_memmap = 1;
3573- } else {
3574- /* If the user specifies memory size, we
3575- * limit the BIOS-provided memory map to
3576- * that size. exactmap can be used to specify
3577- * the exact map. mem=number can be used to
3578- * trim the existing memory map.
3579- */
3580- unsigned long long start_at, mem_size;
3581-
3582- mem_size = memparse(arg, &arg);
3583- if (*arg == '@') {
3584- start_at = memparse(arg+1, &arg);
3585- add_memory_region(start_at, mem_size, E820_RAM);
3586- } else if (*arg == '#') {
3587- start_at = memparse(arg+1, &arg);
3588- add_memory_region(start_at, mem_size, E820_ACPI);
3589- } else if (*arg == '$') {
3590- start_at = memparse(arg+1, &arg);
3591- add_memory_region(start_at, mem_size, E820_RESERVED);
3592- } else {
3593- limit_regions(mem_size);
3594- user_defined_memmap = 1;
3595- }
3596- }
3597- return 0;
3598-}
3599-early_param("memmap", parse_memmap);
3600-
3601 #ifdef CONFIG_PROC_VMCORE
3602 /* elfcorehdr= specifies the location of elf core header
3603 * stored by the crashed kernel.
3604@@ -906,127 +295,6 @@ early_param("reservetop", parse_reservet
3605 #endif
3606
3607 /*
3608- * Callback for efi_memory_walk.
3609- */
3610-static int __init
3611-efi_find_max_pfn(unsigned long start, unsigned long end, void *arg)
3612-{
3613- unsigned long *max_pfn = arg, pfn;
3614-
3615- if (start < end) {
3616- pfn = PFN_UP(end -1);
3617- if (pfn > *max_pfn)
3618- *max_pfn = pfn;
3619- }
3620- return 0;
3621-}
3622-
3623-static int __init
3624-efi_memory_present_wrapper(unsigned long start, unsigned long end, void *arg)
3625-{
3626- memory_present(0, PFN_UP(start), PFN_DOWN(end));
3627- return 0;
3628-}
3629-
3630-/*
3631- * This function checks if any part of the range <start,end> is mapped
3632- * with type.
3633- */
3634-int
3635-e820_any_mapped(u64 start, u64 end, unsigned type)
3636-{
3637- int i;
3638-
3639-#ifndef CONFIG_XEN
3640- for (i = 0; i < e820.nr_map; i++) {
3641- const struct e820entry *ei = &e820.map[i];
3642-#else
3643- if (!is_initial_xendomain())
3644- return 0;
3645- for (i = 0; i < machine_e820.nr_map; ++i) {
3646- const struct e820entry *ei = &machine_e820.map[i];
3647-#endif
3648-
3649- if (type && ei->type != type)
3650- continue;
3651- if (ei->addr >= end || ei->addr + ei->size <= start)
3652- continue;
3653- return 1;
3654- }
3655- return 0;
3656-}
3657-EXPORT_SYMBOL_GPL(e820_any_mapped);
3658-
3659- /*
3660- * This function checks if the entire range <start,end> is mapped with type.
3661- *
3662- * Note: this function only works correct if the e820 table is sorted and
3663- * not-overlapping, which is the case
3664- */
3665-int __init
3666-e820_all_mapped(unsigned long s, unsigned long e, unsigned type)
3667-{
3668- u64 start = s;
3669- u64 end = e;
3670- int i;
3671-
3672-#ifndef CONFIG_XEN
3673- for (i = 0; i < e820.nr_map; i++) {
3674- struct e820entry *ei = &e820.map[i];
3675-#else
3676- if (!is_initial_xendomain())
3677- return 0;
3678- for (i = 0; i < machine_e820.nr_map; ++i) {
3679- const struct e820entry *ei = &machine_e820.map[i];
3680-#endif
3681- if (type && ei->type != type)
3682- continue;
3683- /* is the region (part) in overlap with the current region ?*/
3684- if (ei->addr >= end || ei->addr + ei->size <= start)
3685- continue;
3686- /* if the region is at the beginning of <start,end> we move
3687- * start to the end of the region since it's ok until there
3688- */
3689- if (ei->addr <= start)
3690- start = ei->addr + ei->size;
3691- /* if start is now at or beyond end, we're done, full
3692- * coverage */
3693- if (start >= end)
3694- return 1; /* we're done */
3695- }
3696- return 0;
3697-}
3698-
3699-/*
3700- * Find the highest page frame number we have available
3701- */
3702-void __init find_max_pfn(void)
3703-{
3704- int i;
3705-
3706- max_pfn = 0;
3707- if (efi_enabled) {
3708- efi_memmap_walk(efi_find_max_pfn, &max_pfn);
3709- efi_memmap_walk(efi_memory_present_wrapper, NULL);
3710- return;
3711- }
3712-
3713- for (i = 0; i < e820.nr_map; i++) {
3714- unsigned long start, end;
3715- /* RAM? */
3716- if (e820.map[i].type != E820_RAM)
3717- continue;
3718- start = PFN_UP(e820.map[i].addr);
3719- end = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
3720- if (start >= end)
3721- continue;
3722- if (end > max_pfn)
3723- max_pfn = end;
3724- memory_present(0, start, end);
3725- }
3726-}
3727-
3728-/*
3729 * Determine low and high memory ranges:
3730 */
3731 unsigned long __init find_max_low_pfn(void)
3732@@ -1085,77 +353,6 @@ unsigned long __init find_max_low_pfn(vo
3733 return max_low_pfn;
3734 }
3735
3736-/*
3737- * Free all available memory for boot time allocation. Used
3738- * as a callback function by efi_memory_walk()
3739- */
3740-
3741-static int __init
3742-free_available_memory(unsigned long start, unsigned long end, void *arg)
3743-{
3744- /* check max_low_pfn */
3745- if (start >= (max_low_pfn << PAGE_SHIFT))
3746- return 0;
3747- if (end >= (max_low_pfn << PAGE_SHIFT))
3748- end = max_low_pfn << PAGE_SHIFT;
3749- if (start < end)
3750- free_bootmem(start, end - start);
3751-
3752- return 0;
3753-}
3754-/*
3755- * Register fully available low RAM pages with the bootmem allocator.
3756- */
3757-static void __init register_bootmem_low_pages(unsigned long max_low_pfn)
3758-{
3759- int i;
3760-
3761- if (efi_enabled) {
3762- efi_memmap_walk(free_available_memory, NULL);
3763- return;
3764- }
3765- for (i = 0; i < e820.nr_map; i++) {
3766- unsigned long curr_pfn, last_pfn, size;
3767- /*
3768- * Reserve usable low memory
3769- */
3770- if (e820.map[i].type != E820_RAM)
3771- continue;
3772- /*
3773- * We are rounding up the start address of usable memory:
3774- */
3775- curr_pfn = PFN_UP(e820.map[i].addr);
3776- if (curr_pfn >= max_low_pfn)
3777- continue;
3778- /*
3779- * ... and at the end of the usable range downwards:
3780- */
3781- last_pfn = PFN_DOWN(e820.map[i].addr + e820.map[i].size);
3782-
3783-#ifdef CONFIG_XEN
3784- /*
3785- * Truncate to the number of actual pages currently
3786- * present.
3787- */
3788- if (last_pfn > xen_start_info->nr_pages)
3789- last_pfn = xen_start_info->nr_pages;
3790-#endif
3791-
3792- if (last_pfn > max_low_pfn)
3793- last_pfn = max_low_pfn;
3794-
3795- /*
3796- * .. finally, did all the rounding and playing
3797- * around just make the area go away?
3798- */
3799- if (last_pfn <= curr_pfn)
3800- continue;
3801-
3802- size = last_pfn - curr_pfn;
3803- free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(size));
3804- }
3805-}
3806-
3807 #ifndef CONFIG_XEN
3808 /*
3809 * workaround for Dell systems that neglect to reserve EBDA
3810@@ -1245,8 +442,8 @@ void __init setup_bootmem_allocator(void
3811 * the (very unlikely) case of us accidentally initializing the
3812 * bootmem allocator with an invalid RAM area.
3813 */
3814- reserve_bootmem(__PHYSICAL_START, (PFN_PHYS(min_low_pfn) +
3815- bootmap_size + PAGE_SIZE-1) - (__PHYSICAL_START));
3816+ reserve_bootmem(__pa_symbol(_text), (PFN_PHYS(min_low_pfn) +
3817+ bootmap_size + PAGE_SIZE-1) - __pa_symbol(_text));
3818
3819 #ifndef CONFIG_XEN
3820 /*
3821@@ -1328,160 +525,6 @@ void __init remapped_pgdat_init(void)
3822 }
3823 }
3824
3825-/*
3826- * Request address space for all standard RAM and ROM resources
3827- * and also for regions reported as reserved by the e820.
3828- */
3829-static void __init
3830-legacy_init_iomem_resources(struct e820entry *e820, int nr_map,
3831- struct resource *code_resource,
3832- struct resource *data_resource)
3833-{
3834- int i;
3835-
3836- probe_roms();
3837-
3838- for (i = 0; i < nr_map; i++) {
3839- struct resource *res;
3840-#ifndef CONFIG_RESOURCES_64BIT
3841- if (e820[i].addr + e820[i].size > 0x100000000ULL)
3842- continue;
3843-#endif
3844- res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
3845- switch (e820[i].type) {
3846- case E820_RAM: res->name = "System RAM"; break;
3847- case E820_ACPI: res->name = "ACPI Tables"; break;
3848- case E820_NVS: res->name = "ACPI Non-volatile Storage"; break;
3849- default: res->name = "reserved";
3850- }
3851- res->start = e820[i].addr;
3852- res->end = res->start + e820[i].size - 1;
3853- res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
3854- if (request_resource(&iomem_resource, res)) {
3855- kfree(res);
3856- continue;
3857- }
3858- if (e820[i].type == E820_RAM) {
3859- /*
3860- * We don't know which RAM region contains kernel data,
3861- * so we try it repeatedly and let the resource manager
3862- * test it.
3863- */
3864-#ifndef CONFIG_XEN
3865- request_resource(res, code_resource);
3866- request_resource(res, data_resource);
3867-#endif
3868-#ifdef CONFIG_KEXEC
3869- if (crashk_res.start != crashk_res.end)
3870- request_resource(res, &crashk_res);
3871-#ifdef CONFIG_XEN
3872- xen_machine_kexec_register_resources(res);
3873-#endif
3874-#endif
3875- }
3876- }
3877-}
3878-
3879-/*
3880- * Locate a unused range of the physical address space below 4G which
3881- * can be used for PCI mappings.
3882- */
3883-static void __init
3884-e820_setup_gap(struct e820entry *e820, int nr_map)
3885-{
3886- unsigned long gapstart, gapsize, round;
3887- unsigned long long last;
3888- int i;
3889-
3890- /*
3891- * Search for the bigest gap in the low 32 bits of the e820
3892- * memory space.
3893- */
3894- last = 0x100000000ull;
3895- gapstart = 0x10000000;
3896- gapsize = 0x400000;
3897- i = nr_map;
3898- while (--i >= 0) {
3899- unsigned long long start = e820[i].addr;
3900- unsigned long long end = start + e820[i].size;
3901-
3902- /*
3903- * Since "last" is at most 4GB, we know we'll
3904- * fit in 32 bits if this condition is true
3905- */
3906- if (last > end) {
3907- unsigned long gap = last - end;
3908-
3909- if (gap > gapsize) {
3910- gapsize = gap;
3911- gapstart = end;
3912- }
3913- }
3914- if (start < last)
3915- last = start;
3916- }
3917-
3918- /*
3919- * See how much we want to round up: start off with
3920- * rounding to the next 1MB area.
3921- */
3922- round = 0x100000;
3923- while ((gapsize >> 4) > round)
3924- round += round;
3925- /* Fun with two's complement */
3926- pci_mem_start = (gapstart + round) & -round;
3927-
3928- printk("Allocating PCI resources starting at %08lx (gap: %08lx:%08lx)\n",
3929- pci_mem_start, gapstart, gapsize);
3930-}
3931-
3932-/*
3933- * Request address space for all standard resources
3934- *
3935- * This is called just before pcibios_init(), which is also a
3936- * subsys_initcall, but is linked in later (in arch/i386/pci/common.c).
3937- */
3938-static int __init request_standard_resources(void)
3939-{
3940- int i;
3941-
3942- /* Nothing to do if not running in dom0. */
3943- if (!is_initial_xendomain())
3944- return 0;
3945-
3946- printk("Setting up standard PCI resources\n");
3947-#ifdef CONFIG_XEN
3948- legacy_init_iomem_resources(machine_e820.map, machine_e820.nr_map,
3949- &code_resource, &data_resource);
3950-#else
3951- if (efi_enabled)
3952- efi_initialize_iomem_resources(&code_resource, &data_resource);
3953- else
3954- legacy_init_iomem_resources(e820.map, e820.nr_map,
3955- &code_resource, &data_resource);
3956-#endif
3957-
3958- /* EFI systems may still have VGA */
3959- request_resource(&iomem_resource, &video_ram_resource);
3960-
3961- /* request I/O space for devices used on all i[345]86 PCs */
3962- for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
3963- request_resource(&ioport_resource, &standard_io_resources[i]);
3964- return 0;
3965-}
3966-
3967-subsys_initcall(request_standard_resources);
3968-
3969-static void __init register_memory(void)
3970-{
3971-#ifdef CONFIG_XEN
3972- if (is_initial_xendomain())
3973- e820_setup_gap(machine_e820.map, machine_e820.nr_map);
3974- else
3975-#endif
3976- e820_setup_gap(e820.map, e820.nr_map);
3977-}
3978-
3979 #ifdef CONFIG_MCA
3980 static void set_mca_bus(int x)
3981 {
3982@@ -1491,6 +534,12 @@ static void set_mca_bus(int x)
3983 static void set_mca_bus(int x) { }
3984 #endif
3985
3986+/* Overridden in paravirt.c if CONFIG_PARAVIRT */
3987+char * __init __attribute__((weak)) memory_setup(void)
3988+{
3989+ return machine_specific_memory_setup();
3990+}
3991+
3992 /*
3993 * Determine if we were loaded by an EFI loader. If so, then we have also been
3994 * passed the efi memmap, systab, etc., so we should use these data structures
3995@@ -1578,7 +627,7 @@ void __init setup_arch(char **cmdline_p)
3996 efi_init();
3997 else {
3998 printk(KERN_INFO "BIOS-provided physical RAM map:\n");
3999- print_memory_map(machine_specific_memory_setup());
4000+ print_memory_map(memory_setup());
4001 }
4002
4003 copy_edd();
4004@@ -1757,7 +806,7 @@ void __init setup_arch(char **cmdline_p)
4005 get_smp_config();
4006 #endif
4007
4008- register_memory();
4009+ e820_register_memory();
4010
4011 if (is_initial_xendomain()) {
4012 #ifdef CONFIG_VT
4013--- sle11-2009-06-29.orig/arch/x86/kernel/smp_32-xen.c 2009-03-04 11:28:34.000000000 +0100
4014+++ sle11-2009-06-29/arch/x86/kernel/smp_32-xen.c 2008-12-15 11:26:44.000000000 +0100
4015@@ -659,6 +659,10 @@ int smp_call_function_single(int cpu, vo
4016 put_cpu();
4017 return -EBUSY;
4018 }
4019+
4020+ /* Can deadlock when called with interrupts disabled */
4021+ WARN_ON(irqs_disabled());
4022+
4023 spin_lock_bh(&call_lock);
4024 __smp_call_function_single(cpu, func, info, nonatomic, wait);
4025 spin_unlock_bh(&call_lock);
4026--- sle11-2009-06-29.orig/arch/x86/kernel/time_32-xen.c 2009-03-24 10:08:00.000000000 +0100
4027+++ sle11-2009-06-29/arch/x86/kernel/time_32-xen.c 2009-03-24 10:08:30.000000000 +0100
4028@@ -61,6 +61,7 @@
4029 #include <asm/uaccess.h>
4030 #include <asm/processor.h>
4031 #include <asm/timer.h>
4032+#include <asm/time.h>
4033 #include <asm/sections.h>
4034
4035 #include "mach_time.h"
4036@@ -129,11 +130,11 @@ static DEFINE_PER_CPU(struct vcpu_runsta
4037 /* Must be signed, as it's compared with s64 quantities which can be -ve. */
4038 #define NS_PER_TICK (1000000000LL/HZ)
4039
4040-static void __clock_was_set(void *unused)
4041+static void __clock_was_set(struct work_struct *unused)
4042 {
4043 clock_was_set();
4044 }
4045-static DECLARE_WORK(clock_was_set_work, __clock_was_set, NULL);
4046+static DECLARE_WORK(clock_was_set_work, __clock_was_set);
4047
4048 /*
4049 * GCC 4.3 can turn loops over an induction variable into division. We do
4050@@ -543,10 +544,7 @@ static int set_rtc_mmss(unsigned long no
4051 /* gets recalled with irq locally disabled */
4052 /* XXX - does irqsave resolve this? -johnstul */
4053 spin_lock_irqsave(&rtc_lock, flags);
4054- if (efi_enabled)
4055- retval = efi_set_rtc_mmss(nowtime);
4056- else
4057- retval = mach_set_rtc_mmss(nowtime);
4058+ retval = set_wallclock(nowtime);
4059 spin_unlock_irqrestore(&rtc_lock, flags);
4060
4061 return retval;
4062@@ -873,10 +871,7 @@ unsigned long get_cmos_time(void)
4063
4064 spin_lock_irqsave(&rtc_lock, flags);
4065
4066- if (efi_enabled)
4067- retval = efi_get_time();
4068- else
4069- retval = mach_get_cmos_time();
4070+ retval = get_wallclock();
4071
4072 spin_unlock_irqrestore(&rtc_lock, flags);
4073
4074@@ -978,7 +973,7 @@ static void __init hpet_time_init(void)
4075 printk("Using HPET for base-timer\n");
4076 }
4077
4078- time_init_hook();
4079+ do_time_init();
4080 }
4081 #endif
4082
4083--- sle11-2009-06-29.orig/arch/x86/kernel/traps_32-xen.c 2009-03-04 11:28:34.000000000 +0100
4084+++ sle11-2009-06-29/arch/x86/kernel/traps_32-xen.c 2008-12-15 11:26:44.000000000 +0100
4085@@ -29,6 +29,8 @@
4086 #include <linux/kexec.h>
4087 #include <linux/unwind.h>
4088 #include <linux/uaccess.h>
4089+#include <linux/nmi.h>
4090+#include <linux/bug.h>
4091
4092 #ifdef CONFIG_EISA
4093 #include <linux/ioport.h>
4094@@ -61,9 +63,6 @@ int panic_on_unrecovered_nmi;
4095
4096 asmlinkage int system_call(void);
4097
4098-struct desc_struct default_ldt[] = { { 0, 0 }, { 0, 0 }, { 0, 0 },
4099- { 0, 0 }, { 0, 0 } };
4100-
4101 /* Do we ignore FPU interrupts ? */
4102 char ignore_fpu_irq = 0;
4103
4104@@ -100,12 +99,7 @@ asmlinkage void fixup_4gb_segment(void);
4105 #endif
4106 asmlinkage void machine_check(void);
4107
4108-static int kstack_depth_to_print = 24;
4109-#ifdef CONFIG_STACK_UNWIND
4110-static int call_trace = 1;
4111-#else
4112-#define call_trace (-1)
4113-#endif
4114+int kstack_depth_to_print = 24;
4115 ATOMIC_NOTIFIER_HEAD(i386die_chain);
4116
4117 int register_die_notifier(struct notifier_block *nb)
4118@@ -159,25 +153,7 @@ static inline unsigned long print_contex
4119 return ebp;
4120 }
4121
4122-struct ops_and_data {
4123- struct stacktrace_ops *ops;
4124- void *data;
4125-};
4126-
4127-static asmlinkage int
4128-dump_trace_unwind(struct unwind_frame_info *info, void *data)
4129-{
4130- struct ops_and_data *oad = (struct ops_and_data *)data;
4131- int n = 0;
4132-
4133- while (unwind(info) == 0 && UNW_PC(info)) {
4134- n++;
4135- oad->ops->address(oad->data, UNW_PC(info));
4136- if (arch_unw_user_mode(info))
4137- break;
4138- }
4139- return n;
4140-}
4141+#define MSG(msg) ops->warning(data, msg)
4142
4143 void dump_trace(struct task_struct *task, struct pt_regs *regs,
4144 unsigned long *stack,
4145@@ -188,39 +164,6 @@ void dump_trace(struct task_struct *task
4146 if (!task)
4147 task = current;
4148
4149- if (call_trace >= 0) {
4150- int unw_ret = 0;
4151- struct unwind_frame_info info;
4152- struct ops_and_data oad = { .ops = ops, .data = data };
4153-
4154- if (regs) {
4155- if (unwind_init_frame_info(&info, task, regs) == 0)
4156- unw_ret = dump_trace_unwind(&info, &oad);
4157- } else if (task == current)
4158- unw_ret = unwind_init_running(&info, dump_trace_unwind, &oad);
4159- else {
4160- if (unwind_init_blocked(&info, task) == 0)
4161- unw_ret = dump_trace_unwind(&info, &oad);
4162- }
4163- if (unw_ret > 0) {
4164- if (call_trace == 1 && !arch_unw_user_mode(&info)) {
4165- ops->warning_symbol(data, "DWARF2 unwinder stuck at %s\n",
4166- UNW_PC(&info));
4167- if (UNW_SP(&info) >= PAGE_OFFSET) {
4168- ops->warning(data, "Leftover inexact backtrace:\n");
4169- stack = (void *)UNW_SP(&info);
4170- if (!stack)
4171- return;
4172- ebp = UNW_FP(&info);
4173- } else
4174- ops->warning(data, "Full inexact backtrace again:\n");
4175- } else if (call_trace >= 1)
4176- return;
4177- else
4178- ops->warning(data, "Full inexact backtrace again:\n");
4179- } else
4180- ops->warning(data, "Inexact backtrace:\n");
4181- }
4182 if (!stack) {
4183 unsigned long dummy;
4184 stack = &dummy;
4185@@ -253,6 +196,7 @@ void dump_trace(struct task_struct *task
4186 stack = (unsigned long*)context->previous_esp;
4187 if (!stack)
4188 break;
4189+ touch_nmi_watchdog();
4190 }
4191 }
4192 EXPORT_SYMBOL(dump_trace);
4193@@ -385,7 +329,7 @@ void show_registers(struct pt_regs *regs
4194 * time of the fault..
4195 */
4196 if (in_kernel) {
4197- u8 __user *eip;
4198+ u8 *eip;
4199 int code_bytes = 64;
4200 unsigned char c;
4201
4202@@ -394,18 +338,20 @@ void show_registers(struct pt_regs *regs
4203
4204 printk(KERN_EMERG "Code: ");
4205
4206- eip = (u8 __user *)regs->eip - 43;
4207- if (eip < (u8 __user *)PAGE_OFFSET || __get_user(c, eip)) {
4208+ eip = (u8 *)regs->eip - 43;
4209+ if (eip < (u8 *)PAGE_OFFSET ||
4210+ probe_kernel_address(eip, c)) {
4211 /* try starting at EIP */
4212- eip = (u8 __user *)regs->eip;
4213+ eip = (u8 *)regs->eip;
4214 code_bytes = 32;
4215 }
4216 for (i = 0; i < code_bytes; i++, eip++) {
4217- if (eip < (u8 __user *)PAGE_OFFSET || __get_user(c, eip)) {
4218+ if (eip < (u8 *)PAGE_OFFSET ||
4219+ probe_kernel_address(eip, c)) {
4220 printk(" Bad EIP value.");
4221 break;
4222 }
4223- if (eip == (u8 __user *)regs->eip)
4224+ if (eip == (u8 *)regs->eip)
4225 printk("<%02x> ", c);
4226 else
4227 printk("%02x ", c);
4228@@ -414,43 +360,22 @@ void show_registers(struct pt_regs *regs
4229 printk("\n");
4230 }
4231
4232-static void handle_BUG(struct pt_regs *regs)
4233+int is_valid_bugaddr(unsigned long eip)
4234 {
4235- unsigned long eip = regs->eip;
4236 unsigned short ud2;
4237
4238 if (eip < PAGE_OFFSET)
4239- return;
4240- if (probe_kernel_address((unsigned short __user *)eip, ud2))
4241- return;
4242- if (ud2 != 0x0b0f)
4243- return;
4244+ return 0;
4245+ if (probe_kernel_address((unsigned short *)eip, ud2))
4246+ return 0;
4247
4248- printk(KERN_EMERG "------------[ cut here ]------------\n");
4249-
4250-#ifdef CONFIG_DEBUG_BUGVERBOSE
4251- do {
4252- unsigned short line;
4253- char *file;
4254- char c;
4255-
4256- if (probe_kernel_address((unsigned short __user *)(eip + 2),
4257- line))
4258- break;
4259- if (__get_user(file, (char * __user *)(eip + 4)) ||
4260- (unsigned long)file < PAGE_OFFSET || __get_user(c, file))
4261- file = "<bad filename>";
4262-
4263- printk(KERN_EMERG "kernel BUG at %s:%d!\n", file, line);
4264- return;
4265- } while (0);
4266-#endif
4267- printk(KERN_EMERG "Kernel BUG at [verbose debug info unavailable]\n");
4268+ return ud2 == 0x0b0f;
4269 }
4270
4271-/* This is gone through when something in the kernel
4272- * has done something bad and is about to be terminated.
4273-*/
4274+/*
4275+ * This is gone through when something in the kernel has done something bad and
4276+ * is about to be terminated.
4277+ */
4278 void die(const char * str, struct pt_regs * regs, long err)
4279 {
4280 static struct {
4281@@ -458,7 +383,7 @@ void die(const char * str, struct pt_reg
4282 u32 lock_owner;
4283 int lock_owner_depth;
4284 } die = {
4285- .lock = SPIN_LOCK_UNLOCKED,
4286+ .lock = __SPIN_LOCK_UNLOCKED(die.lock),
4287 .lock_owner = -1,
4288 .lock_owner_depth = 0
4289 };
4290@@ -482,7 +407,8 @@ void die(const char * str, struct pt_reg
4291 unsigned long esp;
4292 unsigned short ss;
4293
4294- handle_BUG(regs);
4295+ report_bug(regs->eip);
4296+
4297 printk(KERN_EMERG "%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter);
4298 #ifdef CONFIG_PREEMPT
4299 printk(KERN_EMERG "PREEMPT ");
4300@@ -682,8 +608,7 @@ mem_parity_error(unsigned char reason, s
4301 {
4302 printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on "
4303 "CPU %d.\n", reason, smp_processor_id());
4304- printk(KERN_EMERG "You probably have a hardware problem with your RAM "
4305- "chips\n");
4306+ printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
4307 if (panic_on_unrecovered_nmi)
4308 panic("NMI: Not continuing");
4309
4310@@ -741,7 +666,6 @@ void __kprobes die_nmi(struct pt_regs *r
4311 printk(" on CPU%d, eip %08lx, registers:\n",
4312 smp_processor_id(), regs->eip);
4313 show_registers(regs);
4314- printk(KERN_EMERG "console shuts up ...\n");
4315 console_silent();
4316 spin_unlock(&nmi_print_lock);
4317 bust_spinlocks(0);
4318@@ -1057,49 +981,24 @@ fastcall void do_spurious_interrupt_bug(
4319 #endif
4320 }
4321
4322-fastcall void setup_x86_bogus_stack(unsigned char * stk)
4323+fastcall unsigned long patch_espfix_desc(unsigned long uesp,
4324+ unsigned long kesp)
4325 {
4326- unsigned long *switch16_ptr, *switch32_ptr;
4327- struct pt_regs *regs;
4328- unsigned long stack_top, stack_bot;
4329- unsigned short iret_frame16_off;
4330- int cpu = smp_processor_id();
4331- /* reserve the space on 32bit stack for the magic switch16 pointer */
4332- memmove(stk, stk + 8, sizeof(struct pt_regs));
4333- switch16_ptr = (unsigned long *)(stk + sizeof(struct pt_regs));
4334- regs = (struct pt_regs *)stk;
4335- /* now the switch32 on 16bit stack */
4336- stack_bot = (unsigned long)&per_cpu(cpu_16bit_stack, cpu);
4337- stack_top = stack_bot + CPU_16BIT_STACK_SIZE;
4338- switch32_ptr = (unsigned long *)(stack_top - 8);
4339- iret_frame16_off = CPU_16BIT_STACK_SIZE - 8 - 20;
4340- /* copy iret frame on 16bit stack */
4341- memcpy((void *)(stack_bot + iret_frame16_off), &regs->eip, 20);
4342- /* fill in the switch pointers */
4343- switch16_ptr[0] = (regs->esp & 0xffff0000) | iret_frame16_off;
4344- switch16_ptr[1] = __ESPFIX_SS;
4345- switch32_ptr[0] = (unsigned long)stk + sizeof(struct pt_regs) +
4346- 8 - CPU_16BIT_STACK_SIZE;
4347- switch32_ptr[1] = __KERNEL_DS;
4348-}
4349-
4350-fastcall unsigned char * fixup_x86_bogus_stack(unsigned short sp)
4351-{
4352- unsigned long *switch32_ptr;
4353- unsigned char *stack16, *stack32;
4354- unsigned long stack_top, stack_bot;
4355- int len;
4356 int cpu = smp_processor_id();
4357- stack_bot = (unsigned long)&per_cpu(cpu_16bit_stack, cpu);
4358- stack_top = stack_bot + CPU_16BIT_STACK_SIZE;
4359- switch32_ptr = (unsigned long *)(stack_top - 8);
4360- /* copy the data from 16bit stack to 32bit stack */
4361- len = CPU_16BIT_STACK_SIZE - 8 - sp;
4362- stack16 = (unsigned char *)(stack_bot + sp);
4363- stack32 = (unsigned char *)
4364- (switch32_ptr[0] + CPU_16BIT_STACK_SIZE - 8 - len);
4365- memcpy(stack32, stack16, len);
4366- return stack32;
4367+ struct Xgt_desc_struct *cpu_gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
4368+ struct desc_struct *gdt = (struct desc_struct *)cpu_gdt_descr->address;
4369+ unsigned long base = (kesp - uesp) & -THREAD_SIZE;
4370+ unsigned long new_kesp = kesp - base;
4371+ unsigned long lim_pages = (new_kesp | (THREAD_SIZE - 1)) >> PAGE_SHIFT;
4372+ __u64 desc = *(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS];
4373+ /* Set up base for espfix segment */
4374+ desc &= 0x00f0ff0000000000ULL;
4375+ desc |= ((((__u64)base) << 16) & 0x000000ffffff0000ULL) |
4376+ ((((__u64)base) << 32) & 0xff00000000000000ULL) |
4377+ ((((__u64)lim_pages) << 32) & 0x000f000000000000ULL) |
4378+ (lim_pages & 0xffff);
4379+ *(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS] = desc;
4380+ return new_kesp;
4381 }
4382 #endif
4383
4384@@ -1113,7 +1012,7 @@ fastcall unsigned char * fixup_x86_bogus
4385 * Must be called with kernel preemption disabled (in this case,
4386 * local interrupts are disabled at the call-site in entry.S).
4387 */
4388-asmlinkage void math_state_restore(struct pt_regs regs)
4389+asmlinkage void math_state_restore(void)
4390 {
4391 struct thread_info *thread = current_thread_info();
4392 struct task_struct *tsk = thread->task;
4393@@ -1123,6 +1022,7 @@ asmlinkage void math_state_restore(struc
4394 init_fpu(tsk);
4395 restore_fpu(tsk);
4396 thread->status |= TS_USEDFPU; /* So we fnsave on switch_to() */
4397+ tsk->fpu_counter++;
4398 }
4399
4400 #ifndef CONFIG_MATH_EMULATION
4401@@ -1234,19 +1134,3 @@ static int __init kstack_setup(char *s)
4402 return 1;
4403 }
4404 __setup("kstack=", kstack_setup);
4405-
4406-#ifdef CONFIG_STACK_UNWIND
4407-static int __init call_trace_setup(char *s)
4408-{
4409- if (strcmp(s, "old") == 0)
4410- call_trace = -1;
4411- else if (strcmp(s, "both") == 0)
4412- call_trace = 0;
4413- else if (strcmp(s, "newfallback") == 0)
4414- call_trace = 1;
4415- else if (strcmp(s, "new") == 2)
4416- call_trace = 2;
4417- return 1;
4418-}
4419-__setup("call_trace=", call_trace_setup);
4420-#endif
4421--- sle11-2009-06-29.orig/arch/x86/kernel/vmlinux_32.lds.S 2009-06-29 15:14:52.000000000 +0200
4422+++ sle11-2009-06-29/arch/x86/kernel/vmlinux_32.lds.S 2008-12-15 11:26:44.000000000 +0100
4423@@ -29,6 +29,12 @@ PHDRS {
4424 SECTIONS
4425 {
4426 . = LOAD_OFFSET + LOAD_PHYSICAL_ADDR;
4427+
4428+#if defined(CONFIG_XEN) && CONFIG_XEN_COMPAT <= 0x030002
4429+#undef LOAD_OFFSET
4430+#define LOAD_OFFSET 0
4431+#endif
4432+
4433 phys_startup_32 = startup_32 - LOAD_OFFSET;
4434
4435 .text.head : AT(ADDR(.text.head) - LOAD_OFFSET) {
4436--- sle11-2009-06-29.orig/arch/x86/kvm/Kconfig 2009-06-29 15:14:52.000000000 +0200
4437+++ sle11-2009-06-29/arch/x86/kvm/Kconfig 2008-12-15 11:26:44.000000000 +0100
4438@@ -7,6 +7,7 @@ config HAVE_KVM
4439 menuconfig VIRTUALIZATION
4440 bool "Virtualization"
4441 depends on HAVE_KVM || X86
4442+ depends on !XEN
4443 default y
4444 ---help---
4445 Say Y here to get to see options for using your Linux host to run other
4446--- sle11-2009-06-29.orig/arch/x86/mm/fault_32-xen.c 2009-03-04 11:28:34.000000000 +0100
4447+++ sle11-2009-06-29/arch/x86/mm/fault_32-xen.c 2008-12-15 11:26:44.000000000 +0100
4448@@ -22,9 +22,9 @@
4449 #include <linux/highmem.h>
4450 #include <linux/module.h>
4451 #include <linux/kprobes.h>
4452+#include <linux/uaccess.h>
4453
4454 #include <asm/system.h>
4455-#include <asm/uaccess.h>
4456 #include <asm/desc.h>
4457 #include <asm/kdebug.h>
4458 #include <asm/segment.h>
4459@@ -167,7 +167,7 @@ static inline unsigned long get_segment_
4460 static int __is_prefetch(struct pt_regs *regs, unsigned long addr)
4461 {
4462 unsigned long limit;
4463- unsigned long instr = get_segment_eip (regs, &limit);
4464+ unsigned char *instr = (unsigned char *)get_segment_eip (regs, &limit);
4465 int scan_more = 1;
4466 int prefetch = 0;
4467 int i;
4468@@ -177,9 +177,9 @@ static int __is_prefetch(struct pt_regs
4469 unsigned char instr_hi;
4470 unsigned char instr_lo;
4471
4472- if (instr > limit)
4473+ if (instr > (unsigned char *)limit)
4474 break;
4475- if (__get_user(opcode, (unsigned char __user *) instr))
4476+ if (probe_kernel_address(instr, opcode))
4477 break;
4478
4479 instr_hi = opcode & 0xf0;
4480@@ -204,9 +204,9 @@ static int __is_prefetch(struct pt_regs
4481 case 0x00:
4482 /* Prefetch instruction is 0x0F0D or 0x0F18 */
4483 scan_more = 0;
4484- if (instr > limit)
4485+ if (instr > (unsigned char *)limit)
4486 break;
4487- if (__get_user(opcode, (unsigned char __user *) instr))
4488+ if (probe_kernel_address(instr, opcode))
4489 break;
4490 prefetch = (instr_lo == 0xF) &&
4491 (opcode == 0x0D || opcode == 0x18);
4492--- sle11-2009-06-29.orig/arch/x86/mm/highmem_32-xen.c 2009-03-04 11:28:34.000000000 +0100
4493+++ sle11-2009-06-29/arch/x86/mm/highmem_32-xen.c 2008-12-15 11:26:44.000000000 +0100
4494@@ -32,7 +32,7 @@ static void *__kmap_atomic(struct page *
4495 unsigned long vaddr;
4496
4497 /* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
4498- inc_preempt_count();
4499+ pagefault_disable();
4500 if (!PageHighMem(page))
4501 return page_address(page);
4502
4503@@ -63,26 +63,22 @@ void kunmap_atomic(void *kvaddr, enum km
4504 unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
4505 enum fixed_addresses idx = type + KM_TYPE_NR*smp_processor_id();
4506
4507-#ifdef CONFIG_DEBUG_HIGHMEM
4508- if (vaddr >= PAGE_OFFSET && vaddr < (unsigned long)high_memory) {
4509- dec_preempt_count();
4510- preempt_check_resched();
4511- return;
4512- }
4513-
4514- if (vaddr != __fix_to_virt(FIX_KMAP_BEGIN+idx))
4515- BUG();
4516-#endif
4517 /*
4518 * Force other mappings to Oops if they'll try to access this pte
4519 * without first remap it. Keeping stale mappings around is a bad idea
4520 * also, in case the page changes cacheability attributes or becomes
4521 * a protected page in a hypervisor.
4522 */
4523- kpte_clear_flush(kmap_pte-idx, vaddr);
4524+ if (vaddr == __fix_to_virt(FIX_KMAP_BEGIN+idx))
4525+ kpte_clear_flush(kmap_pte-idx, vaddr);
4526+ else {
4527+#ifdef CONFIG_DEBUG_HIGHMEM
4528+ BUG_ON(vaddr < PAGE_OFFSET);
4529+ BUG_ON(vaddr >= (unsigned long)high_memory);
4530+#endif
4531+ }
4532
4533- dec_preempt_count();
4534- preempt_check_resched();
4535+ pagefault_enable();
4536 }
4537
4538 /* This is the same as kmap_atomic() but can map memory that doesn't
4539@@ -93,7 +89,7 @@ void *kmap_atomic_pfn(unsigned long pfn,
4540 enum fixed_addresses idx;
4541 unsigned long vaddr;
4542
4543- inc_preempt_count();
4544+ pagefault_disable();
4545
4546 idx = type + KM_TYPE_NR*smp_processor_id();
4547 vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
4548--- sle11-2009-06-29.orig/arch/x86/mm/init_32-xen.c 2009-03-04 11:28:34.000000000 +0100
4549+++ sle11-2009-06-29/arch/x86/mm/init_32-xen.c 2008-12-15 11:26:44.000000000 +0100
4550@@ -233,8 +233,6 @@ static inline int page_kills_ppro(unsign
4551
4552 #endif
4553
4554-extern int is_available_memory(efi_memory_desc_t *);
4555-
4556 int page_is_ram(unsigned long pagenr)
4557 {
4558 int i;
4559@@ -327,7 +325,7 @@ void __init add_one_highpage_init(struct
4560 SetPageReserved(page);
4561 }
4562
4563-static int add_one_highpage_hotplug(struct page *page, unsigned long pfn)
4564+static int __meminit add_one_highpage_hotplug(struct page *page, unsigned long pfn)
4565 {
4566 free_new_highpage(page, pfn);
4567 totalram_pages++;
4568@@ -344,7 +342,7 @@ static int add_one_highpage_hotplug(stru
4569 * has been added dynamically that would be
4570 * onlined here is in HIGHMEM
4571 */
4572-void online_page(struct page *page)
4573+void __meminit online_page(struct page *page)
4574 {
4575 ClearPageReserved(page);
4576 add_one_highpage_hotplug(page, page_to_pfn(page));
4577@@ -732,16 +730,10 @@ void __init mem_init(void)
4578 set_bit(PG_pinned, &virt_to_page(init_mm.pgd)->flags);
4579 }
4580
4581-/*
4582- * this is for the non-NUMA, single node SMP system case.
4583- * Specifically, in the case of x86, we will always add
4584- * memory to the highmem for now.
4585- */
4586 #ifdef CONFIG_MEMORY_HOTPLUG
4587-#ifndef CONFIG_NEED_MULTIPLE_NODES
4588 int arch_add_memory(int nid, u64 start, u64 size)
4589 {
4590- struct pglist_data *pgdata = &contig_page_data;
4591+ struct pglist_data *pgdata = NODE_DATA(nid);
4592 struct zone *zone = pgdata->node_zones + ZONE_HIGHMEM;
4593 unsigned long start_pfn = start >> PAGE_SHIFT;
4594 unsigned long nr_pages = size >> PAGE_SHIFT;
4595@@ -753,11 +745,11 @@ int remove_memory(u64 start, u64 size)
4596 {
4597 return -EINVAL;
4598 }
4599-#endif
4600+EXPORT_SYMBOL_GPL(remove_memory);
4601 #endif
4602
4603-kmem_cache_t *pgd_cache;
4604-kmem_cache_t *pmd_cache;
4605+struct kmem_cache *pgd_cache;
4606+struct kmem_cache *pmd_cache;
4607
4608 void __init pgtable_cache_init(void)
4609 {
4610--- sle11-2009-06-29.orig/arch/x86/mm/pgtable_32-xen.c 2009-03-04 11:28:34.000000000 +0100
4611+++ sle11-2009-06-29/arch/x86/mm/pgtable_32-xen.c 2008-12-15 11:26:44.000000000 +0100
4612@@ -203,7 +203,7 @@ void pte_free(struct page *pte)
4613 __free_page(pte);
4614 }
4615
4616-void pmd_ctor(void *pmd, kmem_cache_t *cache, unsigned long flags)
4617+void pmd_ctor(void *pmd, struct kmem_cache *cache, unsigned long flags)
4618 {
4619 memset(pmd, 0, PTRS_PER_PMD*sizeof(pmd_t));
4620 }
4621@@ -243,7 +243,7 @@ static inline void pgd_list_del(pgd_t *p
4622 set_page_private(next, (unsigned long)pprev);
4623 }
4624
4625-void pgd_ctor(void *pgd, kmem_cache_t *cache, unsigned long unused)
4626+void pgd_ctor(void *pgd, struct kmem_cache *cache, unsigned long unused)
4627 {
4628 unsigned long flags;
4629
4630@@ -264,7 +264,7 @@ void pgd_ctor(void *pgd, kmem_cache_t *c
4631 }
4632
4633 /* never called when PTRS_PER_PMD > 1 */
4634-void pgd_dtor(void *pgd, kmem_cache_t *cache, unsigned long unused)
4635+void pgd_dtor(void *pgd, struct kmem_cache *cache, unsigned long unused)
4636 {
4637 unsigned long flags; /* can be called from interrupt context */
4638
4639--- sle11-2009-06-29.orig/arch/x86/pci/irq-xen.c 2009-03-04 11:28:34.000000000 +0100
4640+++ sle11-2009-06-29/arch/x86/pci/irq-xen.c 2008-12-15 11:26:44.000000000 +0100
4641@@ -768,7 +768,7 @@ static void __init pirq_find_router(stru
4642 DBG(KERN_DEBUG "PCI: Attempting to find IRQ router for %04x:%04x\n",
4643 rt->rtr_vendor, rt->rtr_device);
4644
4645- pirq_router_dev = pci_find_slot(rt->rtr_bus, rt->rtr_devfn);
4646+ pirq_router_dev = pci_get_bus_and_slot(rt->rtr_bus, rt->rtr_devfn);
4647 if (!pirq_router_dev) {
4648 DBG(KERN_DEBUG "PCI: Interrupt router not found at "
4649 "%02x:%02x\n", rt->rtr_bus, rt->rtr_devfn);
4650@@ -788,6 +788,8 @@ static void __init pirq_find_router(stru
4651 pirq_router_dev->vendor,
4652 pirq_router_dev->device,
4653 pci_name(pirq_router_dev));
4654+
4655+ /* The device remains referenced for the kernel lifetime */
4656 }
4657
4658 static struct irq_info *pirq_get_info(struct pci_dev *dev)
4659--- sle11-2009-06-29.orig/arch/x86/kernel/entry_64-xen.S 2009-03-04 11:28:34.000000000 +0100
4660+++ sle11-2009-06-29/arch/x86/kernel/entry_64-xen.S 2008-12-15 11:26:44.000000000 +0100
4661@@ -261,7 +261,6 @@ ENTRY(system_call)
4662 movq %rax,ORIG_RAX-ARGOFFSET(%rsp)
4663 GET_THREAD_INFO(%rcx)
4664 testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SECCOMP),threadinfo_flags(%rcx)
4665- CFI_REMEMBER_STATE
4666 jnz tracesys
4667 cmpq $__NR_syscall_max,%rax
4668 ja badsys
4669@@ -272,7 +271,6 @@ ENTRY(system_call)
4670 * Syscall return path ending with SYSRET (fast path)
4671 * Has incomplete stack frame and undefined top of stack.
4672 */
4673- .globl ret_from_sys_call
4674 ret_from_sys_call:
4675 movl $_TIF_ALLWORK_MASK,%edi
4676 /* edi: flagmask */
4677@@ -282,8 +280,8 @@ sysret_check:
4678 TRACE_IRQS_OFF
4679 movl threadinfo_flags(%rcx),%edx
4680 andl %edi,%edx
4681- CFI_REMEMBER_STATE
4682 jnz sysret_careful
4683+ CFI_REMEMBER_STATE
4684 /*
4685 * sysretq will re-enable interrupts:
4686 */
4687@@ -292,10 +290,10 @@ sysret_check:
4688 RESTORE_ARGS 0,8,0
4689 HYPERVISOR_IRET VGCF_IN_SYSCALL
4690
4691+ CFI_RESTORE_STATE
4692 /* Handle reschedules */
4693 /* edx: work, edi: workmask */
4694 sysret_careful:
4695- CFI_RESTORE_STATE
4696 bt $TIF_NEED_RESCHED,%edx
4697 jnc sysret_signal
4698 TRACE_IRQS_ON
4699@@ -334,7 +332,6 @@ badsys:
4700
4701 /* Do syscall tracing */
4702 tracesys:
4703- CFI_RESTORE_STATE
4704 SAVE_REST
4705 movq $-ENOSYS,RAX(%rsp)
4706 FIXUP_TOP_OF_STACK %rdi
4707@@ -350,32 +347,13 @@ tracesys:
4708 call *sys_call_table(,%rax,8)
4709 1: movq %rax,RAX-ARGOFFSET(%rsp)
4710 /* Use IRET because user could have changed frame */
4711- jmp int_ret_from_sys_call
4712- CFI_ENDPROC
4713-END(system_call)
4714
4715 /*
4716 * Syscall return path ending with IRET.
4717 * Has correct top of stack, but partial stack frame.
4718- */
4719-ENTRY(int_ret_from_sys_call)
4720- CFI_STARTPROC simple
4721- CFI_SIGNAL_FRAME
4722- CFI_DEF_CFA rsp,SS+8-ARGOFFSET
4723- /*CFI_REL_OFFSET ss,SS-ARGOFFSET*/
4724- CFI_REL_OFFSET rsp,RSP-ARGOFFSET
4725- /*CFI_REL_OFFSET rflags,EFLAGS-ARGOFFSET*/
4726- /*CFI_REL_OFFSET cs,CS-ARGOFFSET*/
4727- CFI_REL_OFFSET rip,RIP-ARGOFFSET
4728- CFI_REL_OFFSET rdx,RDX-ARGOFFSET
4729- CFI_REL_OFFSET rcx,RCX-ARGOFFSET
4730- CFI_REL_OFFSET rax,RAX-ARGOFFSET
4731- CFI_REL_OFFSET rdi,RDI-ARGOFFSET
4732- CFI_REL_OFFSET rsi,RSI-ARGOFFSET
4733- CFI_REL_OFFSET r8,R8-ARGOFFSET
4734- CFI_REL_OFFSET r9,R9-ARGOFFSET
4735- CFI_REL_OFFSET r10,R10-ARGOFFSET
4736- CFI_REL_OFFSET r11,R11-ARGOFFSET
4737+ */
4738+ .globl int_ret_from_sys_call
4739+int_ret_from_sys_call:
4740 XEN_BLOCK_EVENTS(%rsi)
4741 TRACE_IRQS_OFF
4742 testb $3,CS-ARGOFFSET(%rsp)
4743@@ -428,8 +406,6 @@ int_very_careful:
4744 popq %rdi
4745 CFI_ADJUST_CFA_OFFSET -8
4746 andl $~(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP),%edi
4747- XEN_BLOCK_EVENTS(%rsi)
4748- TRACE_IRQS_OFF
4749 jmp int_restore_rest
4750
4751 int_signal:
4752@@ -445,7 +421,7 @@ int_restore_rest:
4753 TRACE_IRQS_OFF
4754 jmp int_with_check
4755 CFI_ENDPROC
4756-END(int_ret_from_sys_call)
4757+END(system_call)
4758
4759 /*
4760 * Certain special system calls that need to save a complete full stack frame.
4761@@ -1275,36 +1251,3 @@ ENTRY(call_softirq)
4762 ret
4763 CFI_ENDPROC
4764 ENDPROC(call_softirq)
4765-
4766-#ifdef CONFIG_STACK_UNWIND
4767-ENTRY(arch_unwind_init_running)
4768- CFI_STARTPROC
4769- movq %r15, R15(%rdi)
4770- movq %r14, R14(%rdi)
4771- xchgq %rsi, %rdx
4772- movq %r13, R13(%rdi)
4773- movq %r12, R12(%rdi)
4774- xorl %eax, %eax
4775- movq %rbp, RBP(%rdi)
4776- movq %rbx, RBX(%rdi)
4777- movq (%rsp), %rcx
4778- movq %rax, R11(%rdi)
4779- movq %rax, R10(%rdi)
4780- movq %rax, R9(%rdi)
4781- movq %rax, R8(%rdi)
4782- movq %rax, RAX(%rdi)
4783- movq %rax, RCX(%rdi)
4784- movq %rax, RDX(%rdi)
4785- movq %rax, RSI(%rdi)
4786- movq %rax, RDI(%rdi)
4787- movq %rax, ORIG_RAX(%rdi)
4788- movq %rcx, RIP(%rdi)
4789- leaq 8(%rsp), %rcx
4790- movq $__KERNEL_CS, CS(%rdi)
4791- movq %rax, EFLAGS(%rdi)
4792- movq %rcx, RSP(%rdi)
4793- movq $__KERNEL_DS, SS(%rdi)
4794- jmpq *%rdx
4795- CFI_ENDPROC
4796-ENDPROC(arch_unwind_init_running)
4797-#endif
4798--- sle11-2009-06-29.orig/arch/x86/kernel/genapic_64-xen.c 2009-06-29 15:14:52.000000000 +0200
4799+++ sle11-2009-06-29/arch/x86/kernel/genapic_64-xen.c 2008-12-15 11:26:44.000000000 +0100
4800@@ -34,6 +34,7 @@ extern struct genapic apic_physflat;
4801
4802 #ifndef CONFIG_XEN
4803 struct genapic *genapic = &apic_flat;
4804+struct genapic *genapic_force;
4805 #else
4806 extern struct genapic apic_xen;
4807 struct genapic *genapic = &apic_xen;
4808@@ -52,6 +53,13 @@ void __init clustered_apic_check(void)
4809 u8 cluster_cnt[NUM_APIC_CLUSTERS];
4810 int max_apic = 0;
4811
4812+ /* genapic selection can be forced because of certain quirks.
4813+ */
4814+ if (genapic_force) {
4815+ genapic = genapic_force;
4816+ goto print;
4817+ }
4818+
4819 #if defined(CONFIG_ACPI)
4820 /*
4821 * Some x86_64 machines use physical APIC mode regardless of how many
4822--- sle11-2009-06-29.orig/arch/x86/kernel/head64-xen.c 2009-03-04 11:28:34.000000000 +0100
4823+++ sle11-2009-06-29/arch/x86/kernel/head64-xen.c 2008-12-15 11:26:44.000000000 +0100
4824@@ -104,7 +104,10 @@ void __init x86_64_start_kernel(char * r
4825 machine_to_phys_order++;
4826
4827 #if 0
4828- for (i = 0; i < 256; i++)
4829+ /* clear bss before set_intr_gate with early_idt_handler */
4830+ clear_bss();
4831+
4832+ for (i = 0; i < IDT_ENTRIES; i++)
4833 set_intr_gate(i, early_idt_handler);
4834 asm volatile("lidt %0" :: "m" (idt_descr));
4835 #endif
4836--- sle11-2009-06-29.orig/arch/x86/kernel/io_apic_64-xen.c 2009-03-04 11:28:34.000000000 +0100
4837+++ sle11-2009-06-29/arch/x86/kernel/io_apic_64-xen.c 2008-12-15 11:26:44.000000000 +0100
4838@@ -202,14 +202,20 @@ static struct IO_APIC_route_entry ioapic
4839 * the interrupt, and we need to make sure the entry is fully populated
4840 * before that happens.
4841 */
4842-static void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
4843+static void
4844+__ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
4845 {
4846- unsigned long flags;
4847 union entry_union eu;
4848 eu.entry = e;
4849- spin_lock_irqsave(&ioapic_lock, flags);
4850 io_apic_write(apic, 0x11 + 2*pin, eu.w2);
4851 io_apic_write(apic, 0x10 + 2*pin, eu.w1);
4852+}
4853+
4854+static void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
4855+{
4856+ unsigned long flags;
4857+ spin_lock_irqsave(&ioapic_lock, flags);
4858+ __ioapic_write_entry(apic, pin, e);
4859 spin_unlock_irqrestore(&ioapic_lock, flags);
4860 }
4861
4862@@ -720,6 +726,22 @@ static int assign_irq_vector(int irq, cp
4863 }
4864
4865 #ifndef CONFIG_XEN
4866+static void __clear_irq_vector(int irq)
4867+{
4868+ cpumask_t mask;
4869+ int cpu, vector;
4870+
4871+ BUG_ON(!irq_vector[irq]);
4872+
4873+ vector = irq_vector[irq];
4874+ cpus_and(mask, irq_domain[irq], cpu_online_map);
4875+ for_each_cpu_mask(cpu, mask)
4876+ per_cpu(vector_irq, cpu)[vector] = -1;
4877+
4878+ irq_vector[irq] = 0;
4879+ irq_domain[irq] = CPU_MASK_NONE;
4880+}
4881+
4882 void __setup_vector_irq(int cpu)
4883 {
4884 /* Initialize vector_irq on a new cpu */
4885@@ -767,26 +789,65 @@ static void ioapic_register_intr(int irq
4886 #define ioapic_register_intr(irq, vector, trigger) evtchn_register_pirq(irq)
4887 #endif /* !CONFIG_XEN */
4888
4889-static void __init setup_IO_APIC_irqs(void)
4890+static void __init setup_IO_APIC_irq(int apic, int pin, int idx, int irq)
4891 {
4892 struct IO_APIC_route_entry entry;
4893- int apic, pin, idx, irq, first_notcon = 1, vector;
4894+ int vector;
4895 unsigned long flags;
4896
4897- apic_printk(APIC_VERBOSE, KERN_DEBUG "init IO_APIC IRQs\n");
4898
4899- for (apic = 0; apic < nr_ioapics; apic++) {
4900- for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
4901+ /*
4902+ * add it to the IO-APIC irq-routing table:
4903+ */
4904+ memset(&entry,0,sizeof(entry));
4905
4906- /*
4907- * add it to the IO-APIC irq-routing table:
4908- */
4909- memset(&entry,0,sizeof(entry));
4910+ entry.delivery_mode = INT_DELIVERY_MODE;
4911+ entry.dest_mode = INT_DEST_MODE;
4912+ entry.mask = 0; /* enable IRQ */
4913+ entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS);
4914
4915- entry.delivery_mode = INT_DELIVERY_MODE;
4916- entry.dest_mode = INT_DEST_MODE;
4917- entry.mask = 0; /* enable IRQ */
4918+ entry.trigger = irq_trigger(idx);
4919+ entry.polarity = irq_polarity(idx);
4920+
4921+ if (irq_trigger(idx)) {
4922+ entry.trigger = 1;
4923+ entry.mask = 1;
4924 entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS);
4925+ }
4926+
4927+ if (/* !apic && */ !IO_APIC_IRQ(irq))
4928+ return;
4929+
4930+ if (IO_APIC_IRQ(irq)) {
4931+ cpumask_t mask;
4932+ vector = assign_irq_vector(irq, TARGET_CPUS, &mask);
4933+ if (vector < 0)
4934+ return;
4935+
4936+ entry.dest.logical.logical_dest = cpu_mask_to_apicid(mask);
4937+ entry.vector = vector;
4938+
4939+ ioapic_register_intr(irq, vector, IOAPIC_AUTO);
4940+ if (!apic && (irq < 16))
4941+ disable_8259A_irq(irq);
4942+ }
4943+
4944+ ioapic_write_entry(apic, pin, entry);
4945+
4946+ spin_lock_irqsave(&ioapic_lock, flags);
4947+ set_native_irq_info(irq, TARGET_CPUS);
4948+ spin_unlock_irqrestore(&ioapic_lock, flags);
4949+
4950+}
4951+
4952+static void __init setup_IO_APIC_irqs(void)
4953+{
4954+ int apic, pin, idx, irq, first_notcon = 1;
4955+
4956+ apic_printk(APIC_VERBOSE, KERN_DEBUG "init IO_APIC IRQs\n");
4957+
4958+ for (apic = 0; apic < nr_ioapics; apic++) {
4959+ for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
4960
4961 idx = find_irq_entry(apic,pin,mp_INT);
4962 if (idx == -1) {
4963@@ -798,39 +859,11 @@ static void __init setup_IO_APIC_irqs(vo
4964 continue;
4965 }
4966
4967- entry.trigger = irq_trigger(idx);
4968- entry.polarity = irq_polarity(idx);
4969-
4970- if (irq_trigger(idx)) {
4971- entry.trigger = 1;
4972- entry.mask = 1;
4973- entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS);
4974- }
4975-
4976 irq = pin_2_irq(idx, apic, pin);
4977 add_pin_to_irq(irq, apic, pin);
4978
4979- if (/* !apic && */ !IO_APIC_IRQ(irq))
4980- continue;
4981-
4982- if (IO_APIC_IRQ(irq)) {
4983- cpumask_t mask;
4984- vector = assign_irq_vector(irq, TARGET_CPUS, &mask);
4985- if (vector < 0)
4986- continue;
4987-
4988- entry.dest.logical.logical_dest = cpu_mask_to_apicid(mask);
4989- entry.vector = vector;
4990+ setup_IO_APIC_irq(apic, pin, idx, irq);
4991
4992- ioapic_register_intr(irq, vector, IOAPIC_AUTO);
4993- if (!apic && (irq < 16))
4994- disable_8259A_irq(irq);
4995- }
4996- ioapic_write_entry(apic, pin, entry);
4997-
4998- spin_lock_irqsave(&ioapic_lock, flags);
4999- set_native_irq_info(irq, TARGET_CPUS);
5000- spin_unlock_irqrestore(&ioapic_lock, flags);
5001 }
5002 }
5003
5004@@ -1826,7 +1859,7 @@ void destroy_irq(unsigned int irq)
5005 dynamic_irq_cleanup(irq);
5006
5007 spin_lock_irqsave(&vector_lock, flags);
5008- irq_vector[irq] = 0;
5009+ __clear_irq_vector(irq);
5010 spin_unlock_irqrestore(&vector_lock, flags);
5011 }
5012
5013@@ -2131,7 +2164,15 @@ void __init setup_ioapic_dest(void)
5014 if (irq_entry == -1)
5015 continue;
5016 irq = pin_2_irq(irq_entry, ioapic, pin);
5017- set_ioapic_affinity_irq(irq, TARGET_CPUS);
5018+
5019+ /* setup_IO_APIC_irqs could fail to get vector for some device
5020+ * when you have too many devices, because at that time only boot
5021+ * cpu is online.
5022+ */
5023+ if(!irq_vector[irq])
5024+ setup_IO_APIC_irq(ioapic, pin, irq_entry, irq);
5025+ else
5026+ set_ioapic_affinity_irq(irq, TARGET_CPUS);
5027 }
5028
5029 }
5030--- sle11-2009-06-29.orig/arch/x86/kernel/irq_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5031+++ sle11-2009-06-29/arch/x86/kernel/irq_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5032@@ -120,7 +120,7 @@ asmlinkage unsigned int do_IRQ(struct pt
5033
5034 if (likely(irq < NR_IRQS))
5035 generic_handle_irq(irq);
5036- else
5037+ else if (printk_ratelimit())
5038 printk(KERN_EMERG "%s: %d.%d No irq handler for irq\n",
5039 __func__, smp_processor_id(), irq);
5040
5041--- sle11-2009-06-29.orig/arch/x86/kernel/mpparse_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5042+++ sle11-2009-06-29/arch/x86/kernel/mpparse_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5043@@ -35,8 +35,6 @@
5044 int smp_found_config;
5045 unsigned int __initdata maxcpus = NR_CPUS;
5046
5047-int acpi_found_madt;
5048-
5049 /*
5050 * Various Linux-internal data structures created from the
5051 * MP-table.
5052--- sle11-2009-06-29.orig/arch/x86/kernel/process_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5053+++ sle11-2009-06-29/arch/x86/kernel/process_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5054@@ -119,29 +119,23 @@ void exit_idle(void)
5055 static void poll_idle (void)
5056 {
5057 local_irq_enable();
5058-
5059- asm volatile(
5060- "2:"
5061- "testl %0,%1;"
5062- "rep; nop;"
5063- "je 2b;"
5064- : :
5065- "i" (_TIF_NEED_RESCHED),
5066- "m" (current_thread_info()->flags));
5067+ cpu_relax();
5068 }
5069
5070 static void xen_idle(void)
5071 {
5072+ current_thread_info()->status &= ~TS_POLLING;
5073+ /*
5074+ * TS_POLLING-cleared state must be visible before we
5075+ * test NEED_RESCHED:
5076+ */
5077+ smp_mb();
5078 local_irq_disable();
5079-
5080- if (need_resched())
5081- local_irq_enable();
5082- else {
5083- current_thread_info()->status &= ~TS_POLLING;
5084- smp_mb__after_clear_bit();
5085+ if (!need_resched())
5086 safe_halt();
5087- current_thread_info()->status |= TS_POLLING;
5088- }
5089+ else
5090+ local_irq_enable();
5091+ current_thread_info()->status |= TS_POLLING;
5092 }
5093
5094 #ifdef CONFIG_HOTPLUG_CPU
5095@@ -181,6 +175,12 @@ void cpu_idle (void)
5096 idle = xen_idle; /* no alternatives */
5097 if (cpu_is_offline(smp_processor_id()))
5098 play_dead();
5099+ /*
5100+ * Idle routines should keep interrupts disabled
5101+ * from here on, until they go to idle.
5102+ * Otherwise, idle callbacks can misfire.
5103+ */
5104+ local_irq_disable();
5105 enter_idle();
5106 idle();
5107 /* In many cases the interrupt that ended idle
5108--- sle11-2009-06-29.orig/arch/x86/kernel/setup_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5109+++ sle11-2009-06-29/arch/x86/kernel/setup_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5110@@ -573,8 +573,7 @@ void __init setup_arch(char **cmdline_p)
5111 if (LOADER_TYPE && INITRD_START) {
5112 if (INITRD_START + INITRD_SIZE <= (end_pfn << PAGE_SHIFT)) {
5113 reserve_bootmem_generic(INITRD_START, INITRD_SIZE);
5114- initrd_start =
5115- INITRD_START ? INITRD_START + PAGE_OFFSET : 0;
5116+ initrd_start = INITRD_START + PAGE_OFFSET;
5117 initrd_end = initrd_start+INITRD_SIZE;
5118 }
5119 else {
5120@@ -990,11 +989,8 @@ static void __cpuinit init_amd(struct cp
5121 /* Fix cpuid4 emulation for more */
5122 num_cache_leaves = 3;
5123
5124- /* When there is only one core no need to synchronize RDTSC */
5125- if (num_possible_cpus() == 1)
5126- set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
5127- else
5128- clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
5129+ /* RDTSC can be speculated around */
5130+ clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
5131 }
5132
5133 static void __cpuinit detect_ht(struct cpuinfo_x86 *c)
5134@@ -1093,6 +1089,15 @@ static void __cpuinit init_intel(struct
5135 set_bit(X86_FEATURE_ARCH_PERFMON, &c->x86_capability);
5136 }
5137
5138+ if (cpu_has_ds) {
5139+ unsigned int l1, l2;
5140+ rdmsr(MSR_IA32_MISC_ENABLE, l1, l2);
5141+ if (!(l1 & (1<<11)))
5142+ set_bit(X86_FEATURE_BTS, c->x86_capability);
5143+ if (!(l1 & (1<<12)))
5144+ set_bit(X86_FEATURE_PEBS, c->x86_capability);
5145+ }
5146+
5147 n = c->extended_cpuid_level;
5148 if (n >= 0x80000008) {
5149 unsigned eax = cpuid_eax(0x80000008);
5150@@ -1112,7 +1117,10 @@ static void __cpuinit init_intel(struct
5151 set_bit(X86_FEATURE_CONSTANT_TSC, &c->x86_capability);
5152 if (c->x86 == 6)
5153 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
5154- set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
5155+ if (c->x86 == 15)
5156+ set_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
5157+ else
5158+ clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
5159 c->x86_max_cores = intel_num_cpu_cores(c);
5160
5161 srat_detect_node();
5162--- sle11-2009-06-29.orig/arch/x86/kernel/smp_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5163+++ sle11-2009-06-29/arch/x86/kernel/smp_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5164@@ -384,12 +384,17 @@ int smp_call_function_single (int cpu, v
5165 put_cpu();
5166 return 0;
5167 }
5168+
5169+ /* Can deadlock when called with interrupts disabled */
5170+ WARN_ON(irqs_disabled());
5171+
5172 spin_lock_bh(&call_lock);
5173 __smp_call_function_single(cpu, func, info, nonatomic, wait);
5174 spin_unlock_bh(&call_lock);
5175 put_cpu();
5176 return 0;
5177 }
5178+EXPORT_SYMBOL(smp_call_function_single);
5179
5180 /*
5181 * this function sends a 'generic call function' IPI to all other CPUs
5182--- sle11-2009-06-29.orig/arch/x86/kernel/traps_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5183+++ sle11-2009-06-29/arch/x86/kernel/traps_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5184@@ -30,9 +30,10 @@
5185 #include <linux/kprobes.h>
5186 #include <linux/kexec.h>
5187 #include <linux/unwind.h>
5188+#include <linux/uaccess.h>
5189+#include <linux/bug.h>
5190
5191 #include <asm/system.h>
5192-#include <asm/uaccess.h>
5193 #include <asm/io.h>
5194 #include <asm/atomic.h>
5195 #include <asm/debugreg.h>
5196@@ -108,12 +109,7 @@ static inline void preempt_conditional_c
5197 preempt_enable_no_resched();
5198 }
5199
5200-static int kstack_depth_to_print = 12;
5201-#ifdef CONFIG_STACK_UNWIND
5202-static int call_trace = 1;
5203-#else
5204-#define call_trace (-1)
5205-#endif
5206+int kstack_depth_to_print = 12;
5207
5208 #ifdef CONFIG_KALLSYMS
5209 void printk_address(unsigned long address)
5210@@ -218,24 +214,7 @@ static unsigned long *in_exception_stack
5211 return NULL;
5212 }
5213
5214-struct ops_and_data {
5215- struct stacktrace_ops *ops;
5216- void *data;
5217-};
5218-
5219-static int dump_trace_unwind(struct unwind_frame_info *info, void *context)
5220-{
5221- struct ops_and_data *oad = (struct ops_and_data *)context;
5222- int n = 0;
5223-
5224- while (unwind(info) == 0 && UNW_PC(info)) {
5225- n++;
5226- oad->ops->address(oad->data, UNW_PC(info));
5227- if (arch_unw_user_mode(info))
5228- break;
5229- }
5230- return n;
5231-}
5232+#define MSG(txt) ops->warning(data, txt)
5233
5234 /*
5235 * x86-64 can have upto three kernel stacks:
5236@@ -250,61 +229,24 @@ static inline int valid_stack_ptr(struct
5237 return p > t && p < t + THREAD_SIZE - 3;
5238 }
5239
5240-void dump_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long * stack,
5241+void dump_trace(struct task_struct *tsk, struct pt_regs *regs,
5242+ unsigned long *stack,
5243 struct stacktrace_ops *ops, void *data)
5244 {
5245- const unsigned cpu = smp_processor_id();
5246- unsigned long *irqstack_end = (unsigned long *)cpu_pda(cpu)->irqstackptr;
5247+ const unsigned cpu = get_cpu();
5248+ unsigned long *irqstack_end = (unsigned long*)cpu_pda(cpu)->irqstackptr;
5249 unsigned used = 0;
5250 struct thread_info *tinfo;
5251
5252 if (!tsk)
5253 tsk = current;
5254
5255- if (call_trace >= 0) {
5256- int unw_ret = 0;
5257- struct unwind_frame_info info;
5258- struct ops_and_data oad = { .ops = ops, .data = data };
5259-
5260- if (regs) {
5261- if (unwind_init_frame_info(&info, tsk, regs) == 0)
5262- unw_ret = dump_trace_unwind(&info, &oad);
5263- } else if (tsk == current)
5264- unw_ret = unwind_init_running(&info, dump_trace_unwind, &oad);
5265- else {
5266- if (unwind_init_blocked(&info, tsk) == 0)
5267- unw_ret = dump_trace_unwind(&info, &oad);
5268- }
5269- if (unw_ret > 0) {
5270- if (call_trace == 1 && !arch_unw_user_mode(&info)) {
5271- ops->warning_symbol(data, "DWARF2 unwinder stuck at %s\n",
5272- UNW_PC(&info));
5273- if ((long)UNW_SP(&info) < 0) {
5274- ops->warning(data, "Leftover inexact backtrace:\n");
5275- stack = (unsigned long *)UNW_SP(&info);
5276- if (!stack)
5277- return;
5278- } else
5279- ops->warning(data, "Full inexact backtrace again:\n");
5280- } else if (call_trace >= 1)
5281- return;
5282- else
5283- ops->warning(data, "Full inexact backtrace again:\n");
5284- } else
5285- ops->warning(data, "Inexact backtrace:\n");
5286- }
5287 if (!stack) {
5288 unsigned long dummy;
5289 stack = &dummy;
5290 if (tsk && tsk != current)
5291 stack = (unsigned long *)tsk->thread.rsp;
5292 }
5293- /*
5294- * Align the stack pointer on word boundary, later loops
5295- * rely on that (and corruption / debug info bugs can cause
5296- * unaligned values here):
5297- */
5298- stack = (unsigned long *)((unsigned long)stack & ~(sizeof(long)-1));
5299
5300 /*
5301 * Print function call entries within a stack. 'cond' is the
5302@@ -314,9 +256,9 @@ void dump_trace(struct task_struct *tsk,
5303 #define HANDLE_STACK(cond) \
5304 do while (cond) { \
5305 unsigned long addr = *stack++; \
5306- if (oops_in_progress ? \
5307- __kernel_text_address(addr) : \
5308- kernel_text_address(addr)) { \
5309+ /* Use unlocked access here because except for NMIs \
5310+ we should be already protected against module unloads */ \
5311+ if (__kernel_text_address(addr)) { \
5312 /* \
5313 * If the address is either in the text segment of the \
5314 * kernel, or in the region which contains vmalloc'ed \
5315@@ -379,9 +321,10 @@ void dump_trace(struct task_struct *tsk,
5316 /*
5317 * This handles the process stack:
5318 */
5319- tinfo = current_thread_info();
5320+ tinfo = task_thread_info(tsk);
5321 HANDLE_STACK (valid_stack_ptr(tinfo, stack));
5322 #undef HANDLE_STACK
5323+ put_cpu();
5324 }
5325 EXPORT_SYMBOL(dump_trace);
5326
5327@@ -518,30 +461,15 @@ bad:
5328 printk("\n");
5329 }
5330
5331-void handle_BUG(struct pt_regs *regs)
5332-{
5333- struct bug_frame f;
5334- long len;
5335- const char *prefix = "";
5336+int is_valid_bugaddr(unsigned long rip)
5337+{
5338+ unsigned short ud2;
5339
5340- if (user_mode(regs))
5341- return;
5342- if (__copy_from_user(&f, (const void __user *) regs->rip,
5343- sizeof(struct bug_frame)))
5344- return;
5345- if (f.filename >= 0 ||
5346- f.ud2[0] != 0x0f || f.ud2[1] != 0x0b)
5347- return;
5348- len = __strnlen_user((char *)(long)f.filename, PATH_MAX) - 1;
5349- if (len < 0 || len >= PATH_MAX)
5350- f.filename = (int)(long)"unmapped filename";
5351- else if (len > 50) {
5352- f.filename += len - 50;
5353- prefix = "...";
5354- }
5355- printk("----------- [cut here ] --------- [please bite here ] ---------\n");
5356- printk(KERN_ALERT "Kernel BUG at %s%.50s:%d\n", prefix, (char *)(long)f.filename, f.line);
5357-}
5358+ if (__copy_from_user(&ud2, (const void __user *) rip, sizeof(ud2)))
5359+ return 0;
5360+
5361+ return ud2 == 0x0b0f;
5362+}
5363
5364 #ifdef CONFIG_BUG
5365 void out_of_line_bug(void)
5366@@ -621,7 +549,9 @@ void die(const char * str, struct pt_reg
5367 {
5368 unsigned long flags = oops_begin();
5369
5370- handle_BUG(regs);
5371+ if (!user_mode(regs))
5372+ report_bug(regs->rip);
5373+
5374 __die(str, regs, err);
5375 oops_end(flags);
5376 do_exit(SIGSEGV);
5377@@ -790,8 +720,7 @@ mem_parity_error(unsigned char reason, s
5378 {
5379 printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
5380 reason);
5381- printk(KERN_EMERG "You probably have a hardware problem with your "
5382- "RAM chips\n");
5383+ printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
5384
5385 if (panic_on_unrecovered_nmi)
5386 panic("NMI: Not continuing");
5387@@ -1227,21 +1156,3 @@ static int __init kstack_setup(char *s)
5388 return 0;
5389 }
5390 early_param("kstack", kstack_setup);
5391-
5392-#ifdef CONFIG_STACK_UNWIND
5393-static int __init call_trace_setup(char *s)
5394-{
5395- if (!s)
5396- return -EINVAL;
5397- if (strcmp(s, "old") == 0)
5398- call_trace = -1;
5399- else if (strcmp(s, "both") == 0)
5400- call_trace = 0;
5401- else if (strcmp(s, "newfallback") == 0)
5402- call_trace = 1;
5403- else if (strcmp(s, "new") == 0)
5404- call_trace = 2;
5405- return 0;
5406-}
5407-early_param("call_trace", call_trace_setup);
5408-#endif
5409--- sle11-2009-06-29.orig/arch/x86/kernel/vsyscall_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5410+++ sle11-2009-06-29/arch/x86/kernel/vsyscall_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5411@@ -42,6 +42,7 @@
5412 #include <asm/topology.h>
5413
5414 #define __vsyscall(nr) __attribute__ ((unused,__section__(".vsyscall_" #nr)))
5415+#define __syscall_clobber "r11","rcx","memory"
5416
5417 int __sysctl_vsyscall __section_sysctl_vsyscall = 1;
5418 seqlock_t __xtime_lock __section_xtime_lock = SEQLOCK_UNLOCKED;
5419@@ -224,8 +225,7 @@ out:
5420
5421 static int vsyscall_sysctl_nostrat(ctl_table *t, int __user *name, int nlen,
5422 void __user *oldval, size_t __user *oldlenp,
5423- void __user *newval, size_t newlen,
5424- void **context)
5425+ void __user *newval, size_t newlen)
5426 {
5427 return -ENOSYS;
5428 }
5429@@ -277,7 +277,6 @@ static void __cpuinit cpu_vsyscall_init(
5430 vsyscall_set_cpu(raw_smp_processor_id());
5431 }
5432
5433-#ifdef CONFIG_HOTPLUG_CPU
5434 static int __cpuinit
5435 cpu_vsyscall_notifier(struct notifier_block *n, unsigned long action, void *arg)
5436 {
5437@@ -286,13 +285,13 @@ cpu_vsyscall_notifier(struct notifier_bl
5438 smp_call_function_single(cpu, cpu_vsyscall_init, NULL, 0, 1);
5439 return NOTIFY_DONE;
5440 }
5441-#endif
5442
5443 static void __init map_vsyscall(void)
5444 {
5445 extern char __vsyscall_0;
5446 unsigned long physaddr_page0 = __pa_symbol(&__vsyscall_0);
5447
5448+ /* Note that VSYSCALL_MAPPED_PAGES must agree with the code below. */
5449 __set_fixmap(VSYSCALL_FIRST_PAGE, physaddr_page0, PAGE_KERNEL_VSYSCALL);
5450 }
5451
5452--- sle11-2009-06-29.orig/arch/x86/mm/fault_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5453+++ sle11-2009-06-29/arch/x86/mm/fault_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5454@@ -23,9 +23,9 @@
5455 #include <linux/compiler.h>
5456 #include <linux/module.h>
5457 #include <linux/kprobes.h>
5458+#include <linux/uaccess.h>
5459
5460 #include <asm/system.h>
5461-#include <asm/uaccess.h>
5462 #include <asm/pgalloc.h>
5463 #include <asm/smp.h>
5464 #include <asm/tlbflush.h>
5465@@ -96,7 +96,7 @@ void bust_spinlocks(int yes)
5466 static noinline int is_prefetch(struct pt_regs *regs, unsigned long addr,
5467 unsigned long error_code)
5468 {
5469- unsigned char __user *instr;
5470+ unsigned char *instr;
5471 int scan_more = 1;
5472 int prefetch = 0;
5473 unsigned char *max_instr;
5474@@ -116,7 +116,7 @@ static noinline int is_prefetch(struct p
5475 unsigned char instr_hi;
5476 unsigned char instr_lo;
5477
5478- if (__get_user(opcode, (char __user *)instr))
5479+ if (probe_kernel_address(instr, opcode))
5480 break;
5481
5482 instr_hi = opcode & 0xf0;
5483@@ -154,7 +154,7 @@ static noinline int is_prefetch(struct p
5484 case 0x00:
5485 /* Prefetch instruction is 0x0F0D or 0x0F18 */
5486 scan_more = 0;
5487- if (__get_user(opcode, (char __user *)instr))
5488+ if (probe_kernel_address(instr, opcode))
5489 break;
5490 prefetch = (instr_lo == 0xF) &&
5491 (opcode == 0x0D || opcode == 0x18);
5492@@ -170,7 +170,7 @@ static noinline int is_prefetch(struct p
5493 static int bad_address(void *p)
5494 {
5495 unsigned long dummy;
5496- return __get_user(dummy, (unsigned long __user *)p);
5497+ return probe_kernel_address((unsigned long *)p, dummy);
5498 }
5499
5500 void dump_pagetable(unsigned long address)
5501--- sle11-2009-06-29.orig/arch/x86/mm/init_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5502+++ sle11-2009-06-29/arch/x86/mm/init_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5503@@ -1127,14 +1127,15 @@ static __init int x8664_sysctl_init(void
5504 __initcall(x8664_sysctl_init);
5505 #endif
5506
5507-/* A pseudo VMAs to allow ptrace access for the vsyscall page. This only
5508+/* A pseudo VMA to allow ptrace access for the vsyscall page. This only
5509 covers the 64bit vsyscall page now. 32bit has a real VMA now and does
5510 not need special handling anymore. */
5511
5512 static struct vm_area_struct gate_vma = {
5513 .vm_start = VSYSCALL_START,
5514- .vm_end = VSYSCALL_END,
5515- .vm_page_prot = PAGE_READONLY
5516+ .vm_end = VSYSCALL_START + (VSYSCALL_MAPPED_PAGES << PAGE_SHIFT),
5517+ .vm_page_prot = PAGE_READONLY_EXEC,
5518+ .vm_flags = VM_READ | VM_EXEC
5519 };
5520
5521 struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
5522--- sle11-2009-06-29.orig/arch/x86/mm/pageattr_64-xen.c 2009-03-04 11:28:34.000000000 +0100
5523+++ sle11-2009-06-29/arch/x86/mm/pageattr_64-xen.c 2008-12-15 11:26:44.000000000 +0100
5524@@ -330,34 +330,40 @@ static struct page *split_large_page(uns
5525 return base;
5526 }
5527
5528-
5529-static void flush_kernel_map(void *address)
5530+static void cache_flush_page(void *adr)
5531 {
5532- if (0 && address && cpu_has_clflush) {
5533- /* is this worth it? */
5534- int i;
5535- for (i = 0; i < PAGE_SIZE; i += boot_cpu_data.x86_clflush_size)
5536- asm volatile("clflush (%0)" :: "r" (address + i));
5537- } else
5538- asm volatile("wbinvd":::"memory");
5539- if (address)
5540- __flush_tlb_one(address);
5541- else
5542- __flush_tlb_all();
5543+ int i;
5544+ for (i = 0; i < PAGE_SIZE; i += boot_cpu_data.x86_clflush_size)
5545+ asm volatile("clflush (%0)" :: "r" (adr + i));
5546 }
5547
5548+static void flush_kernel_map(void *arg)
5549+{
5550+ struct list_head *l = (struct list_head *)arg;
5551+ struct page *pg;
5552
5553-static inline void flush_map(unsigned long address)
5554+ /* When clflush is available always use it because it is
5555+ much cheaper than WBINVD */
5556+ if (!cpu_has_clflush)
5557+ asm volatile("wbinvd" ::: "memory");
5558+ list_for_each_entry(pg, l, lru) {
5559+ void *adr = page_address(pg);
5560+ if (cpu_has_clflush)
5561+ cache_flush_page(adr);
5562+ __flush_tlb_one(adr);
5563+ }
5564+}
5565+
5566+static inline void flush_map(struct list_head *l)
5567 {
5568- on_each_cpu(flush_kernel_map, (void *)address, 1, 1);
5569+ on_each_cpu(flush_kernel_map, l, 1, 1);
5570 }
5571
5572-static struct page *deferred_pages; /* protected by init_mm.mmap_sem */
5573+static LIST_HEAD(deferred_pages); /* protected by init_mm.mmap_sem */
5574
5575 static inline void save_page(struct page *fpage)
5576 {
5577- fpage->lru.next = (struct list_head *)deferred_pages;
5578- deferred_pages = fpage;
5579+ list_add(&fpage->lru, &deferred_pages);
5580 }
5581
5582 /*
5583@@ -487,18 +493,18 @@ int change_page_attr(struct page *page,
5584
5585 void global_flush_tlb(void)
5586 {
5587- struct page *dpage;
5588+ struct page *pg, *next;
5589+ struct list_head l;
5590
5591 down_read(&init_mm.mmap_sem);
5592- dpage = xchg(&deferred_pages, NULL);
5593+ list_replace_init(&deferred_pages, &l);
5594 up_read(&init_mm.mmap_sem);
5595
5596- flush_map((dpage && !dpage->lru.next) ? (unsigned long)page_address(dpage) : 0);
5597- while (dpage) {
5598- struct page *tmp = dpage;
5599- dpage = (struct page *)dpage->lru.next;
5600- ClearPagePrivate(tmp);
5601- __free_page(tmp);
5602+ flush_map(&l);
5603+
5604+ list_for_each_entry_safe(pg, next, &l, lru) {
5605+ ClearPagePrivate(pg);
5606+ __free_page(pg);
5607 }
5608 }
5609
5610--- sle11-2009-06-29.orig/drivers/pci/msi-xen.c 2009-04-24 13:31:56.000000000 +0200
5611+++ sle11-2009-06-29/drivers/pci/msi-xen.c 2008-12-15 11:26:44.000000000 +0100
5612@@ -263,10 +263,8 @@ void disable_msi_mode(struct pci_dev *de
5613 pci_write_config_word(dev, msi_control_reg(pos), control);
5614 dev->msix_enabled = 0;
5615 }
5616- if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
5617- /* PCI Express Endpoint device detected */
5618- pci_intx(dev, 1); /* enable intx */
5619- }
5620+
5621+ pci_intx(dev, 1); /* enable intx */
5622 }
5623
5624 static void enable_msi_mode(struct pci_dev *dev, int pos, int type)
5625@@ -284,10 +282,8 @@ static void enable_msi_mode(struct pci_d
5626 pci_write_config_word(dev, msi_control_reg(pos), control);
5627 dev->msix_enabled = 1;
5628 }
5629- if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
5630- /* PCI Express Endpoint device detected */
5631- pci_intx(dev, 0); /* disable intx */
5632- }
5633+
5634+ pci_intx(dev, 0); /* disable intx */
5635 }
5636
5637 #ifdef CONFIG_PM
5638--- sle11-2009-06-29.orig/drivers/xen/balloon/balloon.c 2009-03-04 11:28:34.000000000 +0100
5639+++ sle11-2009-06-29/drivers/xen/balloon/balloon.c 2009-06-29 15:28:36.000000000 +0200
5640@@ -97,8 +97,8 @@ extern unsigned long totalhigh_pages;
5641 static LIST_HEAD(ballooned_pages);
5642
5643 /* Main work function, always executed in process context. */
5644-static void balloon_process(void *unused);
5645-static DECLARE_WORK(balloon_worker, balloon_process, NULL);
5646+static void balloon_process(struct work_struct *unused);
5647+static DECLARE_WORK(balloon_worker, balloon_process);
5648 static struct timer_list balloon_timer;
5649
5650 /* When ballooning out (allocating memory to return to Xen) we don't really
5651@@ -375,7 +375,7 @@ static int decrease_reservation(unsigned
5652 * by the balloon lock), or with changes to the Xen hard limit, but we will
5653 * recover from these in time.
5654 */
5655-static void balloon_process(void *unused)
5656+static void balloon_process(struct work_struct *unused)
5657 {
5658 int need_sleep = 0;
5659 long credit;
5660--- sle11-2009-06-29.orig/drivers/xen/blkback/blkback.c 2009-03-04 11:28:34.000000000 +0100
5661+++ sle11-2009-06-29/drivers/xen/blkback/blkback.c 2008-12-15 11:26:44.000000000 +0100
5662@@ -37,6 +37,7 @@
5663
5664 #include <linux/spinlock.h>
5665 #include <linux/kthread.h>
5666+#include <linux/freezer.h>
5667 #include <linux/list.h>
5668 #include <linux/delay.h>
5669 #include <xen/balloon.h>
5670--- sle11-2009-06-29.orig/drivers/xen/blkback/interface.c 2009-06-29 15:14:52.000000000 +0200
5671+++ sle11-2009-06-29/drivers/xen/blkback/interface.c 2008-12-15 11:26:44.000000000 +0100
5672@@ -34,7 +34,7 @@
5673 #include <xen/evtchn.h>
5674 #include <linux/kthread.h>
5675
5676-static kmem_cache_t *blkif_cachep;
5677+static struct kmem_cache *blkif_cachep;
5678
5679 blkif_t *blkif_alloc(domid_t domid)
5680 {
5681--- sle11-2009-06-29.orig/drivers/xen/blkfront/blkfront.c 2009-03-24 10:08:16.000000000 +0100
5682+++ sle11-2009-06-29/drivers/xen/blkfront/blkfront.c 2009-03-24 10:08:27.000000000 +0100
5683@@ -71,7 +71,7 @@ static int setup_blkring(struct xenbus_d
5684 static void kick_pending_request_queues(struct blkfront_info *);
5685
5686 static irqreturn_t blkif_int(int irq, void *dev_id);
5687-static void blkif_restart_queue(void *arg);
5688+static void blkif_restart_queue(struct work_struct *arg);
5689 static void blkif_recover(struct blkfront_info *);
5690 static void blkif_completion(struct blk_shadow *);
5691 static void blkif_free(struct blkfront_info *, int);
5692@@ -111,7 +111,7 @@ static int blkfront_probe(struct xenbus_
5693 info->xbdev = dev;
5694 info->vdevice = vdevice;
5695 info->connected = BLKIF_STATE_DISCONNECTED;
5696- INIT_WORK(&info->work, blkif_restart_queue, (void *)info);
5697+ INIT_WORK(&info->work, blkif_restart_queue);
5698
5699 for (i = 0; i < BLK_RING_SIZE; i++)
5700 info->shadow[i].req.id = i+1;
5701@@ -462,9 +462,9 @@ static void kick_pending_request_queues(
5702 }
5703 }
5704
5705-static void blkif_restart_queue(void *arg)
5706+static void blkif_restart_queue(struct work_struct *arg)
5707 {
5708- struct blkfront_info *info = (struct blkfront_info *)arg;
5709+ struct blkfront_info *info = container_of(arg, struct blkfront_info, work);
5710 spin_lock_irq(&blkif_io_lock);
5711 if (info->connected == BLKIF_STATE_CONNECTED)
5712 kick_pending_request_queues(info);
5713--- sle11-2009-06-29.orig/drivers/xen/blktap/blktap.c 2009-04-20 11:37:34.000000000 +0200
5714+++ sle11-2009-06-29/drivers/xen/blktap/blktap.c 2009-04-20 11:37:50.000000000 +0200
5715@@ -40,6 +40,7 @@
5716
5717 #include <linux/spinlock.h>
5718 #include <linux/kthread.h>
5719+#include <linux/freezer.h>
5720 #include <linux/list.h>
5721 #include <asm/hypervisor.h>
5722 #include "common.h"
5723--- sle11-2009-06-29.orig/drivers/xen/blktap/interface.c 2009-06-29 15:14:52.000000000 +0200
5724+++ sle11-2009-06-29/drivers/xen/blktap/interface.c 2008-12-15 11:26:44.000000000 +0100
5725@@ -34,7 +34,7 @@
5726 #include "common.h"
5727 #include <xen/evtchn.h>
5728
5729-static kmem_cache_t *blkif_cachep;
5730+static struct kmem_cache *blkif_cachep;
5731
5732 blkif_t *tap_alloc_blkif(domid_t domid)
5733 {
5734--- sle11-2009-06-29.orig/drivers/xen/char/mem.c 2009-06-29 15:14:52.000000000 +0200
5735+++ sle11-2009-06-29/drivers/xen/char/mem.c 2008-12-15 11:26:44.000000000 +0100
5736@@ -157,7 +157,7 @@ static loff_t memory_lseek(struct file *
5737 {
5738 loff_t ret;
5739
5740- mutex_lock(&file->f_dentry->d_inode->i_mutex);
5741+ mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
5742 switch (orig) {
5743 case 0:
5744 file->f_pos = offset;
5745@@ -172,7 +172,7 @@ static loff_t memory_lseek(struct file *
5746 default:
5747 ret = -EINVAL;
5748 }
5749- mutex_unlock(&file->f_dentry->d_inode->i_mutex);
5750+ mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
5751 return ret;
5752 }
5753
5754--- sle11-2009-06-29.orig/drivers/xen/console/console.c 2009-03-04 11:28:34.000000000 +0100
5755+++ sle11-2009-06-29/drivers/xen/console/console.c 2008-12-15 11:26:44.000000000 +0100
5756@@ -85,11 +85,6 @@ static int xc_num = -1;
5757 #define XEN_HVC_MAJOR 229
5758 #define XEN_HVC_MINOR 0
5759
5760-#ifdef CONFIG_MAGIC_SYSRQ
5761-static unsigned long sysrq_requested;
5762-extern int sysrq_enabled;
5763-#endif
5764-
5765 static int __init xencons_setup(char *str)
5766 {
5767 char *q;
5768@@ -355,8 +350,8 @@ void __init dom0_init_screen_info(const
5769 #define DUMMY_TTY(_tty) ((xc_mode == XC_TTY) && \
5770 ((_tty)->index != (xc_num - 1)))
5771
5772-static struct termios *xencons_termios[MAX_NR_CONSOLES];
5773-static struct termios *xencons_termios_locked[MAX_NR_CONSOLES];
5774+static struct ktermios *xencons_termios[MAX_NR_CONSOLES];
5775+static struct ktermios *xencons_termios_locked[MAX_NR_CONSOLES];
5776 static struct tty_struct *xencons_tty;
5777 static int xencons_priv_irq;
5778 static char x_char;
5779@@ -372,7 +367,9 @@ void xencons_rx(char *buf, unsigned len)
5780
5781 for (i = 0; i < len; i++) {
5782 #ifdef CONFIG_MAGIC_SYSRQ
5783- if (sysrq_enabled) {
5784+ if (sysrq_on()) {
5785+ static unsigned long sysrq_requested;
5786+
5787 if (buf[i] == '\x0f') { /* ^O */
5788 if (!sysrq_requested) {
5789 sysrq_requested = jiffies;
5790--- sle11-2009-06-29.orig/drivers/xen/core/reboot.c 2009-03-04 11:28:34.000000000 +0100
5791+++ sle11-2009-06-29/drivers/xen/core/reboot.c 2008-12-15 11:26:44.000000000 +0100
5792@@ -34,8 +34,8 @@ static int suspend_cancelled;
5793 /* Can we leave APs online when we suspend? */
5794 static int fast_suspend;
5795
5796-static void __shutdown_handler(void *unused);
5797-static DECLARE_WORK(shutdown_work, __shutdown_handler, NULL);
5798+static void __shutdown_handler(struct work_struct *unused);
5799+static DECLARE_DELAYED_WORK(shutdown_work, __shutdown_handler);
5800
5801 static int setup_suspend_evtchn(void);
5802
5803@@ -105,7 +105,7 @@ static int xen_suspend(void *__unused)
5804 case SHUTDOWN_RESUMING:
5805 break;
5806 default:
5807- schedule_work(&shutdown_work);
5808+ schedule_delayed_work(&shutdown_work, 0);
5809 break;
5810 }
5811
5812@@ -137,12 +137,12 @@ static void switch_shutdown_state(int ne
5813
5814 /* Either we kick off the work, or we leave it to xen_suspend(). */
5815 if (old_state == SHUTDOWN_INVALID)
5816- schedule_work(&shutdown_work);
5817+ schedule_delayed_work(&shutdown_work, 0);
5818 else
5819 BUG_ON(old_state != SHUTDOWN_RESUMING);
5820 }
5821
5822-static void __shutdown_handler(void *unused)
5823+static void __shutdown_handler(struct work_struct *unused)
5824 {
5825 int err;
5826
5827--- sle11-2009-06-29.orig/drivers/xen/core/smpboot.c 2009-03-04 11:28:34.000000000 +0100
5828+++ sle11-2009-06-29/drivers/xen/core/smpboot.c 2008-12-15 11:26:44.000000000 +0100
5829@@ -161,7 +161,12 @@ static void xen_smp_intr_exit(unsigned i
5830
5831 void __cpuinit cpu_bringup(void)
5832 {
5833+#ifdef __i386__
5834+ cpu_set_gdt(current_thread_info()->cpu);
5835+ secondary_cpu_init();
5836+#else
5837 cpu_init();
5838+#endif
5839 identify_cpu(cpu_data + smp_processor_id());
5840 touch_softlockup_watchdog();
5841 preempt_disable();
5842@@ -300,11 +305,12 @@ void __init smp_prepare_cpus(unsigned in
5843 if (cpu == 0)
5844 continue;
5845
5846+ idle = fork_idle(cpu);
5847+ if (IS_ERR(idle))
5848+ panic("failed fork for CPU %d", cpu);
5849+
5850 #ifdef __x86_64__
5851 gdt_descr = &cpu_gdt_descr[cpu];
5852-#else
5853- gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
5854-#endif
5855 gdt_descr->address = get_zeroed_page(GFP_KERNEL);
5856 if (unlikely(!gdt_descr->address)) {
5857 printk(KERN_CRIT "CPU%d failed to allocate GDT\n",
5858@@ -313,6 +319,11 @@ void __init smp_prepare_cpus(unsigned in
5859 }
5860 gdt_descr->size = GDT_SIZE;
5861 memcpy((void *)gdt_descr->address, cpu_gdt_table, GDT_SIZE);
5862+#else
5863+ if (unlikely(!init_gdt(cpu, idle)))
5864+ continue;
5865+ gdt_descr = &per_cpu(cpu_gdt_descr, cpu);
5866+#endif
5867 make_page_readonly(
5868 (void *)gdt_descr->address,
5869 XENFEAT_writable_descriptor_tables);
5870@@ -332,10 +343,6 @@ void __init smp_prepare_cpus(unsigned in
5871 cpu_2_logical_apicid[cpu] = apicid;
5872 x86_cpu_to_apicid[cpu] = apicid;
5873
5874- idle = fork_idle(cpu);
5875- if (IS_ERR(idle))
5876- panic("failed fork for CPU %d", cpu);
5877-
5878 #ifdef __x86_64__
5879 cpu_pda(cpu)->pcurrent = idle;
5880 cpu_pda(cpu)->cpunumber = cpu;
5881--- sle11-2009-06-29.orig/drivers/xen/fbfront/xenfb.c 2009-03-04 11:28:34.000000000 +0100
5882+++ sle11-2009-06-29/drivers/xen/fbfront/xenfb.c 2008-12-15 11:26:44.000000000 +0100
5883@@ -25,6 +25,7 @@
5884 #include <linux/vmalloc.h>
5885 #include <linux/mm.h>
5886 #include <linux/mutex.h>
5887+#include <linux/freezer.h>
5888 #include <asm/hypervisor.h>
5889 #include <xen/evtchn.h>
5890 #include <xen/interface/io/fbif.h>
5891--- sle11-2009-06-29.orig/drivers/xen/netback/loopback.c 2009-03-04 11:28:34.000000000 +0100
5892+++ sle11-2009-06-29/drivers/xen/netback/loopback.c 2008-12-15 11:26:44.000000000 +0100
5893@@ -54,6 +54,7 @@
5894 #include <net/dst.h>
5895 #include <net/xfrm.h> /* secpath_reset() */
5896 #include <asm/hypervisor.h> /* is_initial_xendomain() */
5897+#include <../net/core/kmap_skb.h> /* k{,un}map_skb_frag() */
5898
5899 static int nloopbacks = -1;
5900 module_param(nloopbacks, int, 0);
5901--- sle11-2009-06-29.orig/drivers/xen/pciback/conf_space_header.c 2009-06-29 15:14:52.000000000 +0200
5902+++ sle11-2009-06-29/drivers/xen/pciback/conf_space_header.c 2008-12-15 11:26:44.000000000 +0100
5903@@ -22,14 +22,14 @@ static int command_write(struct pci_dev
5904 {
5905 int err;
5906
5907- if (!dev->is_enabled && is_enable_cmd(value)) {
5908+ if (!atomic_read(&dev->enable_cnt) && is_enable_cmd(value)) {
5909 if (unlikely(verbose_request))
5910 printk(KERN_DEBUG "pciback: %s: enable\n",
5911 pci_name(dev));
5912 err = pci_enable_device(dev);
5913 if (err)
5914 return err;
5915- } else if (dev->is_enabled && !is_enable_cmd(value)) {
5916+ } else if (atomic_read(&dev->enable_cnt) && !is_enable_cmd(value)) {
5917 if (unlikely(verbose_request))
5918 printk(KERN_DEBUG "pciback: %s: disable\n",
5919 pci_name(dev));
5920--- sle11-2009-06-29.orig/drivers/xen/pciback/pciback.h 2009-03-04 11:28:34.000000000 +0100
5921+++ sle11-2009-06-29/drivers/xen/pciback/pciback.h 2008-12-15 11:26:44.000000000 +0100
5922@@ -88,7 +88,7 @@ void pciback_release_devices(struct pcib
5923
5924 /* Handles events from front-end */
5925 irqreturn_t pciback_handle_event(int irq, void *dev_id);
5926-void pciback_do_op(void *data);
5927+void pciback_do_op(struct work_struct *work);
5928
5929 int pciback_xenbus_register(void);
5930 void pciback_xenbus_unregister(void);
5931--- sle11-2009-06-29.orig/drivers/xen/pciback/pciback_ops.c 2009-03-04 11:28:34.000000000 +0100
5932+++ sle11-2009-06-29/drivers/xen/pciback/pciback_ops.c 2008-12-15 11:26:44.000000000 +0100
5933@@ -25,7 +25,7 @@ void pciback_reset_device(struct pci_dev
5934
5935 pci_write_config_word(dev, PCI_COMMAND, 0);
5936
5937- dev->is_enabled = 0;
5938+ atomic_set(&dev->enable_cnt, 0);
5939 dev->is_busmaster = 0;
5940 } else {
5941 pci_read_config_word(dev, PCI_COMMAND, &cmd);
5942@@ -51,9 +51,9 @@ static inline void test_and_schedule_op(
5943 * context because some of the pci_* functions can sleep (mostly due to ACPI
5944 * use of semaphores). This function is intended to be called from a work
5945 * queue in process context taking a struct pciback_device as a parameter */
5946-void pciback_do_op(void *data)
5947+void pciback_do_op(struct work_struct *work)
5948 {
5949- struct pciback_device *pdev = data;
5950+ struct pciback_device *pdev = container_of(work, struct pciback_device, op_work);
5951 struct pci_dev *dev;
5952 struct xen_pci_op *op = &pdev->sh_info->op;
5953
5954--- sle11-2009-06-29.orig/drivers/xen/pciback/xenbus.c 2009-06-29 15:14:52.000000000 +0200
5955+++ sle11-2009-06-29/drivers/xen/pciback/xenbus.c 2008-12-15 11:26:44.000000000 +0100
5956@@ -32,7 +32,7 @@ static struct pciback_device *alloc_pdev
5957 pdev->evtchn_irq = INVALID_EVTCHN_IRQ;
5958 pdev->be_watching = 0;
5959
5960- INIT_WORK(&pdev->op_work, pciback_do_op, pdev);
5961+ INIT_WORK(&pdev->op_work, pciback_do_op);
5962
5963 if (pciback_init_devices(pdev)) {
5964 kfree(pdev);
5965@@ -54,7 +54,6 @@ static void pciback_disconnect(struct pc
5966
5967 /* If the driver domain started an op, make sure we complete it or
5968 * delete it before releasing the shared memory */
5969- cancel_delayed_work(&pdev->op_work);
5970 flush_scheduled_work();
5971
5972 if (pdev->sh_info != NULL) {
5973--- sle11-2009-06-29.orig/drivers/xen/scsiback/interface.c 2009-06-29 15:14:52.000000000 +0200
5974+++ sle11-2009-06-29/drivers/xen/scsiback/interface.c 2008-12-15 11:26:44.000000000 +0100
5975@@ -39,7 +39,7 @@
5976 #include <linux/kthread.h>
5977
5978
5979-static kmem_cache_t *scsiback_cachep;
5980+static struct kmem_cache *scsiback_cachep;
5981
5982 struct vscsibk_info *vscsibk_info_alloc(domid_t domid)
5983 {
5984--- sle11-2009-06-29.orig/drivers/xen/scsiback/scsiback.c 2009-03-04 11:28:34.000000000 +0100
5985+++ sle11-2009-06-29/drivers/xen/scsiback/scsiback.c 2008-12-15 11:26:44.000000000 +0100
5986@@ -322,13 +322,11 @@ static int scsiback_merge_bio(struct req
5987
5988 if (!rq->bio)
5989 blk_rq_bio_prep(q, rq, bio);
5990- else if (!q->back_merge_fn(q, rq, bio))
5991+ else if (!ll_back_merge_fn(q, rq, bio))
5992 return -EINVAL;
5993 else {
5994 rq->biotail->bi_next = bio;
5995 rq->biotail = bio;
5996- rq->hard_nr_sectors += bio_sectors(bio);
5997- rq->nr_sectors = rq->hard_nr_sectors;
5998 }
5999
6000 return 0;
6001--- sle11-2009-06-29.orig/drivers/xen/sfc_netfront/accel_vi.c 2009-03-30 16:35:11.000000000 +0200
6002+++ sle11-2009-06-29/drivers/xen/sfc_netfront/accel_vi.c 2009-03-30 16:35:25.000000000 +0200
6003@@ -463,7 +463,7 @@ netfront_accel_enqueue_skb_multi(netfron
6004
6005 if (skb->ip_summed == CHECKSUM_PARTIAL) {
6006 /* Set to zero to encourage falcon to work it out for us */
6007- *(u16*)(skb->h.raw + skb->csum) = 0;
6008+ *(u16*)(skb->h.raw + skb->csum_offset) = 0;
6009 }
6010
6011 if (multi_post_start_new_buffer(vnic, &state)) {
6012@@ -582,7 +582,7 @@ netfront_accel_enqueue_skb_single(netfro
6013
6014 if (skb->ip_summed == CHECKSUM_PARTIAL) {
6015 /* Set to zero to encourage falcon to work it out for us */
6016- *(u16*)(skb->h.raw + skb->csum) = 0;
6017+ *(u16*)(skb->h.raw + skb->csum_offset) = 0;
6018 }
6019 NETFRONT_ACCEL_PKTBUFF_FOR_EACH_FRAGMENT
6020 (skb, idx, frag_data, frag_len, {
6021--- sle11-2009-06-29.orig/drivers/xen/tpmback/interface.c 2009-06-29 15:14:52.000000000 +0200
6022+++ sle11-2009-06-29/drivers/xen/tpmback/interface.c 2008-12-15 11:26:44.000000000 +0100
6023@@ -15,7 +15,7 @@
6024 #include <xen/balloon.h>
6025 #include <xen/gnttab.h>
6026
6027-static kmem_cache_t *tpmif_cachep;
6028+static struct kmem_cache *tpmif_cachep;
6029 int num_frontends = 0;
6030
6031 LIST_HEAD(tpmif_list);
6032--- sle11-2009-06-29.orig/drivers/xen/xenbus/xenbus_comms.c 2009-03-04 11:28:34.000000000 +0100
6033+++ sle11-2009-06-29/drivers/xen/xenbus/xenbus_comms.c 2008-12-15 11:26:44.000000000 +0100
6034@@ -49,9 +49,9 @@
6035
6036 static int xenbus_irq;
6037
6038-extern void xenbus_probe(void *);
6039+extern void xenbus_probe(struct work_struct *);
6040 extern int xenstored_ready;
6041-static DECLARE_WORK(probe_work, xenbus_probe, NULL);
6042+static DECLARE_WORK(probe_work, xenbus_probe);
6043
6044 static DECLARE_WAIT_QUEUE_HEAD(xb_waitq);
6045
6046--- sle11-2009-06-29.orig/drivers/xen/xenbus/xenbus_probe.c 2008-11-25 12:35:56.000000000 +0100
6047+++ sle11-2009-06-29/drivers/xen/xenbus/xenbus_probe.c 2008-12-15 11:26:44.000000000 +0100
6048@@ -843,7 +843,7 @@ void unregister_xenstore_notifier(struct
6049 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
6050
6051
6052-void xenbus_probe(void *unused)
6053+void xenbus_probe(struct work_struct *unused)
6054 {
6055 BUG_ON((xenstored_ready <= 0));
6056
6057--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/desc_32.h 2009-03-04 11:28:34.000000000 +0100
6058+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/desc_32.h 2008-12-15 11:26:44.000000000 +0100
6059@@ -4,8 +4,6 @@
6060 #include <asm/ldt.h>
6061 #include <asm/segment.h>
6062
6063-#define CPU_16BIT_STACK_SIZE 1024
6064-
6065 #ifndef __ASSEMBLY__
6066
6067 #include <linux/preempt.h>
6068@@ -15,8 +13,6 @@
6069
6070 extern struct desc_struct cpu_gdt_table[GDT_ENTRIES];
6071
6072-DECLARE_PER_CPU(unsigned char, cpu_16bit_stack[CPU_16BIT_STACK_SIZE]);
6073-
6074 struct Xgt_desc_struct {
6075 unsigned short size;
6076 unsigned long address __attribute__((packed));
6077@@ -32,11 +28,6 @@ static inline struct desc_struct *get_cp
6078 return (struct desc_struct *)per_cpu(cpu_gdt_descr, cpu).address;
6079 }
6080
6081-/*
6082- * This is the ldt that every process will get unless we need
6083- * something other than this.
6084- */
6085-extern struct desc_struct default_ldt[];
6086 extern struct desc_struct idt_table[];
6087 extern void set_intr_gate(unsigned int irq, void * addr);
6088
6089@@ -63,8 +54,8 @@ static inline void pack_gate(__u32 *a, _
6090 #define DESCTYPE_DPL3 0x60 /* DPL-3 */
6091 #define DESCTYPE_S 0x10 /* !system */
6092
6093+#ifndef CONFIG_XEN
6094 #define load_TR_desc() __asm__ __volatile__("ltr %w0"::"q" (GDT_ENTRY_TSS*8))
6095-#define load_LDT_desc() __asm__ __volatile__("lldt %w0"::"q" (GDT_ENTRY_LDT*8))
6096
6097 #define load_gdt(dtr) __asm__ __volatile("lgdt %0"::"m" (*dtr))
6098 #define load_idt(dtr) __asm__ __volatile("lidt %0"::"m" (*dtr))
6099@@ -75,6 +66,7 @@ static inline void pack_gate(__u32 *a, _
6100 #define store_idt(dtr) __asm__ ("sidt %0":"=m" (*dtr))
6101 #define store_tr(tr) __asm__ ("str %0":"=m" (tr))
6102 #define store_ldt(ldt) __asm__ ("sldt %0":"=m" (ldt))
6103+#endif
6104
6105 #if TLS_SIZE != 24
6106 # error update this code.
6107@@ -90,22 +82,43 @@ static inline void load_TLS(struct threa
6108 }
6109
6110 #ifndef CONFIG_XEN
6111+#define write_ldt_entry(dt, entry, a, b) write_dt_entry(dt, entry, a, b)
6112+#define write_gdt_entry(dt, entry, a, b) write_dt_entry(dt, entry, a, b)
6113+#define write_idt_entry(dt, entry, a, b) write_dt_entry(dt, entry, a, b)
6114+
6115 static inline void write_dt_entry(void *dt, int entry, __u32 entry_a, __u32 entry_b)
6116 {
6117 __u32 *lp = (__u32 *)((char *)dt + entry*8);
6118 *lp = entry_a;
6119 *(lp+1) = entry_b;
6120 }
6121-
6122-#define write_ldt_entry(dt, entry, a, b) write_dt_entry(dt, entry, a, b)
6123-#define write_gdt_entry(dt, entry, a, b) write_dt_entry(dt, entry, a, b)
6124+#define set_ldt native_set_ldt
6125 #else
6126 extern int write_ldt_entry(void *ldt, int entry, __u32 entry_a, __u32 entry_b);
6127 extern int write_gdt_entry(void *gdt, int entry, __u32 entry_a, __u32 entry_b);
6128+#define set_ldt xen_set_ldt
6129+#endif
6130+
6131+#ifndef CONFIG_XEN
6132+static inline fastcall void native_set_ldt(const void *addr,
6133+ unsigned int entries)
6134+{
6135+ if (likely(entries == 0))
6136+ __asm__ __volatile__("lldt %w0"::"q" (0));
6137+ else {
6138+ unsigned cpu = smp_processor_id();
6139+ __u32 a, b;
6140+
6141+ pack_descriptor(&a, &b, (unsigned long)addr,
6142+ entries * sizeof(struct desc_struct) - 1,
6143+ DESCTYPE_LDT, 0);
6144+ write_gdt_entry(get_cpu_gdt_table(cpu), GDT_ENTRY_LDT, a, b);
6145+ __asm__ __volatile__("lldt %w0"::"q" (GDT_ENTRY_LDT*8));
6146+ }
6147+}
6148 #endif
6149-#ifndef CONFIG_X86_NO_IDT
6150-#define write_idt_entry(dt, entry, a, b) write_dt_entry(dt, entry, a, b)
6151
6152+#ifndef CONFIG_X86_NO_IDT
6153 static inline void _set_gate(int gate, unsigned int type, void *addr, unsigned short seg)
6154 {
6155 __u32 a, b;
6156@@ -125,14 +138,6 @@ static inline void __set_tss_desc(unsign
6157 }
6158 #endif
6159
6160-static inline void set_ldt_desc(unsigned int cpu, void *addr, unsigned int entries)
6161-{
6162- __u32 a, b;
6163- pack_descriptor(&a, &b, (unsigned long)addr,
6164- entries * sizeof(struct desc_struct) - 1,
6165- DESCTYPE_LDT, 0);
6166- write_gdt_entry(get_cpu_gdt_table(cpu), GDT_ENTRY_LDT, a, b);
6167-}
6168
6169 #define set_tss_desc(cpu,addr) __set_tss_desc(cpu, GDT_ENTRY_TSS, addr)
6170
6171@@ -163,36 +168,22 @@ static inline void set_ldt_desc(unsigned
6172
6173 static inline void clear_LDT(void)
6174 {
6175- int cpu = get_cpu();
6176-
6177- /*
6178- * NB. We load the default_ldt for lcall7/27 handling on demand, as
6179- * it slows down context switching. Noone uses it anyway.
6180- */
6181- cpu = cpu; /* XXX avoid compiler warning */
6182- xen_set_ldt(NULL, 0);
6183- put_cpu();
6184+ set_ldt(NULL, 0);
6185 }
6186
6187 /*
6188 * load one particular LDT into the current CPU
6189 */
6190-static inline void load_LDT_nolock(mm_context_t *pc, int cpu)
6191+static inline void load_LDT_nolock(mm_context_t *pc)
6192 {
6193- void *segments = pc->ldt;
6194- int count = pc->size;
6195-
6196- if (likely(!count))
6197- segments = NULL;
6198-
6199- xen_set_ldt(segments, count);
6200+ set_ldt(pc->ldt, pc->size);
6201 }
6202
6203 static inline void load_LDT(mm_context_t *pc)
6204 {
6205- int cpu = get_cpu();
6206- load_LDT_nolock(pc, cpu);
6207- put_cpu();
6208+ preempt_disable();
6209+ load_LDT_nolock(pc);
6210+ preempt_enable();
6211 }
6212
6213 static inline unsigned long get_desc_base(unsigned long *desc)
6214@@ -204,6 +195,29 @@ static inline unsigned long get_desc_bas
6215 return base;
6216 }
6217
6218+#else /* __ASSEMBLY__ */
6219+
6220+/*
6221+ * GET_DESC_BASE reads the descriptor base of the specified segment.
6222+ *
6223+ * Args:
6224+ * idx - descriptor index
6225+ * gdt - GDT pointer
6226+ * base - 32bit register to which the base will be written
6227+ * lo_w - lo word of the "base" register
6228+ * lo_b - lo byte of the "base" register
6229+ * hi_b - hi byte of the low word of the "base" register
6230+ *
6231+ * Example:
6232+ * GET_DESC_BASE(GDT_ENTRY_ESPFIX_SS, %ebx, %eax, %ax, %al, %ah)
6233+ * Will read the base address of GDT_ENTRY_ESPFIX_SS and put it into %eax.
6234+ */
6235+#define GET_DESC_BASE(idx, gdt, base, lo_w, lo_b, hi_b) \
6236+ movb idx*8+4(gdt), lo_b; \
6237+ movb idx*8+7(gdt), hi_b; \
6238+ shll $16, base; \
6239+ movw idx*8+2(gdt), lo_w;
6240+
6241 #endif /* !__ASSEMBLY__ */
6242
6243 #endif
6244--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/dma-mapping_32.h 2009-06-29 15:14:52.000000000 +0200
6245+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/dma-mapping_32.h 2008-12-15 11:26:44.000000000 +0100
6246@@ -127,10 +127,10 @@ dma_get_cache_alignment(void)
6247 return (1 << INTERNODE_CACHE_SHIFT);
6248 }
6249
6250-#define dma_is_consistent(d) (1)
6251+#define dma_is_consistent(d, h) (1)
6252
6253 static inline void
6254-dma_cache_sync(void *vaddr, size_t size,
6255+dma_cache_sync(struct device *dev, void *vaddr, size_t size,
6256 enum dma_data_direction direction)
6257 {
6258 flush_write_buffers();
6259--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/fixmap_32.h 2009-03-04 11:28:34.000000000 +0100
6260+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/fixmap_32.h 2008-12-15 11:26:44.000000000 +0100
6261@@ -13,13 +13,16 @@
6262 #ifndef _ASM_FIXMAP_H
6263 #define _ASM_FIXMAP_H
6264
6265-
6266 /* used by vmalloc.c, vsyscall.lds.S.
6267 *
6268 * Leave one empty page between vmalloc'ed areas and
6269 * the start of the fixmap.
6270 */
6271 extern unsigned long __FIXADDR_TOP;
6272+#ifdef CONFIG_COMPAT_VDSO
6273+#define FIXADDR_USER_START __fix_to_virt(FIX_VDSO)
6274+#define FIXADDR_USER_END __fix_to_virt(FIX_VDSO - 1)
6275+#endif
6276
6277 #ifndef __ASSEMBLY__
6278 #include <linux/kernel.h>
6279--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/highmem.h 2009-06-29 15:14:52.000000000 +0200
6280+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/highmem.h 2008-12-15 11:26:44.000000000 +0100
6281@@ -85,7 +85,7 @@ static inline void clear_user_highpage(s
6282
6283 void copy_highpage(struct page *to, struct page *from);
6284 static inline void copy_user_highpage(struct page *to, struct page *from,
6285- unsigned long vaddr)
6286+ unsigned long vaddr, struct vm_area_struct *vma)
6287 {
6288 copy_highpage(to, from);
6289 }
6290--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/hypervisor.h 2009-03-04 11:28:34.000000000 +0100
6291+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/hypervisor.h 2008-12-15 11:26:44.000000000 +0100
6292@@ -46,15 +46,6 @@
6293 #include <asm/percpu.h>
6294 #include <asm/ptrace.h>
6295 #include <asm/page.h>
6296-#if defined(__i386__)
6297-# ifdef CONFIG_X86_PAE
6298-# include <asm-generic/pgtable-nopud.h>
6299-# else
6300-# include <asm-generic/pgtable-nopmd.h>
6301-# endif
6302-#elif defined(__x86_64__) && LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
6303-# include <asm-generic/pgtable-nopud.h>
6304-#endif
6305
6306 extern shared_info_t *HYPERVISOR_shared_info;
6307
6308--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/irqflags_32.h 2009-06-29 15:14:52.000000000 +0200
6309+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/irqflags_32.h 2008-12-15 11:26:44.000000000 +0100
6310@@ -22,9 +22,6 @@
6311
6312 #define __raw_local_save_flags() (current_vcpu_info()->evtchn_upcall_mask)
6313
6314-#define raw_local_save_flags(flags) \
6315- do { (flags) = __raw_local_save_flags(); } while (0)
6316-
6317 #define raw_local_irq_restore(x) \
6318 do { \
6319 vcpu_info_t *_vcpu; \
6320@@ -66,18 +63,6 @@ void raw_safe_halt(void);
6321 */
6322 void halt(void);
6323
6324-static inline int raw_irqs_disabled_flags(unsigned long flags)
6325-{
6326- return (flags != 0);
6327-}
6328-
6329-#define raw_irqs_disabled() \
6330-({ \
6331- unsigned long flags = __raw_local_save_flags(); \
6332- \
6333- raw_irqs_disabled_flags(flags); \
6334-})
6335-
6336 /*
6337 * For spinlocks, etc:
6338 */
6339@@ -90,9 +75,62 @@ static inline int raw_irqs_disabled_flag
6340 flags; \
6341 })
6342
6343+#else
6344+/* Offsets into shared_info_t. */
6345+#define evtchn_upcall_pending /* 0 */
6346+#define evtchn_upcall_mask 1
6347+
6348+#define sizeof_vcpu_shift 6
6349+
6350+#ifdef CONFIG_SMP
6351+#define GET_VCPU_INFO movl TI_cpu(%ebp),%esi ; \
6352+ shl $sizeof_vcpu_shift,%esi ; \
6353+ addl HYPERVISOR_shared_info,%esi
6354+#else
6355+#define GET_VCPU_INFO movl HYPERVISOR_shared_info,%esi
6356+#endif
6357+
6358+#define __DISABLE_INTERRUPTS movb $1,evtchn_upcall_mask(%esi)
6359+#define __ENABLE_INTERRUPTS movb $0,evtchn_upcall_mask(%esi)
6360+#define __TEST_PENDING testb $0xFF,evtchn_upcall_pending(%esi)
6361+#define DISABLE_INTERRUPTS(clb) GET_VCPU_INFO ; \
6362+ __DISABLE_INTERRUPTS
6363+#define ENABLE_INTERRUPTS(clb) GET_VCPU_INFO ; \
6364+ __ENABLE_INTERRUPTS
6365+#define ENABLE_INTERRUPTS_SYSEXIT __ENABLE_INTERRUPTS ; \
6366+sysexit_scrit: /**** START OF SYSEXIT CRITICAL REGION ****/ ; \
6367+ __TEST_PENDING ; \
6368+ jnz 14f /* process more events if necessary... */ ; \
6369+ movl PT_ESI(%esp), %esi ; \
6370+ sysexit ; \
6371+14: __DISABLE_INTERRUPTS ; \
6372+ TRACE_IRQS_OFF ; \
6373+sysexit_ecrit: /**** END OF SYSEXIT CRITICAL REGION ****/ ; \
6374+ push %esp ; \
6375+ call evtchn_do_upcall ; \
6376+ add $4,%esp ; \
6377+ jmp ret_from_intr
6378+#define INTERRUPT_RETURN iret
6379+#endif /* __ASSEMBLY__ */
6380+
6381+#ifndef __ASSEMBLY__
6382+#define raw_local_save_flags(flags) \
6383+ do { (flags) = __raw_local_save_flags(); } while (0)
6384+
6385 #define raw_local_irq_save(flags) \
6386 do { (flags) = __raw_local_irq_save(); } while (0)
6387
6388+static inline int raw_irqs_disabled_flags(unsigned long flags)
6389+{
6390+ return (flags != 0);
6391+}
6392+
6393+#define raw_irqs_disabled() \
6394+({ \
6395+ unsigned long flags = __raw_local_save_flags(); \
6396+ \
6397+ raw_irqs_disabled_flags(flags); \
6398+})
6399 #endif /* __ASSEMBLY__ */
6400
6401 /*
6402--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/mmu_context_32.h 2009-06-29 15:14:52.000000000 +0200
6403+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/mmu_context_32.h 2008-12-15 11:26:44.000000000 +0100
6404@@ -27,14 +27,13 @@ static inline void enter_lazy_tlb(struct
6405 static inline void __prepare_arch_switch(void)
6406 {
6407 /*
6408- * Save away %fs and %gs. No need to save %es and %ds, as those
6409- * are always kernel segments while inside the kernel. Must
6410- * happen before reload of cr3/ldt (i.e., not in __switch_to).
6411+ * Save away %fs. No need to save %gs, as it was saved on the
6412+ * stack on entry. No need to save %es and %ds, as those are
6413+ * always kernel segments while inside the kernel.
6414 */
6415- asm volatile ( "mov %%fs,%0 ; mov %%gs,%1"
6416- : "=m" (current->thread.fs),
6417- "=m" (current->thread.gs));
6418- asm volatile ( "movl %0,%%fs ; movl %0,%%gs"
6419+ asm volatile ( "mov %%fs,%0"
6420+ : "=m" (current->thread.fs));
6421+ asm volatile ( "movl %0,%%fs"
6422 : : "r" (0) );
6423 }
6424
6425@@ -89,14 +88,14 @@ static inline void switch_mm(struct mm_s
6426 * tlb flush IPI delivery. We must reload %cr3.
6427 */
6428 load_cr3(next->pgd);
6429- load_LDT_nolock(&next->context, cpu);
6430+ load_LDT_nolock(&next->context);
6431 }
6432 }
6433 #endif
6434 }
6435
6436-#define deactivate_mm(tsk, mm) \
6437- asm("movl %0,%%fs ; movl %0,%%gs": :"r" (0))
6438+#define deactivate_mm(tsk, mm) \
6439+ asm("movl %0,%%fs": :"r" (0));
6440
6441 static inline void activate_mm(struct mm_struct *prev, struct mm_struct *next)
6442 {
6443--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/pgtable-3level.h 2009-03-04 11:28:34.000000000 +0100
6444+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/pgtable-3level.h 2008-12-15 11:26:44.000000000 +0100
6445@@ -1,8 +1,6 @@
6446 #ifndef _I386_PGTABLE_3LEVEL_H
6447 #define _I386_PGTABLE_3LEVEL_H
6448
6449-#include <asm-generic/pgtable-nopud.h>
6450-
6451 /*
6452 * Intel Physical Address Extension (PAE) Mode - three-level page
6453 * tables on PPro+ CPUs.
6454@@ -75,6 +73,23 @@ static inline void set_pte(pte_t *ptep,
6455 xen_l3_entry_update((pudptr), (pudval))
6456
6457 /*
6458+ * For PTEs and PDEs, we must clear the P-bit first when clearing a page table
6459+ * entry, so clear the bottom half first and enforce ordering with a compiler
6460+ * barrier.
6461+ */
6462+static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
6463+{
6464+ if ((mm != current->mm && mm != &init_mm)
6465+ || HYPERVISOR_update_va_mapping(addr, __pte(0), 0)) {
6466+ ptep->pte_low = 0;
6467+ smp_wmb();
6468+ ptep->pte_high = 0;
6469+ }
6470+}
6471+
6472+#define pmd_clear(xp) do { set_pmd(xp, __pmd(0)); } while (0)
6473+
6474+/*
6475 * Pentium-II erratum A13: in PAE mode we explicitly have to flush
6476 * the TLB via cr3 if the top-level pgd is changed...
6477 * We do not let the generic code free and clear pgd entries due to
6478@@ -93,45 +108,16 @@ static inline void pud_clear (pud_t * pu
6479 #define pmd_offset(pud, address) ((pmd_t *) pud_page(*(pud)) + \
6480 pmd_index(address))
6481
6482-static inline int pte_none(pte_t pte)
6483-{
6484- return !(pte.pte_low | pte.pte_high);
6485-}
6486-
6487-/*
6488- * For PTEs and PDEs, we must clear the P-bit first when clearing a page table
6489- * entry, so clear the bottom half first and enforce ordering with a compiler
6490- * barrier.
6491- */
6492-static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
6493+static inline pte_t raw_ptep_get_and_clear(pte_t *ptep, pte_t res)
6494 {
6495- if ((mm != current->mm && mm != &init_mm)
6496- || HYPERVISOR_update_va_mapping(addr, __pte(0), 0)) {
6497- ptep->pte_low = 0;
6498- smp_wmb();
6499+ uint64_t val = __pte_val(res);
6500+ if (__cmpxchg64(ptep, val, 0) != val) {
6501+ /* xchg acts as a barrier before the setting of the high bits */
6502+ res.pte_low = xchg(&ptep->pte_low, 0);
6503+ res.pte_high = ptep->pte_high;
6504 ptep->pte_high = 0;
6505 }
6506-}
6507-
6508-#define pmd_clear(xp) do { set_pmd(xp, __pmd(0)); } while (0)
6509-
6510-#define __HAVE_ARCH_PTEP_GET_AND_CLEAR
6511-static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
6512-{
6513- pte_t pte = *ptep;
6514- if (!pte_none(pte)) {
6515- if ((mm != &init_mm) ||
6516- HYPERVISOR_update_va_mapping(addr, __pte(0), 0)) {
6517- uint64_t val = __pte_val(pte);
6518- if (__cmpxchg64(ptep, val, 0) != val) {
6519- /* xchg acts as a barrier before the setting of the high bits */
6520- pte.pte_low = xchg(&ptep->pte_low, 0);
6521- pte.pte_high = ptep->pte_high;
6522- ptep->pte_high = 0;
6523- }
6524- }
6525- }
6526- return pte;
6527+ return res;
6528 }
6529
6530 #define __HAVE_ARCH_PTEP_CLEAR_FLUSH
6531@@ -160,6 +146,11 @@ static inline int pte_same(pte_t a, pte_
6532
6533 #define pte_page(x) pfn_to_page(pte_pfn(x))
6534
6535+static inline int pte_none(pte_t pte)
6536+{
6537+ return !(pte.pte_low | pte.pte_high);
6538+}
6539+
6540 #define __pte_mfn(_pte) (((_pte).pte_low >> PAGE_SHIFT) | \
6541 ((_pte).pte_high << (32-PAGE_SHIFT)))
6542 #define pte_mfn(_pte) ((_pte).pte_low & _PAGE_PRESENT ? \
6543--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/pgtable_32.h 2009-03-04 11:28:34.000000000 +0100
6544+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/pgtable_32.h 2008-12-15 11:26:44.000000000 +0100
6545@@ -38,14 +38,14 @@ struct vm_area_struct;
6546 #define ZERO_PAGE(vaddr) (virt_to_page(empty_zero_page))
6547 extern unsigned long empty_zero_page[1024];
6548 extern pgd_t *swapper_pg_dir;
6549-extern kmem_cache_t *pgd_cache;
6550-extern kmem_cache_t *pmd_cache;
6551+extern struct kmem_cache *pgd_cache;
6552+extern struct kmem_cache *pmd_cache;
6553 extern spinlock_t pgd_lock;
6554 extern struct page *pgd_list;
6555
6556-void pmd_ctor(void *, kmem_cache_t *, unsigned long);
6557-void pgd_ctor(void *, kmem_cache_t *, unsigned long);
6558-void pgd_dtor(void *, kmem_cache_t *, unsigned long);
6559+void pmd_ctor(void *, struct kmem_cache *, unsigned long);
6560+void pgd_ctor(void *, struct kmem_cache *, unsigned long);
6561+void pgd_dtor(void *, struct kmem_cache *, unsigned long);
6562 void pgtable_cache_init(void);
6563 void paging_init(void);
6564
6565@@ -276,7 +276,6 @@ static inline pte_t pte_mkhuge(pte_t pte
6566 #define pte_update(mm, addr, ptep) do { } while (0)
6567 #define pte_update_defer(mm, addr, ptep) do { } while (0)
6568
6569-
6570 /*
6571 * We only update the dirty/accessed state if we set
6572 * the dirty bit by hand in the kernel, since the hardware
6573@@ -342,6 +341,19 @@ do { \
6574 __young; \
6575 })
6576
6577+#define __HAVE_ARCH_PTEP_GET_AND_CLEAR
6578+static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
6579+{
6580+ pte_t pte = *ptep;
6581+ if (!pte_none(pte)
6582+ && (mm != &init_mm
6583+ || HYPERVISOR_update_va_mapping(addr, __pte(0), 0))) {
6584+ pte = raw_ptep_get_and_clear(ptep, pte);
6585+ pte_update(mm, addr, ptep);
6586+ }
6587+ return pte;
6588+}
6589+
6590 #define __HAVE_ARCH_PTEP_GET_AND_CLEAR_FULL
6591 #define ptep_get_and_clear_full(mm, addr, ptep, full) \
6592 ((full) ? ({ \
6593--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/processor_32.h 2009-03-04 11:28:34.000000000 +0100
6594+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/processor_32.h 2008-12-15 11:26:44.000000000 +0100
6595@@ -20,6 +20,7 @@
6596 #include <linux/threads.h>
6597 #include <asm/percpu.h>
6598 #include <linux/cpumask.h>
6599+#include <linux/init.h>
6600 #include <xen/interface/physdev.h>
6601
6602 /* flag for disabling the tsc */
6603@@ -73,6 +74,7 @@ struct cpuinfo_x86 {
6604 #endif
6605 unsigned char x86_max_cores; /* cpuid returned max cores value */
6606 unsigned char apicid;
6607+ unsigned short x86_clflush_size;
6608 #ifdef CONFIG_SMP
6609 unsigned char booted_cores; /* number of cores as seen by OS */
6610 __u8 phys_proc_id; /* Physical processor id. */
6611@@ -114,6 +116,8 @@ extern struct cpuinfo_x86 cpu_data[];
6612 extern int cpu_llc_id[NR_CPUS];
6613 extern char ignore_fpu_irq;
6614
6615+void __init cpu_detect(struct cpuinfo_x86 *c);
6616+
6617 extern void identify_cpu(struct cpuinfo_x86 *);
6618 extern void print_cpu_info(struct cpuinfo_x86 *);
6619 extern unsigned int init_intel_cacheinfo(struct cpuinfo_x86 *c);
6620@@ -146,8 +150,8 @@ static inline void detect_ht(struct cpui
6621 #define X86_EFLAGS_VIP 0x00100000 /* Virtual Interrupt Pending */
6622 #define X86_EFLAGS_ID 0x00200000 /* CPUID detection flag */
6623
6624-static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
6625- unsigned int *ecx, unsigned int *edx)
6626+static inline fastcall void xen_cpuid(unsigned int *eax, unsigned int *ebx,
6627+ unsigned int *ecx, unsigned int *edx)
6628 {
6629 /* ecx is often an input as well as an output. */
6630 __asm__(XEN_CPUID
6631@@ -158,59 +162,6 @@ static inline void __cpuid(unsigned int
6632 : "0" (*eax), "2" (*ecx));
6633 }
6634
6635-/*
6636- * Generic CPUID function
6637- * clear %ecx since some cpus (Cyrix MII) do not set or clear %ecx
6638- * resulting in stale register contents being returned.
6639- */
6640-static inline void cpuid(unsigned int op, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx)
6641-{
6642- *eax = op;
6643- *ecx = 0;
6644- __cpuid(eax, ebx, ecx, edx);
6645-}
6646-
6647-/* Some CPUID calls want 'count' to be placed in ecx */
6648-static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
6649- int *edx)
6650-{
6651- *eax = op;
6652- *ecx = count;
6653- __cpuid(eax, ebx, ecx, edx);
6654-}
6655-
6656-/*
6657- * CPUID functions returning a single datum
6658- */
6659-static inline unsigned int cpuid_eax(unsigned int op)
6660-{
6661- unsigned int eax, ebx, ecx, edx;
6662-
6663- cpuid(op, &eax, &ebx, &ecx, &edx);
6664- return eax;
6665-}
6666-static inline unsigned int cpuid_ebx(unsigned int op)
6667-{
6668- unsigned int eax, ebx, ecx, edx;
6669-
6670- cpuid(op, &eax, &ebx, &ecx, &edx);
6671- return ebx;
6672-}
6673-static inline unsigned int cpuid_ecx(unsigned int op)
6674-{
6675- unsigned int eax, ebx, ecx, edx;
6676-
6677- cpuid(op, &eax, &ebx, &ecx, &edx);
6678- return ecx;
6679-}
6680-static inline unsigned int cpuid_edx(unsigned int op)
6681-{
6682- unsigned int eax, ebx, ecx, edx;
6683-
6684- cpuid(op, &eax, &ebx, &ecx, &edx);
6685- return edx;
6686-}
6687-
6688 #define load_cr3(pgdir) write_cr3(__pa(pgdir))
6689
6690 /*
6691@@ -480,9 +431,9 @@ struct thread_struct {
6692 .vm86_info = NULL, \
6693 .sysenter_cs = __KERNEL_CS, \
6694 .io_bitmap_ptr = NULL, \
6695+ .gs = __KERNEL_PDA, \
6696 }
6697
6698-#ifndef CONFIG_X86_NO_TSS
6699 /*
6700 * Note that the .io_bitmap member must be extra-big. This is because
6701 * the CPU will access an additional byte beyond the end of the IO
6702@@ -497,26 +448,9 @@ struct thread_struct {
6703 .io_bitmap = { [ 0 ... IO_BITMAP_LONGS] = ~0 }, \
6704 }
6705
6706-static inline void __load_esp0(struct tss_struct *tss, struct thread_struct *thread)
6707-{
6708- tss->esp0 = thread->esp0;
6709- /* This can only happen when SEP is enabled, no need to test "SEP"arately */
6710- if (unlikely(tss->ss1 != thread->sysenter_cs)) {
6711- tss->ss1 = thread->sysenter_cs;
6712- wrmsr(MSR_IA32_SYSENTER_CS, thread->sysenter_cs, 0);
6713- }
6714-}
6715-#define load_esp0(tss, thread) \
6716- __load_esp0(tss, thread)
6717-#else
6718-#define load_esp0(tss, thread) do { \
6719- if (HYPERVISOR_stack_switch(__KERNEL_DS, (thread)->esp0)) \
6720- BUG(); \
6721-} while (0)
6722-#endif
6723-
6724 #define start_thread(regs, new_eip, new_esp) do { \
6725- __asm__("movl %0,%%fs ; movl %0,%%gs": :"r" (0)); \
6726+ __asm__("movl %0,%%fs": :"r" (0)); \
6727+ regs->xgs = 0; \
6728 set_fs(USER_DS); \
6729 regs->xds = __USER_DS; \
6730 regs->xes = __USER_DS; \
6731@@ -526,26 +460,6 @@ static inline void __load_esp0(struct ts
6732 regs->esp = new_esp; \
6733 } while (0)
6734
6735-/*
6736- * These special macros can be used to get or set a debugging register
6737- */
6738-#define get_debugreg(var, register) \
6739- (var) = HYPERVISOR_get_debugreg((register))
6740-#define set_debugreg(value, register) \
6741- WARN_ON(HYPERVISOR_set_debugreg((register), (value)))
6742-
6743-/*
6744- * Set IOPL bits in EFLAGS from given mask
6745- */
6746-static inline void set_iopl_mask(unsigned mask)
6747-{
6748- struct physdev_set_iopl set_iopl;
6749-
6750- /* Force the change at ring 0. */
6751- set_iopl.iopl = (mask == 0) ? 1 : (mask >> 12) & 3;
6752- WARN_ON(HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl));
6753-}
6754-
6755 /* Forward declaration, a strange C thing */
6756 struct task_struct;
6757 struct mm_struct;
6758@@ -637,6 +551,105 @@ static inline void rep_nop(void)
6759
6760 #define cpu_relax() rep_nop()
6761
6762+#define paravirt_enabled() 0
6763+#define __cpuid xen_cpuid
6764+
6765+#ifndef CONFIG_X86_NO_TSS
6766+static inline void __load_esp0(struct tss_struct *tss, struct thread_struct *thread)
6767+{
6768+ tss->esp0 = thread->esp0;
6769+ /* This can only happen when SEP is enabled, no need to test "SEP"arately */
6770+ if (unlikely(tss->ss1 != thread->sysenter_cs)) {
6771+ tss->ss1 = thread->sysenter_cs;
6772+ wrmsr(MSR_IA32_SYSENTER_CS, thread->sysenter_cs, 0);
6773+ }
6774+}
6775+#define load_esp0(tss, thread) \
6776+ __load_esp0(tss, thread)
6777+#else
6778+#define load_esp0(tss, thread) do { \
6779+ if (HYPERVISOR_stack_switch(__KERNEL_DS, (thread)->esp0)) \
6780+ BUG(); \
6781+} while (0)
6782+#endif
6783+
6784+
6785+/*
6786+ * These special macros can be used to get or set a debugging register
6787+ */
6788+#define get_debugreg(var, register) \
6789+ (var) = HYPERVISOR_get_debugreg(register)
6790+#define set_debugreg(value, register) \
6791+ WARN_ON(HYPERVISOR_set_debugreg(register, value))
6792+
6793+#define set_iopl_mask xen_set_iopl_mask
6794+
6795+/*
6796+ * Set IOPL bits in EFLAGS from given mask
6797+ */
6798+static inline void xen_set_iopl_mask(unsigned mask)
6799+{
6800+ struct physdev_set_iopl set_iopl;
6801+
6802+ /* Force the change at ring 0. */
6803+ set_iopl.iopl = (mask == 0) ? 1 : (mask >> 12) & 3;
6804+ WARN_ON(HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl));
6805+}
6806+
6807+
6808+/*
6809+ * Generic CPUID function
6810+ * clear %ecx since some cpus (Cyrix MII) do not set or clear %ecx
6811+ * resulting in stale register contents being returned.
6812+ */
6813+static inline void cpuid(unsigned int op, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx)
6814+{
6815+ *eax = op;
6816+ *ecx = 0;
6817+ __cpuid(eax, ebx, ecx, edx);
6818+}
6819+
6820+/* Some CPUID calls want 'count' to be placed in ecx */
6821+static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
6822+ int *edx)
6823+{
6824+ *eax = op;
6825+ *ecx = count;
6826+ __cpuid(eax, ebx, ecx, edx);
6827+}
6828+
6829+/*
6830+ * CPUID functions returning a single datum
6831+ */
6832+static inline unsigned int cpuid_eax(unsigned int op)
6833+{
6834+ unsigned int eax, ebx, ecx, edx;
6835+
6836+ cpuid(op, &eax, &ebx, &ecx, &edx);
6837+ return eax;
6838+}
6839+static inline unsigned int cpuid_ebx(unsigned int op)
6840+{
6841+ unsigned int eax, ebx, ecx, edx;
6842+
6843+ cpuid(op, &eax, &ebx, &ecx, &edx);
6844+ return ebx;
6845+}
6846+static inline unsigned int cpuid_ecx(unsigned int op)
6847+{
6848+ unsigned int eax, ebx, ecx, edx;
6849+
6850+ cpuid(op, &eax, &ebx, &ecx, &edx);
6851+ return ecx;
6852+}
6853+static inline unsigned int cpuid_edx(unsigned int op)
6854+{
6855+ unsigned int eax, ebx, ecx, edx;
6856+
6857+ cpuid(op, &eax, &ebx, &ecx, &edx);
6858+ return edx;
6859+}
6860+
6861 /* generic versions from gas */
6862 #define GENERIC_NOP1 ".byte 0x90\n"
6863 #define GENERIC_NOP2 ".byte 0x89,0xf6\n"
6864@@ -736,4 +749,8 @@ extern unsigned long boot_option_idle_ov
6865 extern void enable_sep_cpu(void);
6866 extern int sysenter_setup(void);
6867
6868+extern int init_gdt(int cpu, struct task_struct *idle);
6869+extern void cpu_set_gdt(int);
6870+extern void secondary_cpu_init(void);
6871+
6872 #endif /* __ASM_I386_PROCESSOR_H */
6873--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/segment_32.h 2009-03-04 11:28:34.000000000 +0100
6874+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/segment_32.h 2008-12-15 11:26:44.000000000 +0100
6875@@ -39,7 +39,7 @@
6876 * 25 - APM BIOS support
6877 *
6878 * 26 - ESPFIX small SS
6879- * 27 - unused
6880+ * 27 - PDA [ per-cpu private data area ]
6881 * 28 - unused
6882 * 29 - unused
6883 * 30 - unused
6884@@ -74,6 +74,9 @@
6885 #define GDT_ENTRY_ESPFIX_SS (GDT_ENTRY_KERNEL_BASE + 14)
6886 #define __ESPFIX_SS (GDT_ENTRY_ESPFIX_SS * 8)
6887
6888+#define GDT_ENTRY_PDA (GDT_ENTRY_KERNEL_BASE + 15)
6889+#define __KERNEL_PDA (GDT_ENTRY_PDA * 8)
6890+
6891 #define GDT_ENTRY_DOUBLEFAULT_TSS 31
6892
6893 /*
6894--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/smp_32.h 2009-03-04 11:28:34.000000000 +0100
6895+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/smp_32.h 2008-12-15 11:26:44.000000000 +0100
6896@@ -8,6 +8,7 @@
6897 #include <linux/kernel.h>
6898 #include <linux/threads.h>
6899 #include <linux/cpumask.h>
6900+#include <asm/pda.h>
6901 #endif
6902
6903 #ifdef CONFIG_X86_LOCAL_APIC
6904@@ -56,7 +57,7 @@ extern void cpu_uninit(void);
6905 * from the initial startup. We map APIC_BASE very early in page_setup(),
6906 * so this is correct in the x86 case.
6907 */
6908-#define raw_smp_processor_id() (current_thread_info()->cpu)
6909+#define raw_smp_processor_id() (read_pda(cpu_number))
6910
6911 extern cpumask_t cpu_possible_map;
6912 #define cpu_callin_map cpu_possible_map
6913--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/system_32.h 2009-03-04 11:28:34.000000000 +0100
6914+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/system_32.h 2008-12-15 11:26:44.000000000 +0100
6915@@ -139,17 +139,17 @@ __asm__ __volatile__ ("movw %%dx,%1\n\t"
6916 #define write_cr4(x) \
6917 __asm__ __volatile__("movl %0,%%cr4": :"r" (x))
6918
6919-/*
6920- * Clear and set 'TS' bit respectively
6921- */
6922+#define wbinvd() \
6923+ __asm__ __volatile__ ("wbinvd": : :"memory")
6924+
6925+/* Clear the 'TS' bit */
6926 #define clts() (HYPERVISOR_fpu_taskswitch(0))
6927+
6928+/* Set the 'TS' bit */
6929 #define stts() (HYPERVISOR_fpu_taskswitch(1))
6930
6931 #endif /* __KERNEL__ */
6932
6933-#define wbinvd() \
6934- __asm__ __volatile__ ("wbinvd": : :"memory")
6935-
6936 static inline unsigned long get_limit(unsigned long segment)
6937 {
6938 unsigned long __limit;
6939--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/desc_64.h 2009-06-29 15:14:52.000000000 +0200
6940+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/desc_64.h 2008-12-15 11:26:44.000000000 +0100
6941@@ -9,62 +9,11 @@
6942
6943 #include <linux/string.h>
6944 #include <linux/smp.h>
6945+#include <asm/desc_defs.h>
6946
6947 #include <asm/segment.h>
6948 #include <asm/mmu.h>
6949
6950-// 8 byte segment descriptor
6951-struct desc_struct {
6952- u16 limit0;
6953- u16 base0;
6954- unsigned base1 : 8, type : 4, s : 1, dpl : 2, p : 1;
6955- unsigned limit : 4, avl : 1, l : 1, d : 1, g : 1, base2 : 8;
6956-} __attribute__((packed));
6957-
6958-struct n_desc_struct {
6959- unsigned int a,b;
6960-};
6961-
6962-enum {
6963- GATE_INTERRUPT = 0xE,
6964- GATE_TRAP = 0xF,
6965- GATE_CALL = 0xC,
6966-};
6967-
6968-// 16byte gate
6969-struct gate_struct {
6970- u16 offset_low;
6971- u16 segment;
6972- unsigned ist : 3, zero0 : 5, type : 5, dpl : 2, p : 1;
6973- u16 offset_middle;
6974- u32 offset_high;
6975- u32 zero1;
6976-} __attribute__((packed));
6977-
6978-#define PTR_LOW(x) ((unsigned long)(x) & 0xFFFF)
6979-#define PTR_MIDDLE(x) (((unsigned long)(x) >> 16) & 0xFFFF)
6980-#define PTR_HIGH(x) ((unsigned long)(x) >> 32)
6981-
6982-enum {
6983- DESC_TSS = 0x9,
6984- DESC_LDT = 0x2,
6985-};
6986-
6987-// LDT or TSS descriptor in the GDT. 16 bytes.
6988-struct ldttss_desc {
6989- u16 limit0;
6990- u16 base0;
6991- unsigned base1 : 8, type : 5, dpl : 2, p : 1;
6992- unsigned limit1 : 4, zero0 : 3, g : 1, base2 : 8;
6993- u32 base3;
6994- u32 zero1;
6995-} __attribute__((packed));
6996-
6997-struct desc_ptr {
6998- unsigned short size;
6999- unsigned long address;
7000-} __attribute__((packed)) ;
7001-
7002 extern struct desc_ptr idt_descr, cpu_gdt_descr[NR_CPUS];
7003
7004 extern struct desc_struct cpu_gdt_table[GDT_ENTRIES];
7005--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/dma-mapping_64.h 2009-03-04 11:28:34.000000000 +0100
7006+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/dma-mapping_64.h 2008-12-15 11:26:44.000000000 +0100
7007@@ -64,6 +64,9 @@ static inline int dma_mapping_error(dma_
7008 return (dma_addr == bad_dma_address);
7009 }
7010
7011+#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
7012+#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
7013+
7014 extern void *dma_alloc_coherent(struct device *dev, size_t size,
7015 dma_addr_t *dma_handle, gfp_t gfp);
7016 extern void dma_free_coherent(struct device *dev, size_t size, void *vaddr,
7017@@ -181,12 +184,13 @@ static inline int dma_get_cache_alignmen
7018 return boot_cpu_data.x86_clflush_size;
7019 }
7020
7021-#define dma_is_consistent(h) 1
7022+#define dma_is_consistent(d, h) 1
7023
7024 extern int dma_set_mask(struct device *dev, u64 mask);
7025
7026 static inline void
7027-dma_cache_sync(void *vaddr, size_t size, enum dma_data_direction dir)
7028+dma_cache_sync(struct device *dev, void *vaddr, size_t size,
7029+ enum dma_data_direction dir)
7030 {
7031 flush_write_buffers();
7032 }
7033--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/pgtable_64.h 2009-03-04 11:28:34.000000000 +0100
7034+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/pgtable_64.h 2008-12-15 11:26:44.000000000 +0100
7035@@ -237,19 +237,18 @@ extern unsigned int __kernel_page_user;
7036
7037 static inline unsigned long pgd_bad(pgd_t pgd)
7038 {
7039- unsigned long val = __pgd_val(pgd);
7040- val &= ~PTE_MASK;
7041- val &= ~(_PAGE_USER | _PAGE_DIRTY);
7042- return val & ~(_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED);
7043+ return __pgd_val(pgd) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER);
7044 }
7045
7046-static inline unsigned long pud_bad(pud_t pud)
7047-{
7048- unsigned long val = __pud_val(pud);
7049- val &= ~PTE_MASK;
7050- val &= ~(_PAGE_USER | _PAGE_DIRTY);
7051- return val & ~(_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED);
7052-}
7053+static inline unsigned long pud_bad(pud_t pud)
7054+{
7055+ return __pud_val(pud) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER);
7056+}
7057+
7058+static inline unsigned long pmd_bad(pmd_t pmd)
7059+{
7060+ return __pmd_val(pmd) & ~(PTE_MASK | _KERNPG_TABLE | _PAGE_USER);
7061+}
7062
7063 #define set_pte_at(_mm,addr,ptep,pteval) do { \
7064 if (((_mm) != current->mm && (_mm) != &init_mm) || \
7065@@ -404,8 +403,6 @@ static inline int pmd_large(pmd_t pte) {
7066 #define pmd_present(x) (__pmd_val(x) & _PAGE_PRESENT)
7067 #endif
7068 #define pmd_clear(xp) do { set_pmd(xp, __pmd(0)); } while (0)
7069-#define pmd_bad(x) ((__pmd_val(x) & ~(PTE_MASK | _PAGE_USER | _PAGE_PRESENT)) \
7070- != (_KERNPG_TABLE & ~(_PAGE_USER | _PAGE_PRESENT)))
7071 #define pfn_pmd(nr,prot) (__pmd(((nr) << PAGE_SHIFT) | pgprot_val(prot)))
7072 #define pmd_pfn(x) ((pmd_val(x) & __PHYSICAL_MASK) >> PAGE_SHIFT)
7073
7074--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/processor_64.h 2009-03-04 11:28:34.000000000 +0100
7075+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/processor_64.h 2008-12-15 11:26:44.000000000 +0100
7076@@ -484,6 +484,14 @@ static inline void __mwait(unsigned long
7077 : :"a" (eax), "c" (ecx));
7078 }
7079
7080+static inline void __sti_mwait(unsigned long eax, unsigned long ecx)
7081+{
7082+ /* "mwait %eax,%ecx;" */
7083+ asm volatile(
7084+ "sti; .byte 0x0f,0x01,0xc9;"
7085+ : :"a" (eax), "c" (ecx));
7086+}
7087+
7088 extern void mwait_idle_with_hints(unsigned long eax, unsigned long ecx);
7089
7090 #define stack_current() \
7091--- sle11-2009-06-29.orig/include/asm-x86/mach-xen/asm/smp_64.h 2009-03-04 11:28:34.000000000 +0100
7092+++ sle11-2009-06-29/include/asm-x86/mach-xen/asm/smp_64.h 2008-12-15 11:26:44.000000000 +0100
7093@@ -88,11 +88,6 @@ extern u8 x86_cpu_to_log_apicid[NR_CPUS]
7094 extern u8 bios_cpu_apicid[];
7095
7096 #ifdef CONFIG_X86_LOCAL_APIC
7097-static inline unsigned int cpu_mask_to_apicid(cpumask_t cpumask)
7098-{
7099- return cpus_addr(cpumask)[0];
7100-}
7101-
7102 static inline int cpu_present_to_apicid(int mps_cpu)
7103 {
7104 if (mps_cpu < NR_CPUS)
7105@@ -127,13 +122,6 @@ static __inline int logical_smp_processo
7106 #define cpu_physical_id(cpu) x86_cpu_to_apicid[cpu]
7107 #else
7108 #define cpu_physical_id(cpu) boot_cpu_id
7109-static inline int smp_call_function_single(int cpuid, void (*func) (void *info),
7110- void *info, int retry, int wait)
7111-{
7112- /* Disable interrupts here? */
7113- func(info);
7114- return 0;
7115-}
7116 #endif /* !CONFIG_SMP */
7117 #endif
7118
7119--- sle11-2009-06-29.orig/kernel/kexec.c 2009-02-17 11:27:16.000000000 +0100
7120+++ sle11-2009-06-29/kernel/kexec.c 2009-02-17 11:34:22.000000000 +0100
7121@@ -374,7 +374,7 @@ static struct page *kimage_alloc_pages(g
7122 if (limit == ~0UL)
7123 address_bits = BITS_PER_LONG;
7124 else
7125- address_bits = long_log2(limit);
7126+ address_bits = ilog2(limit);
7127
7128 if (xen_limit_pages_to_max_mfn(pages, order, address_bits) < 0) {
7129 __free_pages(pages, order);
7130--- sle11-2009-06-29.orig/net/core/dev.c 2009-03-04 11:28:34.000000000 +0100
7131+++ sle11-2009-06-29/net/core/dev.c 2008-12-15 11:26:44.000000000 +0100
7132@@ -1751,10 +1751,10 @@ inline int skb_checksum_setup(struct sk_
7133 goto out;
7134 switch (skb->nh.iph->protocol) {
7135 case IPPROTO_TCP:
7136- skb->csum = offsetof(struct tcphdr, check);
7137+ skb->csum_offset = offsetof(struct tcphdr, check);
7138 break;
7139 case IPPROTO_UDP:
7140- skb->csum = offsetof(struct udphdr, check);
7141+ skb->csum_offset = offsetof(struct udphdr, check);
7142 break;
7143 default:
7144 if (net_ratelimit())
7145@@ -1763,7 +1763,7 @@ inline int skb_checksum_setup(struct sk_
7146 " %d packet", skb->nh.iph->protocol);
7147 goto out;
7148 }
7149- if ((skb->h.raw + skb->csum + 2) > skb->tail)
7150+ if ((skb->h.raw + skb->csum_offset + 2) > skb->tail)
7151 goto out;
7152 skb->ip_summed = CHECKSUM_PARTIAL;
7153 skb->proto_csum_blank = 0;
Peter's tree of IPFire 2.x