Merge branch 'packaging' into openSUSE-13.1
[opensuse:kernel-source.git] / patches.xen / xen3-patch-3.11
1 From: Linux Kernel Mailing List <linux-kernel@vger.kernel.org>
2 Subject: Linux: 3.11
3 Patch-mainline: 3.11
4
5  This patch contains the differences between 3.10 and 3.11.
6
7 Automatically created from "patch-3.11" by xen-port-patches.py
8 Acked-by: jbeulich@suse.com
9
10 --- head.orig/arch/arm64/Kconfig        2013-09-04 12:53:29.000000000 +0200
11 +++ head/arch/arm64/Kconfig     2013-08-12 14:01:44.000000000 +0200
12 @@ -204,9 +204,9 @@ source "mm/Kconfig"
13  
14  config XEN_DOM0
15         def_bool y
16 -       depends on XEN
17 +       depends on PARAVIRT_XEN
18  
19 -config XEN
20 +config PARAVIRT_XEN
21         bool "Xen guest support on ARM64 (EXPERIMENTAL)"
22         depends on ARM64 && OF
23         help
24 --- head.orig/arch/arm64/Makefile       2013-09-04 12:53:29.000000000 +0200
25 +++ head/arch/arm64/Makefile    2013-08-12 14:02:01.000000000 +0200
26 @@ -38,7 +38,7 @@ export        TEXT_OFFSET GZFLAGS
27  
28  core-y         += arch/arm64/kernel/ arch/arm64/mm/
29  core-$(CONFIG_KVM) += arch/arm64/kvm/
30 -core-$(CONFIG_XEN) += arch/arm64/xen/
31 +core-$(CONFIG_PARAVIRT_XEN) += arch/arm64/xen/
32  libs-y         := arch/arm64/lib/ $(libs-y)
33  libs-y         += $(LIBGCC)
34  
35 --- head.orig/arch/x86/Kconfig  2013-08-09 15:39:40.000000000 +0200
36 +++ head/arch/x86/Kconfig       2013-08-21 09:44:51.000000000 +0200
37 @@ -65,7 +65,7 @@ config X86
38         select HAVE_KERNEL_LZMA if !XEN
39         select HAVE_KERNEL_XZ if !XEN
40         select HAVE_KERNEL_LZO if !XEN
41 -       select HAVE_KERNEL_LZ4
42 +       select HAVE_KERNEL_LZ4 if !XEN
43         select HAVE_HW_BREAKPOINT
44         select HAVE_MIXED_BREAKPOINTS_REGS
45         select PERF_EVENTS
46 @@ -103,7 +103,7 @@ config X86
47         select HAVE_ARCH_SECCOMP_FILTER
48         select BUILDTIME_EXTABLE_SORT
49         select GENERIC_CMOS_UPDATE
50 -       select HAVE_ARCH_SOFT_DIRTY
51 +       select HAVE_ARCH_SOFT_DIRTY if !XEN
52         select CLOCKSOURCE_WATCHDOG if !XEN
53         select GENERIC_CLOCKEVENTS if !XEN
54         select ARCH_CLOCKSOURCE_DATA if X86_64
55 --- head.orig/arch/x86/include/mach-xen/asm/desc.h      2012-06-14 11:23:26.000000000 +0200
56 +++ head/arch/x86/include/mach-xen/asm/desc.h   2013-08-12 13:00:59.000000000 +0200
57 @@ -37,8 +37,8 @@ static inline void fill_ldt(struct desc_
58  #ifndef CONFIG_X86_NO_IDT
59  extern struct desc_ptr idt_descr;
60  extern gate_desc idt_table[];
61 -extern struct desc_ptr nmi_idt_descr;
62 -extern gate_desc nmi_idt_table[];
63 +extern struct desc_ptr debug_idt_descr;
64 +extern gate_desc debug_idt_table[];
65  #endif
66  
67  struct gdt_page {
68 @@ -341,7 +341,20 @@ static inline void set_nmi_gate(int gate
69         gate_desc s;
70  
71         pack_gate(&s, GATE_INTERRUPT, (unsigned long)addr, 0, 0, __KERNEL_CS);
72 -       write_idt_entry(nmi_idt_table, gate, &s);
73 +       write_idt_entry(debug_idt_table, gate, &s);
74 +}
75 +#endif
76 +
77 +#ifdef CONFIG_TRACING
78 +extern struct desc_ptr trace_idt_descr;
79 +extern gate_desc trace_idt_table[];
80 +static inline void write_trace_idt_entry(int entry, const gate_desc *gate)
81 +{
82 +       write_idt_entry(trace_idt_table, entry, gate);
83 +}
84 +#else
85 +static inline void write_trace_idt_entry(int entry, const gate_desc *gate)
86 +{
87  }
88  #endif
89  
90 @@ -356,6 +369,7 @@ static inline void _set_gate(int gate, u
91          * setup time
92          */
93         write_idt_entry(idt_table, gate, &s);
94 +       write_trace_idt_entry(gate, &s);
95  }
96  
97  /*
98 @@ -385,12 +399,39 @@ static inline void alloc_system_vector(i
99         }
100  }
101  
102 -static inline void alloc_intr_gate(unsigned int n, void *addr)
103 +#ifdef CONFIG_TRACING
104 +static inline void trace_set_intr_gate(unsigned int gate, void *addr)
105 +{
106 +       gate_desc s;
107 +
108 +       pack_gate(&s, GATE_INTERRUPT, (unsigned long)addr, 0, 0, __KERNEL_CS);
109 +       write_idt_entry(trace_idt_table, gate, &s);
110 +}
111 +
112 +static inline void __trace_alloc_intr_gate(unsigned int n, void *addr)
113 +{
114 +       trace_set_intr_gate(n, addr);
115 +}
116 +#else
117 +static inline void trace_set_intr_gate(unsigned int gate, void *addr)
118 +{
119 +}
120 +
121 +#define __trace_alloc_intr_gate(n, addr)
122 +#endif
123 +
124 +static inline void __alloc_intr_gate(unsigned int n, void *addr)
125  {
126 -       alloc_system_vector(n);
127         set_intr_gate(n, addr);
128  }
129  
130 +#define alloc_intr_gate(n, addr)                               \
131 +       do {                                                    \
132 +               alloc_system_vector(n);                         \
133 +               __alloc_intr_gate(n, addr);                     \
134 +               __trace_alloc_intr_gate(n, trace_##addr);       \
135 +       } while (0)
136 +
137  /*
138   * This routine sets up an interrupt gate at directory privilege level 3.
139   */
140 @@ -429,6 +470,73 @@ static inline void set_system_intr_gate_
141         BUG_ON((unsigned)n > 0xFF);
142         _set_gate(n, GATE_INTERRUPT, addr, 0x3, ist, __KERNEL_CS);
143  }
144 +
145 +#ifdef CONFIG_X86_64
146 +DECLARE_PER_CPU(u32, debug_idt_ctr);
147 +static inline bool is_debug_idt_enabled(void)
148 +{
149 +       if (this_cpu_read(debug_idt_ctr))
150 +               return true;
151 +
152 +       return false;
153 +}
154 +
155 +static inline void load_debug_idt(void)
156 +{
157 +       load_idt((const struct desc_ptr *)&debug_idt_descr);
158 +}
159 +#else
160 +static inline bool is_debug_idt_enabled(void)
161 +{
162 +       return false;
163 +}
164 +
165 +static inline void load_debug_idt(void)
166 +{
167 +}
168 +#endif
169 +
170 +#ifdef CONFIG_TRACING
171 +extern atomic_t trace_idt_ctr;
172 +static inline bool is_trace_idt_enabled(void)
173 +{
174 +       if (atomic_read(&trace_idt_ctr))
175 +               return true;
176 +
177 +       return false;
178 +}
179 +
180 +static inline void load_trace_idt(void)
181 +{
182 +       load_idt((const struct desc_ptr *)&trace_idt_descr);
183 +}
184 +#else
185 +static inline bool is_trace_idt_enabled(void)
186 +{
187 +       return false;
188 +}
189 +
190 +static inline void load_trace_idt(void)
191 +{
192 +}
193 +#endif
194 +
195 +/*
196 + * The load_current_idt() must be called with interrupts disabled
197 + * to avoid races. That way the IDT will always be set back to the expected
198 + * descriptor. It's also called when a CPU is being initialized, and
199 + * that doesn't need to disable interrupts, as nothing should be
200 + * bothering the CPU then.
201 + */
202 +static inline void load_current_idt(void)
203 +{
204 +       if (is_debug_idt_enabled())
205 +               load_debug_idt();
206 +       else if (is_trace_idt_enabled())
207 +               load_trace_idt();
208 +       else
209 +               load_idt((const struct desc_ptr *)&idt_descr);
210 +}
211  #endif
212  
213  #endif /* _ASM_X86_DESC_H */
214 --- head.orig/arch/x86/include/mach-xen/asm/fixmap.h    2013-05-24 11:49:51.000000000 +0200
215 +++ head/arch/x86/include/mach-xen/asm/fixmap.h 2013-08-12 13:00:59.000000000 +0200
216 @@ -81,11 +81,11 @@ enum fixed_addresses {
217                             + ((VSYSCALL_END-VSYSCALL_START) >> PAGE_SHIFT) - 1,
218         VVAR_PAGE,
219         VSYSCALL_HPET,
220 -#endif
221  #ifdef CONFIG_PARAVIRT_CLOCK
222         PVCLOCK_FIXMAP_BEGIN,
223         PVCLOCK_FIXMAP_END = PVCLOCK_FIXMAP_BEGIN+PVCLOCK_VSYSCALL_NR_PAGES-1,
224  #endif
225 +#endif
226         FIX_DBGP_BASE,
227         FIX_EARLYCON_MEM_BASE,
228  #ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
229 --- head.orig/arch/x86/include/mach-xen/asm/fpu-internal.h      2012-11-15 14:56:34.000000000 +0100
230 +++ head/arch/x86/include/mach-xen/asm/fpu-internal.h   2013-08-12 13:00:59.000000000 +0200
231 @@ -9,7 +9,7 @@ static inline bool xen_thread_fpu_begin(
232  {
233         bool ret = false;
234  
235 -       if (mcl && !use_eager_fpu()) {
236 +       if (mcl && !static_cpu_has_safe(X86_FEATURE_EAGER_FPU)) {
237                 mcl->op = __HYPERVISOR_fpu_taskswitch;
238                 mcl->args[0] = 0;
239                 ret = true;
240 --- head.orig/arch/x86/include/mach-xen/asm/io.h        2011-07-01 15:19:34.000000000 +0200
241 +++ head/arch/x86/include/mach-xen/asm/io.h     2013-08-12 13:00:59.000000000 +0200
242 @@ -340,4 +340,11 @@ extern bool is_early_ioremap_ptep(pte_t 
243  
244  #define IO_SPACE_LIMIT 0xffff
245  
246 +#ifdef CONFIG_MTRR
247 +extern int __must_check arch_phys_wc_add(unsigned long base,
248 +                                        unsigned long size);
249 +extern void arch_phys_wc_del(int handle);
250 +#define arch_phys_wc_add arch_phys_wc_add
251 +#endif
252 +
253  #endif /* _ASM_X86_IO_H */
254 --- head.orig/arch/x86/include/mach-xen/asm/pgtable.h   2013-03-25 09:13:57.000000000 +0100
255 +++ head/arch/x86/include/mach-xen/asm/pgtable.h        2013-08-21 09:43:15.000000000 +0200
256 @@ -201,7 +201,7 @@ static inline pte_t pte_mkexec(pte_t pte
257  
258  static inline pte_t pte_mkdirty(pte_t pte)
259  {
260 -       return pte_set_flags(pte, _PAGE_DIRTY);
261 +       return pte_set_flags(pte, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
262  }
263  
264  static inline pte_t pte_mkyoung(pte_t pte)
265 @@ -266,7 +266,7 @@ static inline pmd_t pmd_wrprotect(pmd_t 
266  
267  static inline pmd_t pmd_mkdirty(pmd_t pmd)
268  {
269 -       return pmd_set_flags(pmd, _PAGE_DIRTY);
270 +       return pmd_set_flags(pmd, _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
271  }
272  
273  static inline pmd_t pmd_mkhuge(pmd_t pmd)
274 @@ -290,6 +290,60 @@ static inline pmd_t pmd_mknotpresent(pmd
275  }
276  #endif
277  
278 +#ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY
279 +static inline int pte_soft_dirty(pte_t pte)
280 +{
281 +       return pte_flags(pte) & _PAGE_SOFT_DIRTY;
282 +}
283 +
284 +static inline int pmd_soft_dirty(pmd_t pmd)
285 +{
286 +       return pmd_flags(pmd) & _PAGE_SOFT_DIRTY;
287 +}
288 +
289 +static inline pte_t pte_mksoft_dirty(pte_t pte)
290 +{
291 +       return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
292 +}
293 +
294 +#ifdef CONFIG_TRANSPARENT_HUGEPAGE
295 +static inline pmd_t pmd_mksoft_dirty(pmd_t pmd)
296 +{
297 +       return pmd_set_flags(pmd, _PAGE_SOFT_DIRTY);
298 +}
299 +#endif
300 +
301 +static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
302 +{
303 +       return pte_set_flags(pte, _PAGE_SWP_SOFT_DIRTY);
304 +}
305 +
306 +static inline int pte_swp_soft_dirty(pte_t pte)
307 +{
308 +       return pte_flags(pte) & _PAGE_SWP_SOFT_DIRTY;
309 +}
310 +
311 +static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
312 +{
313 +       return pte_clear_flags(pte, _PAGE_SWP_SOFT_DIRTY);
314 +}
315 +
316 +static inline pte_t pte_file_clear_soft_dirty(pte_t pte)
317 +{
318 +       return pte_clear_flags(pte, _PAGE_SOFT_DIRTY);
319 +}
320 +
321 +static inline pte_t pte_file_mksoft_dirty(pte_t pte)
322 +{
323 +       return pte_set_flags(pte, _PAGE_SOFT_DIRTY);
324 +}
325 +
326 +static inline int pte_file_soft_dirty(pte_t pte)
327 +{
328 +       return pte_flags(pte) & _PAGE_SOFT_DIRTY;
329 +}
330 +#endif
331 +
332  /*
333   * Mask out unsupported bits in a present pgprot.  Non-present pgprots
334   * can use those bits for other purposes, so leave them be.
335 --- head.orig/arch/x86/include/mach-xen/asm/pgtable-3level.h    2012-08-20 14:37:06.000000000 +0200
336 +++ head/arch/x86/include/mach-xen/asm/pgtable-3level.h 2013-08-21 09:43:15.000000000 +0200
337 @@ -178,6 +178,9 @@ static inline pmd_t xen_pmdp_get_and_cle
338  /*
339   * Bits 0, 6 and 7 are taken in the low part of the pte,
340   * put the 32 bits of offset into the high part.
341 + *
342 + * For soft-dirty tracking bit 11 is taken from
343 + * the low part of pte as well.
344   */
345  #define pte_to_pgoff(pte) ((pte).pte_high)
346  #define pgoff_to_pte(off)                                              \
347 --- head.orig/arch/x86/include/mach-xen/asm/pgtable_types.h     2013-05-24 11:49:51.000000000 +0200
348 +++ head/arch/x86/include/mach-xen/asm/pgtable_types.h  2013-08-21 09:43:15.000000000 +0200
349 @@ -55,6 +55,33 @@
350  #define _PAGE_HIDDEN   (_AT(pteval_t, 0))
351  #endif
352  
353 +/*
354 + * The same hidden bit is used by kmemcheck, but since kmemcheck
355 + * works on kernel pages while soft-dirty engine on user space,
356 + * they do not conflict with each other.
357 + */
358 +
359 +#define _PAGE_BIT_SOFT_DIRTY   _PAGE_BIT_HIDDEN
360 +
361 +#ifdef CONFIG_MEM_SOFT_DIRTY
362 +#define _PAGE_SOFT_DIRTY       (_AT(pteval_t, 1) << _PAGE_BIT_SOFT_DIRTY)
363 +#else
364 +#define _PAGE_SOFT_DIRTY       (_AT(pteval_t, 0))
365 +#endif
366 +
367 +/*
368 + * Tracking soft dirty bit when a page goes to a swap is tricky.
369 + * We need a bit which can be stored in pte _and_ not conflict
370 + * with swap entry format. On x86 bits 6 and 7 are *not* involved
371 + * into swap entry computation, but bit 6 is used for nonlinear
372 + * file mapping, so we borrow bit 7 for soft dirty tracking.
373 + */
374 +#ifdef CONFIG_MEM_SOFT_DIRTY
375 +#define _PAGE_SWP_SOFT_DIRTY   _PAGE_PSE
376 +#else
377 +#define _PAGE_SWP_SOFT_DIRTY   (_AT(pteval_t, 0))
378 +#endif
379 +
380  #if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
381  #define _PAGE_NX       (_AT(pteval_t, 1) << _PAGE_BIT_NX)
382  #else
383 --- head.orig/arch/x86/include/mach-xen/asm/processor.h 2013-05-24 11:49:51.000000000 +0200
384 +++ head/arch/x86/include/mach-xen/asm/processor.h      2013-08-12 13:00:59.000000000 +0200
385 @@ -91,10 +91,10 @@ struct cpuinfo_x86 {
386         char                    wp_works_ok;    /* It doesn't on 386's */
387  
388         /* Problems on some 486Dx4's and old 386's: */
389 -       char                    hard_math;
390  #ifndef CONFIG_XEN
391         char                    rfu;
392         char                    pad0;
393 +       char                    pad1;
394  #endif
395  #else
396         /* Number of 4K pages in DTLB/ITLB combined(in pages): */
397 @@ -175,6 +175,7 @@ extern const struct seq_operations cpuin
398  #define cache_line_size()      (boot_cpu_data.x86_cache_alignment)
399  
400  extern void cpu_detect(struct cpuinfo_x86 *c);
401 +extern void fpu_detect(struct cpuinfo_x86 *c);
402  
403  extern void early_cpu_init(void);
404  extern void identify_boot_cpu(void);
405 @@ -980,5 +981,5 @@ bool xen_set_default_idle(void);
406  #endif
407  
408  void stop_this_cpu(void *dummy);
409 -
410 +void df_debug(struct pt_regs *regs, long error_code);
411  #endif /* _ASM_X86_PROCESSOR_H */
412 --- head.orig/arch/x86/include/mach-xen/asm/smp.h       2013-01-09 15:32:33.000000000 +0100
413 +++ head/arch/x86/include/mach-xen/asm/smp.h    2013-08-12 13:00:59.000000000 +0200
414 @@ -205,7 +205,7 @@ static inline int wbinvd_on_all_cpus(voi
415  int wbinvd_on_all_cpus(void);
416  #endif
417  
418 -extern unsigned disabled_cpus __cpuinitdata;
419 +extern unsigned disabled_cpus;
420  
421  #include <asm/smp-processor-id.h>
422  
423 --- head.orig/arch/x86/include/mach-xen/asm/special_insns.h     2012-07-05 12:31:42.000000000 +0200
424 +++ head/arch/x86/include/mach-xen/asm/special_insns.h  2013-08-12 13:00:59.000000000 +0200
425 @@ -55,7 +55,7 @@ static inline void xen_stts(void)
426   * all loads stores around it, which can hurt performance. Solution is to
427   * use a variable and mimic reads and writes to it to enforce serialization
428   */
429 -#define __force_order machine_to_phys_nr
430 +extern unsigned long __force_order;
431  
432  static inline unsigned long native_read_cr0(void)
433  {
434 --- head.orig/arch/x86/include/mach-xen/asm/spinlock.h  2012-09-05 15:48:38.000000000 +0200
435 +++ head/arch/x86/include/mach-xen/asm/spinlock.h       2013-08-21 09:43:15.000000000 +0200
436 @@ -349,8 +349,4 @@ static inline void arch_write_unlock(arc
437  #define arch_read_relax(lock)  cpu_relax()
438  #define arch_write_relax(lock) cpu_relax()
439  
440 -/* The {read|write|spin}_lock() on x86 are full memory barriers. */
441 -static inline void smp_mb__after_lock(void) { }
442 -#define ARCH_HAS_SMP_MB_AFTER_LOCK
443 -
444  #endif /* _ASM_X86_SPINLOCK_H */
445 --- head.orig/arch/x86/include/mach-xen/asm/time.h      2011-07-11 12:25:07.000000000 +0200
446 +++ head/arch/x86/include/mach-xen/asm/time.h   2013-08-14 08:45:49.000000000 +0200
447 @@ -1,10 +1,10 @@
448  #ifndef _XEN_ASM_TIME_H
449  #define _XEN_ASM_TIME_H
450  
451 -unsigned long xen_read_wallclock(void);
452 -int xen_write_wallclock(unsigned long);
453 -
454  struct timespec;
455 +void xen_read_wallclock(struct timespec *);
456 +int xen_write_wallclock(const struct timespec *);
457 +
458  #ifdef CONFIG_XEN_PRIVILEGED_GUEST
459  int xen_update_wallclock(const struct timespec *);
460  #else
461 --- head.orig/arch/x86/kernel/Makefile  2013-08-09 15:21:24.000000000 +0200
462 +++ head/arch/x86/kernel/Makefile       2013-08-14 09:30:14.000000000 +0200
463 @@ -122,5 +122,6 @@ ifeq ($(CONFIG_X86_64),y)
464  endif
465  
466  disabled-obj-$(CONFIG_XEN) := crash.o early-quirks.o i8237.o i8253.o i8259.o \
467 -       irqinit.o pci-swiotlb.o reboot.o smpboot.o trampoline%.o tsc%.o vsmp%.o
468 +       irqinit.o pci-swiotlb.o reboot.o smpboot.o tracepoint.o trampoline%.o \
469 +       tsc%.o vsmp%.o
470  disabled-obj-$(CONFIG_XEN_UNPRIVILEGED_GUEST) += probe_roms.o
471 --- head.orig/arch/x86/kernel/acpi/boot.c       2013-08-09 15:11:34.000000000 +0200
472 +++ head/arch/x86/kernel/acpi/boot.c    2013-08-14 16:15:00.000000000 +0200
473 @@ -569,7 +569,7 @@ static int acpi_register_gsi_ioapic(stru
474  int (*__acpi_register_gsi)(struct device *dev, u32 gsi,
475                            int trigger, int polarity) = acpi_register_gsi_pic;
476  
477 -#ifdef CONFIG_ACPI_SLEEP
478 +#if defined(CONFIG_ACPI_SLEEP) && !defined(CONFIG_ACPI_PV_SLEEP)
479  int (*acpi_suspend_lowlevel)(void) = x86_acpi_suspend_lowlevel;
480  #else
481  int (*acpi_suspend_lowlevel)(void);
482 --- head.orig/arch/x86/kernel/acpi/processor_extcntl_xen.c      2012-10-31 08:25:00.000000000 +0100
483 +++ head/arch/x86/kernel/acpi/processor_extcntl_xen.c   2013-08-14 15:15:50.000000000 +0200
484 @@ -211,11 +211,18 @@ static int xen_sleep(u8 sleep_state, u32
485         return -1;
486  }
487  
488 +static int xen_acpi_suspend_lowlevel(void)
489 +{
490 +       acpi_enter_sleep_state(ACPI_STATE_S3);
491 +       return 0;
492 +}
493 +
494  static int __init init_extcntl(void)
495  {
496         unsigned int pmbits = (xen_start_info->flags & SIF_PM_MASK) >> 8;
497  
498         acpi_os_set_prepare_sleep(xen_sleep);
499 +       acpi_suspend_lowlevel = xen_acpi_suspend_lowlevel;
500  
501         if (!pmbits)
502                 return 0;
503 --- head.orig/arch/x86/kernel/cpu/common-xen.c  2013-05-24 11:49:51.000000000 +0200
504 +++ head/arch/x86/kernel/cpu/common-xen.c       2013-08-12 13:23:15.000000000 +0200
505 @@ -71,7 +71,7 @@ void __init setup_cpu_local_masks(void)
506  #endif
507  }
508  
509 -static void __cpuinit default_init(struct cpuinfo_x86 *c)
510 +static void default_init(struct cpuinfo_x86 *c)
511  {
512  #ifdef CONFIG_X86_64
513         cpu_detect_cache_sizes(c);
514 @@ -88,13 +88,13 @@ static void __cpuinit default_init(struc
515  #endif
516  }
517  
518 -static const struct cpu_dev __cpuinitconst default_cpu = {
519 +static const struct cpu_dev default_cpu = {
520         .c_init         = default_init,
521         .c_vendor       = "Unknown",
522         .c_x86_vendor   = X86_VENDOR_UNKNOWN,
523  };
524  
525 -static const struct cpu_dev *this_cpu __cpuinitdata = &default_cpu;
526 +static const struct cpu_dev *this_cpu = &default_cpu;
527  
528  DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
529  #ifdef CONFIG_X86_64
530 @@ -177,7 +177,7 @@ static int __init x86_xsaveopt_setup(cha
531  __setup("noxsaveopt", x86_xsaveopt_setup);
532  
533  #ifdef CONFIG_X86_32
534 -static int cachesize_override __cpuinitdata = -1;
535 +static int cachesize_override = -1;
536  
537  static int __init cachesize_setup(char *str)
538  {
539 @@ -233,14 +233,14 @@ static inline int flag_is_changeable_p(u
540  }
541  
542  /* Probe for the CPUID instruction */
543 -int __cpuinit have_cpuid_p(void)
544 +int have_cpuid_p(void)
545  {
546         return flag_is_changeable_p(X86_EFLAGS_ID);
547  }
548  
549 -static int disable_x86_serial_nr __cpuinitdata = 1;
550 +static int disable_x86_serial_nr = 1;
551  
552 -static void __cpuinit squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
553 +static void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
554  {
555         unsigned long lo, hi;
556  
557 @@ -318,7 +318,7 @@ struct cpuid_dependent_feature {
558         u32 level;
559  };
560  
561 -static const struct cpuid_dependent_feature __cpuinitconst
562 +static const struct cpuid_dependent_feature
563  cpuid_dependent_features[] = {
564         { X86_FEATURE_MWAIT,            0x00000005 },
565         { X86_FEATURE_DCA,              0x00000009 },
566 @@ -326,7 +326,7 @@ cpuid_dependent_features[] = {
567         { 0, 0 }
568  };
569  
570 -static void __cpuinit filter_cpuid_features(struct cpuinfo_x86 *c, bool warn)
571 +static void filter_cpuid_features(struct cpuinfo_x86 *c, bool warn)
572  {
573         const struct cpuid_dependent_feature *df;
574  
575 @@ -364,7 +364,7 @@ static void __cpuinit filter_cpuid_featu
576   */
577  
578  /* Look up CPU names by table lookup. */
579 -static const char *__cpuinit table_lookup_model(struct cpuinfo_x86 *c)
580 +static const char *table_lookup_model(struct cpuinfo_x86 *c)
581  {
582         const struct cpu_model_info *info;
583  
584 @@ -384,8 +384,8 @@ static const char *__cpuinit table_looku
585         return NULL;            /* Not found */
586  }
587  
588 -__u32 cpu_caps_cleared[NCAPINTS] __cpuinitdata;
589 -__u32 cpu_caps_set[NCAPINTS] __cpuinitdata;
590 +__u32 cpu_caps_cleared[NCAPINTS];
591 +__u32 cpu_caps_set[NCAPINTS];
592  
593  void load_percpu_segment(int cpu)
594  {
595 @@ -436,9 +436,9 @@ void switch_to_new_gdt(int cpu)
596         load_percpu_segment(cpu);
597  }
598  
599 -static const struct cpu_dev *__cpuinitdata cpu_devs[X86_VENDOR_NUM] = {};
600 +static const struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};
601  
602 -static void __cpuinit get_model_name(struct cpuinfo_x86 *c)
603 +static void get_model_name(struct cpuinfo_x86 *c)
604  {
605         unsigned int *v;
606         char *p, *q;
607 @@ -467,7 +467,7 @@ static void __cpuinit get_model_name(str
608         }
609  }
610  
611 -void __cpuinit cpu_detect_cache_sizes(struct cpuinfo_x86 *c)
612 +void cpu_detect_cache_sizes(struct cpuinfo_x86 *c)
613  {
614         unsigned int n, dummy, ebx, ecx, edx, l2size;
615  
616 @@ -521,7 +521,7 @@ u16 __read_mostly tlb_lld_4m[NR_INFO];
617   */
618  s8  __read_mostly tlb_flushall_shift = -1;
619  
620 -void __cpuinit cpu_detect_tlb(struct cpuinfo_x86 *c)
621 +void cpu_detect_tlb(struct cpuinfo_x86 *c)
622  {
623         if (this_cpu->c_detect_tlb)
624                 this_cpu->c_detect_tlb(c);
625 @@ -535,7 +535,7 @@ void __cpuinit cpu_detect_tlb(struct cpu
626                 tlb_flushall_shift);
627  }
628  
629 -void __cpuinit detect_ht(struct cpuinfo_x86 *c)
630 +void detect_ht(struct cpuinfo_x86 *c)
631  {
632  #ifdef CONFIG_X86_HT
633         u32 eax, ebx, ecx, edx;
634 @@ -586,7 +586,7 @@ out:
635  #endif
636  }
637  
638 -static void __cpuinit get_cpu_vendor(struct cpuinfo_x86 *c)
639 +static void get_cpu_vendor(struct cpuinfo_x86 *c)
640  {
641         char *v = c->x86_vendor_id;
642         int i;
643 @@ -613,7 +613,7 @@ static void __cpuinit get_cpu_vendor(str
644         this_cpu = &default_cpu;
645  }
646  
647 -void __cpuinit cpu_detect(struct cpuinfo_x86 *c)
648 +void cpu_detect(struct cpuinfo_x86 *c)
649  {
650         /* Get vendor name */
651         cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
652 @@ -643,7 +643,7 @@ void __cpuinit cpu_detect(struct cpuinfo
653         }
654  }
655  
656 -void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c)
657 +void get_cpu_cap(struct cpuinfo_x86 *c)
658  {
659         u32 tfms, xlvl;
660         u32 ebx;
661 @@ -697,7 +697,7 @@ void __cpuinit get_cpu_cap(struct cpuinf
662         init_scattered_cpuid_features(c);
663  }
664  
665 -static void __cpuinit identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
666 +static void identify_cpu_without_cpuid(struct cpuinfo_x86 *c)
667  {
668  #ifdef CONFIG_X86_32
669         int i;
670 @@ -756,10 +756,9 @@ static void __init early_identify_cpu(st
671                 return;
672  
673         cpu_detect(c);
674 -
675         get_cpu_vendor(c);
676 -
677         get_cpu_cap(c);
678 +       fpu_detect(c);
679  #ifdef CONFIG_XEN
680         if (!cpu_has_xsave)
681                 x86_xsave_setup(NULL);
682 @@ -773,6 +772,8 @@ static void __init early_identify_cpu(st
683  
684         if (this_cpu->c_bsp_init)
685                 this_cpu->c_bsp_init(c);
686 +
687 +       setup_force_cpu_cap(X86_FEATURE_ALWAYS);
688  }
689  
690  void __init early_cpu_init(void)
691 @@ -817,7 +818,7 @@ void __init early_cpu_init(void)
692   * unless we can find a reliable way to detect all the broken cases.
693   * Enable it explicitly on 64-bit for non-constant inputs of cpu_has().
694   */
695 -static void __cpuinit detect_nopl(struct cpuinfo_x86 *c)
696 +static void detect_nopl(struct cpuinfo_x86 *c)
697  {
698  #ifdef CONFIG_X86_32
699         clear_cpu_cap(c, X86_FEATURE_NOPL);
700 @@ -826,7 +827,7 @@ static void __cpuinit detect_nopl(struct
701  #endif
702  }
703  
704 -static void __cpuinit generic_identify(struct cpuinfo_x86 *c)
705 +static void generic_identify(struct cpuinfo_x86 *c)
706  {
707         c->extended_cpuid_level = 0;
708  
709 @@ -865,7 +866,7 @@ static void __cpuinit generic_identify(s
710  /*
711   * This does the hard work of actually picking apart the CPU stuff...
712   */
713 -static void __cpuinit identify_cpu(struct cpuinfo_x86 *c)
714 +static void identify_cpu(struct cpuinfo_x86 *c)
715  {
716         int i;
717  
718 @@ -1018,7 +1019,7 @@ void __init identify_boot_cpu(void)
719  void set_perf_event_pending(void) {}
720  #endif
721  
722 -void __cpuinit identify_secondary_cpu(struct cpuinfo_x86 *c)
723 +void identify_secondary_cpu(struct cpuinfo_x86 *c)
724  {
725         BUG_ON(c == &boot_cpu_data);
726         identify_cpu(c);
727 @@ -1033,14 +1034,14 @@ struct msr_range {
728         unsigned        max;
729  };
730  
731 -static const struct msr_range msr_range_array[] __cpuinitconst = {
732 +static const struct msr_range msr_range_array[] = {
733         { 0x00000000, 0x00000418},
734         { 0xc0000000, 0xc000040b},
735         { 0xc0010000, 0xc0010142},
736         { 0xc0011000, 0xc001103b},
737  };
738  
739 -static void __cpuinit __print_cpu_msr(void)
740 +static void __print_cpu_msr(void)
741  {
742         unsigned index_min, index_max;
743         unsigned index;
744 @@ -1059,7 +1060,7 @@ static void __cpuinit __print_cpu_msr(vo
745         }
746  }
747  
748 -static int show_msr __cpuinitdata;
749 +static int show_msr;
750  
751  static __init int setup_show_msr(char *arg)
752  {
753 @@ -1080,7 +1081,7 @@ static __init int setup_noclflush(char *
754  }
755  __setup("noclflush", setup_noclflush);
756  
757 -void __cpuinit print_cpu_info(struct cpuinfo_x86 *c)
758 +void print_cpu_info(struct cpuinfo_x86 *c)
759  {
760         const char *vendor = NULL;
761  
762 @@ -1109,7 +1110,7 @@ void __cpuinit print_cpu_info(struct cpu
763         print_cpu_msr(c);
764  }
765  
766 -void __cpuinit print_cpu_msr(struct cpuinfo_x86 *c)
767 +void print_cpu_msr(struct cpuinfo_x86 *c)
768  {
769         if (c->cpu_index < show_msr)
770                 __print_cpu_msr();
771 @@ -1131,8 +1132,8 @@ __setup("clearcpuid=", setup_disablecpui
772  #ifdef CONFIG_X86_64
773  #ifndef CONFIG_X86_NO_IDT
774  struct desc_ptr idt_descr = { NR_VECTORS * 16 - 1, (unsigned long) idt_table };
775 -struct desc_ptr nmi_idt_descr = { NR_VECTORS * 16 - 1,
776 -                                   (unsigned long) nmi_idt_table };
777 +struct desc_ptr debug_idt_descr = { NR_VECTORS * 16 - 1,
778 +                                   (unsigned long) debug_idt_table };
779  #endif
780  
781  DEFINE_PER_CPU_FIRST(union irq_stack_union,
782 @@ -1181,7 +1182,7 @@ static DEFINE_PER_CPU_PAGE_ALIGNED(char,
783         [(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ]);
784  #endif
785  
786 -void __cpuinit syscall_init(void)
787 +void syscall_init(void)
788  {
789  #ifndef CONFIG_XEN
790         /*
791 @@ -1236,20 +1237,20 @@ int is_debug_stack(unsigned long addr)
792                  addr > (__get_cpu_var(debug_stack_addr) - DEBUG_STKSZ));
793  }
794  
795 -static DEFINE_PER_CPU(u32, debug_stack_use_ctr);
796 +DEFINE_PER_CPU(u32, debug_idt_ctr);
797  
798  void debug_stack_set_zero(void)
799  {
800 -       this_cpu_inc(debug_stack_use_ctr);
801 -       load_idt((const struct desc_ptr *)&nmi_idt_descr);
802 +       this_cpu_inc(debug_idt_ctr);
803 +       load_current_idt();
804  }
805  
806  void debug_stack_reset(void)
807  {
808 -       if (WARN_ON(!this_cpu_read(debug_stack_use_ctr)))
809 +       if (WARN_ON(!this_cpu_read(debug_idt_ctr)))
810                 return;
811 -       if (this_cpu_dec_return(debug_stack_use_ctr) == 0)
812 -               load_idt((const struct desc_ptr *)&idt_descr);
813 +       if (this_cpu_dec_return(debug_idt_ctr) == 0)
814 +               load_current_idt();
815  }
816  #endif
817  
818 @@ -1304,7 +1305,7 @@ static void dbg_restore_debug_regs(void)
819   */
820  #ifdef CONFIG_X86_64
821  
822 -void __cpuinit cpu_init(void)
823 +void cpu_init(void)
824  {
825  #ifndef CONFIG_X86_NO_TSS
826         struct orig_ist *oist;
827 @@ -1354,7 +1355,7 @@ void __cpuinit cpu_init(void)
828         loadsegment(fs, 0);
829  
830  #ifndef CONFIG_X86_NO_IDT
831 -       load_idt((const struct desc_ptr *)&idt_descr);
832 +       load_current_idt();
833  #endif
834  
835         memset(me->thread.tls_array, 0, GDT_ENTRY_TLS_ENTRIES * 8);
836 @@ -1422,7 +1423,7 @@ void __cpuinit cpu_init(void)
837  
838  #else
839  
840 -void __cpuinit cpu_init(void)
841 +void cpu_init(void)
842  {
843         int cpu = smp_processor_id();
844         struct task_struct *curr = current;
845 @@ -1473,3 +1474,17 @@ void __cpuinit cpu_init(void)
846         fpu_init();
847  }
848  #endif
849 +
850 +#ifdef CONFIG_X86_DEBUG_STATIC_CPU_HAS
851 +void warn_pre_alternatives(void)
852 +{
853 +       WARN(1, "You're using static_cpu_has before alternatives have run!\n");
854 +}
855 +EXPORT_SYMBOL_GPL(warn_pre_alternatives);
856 +#endif
857 +
858 +inline bool __static_cpu_has_safe(u16 bit)
859 +{
860 +       return boot_cpu_has(bit);
861 +}
862 +EXPORT_SYMBOL_GPL(__static_cpu_has_safe);
863 --- head.orig/arch/x86/kernel/cpu/mtrr/main-xen.c       2011-02-01 15:03:03.000000000 +0100
864 +++ head/arch/x86/kernel/cpu/mtrr/main-xen.c    2013-08-12 13:00:59.000000000 +0200
865 @@ -6,8 +6,12 @@
866  #include <linux/init.h>
867  
868  #include <asm/mtrr.h>
869 +#include <asm/pat.h>
870  #include "mtrr.h"
871  
872 +/* arch_phys_wc_add returns an MTRR register index plus this offset. */
873 +#define MTRR_TO_PHYS_WC_OFFSET 1000
874 +
875  static DEFINE_MUTEX(mtrr_mutex);
876  
877  void generic_get_mtrr(unsigned int reg, unsigned long *base,
878 @@ -158,6 +162,73 @@ int mtrr_del(int reg, unsigned long base
879  }
880  EXPORT_SYMBOL(mtrr_del);
881  
882 +/**
883 + * arch_phys_wc_add - add a WC MTRR and handle errors if PAT is unavailable
884 + * @base: Physical base address
885 + * @size: Size of region
886 + *
887 + * If PAT is available, this does nothing.  If PAT is unavailable, it
888 + * attempts to add a WC MTRR covering size bytes starting at base and
889 + * logs an error if this fails.
890 + *
891 + * Drivers must store the return value to pass to mtrr_del_wc_if_needed,
892 + * but drivers should not try to interpret that return value.
893 + */
894 +int arch_phys_wc_add(unsigned long base, unsigned long size)
895 +{
896 +       int ret;
897 +
898 +       if (pat_enabled)
899 +               return 0;  /* Success!  (We don't need to do anything.) */
900 +
901 +       ret = mtrr_add(base, size, MTRR_TYPE_WRCOMB, true);
902 +       if (ret < 0) {
903 +               pr_warn("Failed to add WC MTRR for [%p-%p]; performance may suffer.",
904 +                       (void *)base, (void *)(base + size - 1));
905 +               return ret;
906 +       }
907 +       return ret + MTRR_TO_PHYS_WC_OFFSET;
908 +}
909 +EXPORT_SYMBOL(arch_phys_wc_add);
910 +
911 +/*
912 + * arch_phys_wc_del - undoes arch_phys_wc_add
913 + * @handle: Return value from arch_phys_wc_add
914 + *
915 + * This cleans up after mtrr_add_wc_if_needed.
916 + *
917 + * The API guarantees that mtrr_del_wc_if_needed(error code) and
918 + * mtrr_del_wc_if_needed(0) do nothing.
919 + */
920 +void arch_phys_wc_del(int handle)
921 +{
922 +       if (handle >= 1) {
923 +               WARN_ON(handle < MTRR_TO_PHYS_WC_OFFSET);
924 +               mtrr_del(handle - MTRR_TO_PHYS_WC_OFFSET, 0, 0);
925 +       }
926 +}
927 +EXPORT_SYMBOL(arch_phys_wc_del);
928 +
929 +/*
930 + * phys_wc_to_mtrr_index - translates arch_phys_wc_add's return value
931 + * @handle: Return value from arch_phys_wc_add
932 + *
933 + * This will turn the return value from arch_phys_wc_add into an mtrr
934 + * index suitable for debugging.
935 + *
936 + * Note: There is no legitimate use for this function, except possibly
937 + * in printk line.  Alas there is an illegitimate use in some ancient
938 + * drm ioctls.
939 + */
940 +int phys_wc_to_mtrr_index(int handle)
941 +{
942 +       if (handle < MTRR_TO_PHYS_WC_OFFSET)
943 +               return -1;
944 +       else
945 +               return handle - MTRR_TO_PHYS_WC_OFFSET;
946 +}
947 +EXPORT_SYMBOL_GPL(phys_wc_to_mtrr_index);
948 +
949  /*
950   * Returns the effective MTRR type for the region
951   * Error returns:
952 --- head.orig/arch/x86/kernel/entry_32-xen.S    2013-03-25 09:13:57.000000000 +0100
953 +++ head/arch/x86/kernel/entry_32-xen.S 2013-08-12 13:00:59.000000000 +0200
954 @@ -865,7 +865,17 @@ ENTRY(name)                                \
955         CFI_ENDPROC;                    \
956  ENDPROC(name)
957  
958 -#define BUILD_INTERRUPT(name, nr)      BUILD_INTERRUPT3(name, nr, smp_##name)
959 +
960 +#ifdef CONFIG_TRACING
961 +#define TRACE_BUILD_INTERRUPT(name, nr)                \
962 +       BUILD_INTERRUPT3(trace_##name, nr, smp_trace_##name)
963 +#else
964 +#define TRACE_BUILD_INTERRUPT(name, nr)
965 +#endif
966 +
967 +#define BUILD_INTERRUPT(name, nr) \
968 +       BUILD_INTERRUPT3(name, nr, smp_##name); \
969 +       TRACE_BUILD_INTERRUPT(name, nr)
970  
971  /* The include is where all of the SMP etc. interrupts come from */
972  #include <asm/entry_arch.h>
973 --- head.orig/arch/x86/kernel/entry_64-xen.S    2013-03-25 09:13:57.000000000 +0100
974 +++ head/arch/x86/kernel/entry_64-xen.S 2013-08-12 13:00:59.000000000 +0200
975 @@ -356,7 +356,7 @@ NMI_MASK = 0x80000000
976         /*CFI_REL_OFFSET        ss,0*/
977         pushq_cfi %rax /* rsp */
978         CFI_REL_OFFSET  rsp,0
979 -       pushq_cfi $(X86_EFLAGS_IF|X86_EFLAGS_BIT1) /* eflags - interrupts on */
980 +       pushq_cfi $(X86_EFLAGS_IF|X86_EFLAGS_FIXED) /* eflags - interrupts on */
981         /*CFI_REL_OFFSET        rflags,0*/
982         pushq_cfi $__KERNEL_CS /* cs */
983         /*CFI_REL_OFFSET        cs,0*/
984 --- head.orig/arch/x86/kernel/head32-xen.c      2013-03-25 09:13:57.000000000 +0100
985 +++ head/arch/x86/kernel/head32-xen.c   2013-08-12 14:13:54.000000000 +0200
986 @@ -44,6 +44,8 @@ void __init i386_start_kernel(void)
987         }
988  
989         BUG_ON(pte_index(hypervisor_virt_start));
990 +
991 +       set_cpu_cap(&new_cpu_data, X86_FEATURE_FPU);
992  #endif
993  
994  #ifndef CONFIG_XEN
995 --- head.orig/arch/x86/kernel/irq-xen.c 2013-05-24 11:49:51.000000000 +0200
996 +++ head/arch/x86/kernel/irq-xen.c      2013-08-14 09:29:01.000000000 +0200
997 @@ -18,6 +18,11 @@
998  #include <asm/mce.h>
999  #include <asm/hw_irq.h>
1000  
1001 +#ifndef CONFIG_XEN
1002 +#define CREATE_TRACE_POINTS
1003 +#include <asm/trace/irq_vectors.h>
1004 +#endif
1005 +
1006  atomic_t irq_err_count;
1007  
1008  #ifndef CONFIG_XEN
1009 @@ -223,23 +228,21 @@ unsigned int __irq_entry do_IRQ(struct p
1010  /*
1011   * Handler for X86_PLATFORM_IPI_VECTOR.
1012   */
1013 -void smp_x86_platform_ipi(struct pt_regs *regs)
1014 +void __smp_x86_platform_ipi(void)
1015  {
1016 -       struct pt_regs *old_regs = set_irq_regs(regs);
1017 -
1018 -       ack_APIC_irq();
1019 -
1020 -       irq_enter();
1021 -
1022 -       exit_idle();
1023 -
1024         inc_irq_stat(x86_platform_ipis);
1025  
1026         if (x86_platform_ipi_callback)
1027                 x86_platform_ipi_callback();
1028 +}
1029  
1030 -       irq_exit();
1031 +void smp_x86_platform_ipi(struct pt_regs *regs)
1032 +{
1033 +       struct pt_regs *old_regs = set_irq_regs(regs);
1034  
1035 +       entering_ack_irq();
1036 +       __smp_x86_platform_ipi();
1037 +       exiting_irq();
1038         set_irq_regs(old_regs);
1039  }
1040  
1041 @@ -265,6 +268,18 @@ void smp_kvm_posted_intr_ipi(struct pt_r
1042  }
1043  #endif
1044  
1045 +void smp_trace_x86_platform_ipi(struct pt_regs *regs)
1046 +{
1047 +       struct pt_regs *old_regs = set_irq_regs(regs);
1048 +
1049 +       entering_ack_irq();
1050 +       trace_x86_platform_ipi_entry(X86_PLATFORM_IPI_VECTOR);
1051 +       __smp_x86_platform_ipi();
1052 +       trace_x86_platform_ipi_exit(X86_PLATFORM_IPI_VECTOR);
1053 +       exiting_irq();
1054 +       set_irq_regs(old_regs);
1055 +}
1056 +
1057  EXPORT_SYMBOL_GPL(vector_used_by_percpu_irq);
1058  #endif
1059  
1060 --- head.orig/arch/x86/kernel/nmi.c     2013-08-09 15:25:46.000000000 +0200
1061 +++ head/arch/x86/kernel/nmi.c  2013-08-14 14:26:32.000000000 +0200
1062 @@ -17,6 +17,8 @@
1063  #include <linux/debugfs.h>
1064  #include <linux/delay.h>
1065  #include <linux/hardirq.h>
1066 +#include <linux/printk.h>
1067 +#include <linux/ratelimit.h>
1068  #include <linux/slab.h>
1069  #include <linux/export.h>
1070  
1071 --- head.orig/arch/x86/kernel/process-xen.c     2013-07-02 10:03:05.000000000 +0200
1072 +++ head/arch/x86/kernel/process-xen.c  2013-08-12 13:00:59.000000000 +0200
1073 @@ -391,7 +391,7 @@ static void amd_e400_idle(void)
1074  }
1075  #endif
1076  
1077 -void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
1078 +void select_idle_routine(const struct cpuinfo_x86 *c)
1079  {
1080  #ifndef CONFIG_XEN
1081  #ifdef CONFIG_SMP
1082 --- head.orig/arch/x86/kernel/process_32-xen.c  2013-05-24 11:49:51.000000000 +0200
1083 +++ head/arch/x86/kernel/process_32-xen.c       2013-08-12 13:00:59.000000000 +0200
1084 @@ -113,11 +113,16 @@ void __show_regs(struct pt_regs *regs, i
1085         get_debugreg(d1, 1);
1086         get_debugreg(d2, 2);
1087         get_debugreg(d3, 3);
1088 -       printk(KERN_DEFAULT "DR0: %08lx DR1: %08lx DR2: %08lx DR3: %08lx\n",
1089 -                       d0, d1, d2, d3);
1090 -
1091         get_debugreg(d6, 6);
1092         get_debugreg(d7, 7);
1093 +
1094 +       /* Only print out debug registers if they are in their non-default state. */
1095 +       if ((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
1096 +           (d6 == DR6_RESERVED) && (d7 == 0x400))
1097 +               return;
1098 +
1099 +       printk(KERN_DEFAULT "DR0: %08lx DR1: %08lx DR2: %08lx DR3: %08lx\n",
1100 +                       d0, d1, d2, d3);
1101         printk(KERN_DEFAULT "DR6: %08lx DR7: %08lx\n",
1102                         d6, d7);
1103  }
1104 @@ -150,7 +155,7 @@ int copy_thread(unsigned long clone_flag
1105                 childregs->bp = arg;
1106                 childregs->orig_ax = -1;
1107                 childregs->cs = __KERNEL_CS | get_kernel_rpl();
1108 -               childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_BIT1;
1109 +               childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
1110                 p->fpu_counter = 0;
1111                 p->thread.io_bitmap_ptr = NULL;
1112                 memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
1113 --- head.orig/arch/x86/kernel/process_64-xen.c  2013-05-24 11:49:51.000000000 +0200
1114 +++ head/arch/x86/kernel/process_64-xen.c       2013-08-12 13:00:59.000000000 +0200
1115 @@ -108,11 +108,18 @@ void __show_regs(struct pt_regs *regs, i
1116         get_debugreg(d0, 0);
1117         get_debugreg(d1, 1);
1118         get_debugreg(d2, 2);
1119 -       printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
1120         get_debugreg(d3, 3);
1121         get_debugreg(d6, 6);
1122         get_debugreg(d7, 7);
1123 +
1124 +       /* Only print out debug registers if they are in their non-default state. */
1125 +       if ((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
1126 +           (d6 == DR6_RESERVED) && (d7 == 0x400))
1127 +               return;
1128 +
1129 +       printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
1130         printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7);
1131 +
1132  }
1133  
1134  void xen_load_gs_index(unsigned gs)
1135 @@ -184,7 +191,7 @@ int copy_thread(unsigned long clone_flag
1136                 childregs->bp = arg;
1137                 childregs->orig_ax = -1;
1138                 childregs->cs = __KERNEL_CS | get_kernel_rpl();
1139 -               childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_BIT1;
1140 +               childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
1141                 return 0;
1142         }
1143         *childregs = *current_pt_regs();
1144 --- head.orig/arch/x86/kernel/setup-xen.c       2013-05-24 11:49:51.000000000 +0200
1145 +++ head/arch/x86/kernel/setup-xen.c    2013-08-12 14:11:03.000000000 +0200
1146 @@ -201,14 +201,12 @@ static struct resource bss_resource = {
1147  
1148  #ifdef CONFIG_X86_32
1149  /* cpu data as detected by the assembly code in head.S */
1150 -struct cpuinfo_x86 new_cpu_data __cpuinitdata = {
1151 +struct cpuinfo_x86 new_cpu_data = {
1152         .wp_works_ok = 1,
1153 -       .hard_math = 1,
1154  };
1155  /* common cpu data for all cpus */
1156  struct cpuinfo_x86 boot_cpu_data __read_mostly = {
1157         .wp_works_ok = 1,
1158 -       .hard_math = 1,
1159  };
1160  EXPORT_SYMBOL(boot_cpu_data);
1161  
1162 @@ -1178,7 +1176,6 @@ void __init setup_arch(char **cmdline_p)
1163         /* max_low_pfn get updated here */
1164         find_low_pfn_range();
1165  #else
1166 -       num_physpages = max_pfn;
1167         max_mapnr = max_pfn;
1168  
1169  #ifdef CONFIG_X86_LOCAL_APIC
1170 --- head.orig/arch/x86/kernel/time-xen.c        2012-04-11 13:26:23.000000000 +0200
1171 +++ head/arch/x86/kernel/time-xen.c     2013-08-12 13:50:48.000000000 +0200
1172 @@ -313,7 +313,7 @@ static unsigned long long local_clock(vo
1173         return time;
1174  }
1175  
1176 -unsigned long xen_read_wallclock(void)
1177 +void xen_read_wallclock(struct timespec *now)
1178  {
1179         const shared_info_t *s = HYPERVISOR_shared_info;
1180         u32 version, sec, nsec;
1181 @@ -328,12 +328,11 @@ unsigned long xen_read_wallclock(void)
1182         } while ((s->wc_version & 1) | (version ^ s->wc_version));
1183  
1184         delta = local_clock() + (u64)sec * NSEC_PER_SEC + nsec;
1185 -       do_div(delta, NSEC_PER_SEC);
1186 -
1187 -       return delta;
1188 +       now->tv_nsec = do_div(delta, NSEC_PER_SEC);
1189 +       now->tv_sec = delta;
1190  }
1191  
1192 -int xen_write_wallclock(unsigned long now)
1193 +int xen_write_wallclock(const struct timespec *now)
1194  {
1195         if (!is_initial_xendomain() || independent_wallclock)
1196                 return 0;
1197 @@ -842,7 +841,7 @@ void time_resume(void)
1198  #ifdef CONFIG_SMP
1199  static char timer_name[NR_CPUS][15];
1200  
1201 -int __cpuinit local_setup_timer(unsigned int cpu)
1202 +int local_setup_timer(unsigned int cpu)
1203  {
1204         int seq, irq;
1205  
1206 @@ -881,7 +880,7 @@ int __cpuinit local_setup_timer(unsigned
1207         return 0;
1208  }
1209  
1210 -void __cpuinit local_teardown_timer(unsigned int cpu)
1211 +void local_teardown_timer(unsigned int cpu)
1212  {
1213         BUG_ON(cpu == 0);
1214         unbind_from_irqhandler(per_cpu(timer_irq, cpu), NULL);
1215 --- head.orig/arch/x86/kernel/traps-xen.c       2013-05-24 11:49:51.000000000 +0200
1216 +++ head/arch/x86/kernel/traps-xen.c    2013-08-12 13:24:12.000000000 +0200
1217 @@ -63,19 +63,21 @@
1218  #include <asm/x86_init.h>
1219  #include <asm/pgalloc.h>
1220  #include <asm/proto.h>
1221 +
1222 +#ifndef CONFIG_X86_NO_IDT
1223 +/* No need to be aligned, but done to keep all IDTs defined the same way. */
1224 +gate_desc debug_idt_table[NR_VECTORS] __page_aligned_bss;
1225 +#endif
1226  #else
1227  #include <asm/processor-flags.h>
1228  #include <asm/setup.h>
1229  
1230  asmlinkage int system_call(void);
1231 +#endif
1232  
1233  #ifndef CONFIG_X86_NO_IDT
1234 -/*
1235 - * The IDT has to be page-aligned to simplify the Pentium
1236 - * F0 0F bug workaround.
1237 - */
1238 -gate_desc idt_table[NR_VECTORS] __page_aligned_data = { { { { 0, 0 } } }, };
1239 -#endif
1240 +/* Must be page-aligned because the real IDT is used in a fixmap. */
1241 +gate_desc idt_table[NR_VECTORS] __page_aligned_bss;
1242  #endif
1243  
1244  #ifndef CONFIG_XEN
1245 @@ -258,6 +260,9 @@ dotraplinkage void do_double_fault(struc
1246         tsk->thread.error_code = error_code;
1247         tsk->thread.trap_nr = X86_TRAP_DF;
1248  
1249 +#ifdef CONFIG_DOUBLEFAULT
1250 +       df_debug(regs, error_code);
1251 +#endif
1252         /*
1253          * This is always a kernel trap and never fixable (and thus must
1254          * never return).
1255 @@ -441,7 +446,7 @@ dotraplinkage void __kprobes do_debug(st
1256         /* Store the virtualized DR6 value */
1257         tsk->thread.debugreg6 = dr6;
1258  
1259 -       if (notify_die(DIE_DEBUG, "debug", regs, PTR_ERR(&dr6), error_code,
1260 +       if (notify_die(DIE_DEBUG, "debug", regs, (long)&dr6, error_code,
1261                                                         SIGTRAP) == NOTIFY_STOP)
1262                 goto exit;
1263  
1264 @@ -727,7 +732,7 @@ static const trap_info_t __initconst ear
1265         { X86_TRAP_PF, 0|4, __KERNEL_CS, (unsigned long)page_fault              },
1266         { }
1267  };
1268 -static const trap_info_t __cpuinitconst trap_table[] = {
1269 +static const trap_info_t trap_table[] = {
1270         { X86_TRAP_DE, 0|X, __KERNEL_CS, (unsigned long)divide_error            },
1271         { X86_TRAP_DB, 0|4, __KERNEL_CS, (unsigned long)debug                   },
1272         { X86_TRAP_BP, 3|4, __KERNEL_CS, (unsigned long)int3                    },
1273 @@ -791,7 +796,7 @@ void __init trap_init(void)
1274         x86_init.irqs.trap_init();
1275  }
1276  
1277 -void __cpuinit smp_trap_init(trap_info_t *trap_ctxt)
1278 +void smp_trap_init(trap_info_t *trap_ctxt)
1279  {
1280         const trap_info_t *t = trap_table;
1281  
1282 --- head.orig/arch/x86/kernel/vsyscall_64-xen.c 2013-01-09 15:32:33.000000000 +0100
1283 +++ head/arch/x86/kernel/vsyscall_64-xen.c      2013-08-12 13:00:59.000000000 +0200
1284 @@ -337,7 +337,7 @@ sigsegv:
1285   * Assume __initcall executes before all user space. Hopefully kmod
1286   * doesn't violate that. We'll find out if it does.
1287   */
1288 -static void __cpuinit vsyscall_set_cpu(int cpu)
1289 +static void vsyscall_set_cpu(int cpu)
1290  {
1291         unsigned long d;
1292         unsigned long node = 0;
1293 @@ -359,13 +359,13 @@ static void __cpuinit vsyscall_set_cpu(i
1294         write_gdt_entry(get_cpu_gdt_table(cpu), GDT_ENTRY_PER_CPU, &d, DESCTYPE_S);
1295  }
1296  
1297 -static void __cpuinit cpu_vsyscall_init(void *arg)
1298 +static void cpu_vsyscall_init(void *arg)
1299  {
1300         /* preemption should be already off */
1301         vsyscall_set_cpu(raw_smp_processor_id());
1302  }
1303  
1304 -static int __cpuinit
1305 +static int
1306  cpu_vsyscall_notifier(struct notifier_block *n, unsigned long action, void *arg)
1307  {
1308         long cpu = (long)arg;
1309 --- head.orig/arch/x86/kernel/x86_init-xen.c    2013-03-25 09:13:57.000000000 +0100
1310 +++ head/arch/x86/kernel/x86_init-xen.c 2013-08-12 13:00:59.000000000 +0200
1311 @@ -23,7 +23,7 @@
1312  #include <asm/iommu.h>
1313  #include <asm/mach_traps.h>
1314  
1315 -void __cpuinit x86_init_noop(void) { }
1316 +void x86_init_noop(void) { }
1317  void __init x86_init_uint_noop(unsigned int unused) { }
1318  int __init iommu_init_noop(void) { return 0; }
1319  
1320 --- head.orig/arch/x86/mm/highmem_32-xen.c      2013-05-24 11:49:51.000000000 +0200
1321 +++ head/arch/x86/mm/highmem_32-xen.c   2013-08-12 13:00:59.000000000 +0200
1322 @@ -1,6 +1,7 @@
1323  #include <linux/highmem.h>
1324  #include <linux/module.h>
1325  #include <linux/swap.h> /* for totalram_pages */
1326 +#include <linux/bootmem.h>
1327  
1328  void *kmap(struct page *page)
1329  {
1330 @@ -168,6 +169,11 @@ void __init set_highmem_pages_init(void)
1331         struct zone *zone;
1332         int nid;
1333  
1334 +       /*
1335 +        * Explicitly reset zone->managed_pages because set_highmem_pages_init()
1336 +        * is invoked before free_all_bootmem()
1337 +        */
1338 +       reset_all_zones_managed_pages();
1339         for_each_zone(zone) {
1340                 unsigned long zone_start_pfn, zone_end_pfn;
1341  
1342 --- head.orig/arch/x86/mm/init-xen.c    2013-08-15 13:02:54.000000000 +0200
1343 +++ head/arch/x86/mm/init-xen.c 2013-09-04 13:03:05.000000000 +0200
1344 @@ -88,8 +88,8 @@ __ref void *alloc_low_pages(unsigned int
1345         return __va(pfn << PAGE_SHIFT);
1346  }
1347  
1348 -/* need 4 4k for initial PMD_SIZE, 4k for 0-ISA_END_ADDRESS */
1349 -#define INIT_PGT_BUF_SIZE      (5 * PAGE_SIZE)
1350 +/* need 3 4k for initial PMD_SIZE,  3 4k for 0-ISA_END_ADDRESS */
1351 +#define INIT_PGT_BUF_SIZE      (6 * PAGE_SIZE)
1352  RESERVE_BRK(early_pgt_alloc, INIT_PGT_BUF_SIZE);
1353  void  __init early_alloc_pgt_buf(void)
1354  {
1355 @@ -512,7 +512,6 @@ int devmem_is_allowed(unsigned long page
1356  
1357  void free_init_pages(char *what, unsigned long begin, unsigned long end)
1358  {
1359 -       unsigned long addr;
1360         unsigned long begin_aligned, end_aligned;
1361  
1362         /* Make sure boundaries are page aligned */
1363 @@ -527,8 +526,6 @@ void free_init_pages(char *what, unsigne
1364         if (begin >= end)
1365                 return;
1366  
1367 -       addr = begin;
1368 -
1369         /*
1370          * If debugging page accesses then do not free this memory but
1371          * mark them not present - any buggy init-section access will
1372 @@ -547,12 +544,11 @@ void free_init_pages(char *what, unsigne
1373         set_memory_nx(begin, (end - begin) >> PAGE_SHIFT);
1374         set_memory_rw(begin, (end - begin) >> PAGE_SHIFT);
1375  
1376 -       printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
1377 -
1378 -       for (; addr < end; addr += PAGE_SIZE) {
1379 -               memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
1380  #ifdef CONFIG_X86_64
1381 -               if (addr >= __START_KERNEL_map) {
1382 +       if (begin >= __START_KERNEL_map) {
1383 +               unsigned long addr;
1384 +
1385 +               for (addr = begin; addr < end; addr += PAGE_SIZE) {
1386                         paddr_t pa = __pa_symbol(addr);
1387  
1388                         /* make_readonly() reports all kernel addresses. */
1389 @@ -564,15 +560,17 @@ void free_init_pages(char *what, unsigne
1390                         if (HYPERVISOR_update_va_mapping(addr, __pte(0), 0))
1391                                 BUG();
1392                 }
1393 -#endif
1394 -               free_reserved_page(virt_to_page(addr));
1395 +               begin = (unsigned long)__va(__pa_symbol(begin));
1396 +               end = (unsigned long)__va(__pa_symbol(end));
1397         }
1398  #endif
1399 +       free_reserved_area((void *)begin, (void *)end, POISON_FREE_INITMEM, what);
1400 +#endif
1401  }
1402  
1403  void free_initmem(void)
1404  {
1405 -       free_init_pages("unused kernel memory",
1406 +       free_init_pages("unused kernel",
1407                         (unsigned long)(&__init_begin),
1408                         (unsigned long)(&__init_end));
1409  }
1410 @@ -598,7 +596,7 @@ void __init free_initrd_mem(unsigned lon
1411          *   - relocate_initrd()
1412          * So here We can do PAGE_ALIGN() safely to get partial page to be freed
1413          */
1414 -       free_init_pages("initrd memory", start, PAGE_ALIGN(end));
1415 +       free_init_pages("initrd", start, PAGE_ALIGN(end));
1416  }
1417  #endif
1418  
1419 --- head.orig/arch/x86/mm/init_32-xen.c 2013-05-24 11:49:51.000000000 +0200
1420 +++ head/arch/x86/mm/init_32-xen.c      2013-08-12 13:00:59.000000000 +0200
1421 @@ -651,10 +651,8 @@ void __init initmem_init(void)
1422                 highstart_pfn = max_low_pfn;
1423         printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
1424                 pages_to_mb(highend_pfn - highstart_pfn));
1425 -       num_physpages = highend_pfn;
1426         high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
1427  #else
1428 -       num_physpages = max_low_pfn;
1429         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
1430  #endif
1431  
1432 @@ -662,7 +660,7 @@ void __init initmem_init(void)
1433         sparse_memory_present_with_active_regions(0);
1434  
1435  #ifdef CONFIG_FLATMEM
1436 -       max_mapnr = num_physpages;
1437 +       max_mapnr = IS_ENABLED(CONFIG_HIGHMEM) ? highend_pfn : max_low_pfn;
1438  #endif
1439         __vmalloc_start_set = true;
1440  
1441 @@ -730,8 +728,6 @@ static void __init test_wp_bit(void)
1442  
1443  void __init mem_init(void)
1444  {
1445 -       int codesize, reservedpages, datasize, initsize;
1446 -       int tmp;
1447         unsigned long pfn;
1448  
1449         pci_iommu_alloc();
1450 @@ -751,37 +747,16 @@ void __init mem_init(void)
1451         set_highmem_pages_init();
1452  
1453         /* this will put all low memory onto the freelists */
1454 -       totalram_pages += free_all_bootmem();
1455 +       free_all_bootmem();
1456         /* XEN: init low-mem pages outside initial allocation. */
1457         for (pfn = xen_start_info->nr_pages; pfn < max_low_pfn; pfn++) {
1458                 ClearPageReserved(pfn_to_page(pfn));
1459                 init_page_count(pfn_to_page(pfn));
1460         }
1461  
1462 -       reservedpages = 0;
1463 -       for (tmp = 0; tmp < max_low_pfn; tmp++)
1464 -               /*
1465 -                * Only count reserved RAM pages:
1466 -                */
1467 -               if (page_is_ram(tmp) && PageReserved(pfn_to_page(tmp)))
1468 -                       reservedpages++;
1469 -
1470         after_bootmem = 1;
1471  
1472 -       codesize =  (unsigned long) &_etext - (unsigned long) &_text;
1473 -       datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
1474 -       initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
1475 -
1476 -       printk(KERN_INFO "Memory: %luk/%luk available (%dk kernel code, "
1477 -                       "%dk reserved, %dk data, %dk init, %ldk highmem)\n",
1478 -               nr_free_pages() << (PAGE_SHIFT-10),
1479 -               num_physpages << (PAGE_SHIFT-10),
1480 -               codesize >> 10,
1481 -               reservedpages << (PAGE_SHIFT-10),
1482 -               datasize >> 10,
1483 -               initsize >> 10,
1484 -               totalhigh_pages << (PAGE_SHIFT-10));
1485 -
1486 +       mem_init_print_info(NULL);
1487         printk(KERN_INFO "virtual kernel memory layout:\n"
1488                 "    fixmap  : 0x%08lx - 0x%08lx   (%4ld kB)\n"
1489  #ifdef CONFIG_HIGHMEM
1490 --- head.orig/arch/x86/mm/init_64-xen.c 2013-05-24 11:49:51.000000000 +0200
1491 +++ head/arch/x86/mm/init_64-xen.c      2013-08-12 13:00:59.000000000 +0200
1492 @@ -438,7 +438,7 @@ void __init init_extra_mapping_uc(unsign
1493   *
1494   *   from __START_KERNEL_map to __START_KERNEL_map + size (== _end-_text)
1495   *
1496 - * phys_addr holds the negative offset to the kernel, which is added
1497 + * phys_base holds the negative offset to the kernel, which is added
1498   * to the compile time generated pmds. This results in invalid pmds up
1499   * to the point where we hit the physaddr 0 mapping.
1500   *
1501 @@ -1002,36 +1002,22 @@ EXPORT_SYMBOL_GPL(arch_add_memory);
1502  
1503  static void __meminit free_pagetable(struct page *page, int order)
1504  {
1505 -       struct zone *zone;
1506 -       bool bootmem = false;
1507         unsigned long magic;
1508         unsigned int nr_pages = 1 << order;
1509  
1510         /* bootmem page has reserved flag */
1511         if (PageReserved(page)) {
1512                 __ClearPageReserved(page);
1513 -               bootmem = true;
1514  
1515                 magic = (unsigned long)page->lru.next;
1516                 if (magic == SECTION_INFO || magic == MIX_SECTION_INFO) {
1517                         while (nr_pages--)
1518                                 put_page_bootmem(page++);
1519                 } else
1520 -                       __free_pages_bootmem(page, order);
1521 +                       while (nr_pages--)
1522 +                               free_reserved_page(page++);
1523         } else
1524                 free_pages((unsigned long)page_address(page), order);
1525 -
1526 -       /*
1527 -        * SECTION_INFO pages and MIX_SECTION_INFO pages
1528 -        * are all allocated by bootmem.
1529 -        */
1530 -       if (bootmem) {
1531 -               zone = page_zone(page);
1532 -               zone_span_writelock(zone);
1533 -               zone->present_pages += nr_pages;
1534 -               zone_span_writeunlock(zone);
1535 -               totalram_pages += nr_pages;
1536 -       }
1537  }
1538  
1539  static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd)
1540 @@ -1348,8 +1334,6 @@ static void __init register_page_bootmem
1541  
1542  void __init mem_init(void)
1543  {
1544 -       long codesize, reservedpages, datasize, initsize;
1545 -       unsigned long absent_pages;
1546         unsigned long pfn;
1547  
1548         pci_iommu_alloc();
1549 @@ -1359,7 +1343,7 @@ void __init mem_init(void)
1550         register_page_bootmem_info();
1551  
1552         /* this will put all memory onto the freelists */
1553 -       totalram_pages = free_all_bootmem();
1554 +       free_all_bootmem();
1555  
1556         /* XEN: init pages outside initial allocation. */
1557         for (pfn = xen_start_info->nr_pages; pfn < max_pfn; pfn++) {
1558 @@ -1367,27 +1351,13 @@ void __init mem_init(void)
1559                 init_page_count(pfn_to_page(pfn));
1560         }
1561  
1562 -       absent_pages = absent_pages_in_range(0, max_pfn);
1563 -       reservedpages = max_pfn - totalram_pages - absent_pages;
1564         after_bootmem = 1;
1565  
1566 -       codesize =  (unsigned long) &_etext - (unsigned long) &_text;
1567 -       datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
1568 -       initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
1569 -
1570         /* Register memory areas for /proc/kcore */
1571         kclist_add(&kcore_vsyscall, (void *)VSYSCALL_START,
1572                          VSYSCALL_END - VSYSCALL_START, KCORE_OTHER);
1573  
1574 -       printk(KERN_INFO "Memory: %luk/%luk available (%ldk kernel code, "
1575 -                        "%ldk absent, %ldk reserved, %ldk data, %ldk init)\n",
1576 -               nr_free_pages() << (PAGE_SHIFT-10),
1577 -               max_pfn << (PAGE_SHIFT-10),
1578 -               codesize >> 10,
1579 -               absent_pages << (PAGE_SHIFT-10),
1580 -               reservedpages << (PAGE_SHIFT-10),
1581 -               datasize >> 10,
1582 -               initsize >> 10);
1583 +       mem_init_print_info(NULL);
1584  }
1585  
1586  #ifdef CONFIG_DEBUG_RODATA
1587 @@ -1463,11 +1433,10 @@ void mark_rodata_ro(void)
1588         set_memory_ro(start, (end-start) >> PAGE_SHIFT);
1589  #endif
1590  
1591 -       free_init_pages("unused kernel memory",
1592 +       free_init_pages("unused kernel",
1593                         (unsigned long) __va(__pa_symbol(text_end)),
1594                         (unsigned long) __va(__pa_symbol(rodata_start)));
1595 -
1596 -       free_init_pages("unused kernel memory",
1597 +       free_init_pages("unused kernel",
1598                         (unsigned long) __va(__pa_symbol(rodata_end)),
1599                         (unsigned long) __va(__pa_symbol(_sdata)));
1600  }
1601 --- head.orig/arch/x86/mm/ioremap-xen.c 2013-05-24 11:49:51.000000000 +0200
1602 +++ head/arch/x86/mm/ioremap-xen.c      2013-08-12 13:00:59.000000000 +0200
1603 @@ -678,15 +678,15 @@ __early_ioremap(resource_size_t phys_add
1604         }
1605  
1606         if (slot < 0) {
1607 -               printk(KERN_INFO "early_iomap(%08llx, %08lx) not found slot\n",
1608 -                        (u64)phys_addr, size);
1609 +               printk(KERN_INFO "%s(%08llx, %08lx) not found slot\n",
1610 +                      __func__, (u64)phys_addr, size);
1611                 WARN_ON(1);
1612                 return NULL;
1613         }
1614  
1615         if (early_ioremap_debug) {
1616 -               printk(KERN_INFO "early_ioremap(%08llx, %08lx) [%d] => ",
1617 -                      (u64)phys_addr, size, slot);
1618 +               printk(KERN_INFO "%s(%08llx, %08lx) [%d] => ",
1619 +                      __func__, (u64)phys_addr, size, slot);
1620                 dump_stack();
1621         }
1622  
1623 --- head.orig/arch/x86/mm/pgtable-xen.c 2013-04-26 11:27:56.000000000 +0200
1624 +++ head/arch/x86/mm/pgtable-xen.c      2013-08-12 13:00:59.000000000 +0200
1625 @@ -610,7 +610,6 @@ static void pgd_mop_up_pmds(struct mm_st
1626  static void pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmds[])
1627  {
1628         pud_t *pud;
1629 -       unsigned long addr;
1630         int i;
1631  
1632         if (PREALLOCATED_PMDS == 0) /* Work around gcc-3.4.x bug */
1633 @@ -618,8 +617,7 @@ static void pgd_prepopulate_pmd(struct m
1634  
1635         pud = pud_offset(pgd, 0);
1636  
1637 -       for (addr = i = 0; i < PREALLOCATED_PMDS;
1638 -            i++, pud++, addr += PUD_SIZE) {
1639 +       for (i = 0; i < PREALLOCATED_PMDS; i++, pud++) {
1640                 pmd_t *pmd = pmds[i];
1641  
1642                 if (i >= KERNEL_PGD_BOUNDARY) {
1643 --- head.orig/arch/x86/vdso/vdso32-setup-xen.c  2012-04-11 13:26:23.000000000 +0200
1644 +++ head/arch/x86/vdso/vdso32-setup-xen.c       2013-08-12 13:23:01.000000000 +0200
1645 @@ -202,13 +202,13 @@ static struct page *vdso32_pages[1];
1646  #define        vdso32_sysenter()       (boot_cpu_has(X86_FEATURE_SYSENTER32))
1647  #define        vdso32_syscall()        (boot_cpu_has(X86_FEATURE_SYSCALL32))
1648  
1649 -void __cpuinit syscall32_cpu_init(void)
1650 +void syscall32_cpu_init(void)
1651  {
1652 -       static const struct callback_register __cpuinitconst cstar = {
1653 +       static const struct callback_register cstar = {
1654                 .type = CALLBACKTYPE_syscall32,
1655                 .address = (unsigned long)ia32_cstar_target
1656         };
1657 -       static const struct callback_register __cpuinitconst sysenter = {
1658 +       static const struct callback_register sysenter = {
1659                 .type = CALLBACKTYPE_sysenter,
1660                 .address = (unsigned long)ia32_sysenter_target
1661         };
1662 @@ -234,16 +234,16 @@ static inline void map_compat_vdso(int m
1663  #define vdso32_syscall()       (boot_cpu_has(X86_FEATURE_SYSCALL32))
1664  
1665  extern asmlinkage void ia32pv_cstar_target(void);
1666 -static const struct callback_register __cpuinitconst cstar = {
1667 +static const struct callback_register cstar = {
1668         .type = CALLBACKTYPE_syscall32,
1669         .address = { __KERNEL_CS, (unsigned long)ia32pv_cstar_target },
1670  };
1671  #endif
1672  
1673 -void __cpuinit enable_sep_cpu(void)
1674 +void enable_sep_cpu(void)
1675  {
1676         extern asmlinkage void ia32pv_sysenter_target(void);
1677 -       static struct callback_register __cpuinitdata sysenter = {
1678 +       static struct callback_register sysenter = {
1679                 .type = CALLBACKTYPE_sysenter,
1680                 .address = { __KERNEL_CS, (unsigned long)ia32pv_sysenter_target },
1681         };
1682 @@ -420,7 +420,7 @@ subsys_initcall(sysenter_setup);
1683  /* Register vsyscall32 into the ABI table */
1684  #include <linux/sysctl.h>
1685  
1686 -static ctl_table abi_table2[] = {
1687 +static struct ctl_table abi_table2[] = {
1688         {
1689                 .procname       = "vsyscall32",
1690                 .data           = &sysctl_vsyscall32,
1691 @@ -431,7 +431,7 @@ static ctl_table abi_table2[] = {
1692         {}
1693  };
1694  
1695 -static ctl_table abi_root_table2[] = {
1696 +static struct ctl_table abi_root_table2[] = {
1697         {
1698                 .procname = "abi",
1699                 .mode = 0555,
1700 --- head.orig/drivers/acpi/acpi_processor.c     2013-08-09 15:36:09.000000000 +0200
1701 +++ head/drivers/acpi/acpi_processor.c  2013-08-14 15:26:05.000000000 +0200
1702 @@ -30,9 +30,7 @@
1703  ACPI_MODULE_NAME("processor");
1704  
1705  DEFINE_PER_CPU(struct acpi_processor *, processors);
1706 -#ifndef CONFIG_XEN
1707  EXPORT_PER_CPU_SYMBOL(processors);
1708 -#endif
1709  
1710  /* --------------------------------------------------------------------------
1711                                  Errata Handling
1712 --- head.orig/drivers/acpi/processor_core.c     2013-03-21 15:29:20.000000000 +0100
1713 +++ head/drivers/acpi/processor_core.c  2013-08-14 15:17:26.000000000 +0200
1714 @@ -27,6 +27,35 @@ ACPI_MODULE_NAME("processor_core");
1715   */
1716  const struct processor_extcntl_ops *processor_extcntl_ops;
1717  EXPORT_SYMBOL(processor_extcntl_ops);
1718 +
1719 +int processor_notify_external(struct acpi_processor *pr, int event, int type)
1720 +{
1721 +       int ret = -EINVAL;
1722 +
1723 +       if (!processor_cntl_external())
1724 +               return -EINVAL;
1725 +
1726 +       switch (event) {
1727 +       case PROCESSOR_PM_INIT:
1728 +       case PROCESSOR_PM_CHANGE:
1729 +               if (type >= PM_TYPE_MAX
1730 +                   || !processor_extcntl_ops->pm_ops[type])
1731 +                       break;
1732 +
1733 +               ret = processor_extcntl_ops->pm_ops[type](pr, event);
1734 +               break;
1735 +       case PROCESSOR_HOTPLUG:
1736 +               if (processor_extcntl_ops->hotplug)
1737 +                       ret = processor_extcntl_ops->hotplug(pr, type);
1738 +               break;
1739 +       default:
1740 +               pr_err("Unsupported processor event %d.\n", event);
1741 +               break;
1742 +       }
1743 +
1744 +       return ret;
1745 +}
1746 +EXPORT_SYMBOL_GPL(processor_notify_external);
1747  #endif
1748  
1749  static int __init set_no_mwait(const struct dmi_system_id *id)
1750 --- head.orig/drivers/acpi/processor_extcntl.c  2011-02-01 15:03:03.000000000 +0100
1751 +++ head/drivers/acpi/processor_extcntl.c       2013-08-14 15:16:46.000000000 +0200
1752 @@ -67,34 +67,6 @@ static int processor_notify_smm(void)
1753         return 0;
1754  }
1755  
1756 -int processor_notify_external(struct acpi_processor *pr, int event, int type)
1757 -{
1758 -       int ret = -EINVAL;
1759 -
1760 -       if (!processor_cntl_external())
1761 -               return -EINVAL;
1762 -
1763 -       switch (event) {
1764 -       case PROCESSOR_PM_INIT:
1765 -       case PROCESSOR_PM_CHANGE:
1766 -               if ((type >= PM_TYPE_MAX) ||
1767 -                       !processor_extcntl_ops->pm_ops[type])
1768 -                       break;
1769 -
1770 -               ret = processor_extcntl_ops->pm_ops[type](pr, event);
1771 -               break;
1772 -       case PROCESSOR_HOTPLUG:
1773 -               if (processor_extcntl_ops->hotplug)
1774 -                       ret = processor_extcntl_ops->hotplug(pr, type);
1775 -               break;
1776 -       default:
1777 -               pr_err("Unsupported processor event %d.\n", event);
1778 -               break;
1779 -       }
1780 -
1781 -       return ret;
1782 -}
1783 -
1784  /*
1785   * This is called from ACPI processor init, and targeted to hold
1786   * some tricky housekeeping jobs to satisfy external control model.
1787 --- head.orig/drivers/hwmon/coretemp-xen.c      2013-05-24 11:49:51.000000000 +0200
1788 +++ head/drivers/hwmon/coretemp-xen.c   2013-08-12 13:00:59.000000000 +0200
1789 @@ -587,7 +587,6 @@ static int coretemp_remove(struct platfo
1790  
1791         device_remove_file(&pdev->dev, &pdata->name_attr);
1792         hwmon_device_unregister(pdata->hwmon_dev);
1793 -       platform_set_drvdata(pdev, NULL);
1794         kfree(pdata);
1795         return 0;
1796  }
1797 --- head.orig/drivers/xen/Makefile      2013-03-25 09:13:58.000000000 +0100
1798 +++ head/drivers/xen/Makefile   2013-08-12 13:00:59.000000000 +0200
1799 @@ -4,12 +4,11 @@ xen-balloon_$(CONFIG_PARAVIRT_XEN) := xe
1800  xen-evtchn-name-$(CONFIG_PARAVIRT_XEN) := xen-evtchn
1801  xen-privcmd_$(CONFIG_PARAVIRT_XEN) := xen-privcmd.o
1802  
1803 -ifneq ($(CONFIG_ARM),y)
1804 -obj-$(CONFIG_PARAVIRT_XEN)     += manage.o
1805 +ifeq ($(filter y, $(CONFIG_ARM) $(CONFIG_ARM64)),)
1806  obj-$(CONFIG_HOTPLUG_CPU)      += $(xen-hotplug-y)
1807  endif
1808  obj-$(CONFIG_X86)              += fallback.o
1809 -obj-$(CONFIG_PARAVIRT_XEN)     += grant-table.o features.o events.o balloon.o
1810 +obj-$(CONFIG_PARAVIRT_XEN)     += grant-table.o features.o events.o balloon.o manage.o
1811  
1812  xen-balloon_$(CONFIG_XEN)      := balloon/
1813  xen-privcmd_$(CONFIG_XEN)      := privcmd/
1814 --- head.orig/drivers/xen/balloon/balloon.c     2013-05-28 09:37:18.000000000 +0200
1815 +++ head/drivers/xen/balloon/balloon.c  2013-08-14 09:49:03.000000000 +0200
1816 @@ -75,14 +75,6 @@ struct balloon_stats balloon_stats;
1817  /* We increase/decrease in batches which fit in a page */
1818  static unsigned long frame_list[PAGE_SIZE / sizeof(unsigned long)];
1819  
1820 -#ifdef CONFIG_HIGHMEM
1821 -#define inc_totalhigh_pages() (totalhigh_pages++)
1822 -#define dec_totalhigh_pages() (totalhigh_pages--)
1823 -#else
1824 -#define inc_totalhigh_pages() ((void)0)
1825 -#define dec_totalhigh_pages() ((void)0)
1826 -#endif
1827 -
1828  #ifndef CONFIG_XEN
1829  /*
1830   * In HVM guests accounting here uses the Xen visible values, but the kernel
1831 @@ -128,13 +120,14 @@ static void balloon_append(struct page *
1832         if (PageHighMem(page)) {
1833                 list_add_tail(PAGE_TO_LIST(page), &ballooned_pages);
1834                 bs.balloon_high++;
1835 -               if (account)
1836 -                       dec_totalhigh_pages();
1837         } else {
1838                 list_add(PAGE_TO_LIST(page), &ballooned_pages);
1839                 bs.balloon_low++;
1840         }
1841  
1842 +       if (account)
1843 +               adjust_managed_page_count(page, -1);
1844 +
1845         pfn = page_to_pfn(page);
1846         if (account) {
1847                 SetPageReserved(page);
1848 @@ -159,12 +152,12 @@ static struct page *balloon_retrieve(int
1849         UNLIST_PAGE(page);
1850         BUG_ON(!PageReserved(page));
1851  
1852 -       if (PageHighMem(page)) {
1853 +       if (PageHighMem(page))
1854                 bs.balloon_high--;
1855 -               inc_totalhigh_pages();
1856 -       }
1857         else
1858                 bs.balloon_low--;
1859 +       adjust_managed_page_count(page, 1);
1860 +
1861         zone = page_zone(page);
1862         *was_empty |= !populated_zone(zone);
1863         zone->present_pages++;
1864 @@ -212,10 +205,23 @@ static unsigned long current_target(void
1865         return target;
1866  }
1867  
1868 +#ifndef CONFIG_XEN
1869 +static unsigned long balloon_num_physpages(void)
1870 +{
1871 +       unsigned int nid;
1872 +       unsigned long phys_pages = 0;
1873 +
1874 +       for_each_online_node(nid)
1875 +               phys_pages += node_spanned_pages(nid);
1876 +
1877 +       return phys_pages;
1878 +}
1879 +#endif
1880 +
1881  static unsigned long minimum_target(void)
1882  {
1883  #ifndef CONFIG_XEN
1884 -#define max_pfn num_physpages
1885 +#define max_pfn balloon_num_physpages()
1886  #endif
1887         unsigned long min_pages, curr_pages = current_target();
1888  
1889 @@ -306,7 +312,6 @@ static int increase_reservation(unsigned
1890         }
1891  
1892         bs.current_pages += rc;
1893 -       totalram_pages = bs.current_pages - totalram_bias;
1894  
1895   out:
1896         balloon_unlock(flags);
1897 @@ -386,7 +391,6 @@ static int decrease_reservation(unsigned
1898         BUG_ON(ret != nr_pages);
1899  
1900         bs.current_pages -= nr_pages;
1901 -       totalram_pages = bs.current_pages - totalram_bias;
1902  
1903         balloon_unlock(flags);
1904  
1905 @@ -711,9 +715,8 @@ struct page **alloc_empty_pages_and_page
1906                         goto err;
1907                 }
1908  
1909 -               totalram_pages = --bs.current_pages - totalram_bias;
1910 -               if (PageHighMem(page))
1911 -                       dec_totalhigh_pages();
1912 +               --bs.current_pages;
1913 +               adjust_managed_page_count(page, -1);
1914                 page_zone(page)->present_pages--;
1915  
1916                 balloon_unlock(flags);
1917 @@ -762,7 +765,7 @@ void balloon_release_driver_page(struct 
1918  
1919         balloon_lock(flags);
1920         balloon_append(page, 1);
1921 -       totalram_pages = --bs.current_pages - totalram_bias;
1922 +       bs.current_pages--;
1923         bs.driver_pages--;
1924         balloon_unlock(flags);
1925  
1926 --- head.orig/drivers/xen/char/mem.c    2013-03-25 09:13:58.000000000 +0100
1927 +++ head/drivers/xen/char/mem.c 2013-08-12 13:00:59.000000000 +0200
1928 @@ -193,7 +193,7 @@ static loff_t memory_lseek(struct file *
1929                 offset += file->f_pos;
1930         case SEEK_SET:
1931                 /* to avoid userland mistaking f_pos=-9 as -EBADF=-9 */
1932 -               if ((unsigned long long)offset >= ~0xFFFULL) {
1933 +               if (IS_ERR_VALUE((unsigned long long)offset)) {
1934                         ret = -EOVERFLOW;
1935                         break;
1936                 }
1937 --- head.orig/drivers/xen/core/smpboot.c        2013-06-04 14:06:43.000000000 +0200
1938 +++ head/drivers/xen/core/smpboot.c     2013-08-12 13:20:04.000000000 +0200
1939 @@ -74,7 +74,7 @@ void __init prefill_possible_map(void)
1940                         ++total_cpus;
1941  }
1942  
1943 -static int __cpuinit xen_smp_intr_init(unsigned int cpu)
1944 +static int xen_smp_intr_init(unsigned int cpu)
1945  {
1946         int rc;
1947  
1948 @@ -167,7 +167,7 @@ static int __cpuinit xen_smp_intr_init(u
1949         return rc;
1950  }
1951  
1952 -static void __cpuinit xen_smp_intr_exit(unsigned int cpu)
1953 +static void xen_smp_intr_exit(unsigned int cpu)
1954  {
1955         if (cpu != 0)
1956                 local_teardown_timer(cpu);
1957 @@ -182,7 +182,7 @@ static void __cpuinit xen_smp_intr_exit(
1958         xen_spinlock_cleanup(cpu);
1959  }
1960  
1961 -static void __cpuinit cpu_bringup(void)
1962 +static void cpu_bringup(void)
1963  {
1964         unsigned int cpu;
1965  
1966 @@ -196,14 +196,13 @@ static void __cpuinit cpu_bringup(void)
1967         local_irq_enable();
1968  }
1969  
1970 -static void __cpuinit cpu_bringup_and_idle(void)
1971 +static void cpu_bringup_and_idle(void)
1972  {
1973         cpu_bringup();
1974         cpu_startup_entry(CPUHP_ONLINE);
1975  }
1976  
1977 -static void __cpuinit cpu_initialize_context(unsigned int cpu,
1978 -                                            unsigned long sp0)
1979 +static void cpu_initialize_context(unsigned int cpu, unsigned long sp0)
1980  {
1981         /* vcpu_guest_context_t is too large to allocate on the stack.
1982          * Hence we allocate statically and protect it with a lock */
1983 @@ -343,7 +342,7 @@ static int __init initialize_cpu_present
1984  }
1985  core_initcall(initialize_cpu_present_map);
1986  
1987 -int __cpuinit __cpu_disable(void)
1988 +int __cpu_disable(void)
1989  {
1990         unsigned int cpu = smp_processor_id();
1991  
1992 @@ -356,7 +355,7 @@ int __cpuinit __cpu_disable(void)
1993         return 0;
1994  }
1995  
1996 -void __cpuinit __cpu_die(unsigned int cpu)
1997 +void __cpu_die(unsigned int cpu)
1998  {
1999         while (HYPERVISOR_vcpu_op(VCPUOP_is_up, cpu, NULL)) {
2000                 current->state = TASK_UNINTERRUPTIBLE;
2001 @@ -368,7 +367,7 @@ void __cpuinit __cpu_die(unsigned int cp
2002  
2003  #endif /* CONFIG_HOTPLUG_CPU */
2004  
2005 -int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *idle)
2006 +int __cpu_up(unsigned int cpu, struct task_struct *idle)
2007  {
2008         int rc;
2009  
2010 --- head.orig/drivers/xen/core/spinlock.c       2012-07-26 14:14:12.000000000 +0200
2011 +++ head/drivers/xen/core/spinlock.c    2013-08-12 13:20:18.000000000 +0200
2012 @@ -41,7 +41,7 @@ static DEFINE_PER_CPU(struct rm_seq, rm_
2013  static bool __read_mostly nopoll;
2014  module_param(nopoll, bool, 0);
2015  
2016 -int __cpuinit xen_spinlock_init(unsigned int cpu)
2017 +int xen_spinlock_init(unsigned int cpu)
2018  {
2019         struct evtchn_bind_ipi bind_ipi;
2020         int rc;
2021 @@ -61,7 +61,7 @@ int __cpuinit xen_spinlock_init(unsigned
2022         return rc;
2023  }
2024  
2025 -void __cpuinit xen_spinlock_cleanup(unsigned int cpu)
2026 +void xen_spinlock_cleanup(unsigned int cpu)
2027  {
2028         struct evtchn_close close;
2029  
2030 @@ -73,7 +73,7 @@ void __cpuinit xen_spinlock_cleanup(unsi
2031  }
2032  
2033  #ifdef CONFIG_PM_SLEEP
2034 -void __cpuinit spinlock_resume(void)
2035 +void spinlock_resume(void)
2036  {
2037         unsigned int cpu;
2038  
2039 --- head.orig/drivers/xen/usbback/xenbus.c      2011-06-30 17:05:05.000000000 +0200
2040 +++ head/drivers/xen/usbback/xenbus.c   2013-08-14 15:01:18.000000000 +0200
2041 @@ -44,6 +44,7 @@
2042   */
2043  
2044  #include "usbback.h"
2045 +#include <linux/usb/ch11.h>
2046  
2047  static int start_xenusbd(usbif_t *usbif)
2048  {
2049 --- head.orig/drivers/xen/xen-pciback/slot.c    2011-09-19 14:36:47.000000000 +0200
2050 +++ head/drivers/xen/xen-pciback/slot.c 2013-08-12 15:04:23.000000000 +0200
2051 @@ -6,6 +6,8 @@
2052   *   Author: Tristan Gingold <tristan.gingold@bull.net>, from vpci.c
2053   */
2054  
2055 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2056 +
2057  #include <linux/spinlock.h>
2058  #include "pciback.h"
2059  
2060 @@ -63,8 +65,7 @@ static int _xen_pcibk_add_pci_dev(struct
2061         for (bus = 0; bus < PCI_BUS_NBR; bus++)
2062                 for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
2063                         if (slot_dev->slots[bus][slot] == NULL) {
2064 -                               pr_info("pciback: slot: %s: assign to"
2065 -                                       " virtual slot %d, bus %d\n",
2066 +                               pr_info("slot: %s: assign to virtual slot %d, bus %d\n",
2067                                         pci_name(dev), slot, bus);
2068                                 slot_dev->slots[bus][slot] = dev;
2069                                 goto unlock;
2070 --- head.orig/drivers/xen/xenbus/xenbus_comms.c 2012-10-29 17:13:41.000000000 +0100
2071 +++ head/drivers/xen/xenbus/xenbus_comms.c      2013-08-12 13:51:56.000000000 +0200
2072 @@ -30,6 +30,8 @@
2073   * IN THE SOFTWARE.
2074   */
2075  
2076 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2077 +
2078  #include <linux/wait.h>
2079  #include <linux/interrupt.h>
2080  #include <linux/sched.h>
2081 @@ -238,13 +240,12 @@ int xb_init_comms(void)
2082         int err;
2083  
2084         if (intf->req_prod != intf->req_cons)
2085 -               pr_err("XENBUS request ring is not quiescent "
2086 -                      "(%08x:%08x)!\n", intf->req_cons, intf->req_prod);
2087 +               pr_err("request ring is not quiescent (%08x:%08x)!\n",
2088 +                      intf->req_cons, intf->req_prod);
2089  
2090         if (intf->rsp_prod != intf->rsp_cons) {
2091 -               pr_warning("XENBUS response ring is not quiescent"
2092 -                          " (%08x:%08x): fixing up\n",
2093 -                          intf->rsp_cons, intf->rsp_prod);
2094 +               pr_warn("response ring is not quiescent (%08x:%08x): fixing up\n",
2095 +                       intf->rsp_cons, intf->rsp_prod);
2096                 /* breaks kdump */
2097                 if (!reset_devices)
2098                         intf->rsp_cons = intf->rsp_prod;
2099 @@ -258,7 +259,7 @@ int xb_init_comms(void)
2100                 xen_store_evtchn, wake_waiting,
2101                 0, "xenbus", &xb_waitq);
2102         if (err <= 0) {
2103 -               pr_err("XENBUS request irq failed %i\n", err);
2104 +               pr_err("request irq failed %i\n", err);
2105                 return err;
2106         }
2107  
2108 @@ -271,7 +272,7 @@ int xb_init_comms(void)
2109                 err = bind_evtchn_to_irqhandler(xen_store_evtchn, wake_waiting,
2110                                                 0, "xenbus", &xb_waitq);
2111                 if (err < 0) {
2112 -                       pr_err("XENBUS request irq failed %i\n", err);
2113 +                       pr_err("request irq failed %i\n", err);
2114                         return err;
2115                 }
2116                 xenbus_irq = err;
2117 --- head.orig/drivers/xen/xenbus/xenbus_probe.c 2013-06-04 14:12:33.000000000 +0200
2118 +++ head/drivers/xen/xenbus/xenbus_probe.c      2013-08-12 15:14:21.000000000 +0200
2119 @@ -31,6 +31,8 @@
2120   * IN THE SOFTWARE.
2121   */
2122  
2123 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2124 +
2125  #define DPRINTK(fmt, args...)                          \
2126         pr_debug("xenbus_probe (%s:%d) " fmt ".\n",     \
2127                  __FUNCTION__, __LINE__, ##args)
2128 @@ -549,7 +551,7 @@ int xenbus_probe_node(struct xen_bus_typ
2129  
2130                 err = bus->get_bus_id(devname, xendev->nodename);
2131                 if (!err)
2132 -                       dev_set_name(&xendev->dev, devname);
2133 +                       dev_set_name(&xendev->dev, "%s", devname);
2134         }
2135  #else
2136         err = bus->get_bus_id(xendev->dev.bus_id, xendev->nodename);
2137 @@ -576,13 +578,13 @@ static int frontend_bus_id(char bus_id[X
2138  {
2139         nodename = strchr(nodename, '/');
2140         if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
2141 -               pr_warning("XENBUS: bad frontend %s\n", nodename);
2142 +               pr_warn("bad frontend %s\n", nodename);
2143                 return -EINVAL;
2144         }
2145  
2146         strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
2147         if (!strchr(bus_id, '/')) {
2148 -               pr_warning("XENBUS: bus_id %s no slash\n", bus_id);
2149 +               pr_warn("bus_id %s no slash\n", bus_id);
2150                 return -EINVAL;
2151         }
2152         *strchr(bus_id, '/') = '-';
2153 @@ -814,8 +816,7 @@ int xenbus_dev_suspend(struct device *de
2154         if (drv->suspend)
2155                 err = drv->suspend(xdev);
2156         if (err)
2157 -               pr_warning("xenbus: suspend %s failed: %i\n",
2158 -                          dev_name(dev), err);
2159 +               pr_warn("suspend %s failed: %i\n", dev_name(dev), err);
2160         return 0;
2161  }
2162  PARAVIRT_EXPORT_SYMBOL(xenbus_dev_suspend);
2163 @@ -836,8 +837,8 @@ static int __maybe_unused suspend_cancel
2164         if (drv->suspend_cancel)
2165                 err = drv->suspend_cancel(xdev);
2166         if (err)
2167 -               pr_warning("xenbus: suspend_cancel %s failed: %i\n",
2168 -                          dev_name(dev), err);
2169 +               pr_warn("suspend_cancel %s failed: %i\n",
2170 +                       dev_name(dev), err);
2171         return 0;
2172  }
2173  
2174 @@ -858,8 +859,8 @@ int xenbus_dev_resume(struct device *dev
2175         drv = to_xenbus_driver(dev->driver);
2176         err = talk_to_otherend(xdev);
2177         if (err) {
2178 -               pr_warning("xenbus: resume (talk_to_otherend) %s failed: %i\n",
2179 -                          dev_name(dev), err);
2180 +               pr_warn("resume (talk_to_otherend) %s failed: %i\n",
2181 +                       dev_name(dev), err);
2182                 return err;
2183         }
2184  
2185 @@ -868,16 +869,15 @@ int xenbus_dev_resume(struct device *dev
2186         if (drv->resume) {
2187                 err = drv->resume(xdev);
2188                 if (err) {
2189 -                       pr_warning("xenbus: resume %s failed: %i\n",
2190 -                                  dev_name(dev), err);
2191 +                       pr_warn("resume %s failed: %i\n", dev_name(dev), err);
2192                         return err;
2193                 }
2194         }
2195  
2196         err = watch_otherend(xdev);
2197         if (err) {
2198 -               pr_warning("xenbus_probe: resume (watch_otherend) %s failed:"
2199 -                          " %d\n", dev_name(dev), err);
2200 +               pr_warn("resume (watch_otherend) %s failed: %d.\n",
2201 +                       dev_name(dev), err);
2202                 return err;
2203         }
2204  
2205 @@ -971,7 +971,7 @@ static void xenbus_reset_wait_for_backen
2206         timeout = wait_event_interruptible_timeout(backend_state_wq,
2207                         backend_state == expected, 5 * HZ);
2208         if (timeout <= 0)
2209 -               pr_info("XENBUS: backend %s timed out.\n", be);
2210 +               pr_info("backend %s timed out.\n", be);
2211  }
2212  
2213  /*
2214 @@ -994,7 +994,7 @@ static void xenbus_reset_frontend(char *
2215         be_watch.callback = xenbus_reset_backend_state_changed;
2216         backend_state = XenbusStateUnknown;
2217  
2218 -       pr_info("XENBUS: triggering reconnect on %s\n", be);
2219 +       pr_info("triggering reconnect on %s\n", be);
2220         register_xenbus_watch(&be_watch);
2221  
2222         /* fall through to forward backend to state XenbusStateInitialising */
2223 @@ -1013,7 +1013,7 @@ static void xenbus_reset_frontend(char *
2224         }
2225  
2226         unregister_xenbus_watch(&be_watch);
2227 -       pr_info("XENBUS: reconnect done on %s\n", be);
2228 +       pr_info("reconnect done on %s\n", be);
2229         kfree(be_watch.node);
2230  }
2231  
2232 @@ -1227,8 +1227,7 @@ int xenbus_conn(domid_t remote_dom, gran
2233  fail1:
2234         rc2 = close_evtchn(xen_store_evtchn);
2235         if (rc2 != 0)
2236 -               pr_warning("XENBUS: Error freeing xenstore event channel:"
2237 -                          " %d\n", rc2);
2238 +               pr_warn("Error freeing xenstore event channel: %d\n", rc2);
2239  fail0:
2240         xen_store_evtchn = -1;
2241         return rc;
2242 @@ -1297,8 +1296,8 @@ xenbus_init(void)
2243         /* Register ourselves with the kernel bus subsystem */
2244         xenbus_frontend.error = bus_register(&xenbus_frontend.bus);
2245         if (xenbus_frontend.error)
2246 -               pr_warning("XENBUS: Error registering frontend bus: %i\n",
2247 -                          xenbus_frontend.error);
2248 +               pr_warn("Error registering frontend bus: %i\n",
2249 +                       xenbus_frontend.error);
2250         xenbus_backend_bus_register();
2251  
2252         /*
2253 @@ -1393,8 +1392,7 @@ xenbus_init(void)
2254         /* Initialize the interface to xenstore. */
2255         err = xs_init();
2256         if (err) {
2257 -               pr_warning("XENBUS: Error initializing xenstore comms: %i\n",
2258 -                          err);
2259 +               pr_warn("Error initializing xenstore comms: %i\n", err);
2260                 goto out_error;
2261         }
2262  
2263 @@ -1404,8 +1402,8 @@ xenbus_init(void)
2264                 xenbus_frontend.error = device_register(&xenbus_frontend.dev);
2265                 if (xenbus_frontend.error) {
2266                         bus_unregister(&xenbus_frontend.bus);
2267 -                       pr_warning("XENBUS: Error registering frontend device:"
2268 -                                  " %d\n", xenbus_frontend.error);
2269 +                       pr_warn("Error registering frontend device: %d\n",
2270 +                               xenbus_frontend.error);
2271                 }
2272         }
2273         xenbus_backend_device_register();
2274 @@ -1487,8 +1485,7 @@ static int print_device_status(struct de
2275  
2276         if (!dev->driver) {
2277                 /* Information only: is this too noisy? */
2278 -               pr_info("XENBUS: Device with no driver: %s\n",
2279 -                       xendev->nodename);
2280 +               pr_info("Device with no driver: %s\n", xendev->nodename);
2281                 return 0;
2282         }
2283  
2284 @@ -1496,15 +1493,14 @@ static int print_device_status(struct de
2285                 enum xenbus_state rstate = XenbusStateUnknown;
2286                 if (xendev->otherend)
2287                         rstate = xenbus_read_driver_state(xendev->otherend);
2288 -               pr_warning("XENBUS: Timeout connecting to device: %s"
2289 -                          " (local state %d, remote state %d)\n",
2290 -                          xendev->nodename, xendev->state, rstate);
2291 +               pr_warn("Timeout connecting to device: %s"
2292 +                       " (local state %d, remote state %d)\n",
2293 +                       xendev->nodename, xendev->state, rstate);
2294         }
2295  
2296         xendrv = to_xenbus_driver(dev->driver);
2297         if (xendrv->is_ready && !xendrv->is_ready(xendev))
2298 -               pr_warning("XENBUS: Device not ready: %s\n",
2299 -                          xendev->nodename);
2300 +               pr_warn("Device not ready: %s\n", xendev->nodename);
2301  
2302         return 0;
2303  }
2304 @@ -1538,8 +1534,7 @@ static void wait_for_devices(struct xenb
2305         while (exists_connecting_device(drv)) {
2306                 if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
2307                         if (!seconds_waited)
2308 -                               pr_warning("XENBUS: Waiting for "
2309 -                                          "devices to initialise: ");
2310 +                               pr_warn("Waiting for devices to initialise: ");
2311                         seconds_waited += 5;
2312                         pr_cont("%us...", 300 - seconds_waited);
2313                         if (seconds_waited == 300)
2314 --- head.orig/drivers/xen/xenbus/xenbus_probe_backend.c 2011-11-17 15:56:06.000000000 +0100
2315 +++ head/drivers/xen/xenbus/xenbus_probe_backend.c      2013-08-12 13:55:51.000000000 +0200
2316 @@ -31,9 +31,11 @@
2317   * IN THE SOFTWARE.
2318   */
2319  
2320 -#define DPRINTK(fmt, args...)                          \
2321 -       pr_debug("xenbus_probe (%s:%d) " fmt ".\n",     \
2322 -                __func__, __LINE__, ##args)
2323 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2324 +
2325 +#define DPRINTK(fmt, ...)                              \
2326 +       pr_debug("(%s:%d) " fmt "\n",                   \
2327 +                __func__, __LINE__, ##__VA_ARGS__)
2328  
2329  #include <linux/kernel.h>
2330  #include <linux/version.h>
2331 @@ -326,8 +328,8 @@ void xenbus_backend_bus_register(void)
2332  {
2333         xenbus_backend.error = bus_register(&xenbus_backend.bus);
2334         if (xenbus_backend.error)
2335 -               pr_warning("XENBUS: Error registering backend bus: %i\n",
2336 -                          xenbus_backend.error);
2337 +               pr_warn("Error registering backend bus: %i\n",
2338 +                       xenbus_backend.error);
2339  }
2340  
2341  void xenbus_backend_device_register(void)
2342 @@ -338,8 +340,8 @@ void xenbus_backend_device_register(void
2343         xenbus_backend.error = device_register(&xenbus_backend.dev);
2344         if (xenbus_backend.error) {
2345                 bus_unregister(&xenbus_backend.bus);
2346 -               pr_warning("XENBUS: Error registering backend device: %i\n",
2347 -                          xenbus_backend.error);
2348 +               pr_warn("Error registering backend device: %i\n",
2349 +                       xenbus_backend.error);
2350         }
2351  }
2352  
2353 --- head.orig/drivers/xen/xenbus/xenbus_xs.c    2013-01-30 12:03:06.000000000 +0100
2354 +++ head/drivers/xen/xenbus/xenbus_xs.c 2013-08-12 13:00:59.000000000 +0200
2355 @@ -31,6 +31,8 @@
2356   * IN THE SOFTWARE.
2357   */
2358  
2359 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2360 +
2361  #include <linux/unistd.h>
2362  #include <linux/errno.h>
2363  #include <linux/types.h>
2364 @@ -139,8 +141,8 @@ static int get_error(const char *errorst
2365  
2366         for (i = 0; strcmp(errorstring, xsd_errors[i].errstring) != 0; i++) {
2367                 if (i == ARRAY_SIZE(xsd_errors) - 1) {
2368 -                       pr_warning("XENBUS xen store gave: unknown error %s",
2369 -                                  errorstring);
2370 +                       pr_warn("xen store gave: unknown error %s\n",
2371 +                               errorstring);
2372                         return EINVAL;
2373                 }
2374         }
2375 @@ -284,7 +286,7 @@ static void *xs_talkv(struct xenbus_tran
2376         }
2377  
2378         if (msg.type != type) {
2379 -               pr_warn_ratelimited("XENBUS unexpected type [%d], expected [%d]\n",
2380 +               pr_warn_ratelimited("unexpected type [%d], expected [%d]\n",
2381                                     msg.type, type);
2382                 kfree(ret);
2383                 return ERR_PTR(-EINVAL);
2384 @@ -672,7 +674,7 @@ static void xs_reset_watches(void)
2385  
2386         err = xs_error(xs_single(XBT_NIL, XS_RESET_WATCHES, "", NULL));
2387         if (err && err != -EEXIST)
2388 -               pr_warning("xs_reset_watches failed: %d\n", err);
2389 +               pr_warn("xs_reset_watches failed: %d\n", err);
2390  #endif
2391  }
2392  
2393 @@ -727,8 +729,7 @@ void unregister_xenbus_watch(struct xenb
2394  
2395         err = xs_unwatch(watch->node, token);
2396         if (err)
2397 -               pr_warning("XENBUS Failed to release watch %s: %i\n",
2398 -                          watch->node, err);
2399 +               pr_warn("Failed to release watch %s: %i\n", watch->node, err);
2400  
2401         up_read(&xs_state.watch_mutex);
2402  
2403 @@ -970,8 +971,7 @@ static int xenbus_thread(void *unused)
2404         for (;;) {
2405                 err = process_msg();
2406                 if (err)
2407 -                       pr_warning("XENBUS error %d while reading "
2408 -                                  "message\n", err);
2409 +                       pr_warn("error %d while reading message\n", err);
2410                 if (kthread_should_stop())
2411                         break;
2412         }
2413 --- head.orig/include/xen/interface/io/blkif.h  2013-06-20 15:31:49.000000000 +0200
2414 +++ head/include/xen/interface/io/blkif.h       2013-08-12 13:00:59.000000000 +0200
2415 @@ -468,6 +468,30 @@
2416  #define BLKIF_OP_DISCARD           5
2417  
2418  /*
2419 + * Recognized if "feature-max-indirect-segments" is present in the backend
2420 + * xenbus info. The "feature-max-indirect-segments" node contains the maximum
2421 + * number of segments allowed by the backend per request. If the node is
2422 + * present, the frontend might use blkif_request_indirect structs in order to
2423 + * issue requests with more than BLKIF_MAX_SEGMENTS_PER_REQUEST (11). The
2424 + * maximum number of indirect segments is fixed by the backend, but the
2425 + * frontend can issue requests with any number of indirect segments as long as
2426 + * it's less than the number provided by the backend. The indirect_grefs field
2427 + * in blkif_request_indirect should be filled by the frontend with the
2428 + * grant references of the pages that are holding the indirect segments.
2429 + * This pages are filled with an array of blkif_request_segment_aligned
2430 + * that hold the information about the segments. The number of indirect
2431 + * pages to use is determined by the maximum number of segments
2432 + * a indirect request contains. Every indirect page can contain a maximum
2433 + * of 512 segments (PAGE_SIZE/sizeof(blkif_request_segment_aligned)),
2434 + * so to calculate the number of indirect pages to use we have to do
2435 + * ceil(indirect_segments/512).
2436 + *
2437 + * If a backend does not recognize BLKIF_OP_INDIRECT, it should *not*
2438 + * create the "feature-max-indirect-segments" node!
2439 + */
2440 +#define BLKIF_OP_INDIRECT          6
2441 +
2442 +/*
2443   * Maximum scatter/gather segments per request.
2444   * This is carefully chosen so that sizeof(struct blkif_ring) <= PAGE_SIZE.
2445   * NB. This could be 12 if the ring indexes weren't stored in the same page.
2446 @@ -489,6 +513,16 @@ struct blkif_request_segment {
2447      uint8_t     first_sect, last_sect;
2448  };
2449  
2450 +#define BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST 8
2451 +
2452 +struct blkif_request_segment_aligned {
2453 +       grant_ref_t gref;        /* reference to I/O buffer frame        */
2454 +       /* @first_sect: first sector in frame to transfer (inclusive).   */
2455 +       /* @last_sect: last sector in frame to transfer (inclusive).     */
2456 +       uint8_t     first_sect, last_sect;
2457 +       uint16_t    _pad; /* padding to make it 8 bytes, so it's cache-aligned */
2458 +} __attribute__((__packed__));
2459 +
2460  /*
2461   * Starting ring element for any I/O request.
2462   */
2463 @@ -533,6 +567,23 @@ struct blkif_request {
2464  #endif
2465                 uint64_t     id;         /* private guest value, echoed in resp  */
2466         } other;
2467 +       struct __attribute__((__packed__)) blkif_request_indirect {
2468 +               uint8_t        indirect_op;
2469 +               uint16_t       nr_segments;
2470 +#ifdef CONFIG_X86_64
2471 +               uint32_t       _pad1;    /* offsetof(blkif_...,u.indirect.id) == 8 */
2472 +#endif
2473 +               uint64_t       id;
2474 +               blkif_sector_t sector_number;
2475 +               blkif_vdev_t   handle;
2476 +               uint16_t       _pad2;
2477 +               grant_ref_t    indirect_grefs[BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST];
2478 +#ifdef CONFIG_X86_64
2479 +               uint32_t      _pad3;     /* make it 64 byte aligned */
2480 +#else
2481 +               uint64_t      _pad3;     /* make it 64 byte aligned */
2482 +#endif
2483 +       } indirect;
2484      } u;
2485  } __attribute__((__packed__));
2486  #endif
2487 --- head.orig/mm/page_alloc.c   2013-08-09 15:37:59.000000000 +0200
2488 +++ head/mm/page_alloc.c        2013-08-14 08:39:04.000000000 +0200
2489 @@ -5529,8 +5529,8 @@ static void __setup_per_zone_wmarks(void
2490                         high = percpu_pagelist_fraction
2491                                ? zone->present_pages / percpu_pagelist_fraction
2492                                : 5 * zone_batchsize(zone);
2493 -                       setup_pagelist_highmark(
2494 -                               per_cpu_ptr(zone->pageset, cpu), high);
2495 +                       pageset_set_high(per_cpu_ptr(zone->pageset, cpu),
2496 +                                        high);
2497                 }
2498         }
2499  #endif