]>
Commit | Line | Data |
---|---|---|
cc90b958 BS |
1 | From: www.kernel.org |
2 | Subject: Linux 2.6.21 | |
3 | Patch-mainline: 2.6.21 | |
4 | ||
5 | Automatically created from "patches.kernel.org/patch-2.6.21" by xen-port-patches.py | |
6 | ||
7 | Acked-by: jbeulich@novell.com | |
8 | ||
9 | --- | |
10 | arch/x86/Kconfig | 4 | |
11 | arch/x86/ia32/ia32entry-xen.S | 5 | |
12 | arch/x86/kernel/Makefile | 4 | |
13 | arch/x86/kernel/acpi/sleep_64-xen.c | 6 | |
14 | arch/x86/kernel/apic_32-xen.c | 65 ---- | |
15 | arch/x86/kernel/cpu/common-xen.c | 14 | |
16 | arch/x86/kernel/e820_32-xen.c | 18 - | |
17 | arch/x86/kernel/e820_64-xen.c | 40 ++ | |
18 | arch/x86/kernel/entry_32-xen.S | 80 +++-- | |
19 | arch/x86/kernel/entry_64-xen.S | 3 | |
20 | arch/x86/kernel/genapic_64-xen.c | 4 | |
21 | arch/x86/kernel/head64-xen.c | 8 | |
22 | arch/x86/kernel/head_32-xen.S | 9 | |
23 | arch/x86/kernel/io_apic_32-xen.c | 43 +- | |
24 | arch/x86/kernel/io_apic_64-xen.c | 414 +++++++++++++------------- | |
25 | arch/x86/kernel/irq_32-xen.c | 22 + | |
26 | arch/x86/kernel/irq_64-xen.c | 13 | |
27 | arch/x86/kernel/microcode-xen.c | 2 | |
28 | arch/x86/kernel/mpparse_32-xen.c | 4 | |
29 | arch/x86/kernel/mpparse_64-xen.c | 6 | |
30 | arch/x86/kernel/pci-dma-xen.c | 2 | |
31 | arch/x86/kernel/pcspeaker.c | 5 | |
32 | arch/x86/kernel/process_32-xen.c | 42 +- | |
33 | arch/x86/kernel/process_64-xen.c | 13 | |
34 | arch/x86/kernel/setup_32-xen.c | 46 -- | |
35 | arch/x86/kernel/setup_64-xen.c | 184 +---------- | |
36 | arch/x86/kernel/smp_32-xen.c | 5 | |
37 | arch/x86/kernel/time_32-xen.c | 279 +---------------- | |
38 | arch/x86/kernel/traps_32-xen.c | 27 + | |
39 | arch/x86/kernel/vsyscall_64-xen.c | 127 ++++--- | |
40 | arch/x86/mm/fault_32-xen.c | 44 -- | |
41 | arch/x86/mm/fault_64-xen.c | 39 -- | |
42 | arch/x86/mm/highmem_32-xen.c | 9 | |
43 | arch/x86/mm/init_32-xen.c | 2 | |
44 | arch/x86/mm/init_64-xen.c | 24 + | |
45 | arch/x86/mm/pageattr_64-xen.c | 6 | |
46 | arch/x86/mm/pgtable_32-xen.c | 28 + | |
47 | drivers/acpi/processor_extcntl.c | 18 - | |
48 | drivers/char/tpm/tpm_xen.c | 5 | |
49 | drivers/pci/msi-xen.c | 196 +++--------- | |
50 | drivers/xen/balloon/sysfs.c | 1 | |
51 | drivers/xen/blkback/xenbus.c | 4 | |
52 | drivers/xen/blkfront/blkfront.c | 1 | |
53 | drivers/xen/blktap/xenbus.c | 4 | |
54 | drivers/xen/core/evtchn.c | 4 | |
55 | drivers/xen/core/smpboot.c | 22 - | |
56 | drivers/xen/fbfront/xenfb.c | 1 | |
57 | drivers/xen/fbfront/xenkbd.c | 1 | |
58 | drivers/xen/netback/xenbus.c | 4 | |
59 | drivers/xen/netfront/netfront.c | 49 +-- | |
60 | drivers/xen/pciback/xenbus.c | 1 | |
61 | drivers/xen/pcifront/xenbus.c | 1 | |
62 | drivers/xen/scsiback/xenbus.c | 1 | |
63 | drivers/xen/scsifront/xenbus.c | 1 | |
64 | drivers/xen/tpmback/common.h | 4 | |
65 | drivers/xen/tpmback/interface.c | 5 | |
66 | drivers/xen/tpmback/tpmback.c | 16 - | |
67 | drivers/xen/tpmback/xenbus.c | 5 | |
68 | drivers/xen/xenbus/xenbus_probe.c | 17 - | |
69 | drivers/xen/xenbus/xenbus_probe.h | 4 | |
70 | drivers/xen/xenbus/xenbus_probe_backend.c | 8 | |
71 | drivers/xen/xenoprof/xenoprofile.c | 2 | |
72 | include/asm-x86/i8253.h | 4 | |
73 | include/asm-x86/mach-xen/asm/desc_32.h | 2 | |
74 | include/asm-x86/mach-xen/asm/dma-mapping_64.h | 4 | |
75 | include/asm-x86/mach-xen/asm/hypervisor.h | 15 | |
76 | include/asm-x86/mach-xen/asm/io_32.h | 6 | |
77 | include/asm-x86/mach-xen/asm/io_64.h | 8 | |
78 | include/asm-x86/mach-xen/asm/mmu_context_32.h | 10 | |
79 | include/asm-x86/mach-xen/asm/pgalloc_32.h | 21 + | |
80 | include/asm-x86/mach-xen/asm/pgtable_32.h | 25 + | |
81 | include/asm-x86/mach-xen/asm/pgtable_64.h | 9 | |
82 | include/asm-x86/mach-xen/asm/processor_32.h | 6 | |
83 | include/asm-x86/mach-xen/asm/segment_32.h | 23 + | |
84 | include/asm-x86/mach-xen/asm/smp_32.h | 5 | |
85 | include/asm-x86/mach-xen/asm/smp_64.h | 3 | |
86 | include/xen/xenbus.h | 24 + | |
87 | lib/swiotlb-xen.c | 19 - | |
88 | 78 files changed, 946 insertions(+), 1259 deletions(-) | |
89 | ||
90 | --- a/arch/x86/ia32/ia32entry-xen.S | |
91 | +++ b/arch/x86/ia32/ia32entry-xen.S | |
92 | @@ -465,7 +465,7 @@ ia32_sys_call_table: | |
93 | .quad sys32_vm86_warning /* vm86old */ | |
94 | .quad compat_sys_wait4 | |
95 | .quad sys_swapoff /* 115 */ | |
96 | - .quad sys32_sysinfo | |
97 | + .quad compat_sys_sysinfo | |
98 | .quad sys32_ipc | |
99 | .quad sys_fsync | |
100 | .quad stub32_sigreturn | |
101 | @@ -510,7 +510,7 @@ ia32_sys_call_table: | |
102 | .quad sys_sched_yield | |
103 | .quad sys_sched_get_priority_max | |
104 | .quad sys_sched_get_priority_min /* 160 */ | |
105 | - .quad sys_sched_rr_get_interval | |
106 | + .quad sys32_sched_rr_get_interval | |
107 | .quad compat_sys_nanosleep | |
108 | .quad sys_mremap | |
109 | .quad sys_setresuid16 | |
110 | @@ -668,4 +668,5 @@ ia32_sys_call_table: | |
111 | .quad compat_sys_vmsplice | |
112 | .quad compat_sys_move_pages | |
113 | .quad sys_getcpu | |
114 | + .quad sys_epoll_pwait | |
115 | ia32_syscall_end: | |
116 | --- a/arch/x86/Kconfig | |
117 | +++ b/arch/x86/Kconfig | |
118 | @@ -50,13 +50,15 @@ config GENERIC_CMOS_UPDATE | |
119 | ||
120 | config CLOCKSOURCE_WATCHDOG | |
121 | def_bool y | |
122 | + depends on !X86_XEN | |
123 | ||
124 | config GENERIC_CLOCKEVENTS | |
125 | def_bool y | |
126 | + depends on !X86_XEN | |
127 | ||
128 | config GENERIC_CLOCKEVENTS_BROADCAST | |
129 | def_bool y | |
130 | - depends on X86_64 || (X86_32 && X86_LOCAL_APIC) | |
131 | + depends on X86_64 || (X86_32 && X86_LOCAL_APIC && !X86_XEN) | |
132 | ||
133 | config LOCKDEP_SUPPORT | |
134 | def_bool y | |
135 | --- a/arch/x86/kernel/acpi/sleep_64-xen.c | |
136 | +++ b/arch/x86/kernel/acpi/sleep_64-xen.c | |
137 | @@ -59,7 +59,7 @@ unsigned long acpi_wakeup_address = 0; | |
138 | unsigned long acpi_video_flags; | |
139 | extern char wakeup_start, wakeup_end; | |
140 | ||
141 | -extern unsigned long FASTCALL(acpi_copy_wakeup_routine(unsigned long)); | |
142 | +extern unsigned long acpi_copy_wakeup_routine(unsigned long); | |
143 | ||
144 | static pgd_t low_ptr; | |
145 | ||
146 | @@ -67,8 +67,10 @@ static void init_low_mapping(void) | |
147 | { | |
148 | pgd_t *slot0 = pgd_offset(current->mm, 0UL); | |
149 | low_ptr = *slot0; | |
150 | + /* FIXME: We're playing with the current task's page tables here, which | |
151 | + * is potentially dangerous on SMP systems. | |
152 | + */ | |
153 | set_pgd(slot0, *pgd_offset(current->mm, PAGE_OFFSET)); | |
154 | - WARN_ON(num_online_cpus() != 1); | |
155 | local_flush_tlb(); | |
156 | } | |
157 | #endif | |
158 | --- a/arch/x86/kernel/apic_32-xen.c | |
159 | +++ b/arch/x86/kernel/apic_32-xen.c | |
160 | @@ -25,6 +25,8 @@ | |
161 | #include <linux/kernel_stat.h> | |
162 | #include <linux/sysdev.h> | |
163 | #include <linux/cpu.h> | |
164 | +#include <linux/clockchips.h> | |
165 | +#include <linux/acpi_pmtmr.h> | |
166 | #include <linux/module.h> | |
167 | ||
168 | #include <asm/atomic.h> | |
169 | @@ -56,83 +58,26 @@ static cpumask_t timer_bcast_ipi; | |
170 | */ | |
171 | ||
172 | /* | |
173 | - * Debug level | |
174 | + * Debug level, exported for io_apic.c | |
175 | */ | |
176 | int apic_verbosity; | |
177 | ||
178 | #ifndef CONFIG_XEN | |
179 | static int modern_apic(void) | |
180 | { | |
181 | - unsigned int lvr, version; | |
182 | /* AMD systems use old APIC versions, so check the CPU */ | |
183 | if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD && | |
184 | - boot_cpu_data.x86 >= 0xf) | |
185 | + boot_cpu_data.x86 >= 0xf) | |
186 | return 1; | |
187 | - lvr = apic_read(APIC_LVR); | |
188 | - version = GET_APIC_VERSION(lvr); | |
189 | - return version >= 0x14; | |
190 | + return lapic_get_version() >= 0x14; | |
191 | } | |
192 | #endif /* !CONFIG_XEN */ | |
193 | ||
194 | -/* | |
195 | - * 'what should we do if we get a hw irq event on an illegal vector'. | |
196 | - * each architecture has to answer this themselves. | |
197 | - */ | |
198 | -void ack_bad_irq(unsigned int irq) | |
199 | -{ | |
200 | - printk("unexpected IRQ trap at vector %02x\n", irq); | |
201 | - /* | |
202 | - * Currently unexpected vectors happen only on SMP and APIC. | |
203 | - * We _must_ ack these because every local APIC has only N | |
204 | - * irq slots per priority level, and a 'hanging, unacked' IRQ | |
205 | - * holds up an irq slot - in excessive cases (when multiple | |
206 | - * unexpected vectors occur) that might lock up the APIC | |
207 | - * completely. | |
208 | - * But only ack when the APIC is enabled -AK | |
209 | - */ | |
210 | - if (cpu_has_apic) | |
211 | - ack_APIC_irq(); | |
212 | -} | |
213 | - | |
214 | int get_physical_broadcast(void) | |
215 | { | |
216 | return 0xff; | |
217 | } | |
218 | ||
219 | -#ifndef CONFIG_XEN | |
220 | -#ifndef CONFIG_SMP | |
221 | -static void up_apic_timer_interrupt_call(void) | |
222 | -{ | |
223 | - int cpu = smp_processor_id(); | |
224 | - | |
225 | - /* | |
226 | - * the NMI deadlock-detector uses this. | |
227 | - */ | |
228 | - per_cpu(irq_stat, cpu).apic_timer_irqs++; | |
229 | - | |
230 | - smp_local_timer_interrupt(); | |
231 | -} | |
232 | -#endif | |
233 | - | |
234 | -void smp_send_timer_broadcast_ipi(void) | |
235 | -{ | |
236 | - cpumask_t mask; | |
237 | - | |
238 | - cpus_and(mask, cpu_online_map, timer_bcast_ipi); | |
239 | - if (!cpus_empty(mask)) { | |
240 | -#ifdef CONFIG_SMP | |
241 | - send_IPI_mask(mask, LOCAL_TIMER_VECTOR); | |
242 | -#else | |
243 | - /* | |
244 | - * We can directly call the apic timer interrupt handler | |
245 | - * in UP case. Minus all irq related functions | |
246 | - */ | |
247 | - up_apic_timer_interrupt_call(); | |
248 | -#endif | |
249 | - } | |
250 | -} | |
251 | -#endif | |
252 | - | |
253 | int setup_profiling_timer(unsigned int multiplier) | |
254 | { | |
255 | return -EINVAL; | |
256 | --- a/arch/x86/kernel/cpu/common-xen.c | |
257 | +++ b/arch/x86/kernel/cpu/common-xen.c | |
258 | @@ -610,7 +610,7 @@ void __init early_cpu_init(void) | |
259 | struct pt_regs * __devinit idle_regs(struct pt_regs *regs) | |
260 | { | |
261 | memset(regs, 0, sizeof(struct pt_regs)); | |
262 | - regs->xgs = __KERNEL_PDA; | |
263 | + regs->xfs = __KERNEL_PDA; | |
264 | return regs; | |
265 | } | |
266 | ||
267 | @@ -667,12 +667,12 @@ struct i386_pda boot_pda = { | |
268 | .pcurrent = &init_task, | |
269 | }; | |
270 | ||
271 | -static inline void set_kernel_gs(void) | |
272 | +static inline void set_kernel_fs(void) | |
273 | { | |
274 | - /* Set %gs for this CPU's PDA. Memory clobber is to create a | |
275 | + /* Set %fs for this CPU's PDA. Memory clobber is to create a | |
276 | barrier with respect to any PDA operations, so the compiler | |
277 | doesn't move any before here. */ | |
278 | - asm volatile ("mov %0, %%gs" : : "r" (__KERNEL_PDA) : "memory"); | |
279 | + asm volatile ("mov %0, %%fs" : : "r" (__KERNEL_PDA) : "memory"); | |
280 | } | |
281 | ||
282 | /* Initialize the CPU's GDT and PDA. The boot CPU does this for | |
283 | @@ -730,7 +730,7 @@ void __cpuinit cpu_set_gdt(int cpu) | |
284 | } | |
285 | BUG_ON(HYPERVISOR_set_gdt(frames, (cpu_gdt_descr->size + 1) / 8)); | |
286 | ||
287 | - set_kernel_gs(); | |
288 | + set_kernel_fs(); | |
289 | } | |
290 | ||
291 | /* Common CPU init for both boot and secondary CPUs */ | |
292 | @@ -775,8 +775,8 @@ static void __cpuinit _cpu_init(int cpu, | |
293 | __set_tss_desc(cpu, GDT_ENTRY_DOUBLEFAULT_TSS, &doublefault_tss); | |
294 | #endif | |
295 | ||
296 | - /* Clear %fs. */ | |
297 | - asm volatile ("mov %0, %%fs" : : "r" (0)); | |
298 | + /* Clear %gs. */ | |
299 | + asm volatile ("mov %0, %%gs" : : "r" (0)); | |
300 | ||
301 | /* Clear all 6 debug registers: */ | |
302 | set_debugreg(0, 0); | |
303 | --- a/arch/x86/kernel/e820_32-xen.c | |
304 | +++ b/arch/x86/kernel/e820_32-xen.c | |
305 | @@ -14,6 +14,7 @@ | |
306 | #include <asm/pgtable.h> | |
307 | #include <asm/page.h> | |
308 | #include <asm/e820.h> | |
309 | +#include <asm/setup.h> | |
310 | #include <xen/interface/memory.h> | |
311 | ||
312 | #ifdef CONFIG_EFI | |
313 | @@ -157,21 +158,22 @@ static struct resource standard_io_resou | |
314 | .flags = IORESOURCE_BUSY | IORESOURCE_IO | |
315 | } }; | |
316 | ||
317 | -static int romsignature(const unsigned char *x) | |
318 | +#define ROMSIGNATURE 0xaa55 | |
319 | + | |
320 | +static int __init romsignature(const unsigned char *rom) | |
321 | { | |
322 | unsigned short sig; | |
323 | - int ret = 0; | |
324 | - if (probe_kernel_address((const unsigned short *)x, sig) == 0) | |
325 | - ret = (sig == 0xaa55); | |
326 | - return ret; | |
327 | + | |
328 | + return probe_kernel_address((const unsigned short *)rom, sig) == 0 && | |
329 | + sig == ROMSIGNATURE; | |
330 | } | |
331 | ||
332 | static int __init romchecksum(unsigned char *rom, unsigned long length) | |
333 | { | |
334 | - unsigned char *p, sum = 0; | |
335 | + unsigned char sum; | |
336 | ||
337 | - for (p = rom; p < rom + length; p++) | |
338 | - sum += *p; | |
339 | + for (sum = 0; length; length--) | |
340 | + sum += *rom++; | |
341 | return sum == 0; | |
342 | } | |
343 | ||
344 | --- a/arch/x86/kernel/e820_64-xen.c | |
345 | +++ b/arch/x86/kernel/e820_64-xen.c | |
346 | @@ -88,6 +88,13 @@ static inline int bad_addr(unsigned long | |
347 | return 1; | |
348 | } | |
349 | ||
350 | +#ifdef CONFIG_NUMA | |
351 | + /* NUMA memory to node map */ | |
352 | + if (last >= nodemap_addr && addr < nodemap_addr + nodemap_size) { | |
353 | + *addrp = nodemap_addr + nodemap_size; | |
354 | + return 1; | |
355 | + } | |
356 | +#endif | |
357 | /* XXX ramdisk image here? */ | |
358 | #else | |
359 | if (last < (table_end<<PAGE_SHIFT)) { | |
360 | @@ -213,6 +220,37 @@ unsigned long __init e820_end_of_ram(voi | |
361 | } | |
362 | ||
363 | /* | |
364 | + * Find the hole size in the range. | |
365 | + */ | |
366 | +unsigned long __init e820_hole_size(unsigned long start, unsigned long end) | |
367 | +{ | |
368 | + unsigned long ram = 0; | |
369 | + int i; | |
370 | + | |
371 | + for (i = 0; i < e820.nr_map; i++) { | |
372 | + struct e820entry *ei = &e820.map[i]; | |
373 | + unsigned long last, addr; | |
374 | + | |
375 | + if (ei->type != E820_RAM || | |
376 | + ei->addr+ei->size <= start || | |
377 | + ei->addr >= end) | |
378 | + continue; | |
379 | + | |
380 | + addr = round_up(ei->addr, PAGE_SIZE); | |
381 | + if (addr < start) | |
382 | + addr = start; | |
383 | + | |
384 | + last = round_down(ei->addr + ei->size, PAGE_SIZE); | |
385 | + if (last >= end) | |
386 | + last = end; | |
387 | + | |
388 | + if (last > addr) | |
389 | + ram += last - addr; | |
390 | + } | |
391 | + return ((end - start) - ram); | |
392 | +} | |
393 | + | |
394 | +/* | |
395 | * Mark e820 reserved areas as busy for the resource manager. | |
396 | */ | |
397 | void __init e820_reserve_resources(struct e820entry *e820, int nr_map) | |
398 | @@ -738,7 +776,7 @@ static int __init parse_memmap_opt(char | |
399 | } | |
400 | early_param("memmap", parse_memmap_opt); | |
401 | ||
402 | -void finish_e820_parsing(void) | |
403 | +void __init finish_e820_parsing(void) | |
404 | { | |
405 | if (userdef) { | |
406 | printk(KERN_INFO "user-defined physical RAM map:\n"); | |
407 | --- a/arch/x86/kernel/entry_32-xen.S | |
408 | +++ b/arch/x86/kernel/entry_32-xen.S | |
409 | @@ -30,7 +30,7 @@ | |
410 | * 18(%esp) - %eax | |
411 | * 1C(%esp) - %ds | |
412 | * 20(%esp) - %es | |
413 | - * 24(%esp) - %gs | |
414 | + * 24(%esp) - %fs | |
415 | * 28(%esp) - orig_eax | |
416 | * 2C(%esp) - %eip | |
417 | * 30(%esp) - %cs | |
418 | @@ -102,9 +102,9 @@ NMI_MASK = 0x80000000 | |
419 | ||
420 | #define SAVE_ALL \ | |
421 | cld; \ | |
422 | - pushl %gs; \ | |
423 | + pushl %fs; \ | |
424 | CFI_ADJUST_CFA_OFFSET 4;\ | |
425 | - /*CFI_REL_OFFSET gs, 0;*/\ | |
426 | + /*CFI_REL_OFFSET fs, 0;*/\ | |
427 | pushl %es; \ | |
428 | CFI_ADJUST_CFA_OFFSET 4;\ | |
429 | /*CFI_REL_OFFSET es, 0;*/\ | |
430 | @@ -136,7 +136,7 @@ NMI_MASK = 0x80000000 | |
431 | movl %edx, %ds; \ | |
432 | movl %edx, %es; \ | |
433 | movl $(__KERNEL_PDA), %edx; \ | |
434 | - movl %edx, %gs | |
435 | + movl %edx, %fs | |
436 | ||
437 | #define RESTORE_INT_REGS \ | |
438 | popl %ebx; \ | |
439 | @@ -169,9 +169,9 @@ NMI_MASK = 0x80000000 | |
440 | 2: popl %es; \ | |
441 | CFI_ADJUST_CFA_OFFSET -4;\ | |
442 | /*CFI_RESTORE es;*/\ | |
443 | -3: popl %gs; \ | |
444 | +3: popl %fs; \ | |
445 | CFI_ADJUST_CFA_OFFSET -4;\ | |
446 | - /*CFI_RESTORE gs;*/\ | |
447 | + /*CFI_RESTORE fs;*/\ | |
448 | .pushsection .fixup,"ax"; \ | |
449 | 4: movl $0,(%esp); \ | |
450 | jmp 1b; \ | |
451 | @@ -230,6 +230,7 @@ ENTRY(ret_from_fork) | |
452 | CFI_ADJUST_CFA_OFFSET -4 | |
453 | jmp syscall_exit | |
454 | CFI_ENDPROC | |
455 | +END(ret_from_fork) | |
456 | ||
457 | /* | |
458 | * Return to user mode is not as complex as all this looks, | |
459 | @@ -261,6 +262,7 @@ ENTRY(resume_userspace) | |
460 | # int/exception return? | |
461 | jne work_pending | |
462 | jmp restore_all | |
463 | +END(ret_from_exception) | |
464 | ||
465 | #ifdef CONFIG_PREEMPT | |
466 | ENTRY(resume_kernel) | |
467 | @@ -275,6 +277,7 @@ need_resched: | |
468 | jz restore_all | |
469 | call preempt_schedule_irq | |
470 | jmp need_resched | |
471 | +END(resume_kernel) | |
472 | #endif | |
473 | CFI_ENDPROC | |
474 | ||
475 | @@ -352,16 +355,17 @@ sysenter_past_esp: | |
476 | movl PT_OLDESP(%esp), %ecx | |
477 | xorl %ebp,%ebp | |
478 | TRACE_IRQS_ON | |
479 | -1: mov PT_GS(%esp), %gs | |
480 | +1: mov PT_FS(%esp), %fs | |
481 | ENABLE_INTERRUPTS_SYSEXIT | |
482 | CFI_ENDPROC | |
483 | .pushsection .fixup,"ax" | |
484 | -2: movl $0,PT_GS(%esp) | |
485 | +2: movl $0,PT_FS(%esp) | |
486 | jmp 1b | |
487 | .section __ex_table,"a" | |
488 | .align 4 | |
489 | .long 1b,2b | |
490 | .popsection | |
491 | +ENDPROC(sysenter_entry) | |
492 | ||
493 | # pv sysenter call handler stub | |
494 | ENTRY(sysenter_entry_pv) | |
495 | @@ -533,6 +537,7 @@ hypervisor_iret: | |
496 | jmp hypercall_page + (__HYPERVISOR_iret * 32) | |
497 | #endif | |
498 | CFI_ENDPROC | |
499 | +ENDPROC(system_call) | |
500 | ||
501 | # perform work that needs to be done immediately before resumption | |
502 | ALIGN | |
503 | @@ -578,6 +583,7 @@ work_notifysig_v86: | |
504 | xorl %edx, %edx | |
505 | call do_notify_resume | |
506 | jmp resume_userspace_sig | |
507 | +END(work_pending) | |
508 | ||
509 | # perform syscall exit tracing | |
510 | ALIGN | |
511 | @@ -593,6 +599,7 @@ syscall_trace_entry: | |
512 | cmpl $(nr_syscalls), %eax | |
513 | jnae syscall_call | |
514 | jmp syscall_exit | |
515 | +END(syscall_trace_entry) | |
516 | ||
517 | # perform syscall exit tracing | |
518 | ALIGN | |
519 | @@ -606,6 +613,7 @@ syscall_exit_work: | |
520 | movl $1, %edx | |
521 | call do_syscall_trace | |
522 | jmp resume_userspace | |
523 | +END(syscall_exit_work) | |
524 | CFI_ENDPROC | |
525 | ||
526 | RING0_INT_FRAME # can't unwind into user space anyway | |
527 | @@ -616,16 +624,18 @@ syscall_fault: | |
528 | GET_THREAD_INFO(%ebp) | |
529 | movl $-EFAULT,PT_EAX(%esp) | |
530 | jmp resume_userspace | |
531 | +END(syscall_fault) | |
532 | ||
533 | syscall_badsys: | |
534 | movl $-ENOSYS,PT_EAX(%esp) | |
535 | jmp resume_userspace | |
536 | +END(syscall_badsys) | |
537 | CFI_ENDPROC | |
538 | ||
539 | #ifndef CONFIG_XEN | |
540 | #define FIXUP_ESPFIX_STACK \ | |
541 | /* since we are on a wrong stack, we cant make it a C code :( */ \ | |
542 | - movl %gs:PDA_cpu, %ebx; \ | |
543 | + movl %fs:PDA_cpu, %ebx; \ | |
544 | PER_CPU(cpu_gdt_descr, %ebx); \ | |
545 | movl GDS_address(%ebx), %ebx; \ | |
546 | GET_DESC_BASE(GDT_ENTRY_ESPFIX_SS, %ebx, %eax, %ax, %al, %ah); \ | |
547 | @@ -656,9 +666,9 @@ syscall_badsys: | |
548 | ENTRY(interrupt) | |
549 | .text | |
550 | ||
551 | -vector=0 | |
552 | ENTRY(irq_entries_start) | |
553 | RING0_INT_FRAME | |
554 | +vector=0 | |
555 | .rept NR_IRQS | |
556 | ALIGN | |
557 | .if vector | |
558 | @@ -667,11 +677,16 @@ ENTRY(irq_entries_start) | |
559 | 1: pushl $~(vector) | |
560 | CFI_ADJUST_CFA_OFFSET 4 | |
561 | jmp common_interrupt | |
562 | -.data | |
563 | + .previous | |
564 | .long 1b | |
565 | -.text | |
566 | + .text | |
567 | vector=vector+1 | |
568 | .endr | |
569 | +END(irq_entries_start) | |
570 | + | |
571 | +.previous | |
572 | +END(interrupt) | |
573 | +.previous | |
574 | ||
575 | /* | |
576 | * the CPU automatically disables interrupts when executing an IRQ vector, | |
577 | @@ -684,6 +699,7 @@ common_interrupt: | |
578 | movl %esp,%eax | |
579 | call do_IRQ | |
580 | jmp ret_from_intr | |
581 | +ENDPROC(common_interrupt) | |
582 | CFI_ENDPROC | |
583 | ||
584 | #define BUILD_INTERRUPT(name, nr) \ | |
585 | @@ -696,10 +712,16 @@ ENTRY(name) \ | |
586 | movl %esp,%eax; \ | |
587 | call smp_/**/name; \ | |
588 | jmp ret_from_intr; \ | |
589 | - CFI_ENDPROC | |
590 | + CFI_ENDPROC; \ | |
591 | +ENDPROC(name) | |
592 | ||
593 | /* The include is where all of the SMP etc. interrupts come from */ | |
594 | #include "entry_arch.h" | |
595 | + | |
596 | +/* This alternate entry is needed because we hijack the apic LVTT */ | |
597 | +#if defined(CONFIG_VMI) && defined(CONFIG_X86_LOCAL_APIC) | |
598 | +BUILD_INTERRUPT(apic_vmi_timer_interrupt,LOCAL_TIMER_VECTOR) | |
599 | +#endif | |
600 | #else | |
601 | #define UNWIND_ESPFIX_STACK | |
602 | #endif | |
603 | @@ -710,7 +732,7 @@ KPROBE_ENTRY(page_fault) | |
604 | CFI_ADJUST_CFA_OFFSET 4 | |
605 | ALIGN | |
606 | error_code: | |
607 | - /* the function address is in %gs's slot on the stack */ | |
608 | + /* the function address is in %fs's slot on the stack */ | |
609 | pushl %es | |
610 | CFI_ADJUST_CFA_OFFSET 4 | |
611 | /*CFI_REL_OFFSET es, 0*/ | |
612 | @@ -739,20 +761,20 @@ error_code: | |
613 | CFI_ADJUST_CFA_OFFSET 4 | |
614 | CFI_REL_OFFSET ebx, 0 | |
615 | cld | |
616 | - pushl %gs | |
617 | + pushl %fs | |
618 | CFI_ADJUST_CFA_OFFSET 4 | |
619 | - /*CFI_REL_OFFSET gs, 0*/ | |
620 | + /*CFI_REL_OFFSET fs, 0*/ | |
621 | movl $(__KERNEL_PDA), %ecx | |
622 | - movl %ecx, %gs | |
623 | + movl %ecx, %fs | |
624 | UNWIND_ESPFIX_STACK | |
625 | popl %ecx | |
626 | CFI_ADJUST_CFA_OFFSET -4 | |
627 | /*CFI_REGISTER es, ecx*/ | |
628 | - movl PT_GS(%esp), %edi # get the function address | |
629 | + movl PT_FS(%esp), %edi # get the function address | |
630 | movl PT_ORIG_EAX(%esp), %edx # get the error code | |
631 | movl $-1, PT_ORIG_EAX(%esp) # no syscall to restart | |
632 | - mov %ecx, PT_GS(%esp) | |
633 | - /*CFI_REL_OFFSET gs, ES*/ | |
634 | + mov %ecx, PT_FS(%esp) | |
635 | + /*CFI_REL_OFFSET fs, ES*/ | |
636 | movl $(__USER_DS), %ecx | |
637 | movl %ecx, %ds | |
638 | movl %ecx, %es | |
639 | @@ -839,7 +861,7 @@ critical_fixup_table: | |
640 | .byte 0x18 # pop %eax | |
641 | .byte 0x1c # pop %ds | |
642 | .byte 0x20 # pop %es | |
643 | - .byte 0x24,0x24 # pop %gs | |
644 | + .byte 0x24,0x24 # pop %fs | |
645 | .byte 0x28,0x28,0x28 # add $4,%esp | |
646 | .byte 0x2c # iret | |
647 | .byte 0xff,0xff,0xff,0xff # movb $1,1(%esi) | |
648 | @@ -905,6 +927,7 @@ ENTRY(coprocessor_error) | |
649 | CFI_ADJUST_CFA_OFFSET 4 | |
650 | jmp error_code | |
651 | CFI_ENDPROC | |
652 | +END(coprocessor_error) | |
653 | ||
654 | ENTRY(simd_coprocessor_error) | |
655 | RING0_INT_FRAME | |
656 | @@ -914,6 +937,7 @@ ENTRY(simd_coprocessor_error) | |
657 | CFI_ADJUST_CFA_OFFSET 4 | |
658 | jmp error_code | |
659 | CFI_ENDPROC | |
660 | +END(simd_coprocessor_error) | |
661 | ||
662 | ENTRY(device_not_available) | |
663 | RING0_INT_FRAME | |
664 | @@ -936,6 +960,7 @@ device_available_emulate: | |
665 | call math_state_restore | |
666 | jmp ret_from_exception | |
667 | CFI_ENDPROC | |
668 | +END(device_not_available) | |
669 | ||
670 | #ifndef CONFIG_XEN | |
671 | /* | |
672 | @@ -1097,10 +1122,12 @@ ENTRY(native_iret) | |
673 | .align 4 | |
674 | .long 1b,iret_exc | |
675 | .previous | |
676 | +END(native_iret) | |
677 | ||
678 | ENTRY(native_irq_enable_sysexit) | |
679 | sti | |
680 | sysexit | |
681 | +END(native_irq_enable_sysexit) | |
682 | #endif | |
683 | ||
684 | KPROBE_ENTRY(int3) | |
685 | @@ -1123,6 +1150,7 @@ ENTRY(overflow) | |
686 | CFI_ADJUST_CFA_OFFSET 4 | |
687 | jmp error_code | |
688 | CFI_ENDPROC | |
689 | +END(overflow) | |
690 | ||
691 | ENTRY(bounds) | |
692 | RING0_INT_FRAME | |
693 | @@ -1132,6 +1160,7 @@ ENTRY(bounds) | |
694 | CFI_ADJUST_CFA_OFFSET 4 | |
695 | jmp error_code | |
696 | CFI_ENDPROC | |
697 | +END(bounds) | |
698 | ||
699 | ENTRY(invalid_op) | |
700 | RING0_INT_FRAME | |
701 | @@ -1141,6 +1170,7 @@ ENTRY(invalid_op) | |
702 | CFI_ADJUST_CFA_OFFSET 4 | |
703 | jmp error_code | |
704 | CFI_ENDPROC | |
705 | +END(invalid_op) | |
706 | ||
707 | ENTRY(coprocessor_segment_overrun) | |
708 | RING0_INT_FRAME | |
709 | @@ -1150,6 +1180,7 @@ ENTRY(coprocessor_segment_overrun) | |
710 | CFI_ADJUST_CFA_OFFSET 4 | |
711 | jmp error_code | |
712 | CFI_ENDPROC | |
713 | +END(coprocessor_segment_overrun) | |
714 | ||
715 | ENTRY(invalid_TSS) | |
716 | RING0_EC_FRAME | |
717 | @@ -1157,6 +1188,7 @@ ENTRY(invalid_TSS) | |
718 | CFI_ADJUST_CFA_OFFSET 4 | |
719 | jmp error_code | |
720 | CFI_ENDPROC | |
721 | +END(invalid_TSS) | |
722 | ||
723 | ENTRY(segment_not_present) | |
724 | RING0_EC_FRAME | |
725 | @@ -1164,6 +1196,7 @@ ENTRY(segment_not_present) | |
726 | CFI_ADJUST_CFA_OFFSET 4 | |
727 | jmp error_code | |
728 | CFI_ENDPROC | |
729 | +END(segment_not_present) | |
730 | ||
731 | ENTRY(stack_segment) | |
732 | RING0_EC_FRAME | |
733 | @@ -1171,6 +1204,7 @@ ENTRY(stack_segment) | |
734 | CFI_ADJUST_CFA_OFFSET 4 | |
735 | jmp error_code | |
736 | CFI_ENDPROC | |
737 | +END(stack_segment) | |
738 | ||
739 | KPROBE_ENTRY(general_protection) | |
740 | RING0_EC_FRAME | |
741 | @@ -1186,6 +1220,7 @@ ENTRY(alignment_check) | |
742 | CFI_ADJUST_CFA_OFFSET 4 | |
743 | jmp error_code | |
744 | CFI_ENDPROC | |
745 | +END(alignment_check) | |
746 | ||
747 | ENTRY(divide_error) | |
748 | RING0_INT_FRAME | |
749 | @@ -1195,6 +1230,7 @@ ENTRY(divide_error) | |
750 | CFI_ADJUST_CFA_OFFSET 4 | |
751 | jmp error_code | |
752 | CFI_ENDPROC | |
753 | +END(divide_error) | |
754 | ||
755 | #ifdef CONFIG_X86_MCE | |
756 | ENTRY(machine_check) | |
757 | @@ -1205,6 +1241,7 @@ ENTRY(machine_check) | |
758 | CFI_ADJUST_CFA_OFFSET 4 | |
759 | jmp error_code | |
760 | CFI_ENDPROC | |
761 | +END(machine_check) | |
762 | #endif | |
763 | ||
764 | #ifndef CONFIG_XEN | |
765 | @@ -1224,6 +1261,7 @@ ENTRY(fixup_4gb_segment) | |
766 | CFI_ADJUST_CFA_OFFSET 4 | |
767 | jmp error_code | |
768 | CFI_ENDPROC | |
769 | +END(spurious_interrupt_bug) | |
770 | ||
771 | ENTRY(kernel_thread_helper) | |
772 | pushl $0 # fake return address for unwinder | |
773 | --- a/arch/x86/kernel/entry_64-xen.S | |
774 | +++ b/arch/x86/kernel/entry_64-xen.S | |
775 | @@ -629,6 +629,9 @@ END(invalidate_interrupt\num) | |
776 | ENTRY(call_function_interrupt) | |
777 | apicinterrupt CALL_FUNCTION_VECTOR,smp_call_function_interrupt | |
778 | END(call_function_interrupt) | |
779 | +ENTRY(irq_move_cleanup_interrupt) | |
780 | + apicinterrupt IRQ_MOVE_CLEANUP_VECTOR,smp_irq_move_cleanup_interrupt | |
781 | +END(irq_move_cleanup_interrupt) | |
782 | #endif | |
783 | ||
784 | ENTRY(apic_timer_interrupt) | |
785 | --- a/arch/x86/kernel/genapic_64-xen.c | |
786 | +++ b/arch/x86/kernel/genapic_64-xen.c | |
787 | @@ -65,8 +65,8 @@ void __init clustered_apic_check(void) | |
788 | * Some x86_64 machines use physical APIC mode regardless of how many | |
789 | * procs/clusters are present (x86_64 ES7000 is an example). | |
790 | */ | |
791 | - if (acpi_fadt.revision > FADT2_REVISION_ID) | |
792 | - if (acpi_fadt.force_apic_physical_destination_mode) { | |
793 | + if (acpi_gbl_FADT.header.revision > FADT2_REVISION_ID) | |
794 | + if (acpi_gbl_FADT.flags & ACPI_FADT_APIC_PHYSICAL) { | |
795 | genapic = &apic_cluster; | |
796 | goto print; | |
797 | } | |
798 | --- a/arch/x86/kernel/head_32-xen.S | |
799 | +++ b/arch/x86/kernel/head_32-xen.S | |
800 | @@ -27,6 +27,7 @@ | |
801 | #define X86_CAPABILITY new_cpu_data+CPUINFO_x86_capability | |
802 | #define X86_VENDOR_ID new_cpu_data+CPUINFO_x86_vendor_id | |
803 | ||
804 | +.section .text.head,"ax",@progbits | |
805 | #define VIRT_ENTRY_OFFSET 0x0 | |
806 | .org VIRT_ENTRY_OFFSET | |
807 | ENTRY(startup_32) | |
808 | @@ -60,11 +61,11 @@ ENTRY(startup_32) | |
809 | ||
810 | movb $1,X86_HARD_MATH | |
811 | ||
812 | - xorl %eax,%eax # Clear FS | |
813 | - movl %eax,%fs | |
814 | + xorl %eax,%eax # Clear GS | |
815 | + movl %eax,%gs | |
816 | ||
817 | movl $(__KERNEL_PDA),%eax | |
818 | - mov %eax,%gs | |
819 | + mov %eax,%fs | |
820 | ||
821 | cld # gcc2 wants the direction flag cleared at all times | |
822 | ||
823 | @@ -75,7 +76,7 @@ ENTRY(startup_32) | |
824 | * Point the GDT at this CPU's PDA. This will be | |
825 | * cpu_gdt_table and boot_pda. | |
826 | */ | |
827 | -setup_pda: | |
828 | +ENTRY(setup_pda) | |
829 | /* get the PDA pointer */ | |
830 | movl $boot_pda, %eax | |
831 | ||
832 | --- a/arch/x86/kernel/head64-xen.c | |
833 | +++ b/arch/x86/kernel/head64-xen.c | |
834 | @@ -45,8 +45,6 @@ static void __init clear_bss(void) | |
835 | #define OLD_CL_BASE_ADDR 0x90000 | |
836 | #define OLD_CL_OFFSET 0x90022 | |
837 | ||
838 | -extern char saved_command_line[]; | |
839 | - | |
840 | static void __init copy_bootdata(char *real_mode_data) | |
841 | { | |
842 | #ifndef CONFIG_XEN | |
843 | @@ -62,14 +60,14 @@ static void __init copy_bootdata(char *r | |
844 | new_data = OLD_CL_BASE_ADDR + * (u16 *) OLD_CL_OFFSET; | |
845 | } | |
846 | command_line = (char *) ((u64)(new_data)); | |
847 | - memcpy(saved_command_line, command_line, COMMAND_LINE_SIZE); | |
848 | + memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE); | |
849 | #else | |
850 | int max_cmdline; | |
851 | ||
852 | if ((max_cmdline = MAX_GUEST_CMDLINE) > COMMAND_LINE_SIZE) | |
853 | max_cmdline = COMMAND_LINE_SIZE; | |
854 | - memcpy(saved_command_line, xen_start_info->cmd_line, max_cmdline); | |
855 | - saved_command_line[max_cmdline-1] = '\0'; | |
856 | + memcpy(boot_command_line, xen_start_info->cmd_line, max_cmdline); | |
857 | + boot_command_line[max_cmdline-1] = '\0'; | |
858 | #endif | |
859 | } | |
860 | ||
861 | --- a/arch/x86/kernel/io_apic_32-xen.c | |
862 | +++ b/arch/x86/kernel/io_apic_32-xen.c | |
863 | @@ -167,7 +167,7 @@ static inline void io_apic_write(unsigne | |
864 | */ | |
865 | static inline void io_apic_modify(unsigned int apic, unsigned int reg, unsigned int value) | |
866 | { | |
867 | - volatile struct io_apic *io_apic = io_apic_base(apic); | |
868 | + volatile struct io_apic __iomem *io_apic = io_apic_base(apic); | |
869 | if (sis_apic_bug) | |
870 | writel(reg, &io_apic->index); | |
871 | writel(value, &io_apic->data); | |
872 | @@ -392,7 +392,7 @@ static void set_ioapic_affinity_irq(unsi | |
873 | break; | |
874 | entry = irq_2_pin + entry->next; | |
875 | } | |
876 | - set_native_irq_info(irq, cpumask); | |
877 | + irq_desc[irq].affinity = cpumask; | |
878 | spin_unlock_irqrestore(&ioapic_lock, flags); | |
879 | } | |
880 | ||
881 | @@ -531,8 +531,8 @@ static void do_irq_balance(void) | |
882 | package_index = CPU_TO_PACKAGEINDEX(i); | |
883 | for (j = 0; j < NR_IRQS; j++) { | |
884 | unsigned long value_now, delta; | |
885 | - /* Is this an active IRQ? */ | |
886 | - if (!irq_desc[j].action) | |
887 | + /* Is this an active IRQ or balancing disabled ? */ | |
888 | + if (!irq_desc[j].action || irq_balancing_disabled(j)) | |
889 | continue; | |
890 | if ( package_index == i ) | |
891 | IRQ_DELTA(package_index,j) = 0; | |
892 | @@ -785,7 +785,7 @@ failed: | |
893 | return 0; | |
894 | } | |
895 | ||
896 | -int __init irqbalance_disable(char *str) | |
897 | +int __devinit irqbalance_disable(char *str) | |
898 | { | |
899 | irqbalance_disabled = 1; | |
900 | return 1; | |
901 | @@ -1329,11 +1329,9 @@ static void ioapic_register_intr(int irq | |
902 | trigger == IOAPIC_LEVEL) | |
903 | set_irq_chip_and_handler_name(irq, &ioapic_chip, | |
904 | handle_fasteoi_irq, "fasteoi"); | |
905 | - else { | |
906 | - irq_desc[irq].status |= IRQ_DELAYED_DISABLE; | |
907 | + else | |
908 | set_irq_chip_and_handler_name(irq, &ioapic_chip, | |
909 | handle_edge_irq, "edge"); | |
910 | - } | |
911 | set_intr_gate(vector, interrupt[irq]); | |
912 | } | |
913 | #else | |
914 | @@ -1407,7 +1405,6 @@ static void __init setup_IO_APIC_irqs(vo | |
915 | } | |
916 | spin_lock_irqsave(&ioapic_lock, flags); | |
917 | __ioapic_write_entry(apic, pin, entry); | |
918 | - set_native_irq_info(irq, TARGET_CPUS); | |
919 | spin_unlock_irqrestore(&ioapic_lock, flags); | |
920 | } | |
921 | } | |
922 | @@ -1638,7 +1635,7 @@ void /*__init*/ print_local_APIC(void * | |
923 | v = apic_read(APIC_LVR); | |
924 | printk(KERN_INFO "... APIC VERSION: %08x\n", v); | |
925 | ver = GET_APIC_VERSION(v); | |
926 | - maxlvt = get_maxlvt(); | |
927 | + maxlvt = lapic_get_maxlvt(); | |
928 | ||
929 | v = apic_read(APIC_TASKPRI); | |
930 | printk(KERN_DEBUG "... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK); | |
931 | @@ -1976,7 +1973,7 @@ static void __init setup_ioapic_ids_from | |
932 | #endif | |
933 | ||
934 | #ifndef CONFIG_XEN | |
935 | -static int no_timer_check __initdata; | |
936 | +int no_timer_check __initdata; | |
937 | ||
938 | static int __init notimercheck(char *s) | |
939 | { | |
940 | @@ -2369,7 +2366,7 @@ static inline void __init check_timer(vo | |
941 | ||
942 | disable_8259A_irq(0); | |
943 | set_irq_chip_and_handler_name(0, &lapic_chip, handle_fasteoi_irq, | |
944 | - "fasteio"); | |
945 | + "fasteoi"); | |
946 | apic_write_around(APIC_LVT0, APIC_DM_FIXED | vector); /* Fixed mode */ | |
947 | enable_8259A_irq(0); | |
948 | ||
949 | @@ -2662,7 +2659,7 @@ static void set_msi_irq_affinity(unsigne | |
950 | msg.address_lo |= MSI_ADDR_DEST_ID(dest); | |
951 | ||
952 | write_msi_msg(irq, &msg); | |
953 | - set_native_irq_info(irq, mask); | |
954 | + irq_desc[irq].affinity = mask; | |
955 | } | |
956 | #endif /* CONFIG_SMP */ | |
957 | ||
958 | @@ -2681,25 +2678,32 @@ static struct irq_chip msi_chip = { | |
959 | .retrigger = ioapic_retrigger_irq, | |
960 | }; | |
961 | ||
962 | -int arch_setup_msi_irq(unsigned int irq, struct pci_dev *dev) | |
963 | +int arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc) | |
964 | { | |
965 | struct msi_msg msg; | |
966 | - int ret; | |
967 | + int irq, ret; | |
968 | + irq = create_irq(); | |
969 | + if (irq < 0) | |
970 | + return irq; | |
971 | + | |
972 | + set_irq_msi(irq, desc); | |
973 | ret = msi_compose_msg(dev, irq, &msg); | |
974 | - if (ret < 0) | |
975 | + if (ret < 0) { | |
976 | + destroy_irq(irq); | |
977 | return ret; | |
978 | + } | |
979 | ||
980 | write_msi_msg(irq, &msg); | |
981 | ||
982 | set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, | |
983 | "edge"); | |
984 | ||
985 | - return 0; | |
986 | + return irq; | |
987 | } | |
988 | ||
989 | void arch_teardown_msi_irq(unsigned int irq) | |
990 | { | |
991 | - return; | |
992 | + destroy_irq(irq); | |
993 | } | |
994 | ||
995 | #endif /* CONFIG_PCI_MSI */ | |
996 | @@ -2739,7 +2743,7 @@ static void set_ht_irq_affinity(unsigned | |
997 | dest = cpu_mask_to_apicid(mask); | |
998 | ||
999 | target_ht_irq(irq, dest); | |
1000 | - set_native_irq_info(irq, mask); | |
1001 | + irq_desc[irq].affinity = mask; | |
1002 | } | |
1003 | #endif | |
1004 | ||
1005 | @@ -2947,7 +2951,6 @@ int io_apic_set_pci_routing (int ioapic, | |
1006 | ||
1007 | spin_lock_irqsave(&ioapic_lock, flags); | |
1008 | __ioapic_write_entry(ioapic, pin, entry); | |
1009 | - set_native_irq_info(irq, TARGET_CPUS); | |
1010 | spin_unlock_irqrestore(&ioapic_lock, flags); | |
1011 | ||
1012 | return 0; | |
1013 | --- a/arch/x86/kernel/io_apic_64-xen.c | |
1014 | +++ b/arch/x86/kernel/io_apic_64-xen.c | |
1015 | @@ -36,6 +36,7 @@ | |
1016 | #include <acpi/acpi_bus.h> | |
1017 | #endif | |
1018 | ||
1019 | +#include <asm/idle.h> | |
1020 | #include <asm/io.h> | |
1021 | #include <asm/smp.h> | |
1022 | #include <asm/desc.h> | |
1023 | @@ -47,7 +48,20 @@ | |
1024 | #include <asm/msidef.h> | |
1025 | #include <asm/hypertransport.h> | |
1026 | ||
1027 | -static int assign_irq_vector(int irq, cpumask_t mask, cpumask_t *result); | |
1028 | +struct irq_cfg { | |
1029 | +#ifndef CONFIG_XEN | |
1030 | + cpumask_t domain; | |
1031 | + cpumask_t old_domain; | |
1032 | +#endif | |
1033 | + unsigned move_cleanup_count; | |
1034 | + u8 vector; | |
1035 | + u8 move_in_progress : 1; | |
1036 | +}; | |
1037 | + | |
1038 | +/* irq_cfg is indexed by the sum of all RTEs in all I/O APICs. */ | |
1039 | +struct irq_cfg irq_cfg[NR_IRQS] __read_mostly; | |
1040 | + | |
1041 | +static int assign_irq_vector(int irq, cpumask_t mask); | |
1042 | ||
1043 | #define __apicdebuginit __init | |
1044 | ||
1045 | @@ -89,7 +103,7 @@ int nr_ioapic_registers[MAX_IO_APICS]; | |
1046 | * Rough estimation of how many shared IRQs there are, can | |
1047 | * be changed anytime. | |
1048 | */ | |
1049 | -#define MAX_PLUS_SHARED_IRQS NR_IRQ_VECTORS | |
1050 | +#define MAX_PLUS_SHARED_IRQS NR_IRQS | |
1051 | #define PIN_MAP_SIZE (MAX_PLUS_SHARED_IRQS + NR_IRQS) | |
1052 | ||
1053 | /* | |
1054 | @@ -262,21 +276,19 @@ static void __target_IO_APIC_irq(unsigne | |
1055 | ||
1056 | static void set_ioapic_affinity_irq(unsigned int irq, cpumask_t mask) | |
1057 | { | |
1058 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1059 | unsigned long flags; | |
1060 | unsigned int dest; | |
1061 | cpumask_t tmp; | |
1062 | - int vector; | |
1063 | ||
1064 | cpus_and(tmp, mask, cpu_online_map); | |
1065 | if (cpus_empty(tmp)) | |
1066 | - tmp = TARGET_CPUS; | |
1067 | - | |
1068 | - cpus_and(mask, tmp, CPU_MASK_ALL); | |
1069 | + return; | |
1070 | ||
1071 | - vector = assign_irq_vector(irq, mask, &tmp); | |
1072 | - if (vector < 0) | |
1073 | + if (assign_irq_vector(irq, mask)) | |
1074 | return; | |
1075 | ||
1076 | + cpus_and(tmp, cfg->domain, mask); | |
1077 | dest = cpu_mask_to_apicid(tmp); | |
1078 | ||
1079 | /* | |
1080 | @@ -285,8 +297,8 @@ static void set_ioapic_affinity_irq(unsi | |
1081 | dest = SET_APIC_LOGICAL_ID(dest); | |
1082 | ||
1083 | spin_lock_irqsave(&ioapic_lock, flags); | |
1084 | - __target_IO_APIC_irq(irq, dest, vector); | |
1085 | - set_native_irq_info(irq, mask); | |
1086 | + __target_IO_APIC_irq(irq, dest, cfg->vector); | |
1087 | + irq_desc[irq].affinity = mask; | |
1088 | spin_unlock_irqrestore(&ioapic_lock, flags); | |
1089 | } | |
1090 | #endif | |
1091 | @@ -332,11 +344,11 @@ static void add_pin_to_irq(unsigned int | |
1092 | reg = io_apic_read(entry->apic, 0x10 + R + pin*2); \ | |
1093 | reg ACTION; \ | |
1094 | io_apic_modify(entry->apic, reg); \ | |
1095 | + FINAL; \ | |
1096 | if (!entry->next) \ | |
1097 | break; \ | |
1098 | entry = irq_2_pin + entry->next; \ | |
1099 | } \ | |
1100 | - FINAL; \ | |
1101 | } | |
1102 | ||
1103 | #define DO_ACTION(name,R,ACTION, FINAL) \ | |
1104 | @@ -669,77 +681,62 @@ static int pin_2_irq(int idx, int apic, | |
1105 | return irq; | |
1106 | } | |
1107 | ||
1108 | -static inline int IO_APIC_irq_trigger(int irq) | |
1109 | -{ | |
1110 | - int apic, idx, pin; | |
1111 | - | |
1112 | - for (apic = 0; apic < nr_ioapics; apic++) { | |
1113 | - for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) { | |
1114 | - idx = find_irq_entry(apic,pin,mp_INT); | |
1115 | - if ((idx != -1) && (irq == pin_2_irq(idx,apic,pin))) | |
1116 | - return irq_trigger(idx); | |
1117 | - } | |
1118 | - } | |
1119 | - /* | |
1120 | - * nonexistent IRQs are edge default | |
1121 | - */ | |
1122 | - return 0; | |
1123 | -} | |
1124 | - | |
1125 | -/* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */ | |
1126 | -static u8 irq_vector[NR_IRQ_VECTORS] __read_mostly; | |
1127 | - | |
1128 | -static int __assign_irq_vector(int irq, cpumask_t mask, cpumask_t *result) | |
1129 | +static int __assign_irq_vector(int irq, cpumask_t mask) | |
1130 | { | |
1131 | - int vector; | |
1132 | struct physdev_irq irq_op; | |
1133 | + struct irq_cfg *cfg; | |
1134 | ||
1135 | - BUG_ON((unsigned)irq >= NR_IRQ_VECTORS); | |
1136 | + BUG_ON((unsigned)irq >= NR_IRQS); | |
1137 | ||
1138 | if (irq < PIRQ_BASE || irq - PIRQ_BASE > NR_PIRQS) | |
1139 | return -EINVAL; | |
1140 | ||
1141 | - cpus_and(*result, mask, cpu_online_map); | |
1142 | + cfg = &irq_cfg[irq]; | |
1143 | + | |
1144 | + if ((cfg->move_in_progress) || cfg->move_cleanup_count) | |
1145 | + return -EBUSY; | |
1146 | ||
1147 | - if (irq_vector[irq] > 0) | |
1148 | - return irq_vector[irq]; | |
1149 | + if (cfg->vector) | |
1150 | + return 0; | |
1151 | ||
1152 | irq_op.irq = irq; | |
1153 | if (HYPERVISOR_physdev_op(PHYSDEVOP_alloc_irq_vector, &irq_op)) | |
1154 | return -ENOSPC; | |
1155 | ||
1156 | - vector = irq_op.vector; | |
1157 | - irq_vector[irq] = vector; | |
1158 | + cfg->vector = irq_op.vector; | |
1159 | ||
1160 | - return vector; | |
1161 | + return 0; | |
1162 | } | |
1163 | ||
1164 | -static int assign_irq_vector(int irq, cpumask_t mask, cpumask_t *result) | |
1165 | +static int assign_irq_vector(int irq, cpumask_t mask) | |
1166 | { | |
1167 | - int vector; | |
1168 | + int err; | |
1169 | unsigned long flags; | |
1170 | ||
1171 | spin_lock_irqsave(&vector_lock, flags); | |
1172 | - vector = __assign_irq_vector(irq, mask, result); | |
1173 | + err = __assign_irq_vector(irq, mask); | |
1174 | spin_unlock_irqrestore(&vector_lock, flags); | |
1175 | - return vector; | |
1176 | + return err; | |
1177 | } | |
1178 | ||
1179 | #ifndef CONFIG_XEN | |
1180 | static void __clear_irq_vector(int irq) | |
1181 | { | |
1182 | + struct irq_cfg *cfg; | |
1183 | cpumask_t mask; | |
1184 | int cpu, vector; | |
1185 | ||
1186 | - BUG_ON(!irq_vector[irq]); | |
1187 | + BUG_ON((unsigned)irq >= NR_IRQS); | |
1188 | + cfg = &irq_cfg[irq]; | |
1189 | + BUG_ON(!cfg->vector); | |
1190 | ||
1191 | - vector = irq_vector[irq]; | |
1192 | - cpus_and(mask, irq_domain[irq], cpu_online_map); | |
1193 | + vector = cfg->vector; | |
1194 | + cpus_and(mask, cfg->domain, cpu_online_map); | |
1195 | for_each_cpu_mask(cpu, mask) | |
1196 | per_cpu(vector_irq, cpu)[vector] = -1; | |
1197 | ||
1198 | - irq_vector[irq] = 0; | |
1199 | - irq_domain[irq] = CPU_MASK_NONE; | |
1200 | + cfg->vector = 0; | |
1201 | + cfg->domain = CPU_MASK_NONE; | |
1202 | } | |
1203 | ||
1204 | void __setup_vector_irq(int cpu) | |
1205 | @@ -749,10 +746,10 @@ void __setup_vector_irq(int cpu) | |
1206 | int irq, vector; | |
1207 | ||
1208 | /* Mark the inuse vectors */ | |
1209 | - for (irq = 0; irq < NR_IRQ_VECTORS; ++irq) { | |
1210 | - if (!cpu_isset(cpu, irq_domain[irq])) | |
1211 | + for (irq = 0; irq < NR_IRQS; ++irq) { | |
1212 | + if (!cpu_isset(cpu, irq_cfg[irq].domain)) | |
1213 | continue; | |
1214 | - vector = irq_vector[irq]; | |
1215 | + vector = irq_cfg[irq].vector; | |
1216 | per_cpu(vector_irq, cpu)[vector] = irq; | |
1217 | } | |
1218 | /* Mark the free vectors */ | |
1219 | @@ -760,41 +757,49 @@ void __setup_vector_irq(int cpu) | |
1220 | irq = per_cpu(vector_irq, cpu)[vector]; | |
1221 | if (irq < 0) | |
1222 | continue; | |
1223 | - if (!cpu_isset(cpu, irq_domain[irq])) | |
1224 | + if (!cpu_isset(cpu, irq_cfg[irq].domain)) | |
1225 | per_cpu(vector_irq, cpu)[vector] = -1; | |
1226 | } | |
1227 | } | |
1228 | ||
1229 | -extern void (*interrupt[NR_IRQS])(void); | |
1230 | - | |
1231 | static struct irq_chip ioapic_chip; | |
1232 | ||
1233 | -#define IOAPIC_AUTO -1 | |
1234 | -#define IOAPIC_EDGE 0 | |
1235 | -#define IOAPIC_LEVEL 1 | |
1236 | - | |
1237 | -static void ioapic_register_intr(int irq, int vector, unsigned long trigger) | |
1238 | +static void ioapic_register_intr(int irq, unsigned long trigger) | |
1239 | { | |
1240 | - if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) || | |
1241 | - trigger == IOAPIC_LEVEL) | |
1242 | + if (trigger) | |
1243 | set_irq_chip_and_handler_name(irq, &ioapic_chip, | |
1244 | handle_fasteoi_irq, "fasteoi"); | |
1245 | - else { | |
1246 | - irq_desc[irq].status |= IRQ_DELAYED_DISABLE; | |
1247 | + else | |
1248 | set_irq_chip_and_handler_name(irq, &ioapic_chip, | |
1249 | handle_edge_irq, "edge"); | |
1250 | - } | |
1251 | } | |
1252 | #else | |
1253 | -#define ioapic_register_intr(irq, vector, trigger) evtchn_register_pirq(irq) | |
1254 | +#define ioapic_register_intr(irq, trigger) evtchn_register_pirq(irq) | |
1255 | #endif /* !CONFIG_XEN */ | |
1256 | ||
1257 | -static void __init setup_IO_APIC_irq(int apic, int pin, int idx, int irq) | |
1258 | +static void setup_IO_APIC_irq(int apic, int pin, unsigned int irq, | |
1259 | + int trigger, int polarity) | |
1260 | { | |
1261 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1262 | struct IO_APIC_route_entry entry; | |
1263 | - int vector; | |
1264 | - unsigned long flags; | |
1265 | + cpumask_t mask; | |
1266 | + | |
1267 | + if (!IO_APIC_IRQ(irq)) | |
1268 | + return; | |
1269 | ||
1270 | + mask = TARGET_CPUS; | |
1271 | + if (assign_irq_vector(irq, mask)) | |
1272 | + return; | |
1273 | + | |
1274 | +#ifndef CONFIG_XEN | |
1275 | + cpus_and(mask, cfg->domain, mask); | |
1276 | +#endif | |
1277 | + | |
1278 | + apic_printk(APIC_VERBOSE,KERN_DEBUG | |
1279 | + "IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> " | |
1280 | + "IRQ %d Mode:%i Active:%i)\n", | |
1281 | + apic, mp_ioapics[apic].mpc_apicid, pin, cfg->vector, | |
1282 | + irq, trigger, polarity); | |
1283 | ||
1284 | /* | |
1285 | * add it to the IO-APIC irq-routing table: | |
1286 | @@ -803,41 +808,23 @@ static void __init setup_IO_APIC_irq(int | |
1287 | ||
1288 | entry.delivery_mode = INT_DELIVERY_MODE; | |
1289 | entry.dest_mode = INT_DEST_MODE; | |
1290 | + entry.dest = cpu_mask_to_apicid(mask); | |
1291 | entry.mask = 0; /* enable IRQ */ | |
1292 | - entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS); | |
1293 | - | |
1294 | - entry.trigger = irq_trigger(idx); | |
1295 | - entry.polarity = irq_polarity(idx); | |
1296 | + entry.trigger = trigger; | |
1297 | + entry.polarity = polarity; | |
1298 | + entry.vector = cfg->vector; | |
1299 | ||
1300 | - if (irq_trigger(idx)) { | |
1301 | - entry.trigger = 1; | |
1302 | + /* Mask level triggered irqs. | |
1303 | + * Use IRQ_DELAYED_DISABLE for edge triggered irqs. | |
1304 | + */ | |
1305 | + if (trigger) | |
1306 | entry.mask = 1; | |
1307 | - entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS); | |
1308 | - } | |
1309 | - | |
1310 | - if (/* !apic && */ !IO_APIC_IRQ(irq)) | |
1311 | - return; | |
1312 | ||
1313 | - if (IO_APIC_IRQ(irq)) { | |
1314 | - cpumask_t mask; | |
1315 | - vector = assign_irq_vector(irq, TARGET_CPUS, &mask); | |
1316 | - if (vector < 0) | |
1317 | - return; | |
1318 | - | |
1319 | - entry.dest.logical.logical_dest = cpu_mask_to_apicid(mask); | |
1320 | - entry.vector = vector; | |
1321 | - | |
1322 | - ioapic_register_intr(irq, vector, IOAPIC_AUTO); | |
1323 | - if (!apic && (irq < 16)) | |
1324 | - disable_8259A_irq(irq); | |
1325 | - } | |
1326 | + ioapic_register_intr(irq, trigger); | |
1327 | + if (irq < 16) | |
1328 | + disable_8259A_irq(irq); | |
1329 | ||
1330 | ioapic_write_entry(apic, pin, entry); | |
1331 | - | |
1332 | - spin_lock_irqsave(&ioapic_lock, flags); | |
1333 | - set_native_irq_info(irq, TARGET_CPUS); | |
1334 | - spin_unlock_irqrestore(&ioapic_lock, flags); | |
1335 | - | |
1336 | } | |
1337 | ||
1338 | static void __init setup_IO_APIC_irqs(void) | |
1339 | @@ -862,8 +849,8 @@ static void __init setup_IO_APIC_irqs(vo | |
1340 | irq = pin_2_irq(idx, apic, pin); | |
1341 | add_pin_to_irq(irq, apic, pin); | |
1342 | ||
1343 | - setup_IO_APIC_irq(apic, pin, idx, irq); | |
1344 | - | |
1345 | + setup_IO_APIC_irq(apic, pin, irq, | |
1346 | + irq_trigger(idx), irq_polarity(idx)); | |
1347 | } | |
1348 | } | |
1349 | ||
1350 | @@ -894,7 +881,7 @@ static void __init setup_ExtINT_IRQ0_pin | |
1351 | */ | |
1352 | entry.dest_mode = INT_DEST_MODE; | |
1353 | entry.mask = 0; /* unmask IRQ now */ | |
1354 | - entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS); | |
1355 | + entry.dest = cpu_mask_to_apicid(TARGET_CPUS); | |
1356 | entry.delivery_mode = INT_DELIVERY_MODE; | |
1357 | entry.polarity = 0; | |
1358 | entry.trigger = 0; | |
1359 | @@ -994,18 +981,17 @@ void __apicdebuginit print_IO_APIC(void) | |
1360 | ||
1361 | printk(KERN_DEBUG ".... IRQ redirection table:\n"); | |
1362 | ||
1363 | - printk(KERN_DEBUG " NR Log Phy Mask Trig IRR Pol" | |
1364 | - " Stat Dest Deli Vect: \n"); | |
1365 | + printk(KERN_DEBUG " NR Dst Mask Trig IRR Pol" | |
1366 | + " Stat Dmod Deli Vect: \n"); | |
1367 | ||
1368 | for (i = 0; i <= reg_01.bits.entries; i++) { | |
1369 | struct IO_APIC_route_entry entry; | |
1370 | ||
1371 | entry = ioapic_read_entry(apic, i); | |
1372 | ||
1373 | - printk(KERN_DEBUG " %02x %03X %02X ", | |
1374 | + printk(KERN_DEBUG " %02x %03X ", | |
1375 | i, | |
1376 | - entry.dest.logical.logical_dest, | |
1377 | - entry.dest.physical.physical_dest | |
1378 | + entry.dest | |
1379 | ); | |
1380 | ||
1381 | printk("%1d %1d %1d %1d %1d %1d %1d %02X\n", | |
1382 | @@ -1269,8 +1255,7 @@ void disable_IO_APIC(void) | |
1383 | entry.dest_mode = 0; /* Physical */ | |
1384 | entry.delivery_mode = dest_ExtINT; /* ExtInt */ | |
1385 | entry.vector = 0; | |
1386 | - entry.dest.physical.physical_dest = | |
1387 | - GET_APIC_ID(apic_read(APIC_ID)); | |
1388 | + entry.dest = GET_APIC_ID(apic_read(APIC_ID)); | |
1389 | ||
1390 | /* | |
1391 | * Add it to the IO-APIC irq-routing table: | |
1392 | @@ -1355,16 +1340,15 @@ static unsigned int startup_ioapic_irq(u | |
1393 | ||
1394 | static int ioapic_retrigger_irq(unsigned int irq) | |
1395 | { | |
1396 | + struct irq_cfg *cfg = &irq_cfg[irq]; | |
1397 | cpumask_t mask; | |
1398 | - unsigned vector; | |
1399 | unsigned long flags; | |
1400 | ||
1401 | spin_lock_irqsave(&vector_lock, flags); | |
1402 | - vector = irq_vector[irq]; | |
1403 | cpus_clear(mask); | |
1404 | - cpu_set(first_cpu(irq_domain[irq]), mask); | |
1405 | + cpu_set(first_cpu(cfg->domain), mask); | |
1406 | ||
1407 | - send_IPI_mask(mask, vector); | |
1408 | + send_IPI_mask(mask, cfg->vector); | |
1409 | spin_unlock_irqrestore(&vector_lock, flags); | |
1410 | ||
1411 | return 1; | |
1412 | @@ -1379,8 +1363,68 @@ static int ioapic_retrigger_irq(unsigned | |
1413 | * races. | |
1414 | */ | |
1415 | ||
1416 | +#ifdef CONFIG_SMP | |
1417 | +asmlinkage void smp_irq_move_cleanup_interrupt(void) | |
1418 | +{ | |
1419 | + unsigned vector, me; | |
1420 | + ack_APIC_irq(); | |
1421 | + exit_idle(); | |
1422 | + irq_enter(); | |
1423 | + | |
1424 | + me = smp_processor_id(); | |
1425 | + for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) { | |
1426 | + unsigned int irq; | |
1427 | + struct irq_desc *desc; | |
1428 | + struct irq_cfg *cfg; | |
1429 | + irq = __get_cpu_var(vector_irq)[vector]; | |
1430 | + if (irq >= NR_IRQS) | |
1431 | + continue; | |
1432 | + | |
1433 | + desc = irq_desc + irq; | |
1434 | + cfg = irq_cfg + irq; | |
1435 | + spin_lock(&desc->lock); | |
1436 | + if (!cfg->move_cleanup_count) | |
1437 | + goto unlock; | |
1438 | + | |
1439 | + if ((vector == cfg->vector) && cpu_isset(me, cfg->domain)) | |
1440 | + goto unlock; | |
1441 | + | |
1442 | + __get_cpu_var(vector_irq)[vector] = -1; | |
1443 | + cfg->move_cleanup_count--; | |
1444 | +unlock: | |
1445 | + spin_unlock(&desc->lock); | |
1446 | + } | |
1447 | + | |
1448 | + irq_exit(); | |
1449 | +} | |
1450 | + | |
1451 | +static void irq_complete_move(unsigned int irq) | |
1452 | +{ | |
1453 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1454 | + unsigned vector, me; | |
1455 | + | |
1456 | + if (likely(!cfg->move_in_progress)) | |
1457 | + return; | |
1458 | + | |
1459 | + vector = ~get_irq_regs()->orig_rax; | |
1460 | + me = smp_processor_id(); | |
1461 | + if ((vector == cfg->vector) && | |
1462 | + cpu_isset(smp_processor_id(), cfg->domain)) { | |
1463 | + cpumask_t cleanup_mask; | |
1464 | + | |
1465 | + cpus_and(cleanup_mask, cfg->old_domain, cpu_online_map); | |
1466 | + cfg->move_cleanup_count = cpus_weight(cleanup_mask); | |
1467 | + send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR); | |
1468 | + cfg->move_in_progress = 0; | |
1469 | + } | |
1470 | +} | |
1471 | +#else | |
1472 | +static inline void irq_complete_move(unsigned int irq) {} | |
1473 | +#endif | |
1474 | + | |
1475 | static void ack_apic_edge(unsigned int irq) | |
1476 | { | |
1477 | + irq_complete_move(irq); | |
1478 | move_native_irq(irq); | |
1479 | ack_APIC_irq(); | |
1480 | } | |
1481 | @@ -1389,6 +1433,7 @@ static void ack_apic_level(unsigned int | |
1482 | { | |
1483 | int do_unmask_irq = 0; | |
1484 | ||
1485 | + irq_complete_move(irq); | |
1486 | #if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE) | |
1487 | /* If we are moving the irq we need to mask it */ | |
1488 | if (unlikely(irq_desc[irq].status & IRQ_MOVE_PENDING)) { | |
1489 | @@ -1440,7 +1485,7 @@ static inline void init_IO_APIC_traps(vo | |
1490 | */ | |
1491 | for (irq = 0; irq < NR_IRQS ; irq++) { | |
1492 | int tmp = irq; | |
1493 | - if (IO_APIC_IRQ(tmp) && !irq_vector[tmp]) { | |
1494 | + if (IO_APIC_IRQ(tmp) && !irq_cfg[tmp].vector) { | |
1495 | /* | |
1496 | * Hmm.. We don't have an entry for this, | |
1497 | * so default to an old-fashioned 8259 | |
1498 | @@ -1538,7 +1583,7 @@ static inline void unlock_ExtINT_logic(v | |
1499 | ||
1500 | entry1.dest_mode = 0; /* physical delivery */ | |
1501 | entry1.mask = 0; /* unmask IRQ now */ | |
1502 | - entry1.dest.physical.physical_dest = hard_smp_processor_id(); | |
1503 | + entry1.dest = hard_smp_processor_id(); | |
1504 | entry1.delivery_mode = dest_ExtINT; | |
1505 | entry1.polarity = entry0.polarity; | |
1506 | entry1.trigger = 0; | |
1507 | @@ -1582,15 +1627,14 @@ static inline void unlock_ExtINT_logic(v | |
1508 | */ | |
1509 | static inline void check_timer(void) | |
1510 | { | |
1511 | + struct irq_cfg *cfg = irq_cfg + 0; | |
1512 | int apic1, pin1, apic2, pin2; | |
1513 | - int vector; | |
1514 | - cpumask_t mask; | |
1515 | ||
1516 | /* | |
1517 | * get/set the timer IRQ vector: | |
1518 | */ | |
1519 | disable_8259A_irq(0); | |
1520 | - vector = assign_irq_vector(0, TARGET_CPUS, &mask); | |
1521 | + assign_irq_vector(0, TARGET_CPUS); | |
1522 | ||
1523 | /* | |
1524 | * Subtle, code in do_timer_interrupt() expects an AEOI | |
1525 | @@ -1610,7 +1654,7 @@ static inline void check_timer(void) | |
1526 | apic2 = ioapic_i8259.apic; | |
1527 | ||
1528 | apic_printk(APIC_VERBOSE,KERN_INFO "..TIMER: vector=0x%02X apic1=%d pin1=%d apic2=%d pin2=%d\n", | |
1529 | - vector, apic1, pin1, apic2, pin2); | |
1530 | + cfg->vector, apic1, pin1, apic2, pin2); | |
1531 | ||
1532 | if (pin1 != -1) { | |
1533 | /* | |
1534 | @@ -1641,7 +1685,7 @@ static inline void check_timer(void) | |
1535 | /* | |
1536 | * legacy devices should be connected to IO APIC #0 | |
1537 | */ | |
1538 | - setup_ExtINT_IRQ0_pin(apic2, pin2, vector); | |
1539 | + setup_ExtINT_IRQ0_pin(apic2, pin2, cfg->vector); | |
1540 | if (timer_irq_works()) { | |
1541 | apic_printk(APIC_VERBOSE," works.\n"); | |
1542 | nmi_watchdog_default(); | |
1543 | @@ -1666,14 +1710,14 @@ static inline void check_timer(void) | |
1544 | ||
1545 | disable_8259A_irq(0); | |
1546 | irq_desc[0].chip = &lapic_irq_type; | |
1547 | - apic_write(APIC_LVT0, APIC_DM_FIXED | vector); /* Fixed mode */ | |
1548 | + apic_write(APIC_LVT0, APIC_DM_FIXED | cfg->vector); /* Fixed mode */ | |
1549 | enable_8259A_irq(0); | |
1550 | ||
1551 | if (timer_irq_works()) { | |
1552 | apic_printk(APIC_VERBOSE," works.\n"); | |
1553 | return; | |
1554 | } | |
1555 | - apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | vector); | |
1556 | + apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | cfg->vector); | |
1557 | apic_printk(APIC_VERBOSE," failed.\n"); | |
1558 | ||
1559 | apic_printk(APIC_VERBOSE, KERN_INFO "...trying to set up timer as ExtINT IRQ..."); | |
1560 | @@ -1828,19 +1872,16 @@ int create_irq(void) | |
1561 | /* Allocate an unused irq */ | |
1562 | int irq; | |
1563 | int new; | |
1564 | - int vector = 0; | |
1565 | unsigned long flags; | |
1566 | - cpumask_t mask; | |
1567 | ||
1568 | irq = -ENOSPC; | |
1569 | spin_lock_irqsave(&vector_lock, flags); | |
1570 | for (new = (NR_IRQS - 1); new >= 0; new--) { | |
1571 | if (platform_legacy_irq(new)) | |
1572 | continue; | |
1573 | - if (irq_vector[new] != 0) | |
1574 | + if (irq_cfg[new].vector != 0) | |
1575 | continue; | |
1576 | - vector = __assign_irq_vector(new, TARGET_CPUS, &mask); | |
1577 | - if (likely(vector > 0)) | |
1578 | + if (__assign_irq_vector(new, TARGET_CPUS) == 0) | |
1579 | irq = new; | |
1580 | break; | |
1581 | } | |
1582 | @@ -1871,12 +1912,15 @@ void destroy_irq(unsigned int irq) | |
1583 | #if defined(CONFIG_PCI_MSI) && !defined(CONFIG_XEN) | |
1584 | static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq, struct msi_msg *msg) | |
1585 | { | |
1586 | - int vector; | |
1587 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1588 | + int err; | |
1589 | unsigned dest; | |
1590 | cpumask_t tmp; | |
1591 | ||
1592 | - vector = assign_irq_vector(irq, TARGET_CPUS, &tmp); | |
1593 | - if (vector >= 0) { | |
1594 | + tmp = TARGET_CPUS; | |
1595 | + err = assign_irq_vector(irq, tmp); | |
1596 | + if (!err) { | |
1597 | + cpus_and(tmp, cfg->domain, tmp); | |
1598 | dest = cpu_mask_to_apicid(tmp); | |
1599 | ||
1600 | msg->address_hi = MSI_ADDR_BASE_HI; | |
1601 | @@ -1896,40 +1940,38 @@ static int msi_compose_msg(struct pci_de | |
1602 | ((INT_DELIVERY_MODE != dest_LowestPrio) ? | |
1603 | MSI_DATA_DELIVERY_FIXED: | |
1604 | MSI_DATA_DELIVERY_LOWPRI) | | |
1605 | - MSI_DATA_VECTOR(vector); | |
1606 | + MSI_DATA_VECTOR(cfg->vector); | |
1607 | } | |
1608 | - return vector; | |
1609 | + return err; | |
1610 | } | |
1611 | ||
1612 | #ifdef CONFIG_SMP | |
1613 | static void set_msi_irq_affinity(unsigned int irq, cpumask_t mask) | |
1614 | { | |
1615 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1616 | struct msi_msg msg; | |
1617 | unsigned int dest; | |
1618 | cpumask_t tmp; | |
1619 | - int vector; | |
1620 | ||
1621 | cpus_and(tmp, mask, cpu_online_map); | |
1622 | if (cpus_empty(tmp)) | |
1623 | - tmp = TARGET_CPUS; | |
1624 | - | |
1625 | - cpus_and(mask, tmp, CPU_MASK_ALL); | |
1626 | + return; | |
1627 | ||
1628 | - vector = assign_irq_vector(irq, mask, &tmp); | |
1629 | - if (vector < 0) | |
1630 | + if (assign_irq_vector(irq, mask)) | |
1631 | return; | |
1632 | ||
1633 | + cpus_and(tmp, cfg->domain, mask); | |
1634 | dest = cpu_mask_to_apicid(tmp); | |
1635 | ||
1636 | read_msi_msg(irq, &msg); | |
1637 | ||
1638 | msg.data &= ~MSI_DATA_VECTOR_MASK; | |
1639 | - msg.data |= MSI_DATA_VECTOR(vector); | |
1640 | + msg.data |= MSI_DATA_VECTOR(cfg->vector); | |
1641 | msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK; | |
1642 | msg.address_lo |= MSI_ADDR_DEST_ID(dest); | |
1643 | ||
1644 | write_msi_msg(irq, &msg); | |
1645 | - set_native_irq_info(irq, mask); | |
1646 | + irq_desc[irq].affinity = mask; | |
1647 | } | |
1648 | #endif /* CONFIG_SMP */ | |
1649 | ||
1650 | @@ -1948,24 +1990,31 @@ static struct irq_chip msi_chip = { | |
1651 | .retrigger = ioapic_retrigger_irq, | |
1652 | }; | |
1653 | ||
1654 | -int arch_setup_msi_irq(unsigned int irq, struct pci_dev *dev) | |
1655 | +int arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc) | |
1656 | { | |
1657 | struct msi_msg msg; | |
1658 | - int ret; | |
1659 | + int irq, ret; | |
1660 | + irq = create_irq(); | |
1661 | + if (irq < 0) | |
1662 | + return irq; | |
1663 | + | |
1664 | + set_irq_msi(irq, desc); | |
1665 | ret = msi_compose_msg(dev, irq, &msg); | |
1666 | - if (ret < 0) | |
1667 | + if (ret < 0) { | |
1668 | + destroy_irq(irq); | |
1669 | return ret; | |
1670 | + } | |
1671 | ||
1672 | write_msi_msg(irq, &msg); | |
1673 | ||
1674 | set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, "edge"); | |
1675 | ||
1676 | - return 0; | |
1677 | + return irq; | |
1678 | } | |
1679 | ||
1680 | void arch_teardown_msi_irq(unsigned int irq) | |
1681 | { | |
1682 | - return; | |
1683 | + destroy_irq(irq); | |
1684 | } | |
1685 | ||
1686 | #endif /* CONFIG_PCI_MSI */ | |
1687 | @@ -1993,24 +2042,22 @@ static void target_ht_irq(unsigned int i | |
1688 | ||
1689 | static void set_ht_irq_affinity(unsigned int irq, cpumask_t mask) | |
1690 | { | |
1691 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1692 | unsigned int dest; | |
1693 | cpumask_t tmp; | |
1694 | - int vector; | |
1695 | ||
1696 | cpus_and(tmp, mask, cpu_online_map); | |
1697 | if (cpus_empty(tmp)) | |
1698 | - tmp = TARGET_CPUS; | |
1699 | - | |
1700 | - cpus_and(mask, tmp, CPU_MASK_ALL); | |
1701 | + return; | |
1702 | ||
1703 | - vector = assign_irq_vector(irq, mask, &tmp); | |
1704 | - if (vector < 0) | |
1705 | + if (assign_irq_vector(irq, mask)) | |
1706 | return; | |
1707 | ||
1708 | + cpus_and(tmp, cfg->domain, mask); | |
1709 | dest = cpu_mask_to_apicid(tmp); | |
1710 | ||
1711 | - target_ht_irq(irq, dest, vector); | |
1712 | - set_native_irq_info(irq, mask); | |
1713 | + target_ht_irq(irq, dest, cfg->vector); | |
1714 | + irq_desc[irq].affinity = mask; | |
1715 | } | |
1716 | #endif | |
1717 | ||
1718 | @@ -2027,14 +2074,17 @@ static struct irq_chip ht_irq_chip = { | |
1719 | ||
1720 | int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev) | |
1721 | { | |
1722 | - int vector; | |
1723 | + struct irq_cfg *cfg = irq_cfg + irq; | |
1724 | + int err; | |
1725 | cpumask_t tmp; | |
1726 | ||
1727 | - vector = assign_irq_vector(irq, TARGET_CPUS, &tmp); | |
1728 | - if (vector >= 0) { | |
1729 | + tmp = TARGET_CPUS; | |
1730 | + err = assign_irq_vector(irq, tmp); | |
1731 | + if (!err) { | |
1732 | struct ht_irq_msg msg; | |
1733 | unsigned dest; | |
1734 | ||
1735 | + cpus_and(tmp, cfg->domain, tmp); | |
1736 | dest = cpu_mask_to_apicid(tmp); | |
1737 | ||
1738 | msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest); | |
1739 | @@ -2042,7 +2092,7 @@ int arch_setup_ht_irq(unsigned int irq, | |
1740 | msg.address_lo = | |
1741 | HT_IRQ_LOW_BASE | | |
1742 | HT_IRQ_LOW_DEST_ID(dest) | | |
1743 | - HT_IRQ_LOW_VECTOR(vector) | | |
1744 | + HT_IRQ_LOW_VECTOR(cfg->vector) | | |
1745 | ((INT_DEST_MODE == 0) ? | |
1746 | HT_IRQ_LOW_DM_PHYSICAL : | |
1747 | HT_IRQ_LOW_DM_LOGICAL) | | |
1748 | @@ -2057,7 +2107,7 @@ int arch_setup_ht_irq(unsigned int irq, | |
1749 | set_irq_chip_and_handler_name(irq, &ht_irq_chip, | |
1750 | handle_edge_irq, "edge"); | |
1751 | } | |
1752 | - return vector; | |
1753 | + return err; | |
1754 | } | |
1755 | #endif /* CONFIG_HT_IRQ */ | |
1756 | ||
1757 | @@ -2082,13 +2132,8 @@ int __init io_apic_get_redir_entries (in | |
1758 | } | |
1759 | ||
1760 | ||
1761 | -int io_apic_set_pci_routing (int ioapic, int pin, int irq, int edge_level, int active_high_low) | |
1762 | +int io_apic_set_pci_routing (int ioapic, int pin, int irq, int triggering, int polarity) | |
1763 | { | |
1764 | - struct IO_APIC_route_entry entry; | |
1765 | - unsigned long flags; | |
1766 | - int vector; | |
1767 | - cpumask_t mask; | |
1768 | - | |
1769 | if (!IO_APIC_IRQ(irq)) { | |
1770 | apic_printk(APIC_QUIET,KERN_ERR "IOAPIC[%d]: Invalid reference to IRQ 0\n", | |
1771 | ioapic); | |
1772 | @@ -2101,42 +2146,7 @@ int io_apic_set_pci_routing (int ioapic, | |
1773 | if (irq >= 16) | |
1774 | add_pin_to_irq(irq, ioapic, pin); | |
1775 | ||
1776 | - | |
1777 | - vector = assign_irq_vector(irq, TARGET_CPUS, &mask); | |
1778 | - if (vector < 0) | |
1779 | - return vector; | |
1780 | - | |
1781 | - /* | |
1782 | - * Generate a PCI IRQ routing entry and program the IOAPIC accordingly. | |
1783 | - * Note that we mask (disable) IRQs now -- these get enabled when the | |
1784 | - * corresponding device driver registers for this IRQ. | |
1785 | - */ | |
1786 | - | |
1787 | - memset(&entry,0,sizeof(entry)); | |
1788 | - | |
1789 | - entry.delivery_mode = INT_DELIVERY_MODE; | |
1790 | - entry.dest_mode = INT_DEST_MODE; | |
1791 | - entry.dest.logical.logical_dest = cpu_mask_to_apicid(mask); | |
1792 | - entry.trigger = edge_level; | |
1793 | - entry.polarity = active_high_low; | |
1794 | - entry.mask = 1; /* Disabled (masked) */ | |
1795 | - entry.vector = vector & 0xff; | |
1796 | - | |
1797 | - apic_printk(APIC_VERBOSE,KERN_DEBUG "IOAPIC[%d]: Set PCI routing entry (%d-%d -> 0x%x -> " | |
1798 | - "IRQ %d Mode:%i Active:%i)\n", ioapic, | |
1799 | - mp_ioapics[ioapic].mpc_apicid, pin, entry.vector, irq, | |
1800 | - edge_level, active_high_low); | |
1801 | - | |
1802 | - ioapic_register_intr(irq, entry.vector, edge_level); | |
1803 | - | |
1804 | - if (!ioapic && (irq < 16)) | |
1805 | - disable_8259A_irq(irq); | |
1806 | - | |
1807 | - ioapic_write_entry(ioapic, pin, entry); | |
1808 | - | |
1809 | - spin_lock_irqsave(&ioapic_lock, flags); | |
1810 | - set_native_irq_info(irq, TARGET_CPUS); | |
1811 | - spin_unlock_irqrestore(&ioapic_lock, flags); | |
1812 | + setup_IO_APIC_irq(ioapic, pin, irq, triggering, polarity); | |
1813 | ||
1814 | return 0; | |
1815 | } | |
1816 | @@ -2169,8 +2179,10 @@ void __init setup_ioapic_dest(void) | |
1817 | * when you have too many devices, because at that time only boot | |
1818 | * cpu is online. | |
1819 | */ | |
1820 | - if(!irq_vector[irq]) | |
1821 | - setup_IO_APIC_irq(ioapic, pin, irq_entry, irq); | |
1822 | + if (!irq_cfg[irq].vector) | |
1823 | + setup_IO_APIC_irq(ioapic, pin, irq, | |
1824 | + irq_trigger(irq_entry), | |
1825 | + irq_polarity(irq_entry)); | |
1826 | else | |
1827 | set_ioapic_affinity_irq(irq, TARGET_CPUS); | |
1828 | } | |
1829 | --- a/arch/x86/kernel/irq_32-xen.c | |
1830 | +++ b/arch/x86/kernel/irq_32-xen.c | |
1831 | @@ -10,7 +10,6 @@ | |
1832 | * io_apic.c.) | |
1833 | */ | |
1834 | ||
1835 | -#include <asm/uaccess.h> | |
1836 | #include <linux/module.h> | |
1837 | #include <linux/seq_file.h> | |
1838 | #include <linux/interrupt.h> | |
1839 | @@ -19,19 +18,34 @@ | |
1840 | #include <linux/cpu.h> | |
1841 | #include <linux/delay.h> | |
1842 | ||
1843 | +#include <asm/apic.h> | |
1844 | +#include <asm/uaccess.h> | |
1845 | + | |
1846 | DEFINE_PER_CPU(irq_cpustat_t, irq_stat) ____cacheline_internodealigned_in_smp; | |
1847 | EXPORT_PER_CPU_SYMBOL(irq_stat); | |
1848 | ||
1849 | -#ifndef CONFIG_X86_LOCAL_APIC | |
1850 | /* | |
1851 | * 'what should we do if we get a hw irq event on an illegal vector'. | |
1852 | * each architecture has to answer this themselves. | |
1853 | */ | |
1854 | void ack_bad_irq(unsigned int irq) | |
1855 | { | |
1856 | - printk("unexpected IRQ trap at vector %02x\n", irq); | |
1857 | -} | |
1858 | + printk(KERN_ERR "unexpected IRQ trap at vector %02x\n", irq); | |
1859 | + | |
1860 | +#if defined(CONFIG_X86_LOCAL_APIC) && !defined(CONFIG_XEN) | |
1861 | + /* | |
1862 | + * Currently unexpected vectors happen only on SMP and APIC. | |
1863 | + * We _must_ ack these because every local APIC has only N | |
1864 | + * irq slots per priority level, and a 'hanging, unacked' IRQ | |
1865 | + * holds up an irq slot - in excessive cases (when multiple | |
1866 | + * unexpected vectors occur) that might lock up the APIC | |
1867 | + * completely. | |
1868 | + * But only ack when the APIC is enabled -AK | |
1869 | + */ | |
1870 | + if (cpu_has_apic) | |
1871 | + ack_APIC_irq(); | |
1872 | #endif | |
1873 | +} | |
1874 | ||
1875 | #ifdef CONFIG_4KSTACKS | |
1876 | /* | |
1877 | --- a/arch/x86/kernel/irq_64-xen.c | |
1878 | +++ b/arch/x86/kernel/irq_64-xen.c | |
1879 | @@ -18,6 +18,7 @@ | |
1880 | #include <asm/uaccess.h> | |
1881 | #include <asm/io_apic.h> | |
1882 | #include <asm/idle.h> | |
1883 | +#include <asm/smp.h> | |
1884 | ||
1885 | atomic_t irq_err_count; | |
1886 | ||
1887 | @@ -120,9 +121,15 @@ asmlinkage unsigned int do_IRQ(struct pt | |
1888 | ||
1889 | if (likely(irq < NR_IRQS)) | |
1890 | generic_handle_irq(irq); | |
1891 | - else if (printk_ratelimit()) | |
1892 | - printk(KERN_EMERG "%s: %d.%d No irq handler for irq\n", | |
1893 | - __func__, smp_processor_id(), irq); | |
1894 | + else { | |
1895 | +#ifndef CONFIG_XEN | |
1896 | + if (!disable_apic) | |
1897 | + ack_APIC_irq(); | |
1898 | +#endif | |
1899 | + if (printk_ratelimit()) | |
1900 | + printk(KERN_EMERG "%s: %d.%d No irq handler for irq\n", | |
1901 | + __func__, smp_processor_id(), irq); | |
1902 | + } | |
1903 | ||
1904 | /*irq_exit();*/ | |
1905 | ||
1906 | --- a/arch/x86/kernel/Makefile | |
1907 | +++ b/arch/x86/kernel/Makefile | |
1908 | @@ -124,7 +124,7 @@ ifeq ($(CONFIG_X86_64),y) | |
1909 | pci-dma_64-$(CONFIG_XEN) += pci-dma_32.o | |
1910 | endif | |
1911 | ||
1912 | -disabled-obj-$(CONFIG_XEN) := early-quirks.o i8253.o i8259_$(BITS).o reboot.o \ | |
1913 | - smpboot_$(BITS).o tsc_$(BITS).o | |
1914 | +disabled-obj-$(CONFIG_XEN) := early-quirks.o hpet.o i8253.o i8259_$(BITS).o reboot.o \ | |
1915 | + smpboot_$(BITS).o tsc_$(BITS).o tsc_sync.o | |
1916 | disabled-obj-$(CONFIG_XEN_UNPRIVILEGED_GUEST) += mpparse_64.o | |
1917 | %/head_$(BITS).o %/head_$(BITS).s: $(if $(CONFIG_XEN),EXTRA_AFLAGS,dummy) := | |
1918 | --- a/arch/x86/kernel/microcode-xen.c | |
1919 | +++ b/arch/x86/kernel/microcode-xen.c | |
1920 | @@ -108,7 +108,7 @@ static ssize_t microcode_write (struct f | |
1921 | return ret; | |
1922 | } | |
1923 | ||
1924 | -static struct file_operations microcode_fops = { | |
1925 | +static const struct file_operations microcode_fops = { | |
1926 | .owner = THIS_MODULE, | |
1927 | .write = microcode_write, | |
1928 | .open = microcode_open, | |
1929 | --- a/arch/x86/kernel/mpparse_32-xen.c | |
1930 | +++ b/arch/x86/kernel/mpparse_32-xen.c | |
1931 | @@ -1079,7 +1079,7 @@ int mp_register_gsi(u32 gsi, int trigger | |
1932 | static int gsi_to_irq[MAX_GSI_NUM]; | |
1933 | ||
1934 | /* Don't set up the ACPI SCI because it's already set up */ | |
1935 | - if (acpi_fadt.sci_int == gsi) | |
1936 | + if (acpi_gbl_FADT.sci_interrupt == gsi) | |
1937 | return gsi; | |
1938 | ||
1939 | ioapic = mp_find_ioapic(gsi); | |
1940 | @@ -1136,7 +1136,7 @@ int mp_register_gsi(u32 gsi, int trigger | |
1941 | /* | |
1942 | * Don't assign IRQ used by ACPI SCI | |
1943 | */ | |
1944 | - if (gsi == acpi_fadt.sci_int) | |
1945 | + if (gsi == acpi_gbl_FADT.sci_interrupt) | |
1946 | gsi = pci_irq++; | |
1947 | gsi_to_irq[irq] = gsi; | |
1948 | } else { | |
1949 | --- a/arch/x86/kernel/mpparse_64-xen.c | |
1950 | +++ b/arch/x86/kernel/mpparse_64-xen.c | |
1951 | @@ -60,9 +60,9 @@ unsigned long mp_lapic_addr = 0; | |
1952 | /* Processor that is doing the boot up */ | |
1953 | unsigned int boot_cpu_id = -1U; | |
1954 | /* Internal processor count */ | |
1955 | -unsigned int num_processors __initdata = 0; | |
1956 | +unsigned int num_processors __cpuinitdata = 0; | |
1957 | ||
1958 | -unsigned disabled_cpus __initdata; | |
1959 | +unsigned disabled_cpus __cpuinitdata; | |
1960 | ||
1961 | /* Bitmask of physically existing CPUs */ | |
1962 | physid_mask_t phys_cpu_present_map = PHYSID_MASK_NONE; | |
1963 | @@ -808,7 +808,7 @@ int mp_register_gsi(u32 gsi, int trigger | |
1964 | return gsi; | |
1965 | ||
1966 | /* Don't set up the ACPI SCI because it's already set up */ | |
1967 | - if (acpi_fadt.sci_int == gsi) | |
1968 | + if (acpi_gbl_FADT.sci_interrupt == gsi) | |
1969 | return gsi; | |
1970 | ||
1971 | ioapic = mp_find_ioapic(gsi); | |
1972 | --- a/arch/x86/kernel/pci-dma-xen.c | |
1973 | +++ b/arch/x86/kernel/pci-dma-xen.c | |
1974 | @@ -311,7 +311,7 @@ int dma_declare_coherent_memory(struct d | |
1975 | return DMA_MEMORY_IO; | |
1976 | ||
1977 | free1_out: | |
1978 | - kfree(dev->dma_mem->bitmap); | |
1979 | + kfree(dev->dma_mem); | |
1980 | out: | |
1981 | if (mem_base) | |
1982 | iounmap(mem_base); | |
1983 | --- a/arch/x86/kernel/pcspeaker.c | |
1984 | +++ b/arch/x86/kernel/pcspeaker.c | |
1985 | @@ -7,6 +7,11 @@ static __init int add_pcspkr(void) | |
1986 | struct platform_device *pd; | |
1987 | int ret; | |
1988 | ||
1989 | +#ifdef CONFIG_XEN | |
1990 | + if (!is_initial_xendomain()) | |
1991 | + return 0; | |
1992 | +#endif | |
1993 | + | |
1994 | pd = platform_device_alloc("pcspkr", -1); | |
1995 | if (!pd) | |
1996 | return -ENOMEM; | |
1997 | --- a/arch/x86/kernel/process_32-xen.c | |
1998 | +++ b/arch/x86/kernel/process_32-xen.c | |
1999 | @@ -38,6 +38,7 @@ | |
2000 | #include <linux/ptrace.h> | |
2001 | #include <linux/random.h> | |
2002 | #include <linux/personality.h> | |
2003 | +#include <linux/tick.h> | |
2004 | ||
2005 | #include <asm/uaccess.h> | |
2006 | #include <asm/pgtable.h> | |
2007 | @@ -160,6 +161,7 @@ void cpu_idle(void) | |
2008 | ||
2009 | /* endless idle loop with no priority at all */ | |
2010 | while (1) { | |
2011 | + tick_nohz_stop_sched_tick(); | |
2012 | while (!need_resched()) { | |
2013 | void (*idle)(void); | |
2014 | ||
2015 | @@ -175,6 +177,7 @@ void cpu_idle(void) | |
2016 | __get_cpu_var(irq_stat).idle_timestamp = jiffies; | |
2017 | idle(); | |
2018 | } | |
2019 | + tick_nohz_restart_sched_tick(); | |
2020 | preempt_enable_no_resched(); | |
2021 | schedule(); | |
2022 | preempt_disable(); | |
2023 | @@ -247,8 +250,8 @@ void show_regs(struct pt_regs * regs) | |
2024 | regs->eax,regs->ebx,regs->ecx,regs->edx); | |
2025 | printk("ESI: %08lx EDI: %08lx EBP: %08lx", | |
2026 | regs->esi, regs->edi, regs->ebp); | |
2027 | - printk(" DS: %04x ES: %04x GS: %04x\n", | |
2028 | - 0xffff & regs->xds,0xffff & regs->xes, 0xffff & regs->xgs); | |
2029 | + printk(" DS: %04x ES: %04x FS: %04x\n", | |
2030 | + 0xffff & regs->xds,0xffff & regs->xes, 0xffff & regs->xfs); | |
2031 | ||
2032 | cr0 = read_cr0(); | |
2033 | cr2 = read_cr2(); | |
2034 | @@ -279,7 +282,7 @@ int kernel_thread(int (*fn)(void *), voi | |
2035 | ||
2036 | regs.xds = __USER_DS; | |
2037 | regs.xes = __USER_DS; | |
2038 | - regs.xgs = __KERNEL_PDA; | |
2039 | + regs.xfs = __KERNEL_PDA; | |
2040 | regs.orig_eax = -1; | |
2041 | regs.eip = (unsigned long) kernel_thread_helper; | |
2042 | regs.xcs = __KERNEL_CS | get_kernel_rpl(); | |
2043 | @@ -356,7 +359,7 @@ int copy_thread(int nr, unsigned long cl | |
2044 | ||
2045 | p->thread.eip = (unsigned long) ret_from_fork; | |
2046 | ||
2047 | - savesegment(fs,p->thread.fs); | |
2048 | + savesegment(gs,p->thread.gs); | |
2049 | ||
2050 | tsk = current; | |
2051 | if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) { | |
2052 | @@ -434,8 +437,8 @@ void dump_thread(struct pt_regs * regs, | |
2053 | dump->regs.eax = regs->eax; | |
2054 | dump->regs.ds = regs->xds; | |
2055 | dump->regs.es = regs->xes; | |
2056 | - savesegment(fs,dump->regs.fs); | |
2057 | - dump->regs.gs = regs->xgs; | |
2058 | + dump->regs.fs = regs->xfs; | |
2059 | + savesegment(gs,dump->regs.gs); | |
2060 | dump->regs.orig_eax = regs->orig_eax; | |
2061 | dump->regs.eip = regs->eip; | |
2062 | dump->regs.cs = regs->xcs; | |
2063 | @@ -637,16 +640,6 @@ struct task_struct fastcall * __switch_t | |
2064 | prefetch(&next->i387.fxsave); | |
2065 | ||
2066 | /* | |
2067 | - * Restore %fs if needed. | |
2068 | - * | |
2069 | - * Glibc normally makes %fs be zero. | |
2070 | - */ | |
2071 | - if (unlikely(next->fs)) | |
2072 | - loadsegment(fs, next->fs); | |
2073 | - | |
2074 | - write_pda(pcurrent, next_p); | |
2075 | - | |
2076 | - /* | |
2077 | * Now maybe handle debug registers | |
2078 | */ | |
2079 | if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW)) | |
2080 | @@ -654,6 +647,15 @@ struct task_struct fastcall * __switch_t | |
2081 | ||
2082 | disable_tsc(prev_p, next_p); | |
2083 | ||
2084 | + /* | |
2085 | + * Leave lazy mode, flushing any hypercalls made here. | |
2086 | + * This must be done before restoring TLS segments so | |
2087 | + * the GDT and LDT are properly updated, and must be | |
2088 | + * done before math_state_restore, so the TS bit is up | |
2089 | + * to date. | |
2090 | + */ | |
2091 | + arch_leave_lazy_cpu_mode(); | |
2092 | + | |
2093 | /* If the task has used fpu the last 5 timeslices, just do a full | |
2094 | * restore of the math state immediately to avoid the trap; the | |
2095 | * chances of needing FPU soon are obviously high now | |
2096 | @@ -661,6 +663,14 @@ struct task_struct fastcall * __switch_t | |
2097 | if (next_p->fpu_counter > 5) | |
2098 | math_state_restore(); | |
2099 | ||
2100 | + /* | |
2101 | + * Restore %gs if needed (which is common) | |
2102 | + */ | |
2103 | + if (prev->gs | next->gs) | |
2104 | + loadsegment(gs, next->gs); | |
2105 | + | |
2106 | + write_pda(pcurrent, next_p); | |
2107 | + | |
2108 | return prev_p; | |
2109 | } | |
2110 | ||
2111 | --- a/arch/x86/kernel/process_64-xen.c | |
2112 | +++ b/arch/x86/kernel/process_64-xen.c | |
2113 | @@ -338,14 +338,17 @@ void load_gs_index(unsigned gs) | |
2114 | void flush_thread(void) | |
2115 | { | |
2116 | struct task_struct *tsk = current; | |
2117 | - struct thread_info *t = current_thread_info(); | |
2118 | ||
2119 | - if (t->flags & _TIF_ABI_PENDING) { | |
2120 | - t->flags ^= (_TIF_ABI_PENDING | _TIF_IA32); | |
2121 | - if (t->flags & _TIF_IA32) | |
2122 | + if (test_tsk_thread_flag(tsk, TIF_ABI_PENDING)) { | |
2123 | + clear_tsk_thread_flag(tsk, TIF_ABI_PENDING); | |
2124 | + if (test_tsk_thread_flag(tsk, TIF_IA32)) { | |
2125 | + clear_tsk_thread_flag(tsk, TIF_IA32); | |
2126 | + } else { | |
2127 | + set_tsk_thread_flag(tsk, TIF_IA32); | |
2128 | current_thread_info()->status |= TS_COMPAT; | |
2129 | + } | |
2130 | } | |
2131 | - t->flags &= ~_TIF_DEBUG; | |
2132 | + clear_tsk_thread_flag(tsk, TIF_DEBUG); | |
2133 | ||
2134 | tsk->thread.debugreg0 = 0; | |
2135 | tsk->thread.debugreg1 = 0; | |
2136 | --- a/arch/x86/kernel/setup_32-xen.c | |
2137 | +++ b/arch/x86/kernel/setup_32-xen.c | |
2138 | @@ -33,7 +33,6 @@ | |
2139 | #include <linux/initrd.h> | |
2140 | #include <linux/bootmem.h> | |
2141 | #include <linux/seq_file.h> | |
2142 | -#include <linux/platform_device.h> | |
2143 | #include <linux/console.h> | |
2144 | #include <linux/mca.h> | |
2145 | #include <linux/root_dev.h> | |
2146 | @@ -148,7 +147,7 @@ unsigned long saved_videomode; | |
2147 | #define RAMDISK_PROMPT_FLAG 0x8000 | |
2148 | #define RAMDISK_LOAD_FLAG 0x4000 | |
2149 | ||
2150 | -static char command_line[COMMAND_LINE_SIZE]; | |
2151 | +static char __initdata command_line[COMMAND_LINE_SIZE]; | |
2152 | ||
2153 | unsigned char __initdata boot_params[PARAM_SIZE]; | |
2154 | ||
2155 | @@ -647,8 +646,8 @@ void __init setup_arch(char **cmdline_p) | |
2156 | ||
2157 | if ((i = MAX_GUEST_CMDLINE) > COMMAND_LINE_SIZE) | |
2158 | i = COMMAND_LINE_SIZE; | |
2159 | - memcpy(saved_command_line, xen_start_info->cmd_line, i); | |
2160 | - saved_command_line[i - 1] = '\0'; | |
2161 | + memcpy(boot_command_line, xen_start_info->cmd_line, i); | |
2162 | + boot_command_line[i - 1] = '\0'; | |
2163 | parse_early_param(); | |
2164 | ||
2165 | if (user_defined_memmap) { | |
2166 | @@ -656,11 +655,19 @@ void __init setup_arch(char **cmdline_p) | |
2167 | print_memory_map("user"); | |
2168 | } | |
2169 | ||
2170 | - strlcpy(command_line, saved_command_line, COMMAND_LINE_SIZE); | |
2171 | + strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); | |
2172 | *cmdline_p = command_line; | |
2173 | ||
2174 | max_low_pfn = setup_memory(); | |
2175 | ||
2176 | +#ifdef CONFIG_VMI | |
2177 | + /* | |
2178 | + * Must be after max_low_pfn is determined, and before kernel | |
2179 | + * pagetables are setup. | |
2180 | + */ | |
2181 | + vmi_init(); | |
2182 | +#endif | |
2183 | + | |
2184 | /* | |
2185 | * NOTE: before this point _nobody_ is allowed to allocate | |
2186 | * any memory using the bootmem allocator. Although the | |
2187 | @@ -823,7 +830,6 @@ void __init setup_arch(char **cmdline_p) | |
2188 | conswitchp = &dummy_con; | |
2189 | #endif | |
2190 | } | |
2191 | - tsc_init(); | |
2192 | } | |
2193 | ||
2194 | static int | |
2195 | @@ -833,31 +839,3 @@ xen_panic_event(struct notifier_block *t | |
2196 | /* we're never actually going to get here... */ | |
2197 | return NOTIFY_DONE; | |
2198 | } | |
2199 | - | |
2200 | -static __init int add_pcspkr(void) | |
2201 | -{ | |
2202 | - struct platform_device *pd; | |
2203 | - int ret; | |
2204 | - | |
2205 | - if (!is_initial_xendomain()) | |
2206 | - return 0; | |
2207 | - | |
2208 | - pd = platform_device_alloc("pcspkr", -1); | |
2209 | - if (!pd) | |
2210 | - return -ENOMEM; | |
2211 | - | |
2212 | - ret = platform_device_add(pd); | |
2213 | - if (ret) | |
2214 | - platform_device_put(pd); | |
2215 | - | |
2216 | - return ret; | |
2217 | -} | |
2218 | -device_initcall(add_pcspkr); | |
2219 | - | |
2220 | -/* | |
2221 | - * Local Variables: | |
2222 | - * mode:c | |
2223 | - * c-file-style:"k&r" | |
2224 | - * c-basic-offset:8 | |
2225 | - * End: | |
2226 | - */ | |
2227 | --- a/arch/x86/kernel/setup_64-xen.c | |
2228 | +++ b/arch/x86/kernel/setup_64-xen.c | |
2229 | @@ -141,7 +141,7 @@ EXPORT_SYMBOL_GPL(edid_info); | |
2230 | ||
2231 | extern int root_mountflags; | |
2232 | ||
2233 | -char command_line[COMMAND_LINE_SIZE]; | |
2234 | +char __initdata command_line[COMMAND_LINE_SIZE]; | |
2235 | ||
2236 | struct resource standard_io_resources[] = { | |
2237 | { .name = "dma1", .start = 0x00, .end = 0x1f, | |
2238 | @@ -179,134 +179,6 @@ struct resource code_resource = { | |
2239 | .flags = IORESOURCE_RAM, | |
2240 | }; | |
2241 | ||
2242 | -#define IORESOURCE_ROM (IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM) | |
2243 | - | |
2244 | -static struct resource system_rom_resource = { | |
2245 | - .name = "System ROM", | |
2246 | - .start = 0xf0000, | |
2247 | - .end = 0xfffff, | |
2248 | - .flags = IORESOURCE_ROM, | |
2249 | -}; | |
2250 | - | |
2251 | -static struct resource extension_rom_resource = { | |
2252 | - .name = "Extension ROM", | |
2253 | - .start = 0xe0000, | |
2254 | - .end = 0xeffff, | |
2255 | - .flags = IORESOURCE_ROM, | |
2256 | -}; | |
2257 | - | |
2258 | -static struct resource adapter_rom_resources[] = { | |
2259 | - { .name = "Adapter ROM", .start = 0xc8000, .end = 0, | |
2260 | - .flags = IORESOURCE_ROM }, | |
2261 | - { .name = "Adapter ROM", .start = 0, .end = 0, | |
2262 | - .flags = IORESOURCE_ROM }, | |
2263 | - { .name = "Adapter ROM", .start = 0, .end = 0, | |
2264 | - .flags = IORESOURCE_ROM }, | |
2265 | - { .name = "Adapter ROM", .start = 0, .end = 0, | |
2266 | - .flags = IORESOURCE_ROM }, | |
2267 | - { .name = "Adapter ROM", .start = 0, .end = 0, | |
2268 | - .flags = IORESOURCE_ROM }, | |
2269 | - { .name = "Adapter ROM", .start = 0, .end = 0, | |
2270 | - .flags = IORESOURCE_ROM } | |
2271 | -}; | |
2272 | - | |
2273 | -static struct resource video_rom_resource = { | |
2274 | - .name = "Video ROM", | |
2275 | - .start = 0xc0000, | |
2276 | - .end = 0xc7fff, | |
2277 | - .flags = IORESOURCE_ROM, | |
2278 | -}; | |
2279 | - | |
2280 | -static struct resource video_ram_resource = { | |
2281 | - .name = "Video RAM area", | |
2282 | - .start = 0xa0000, | |
2283 | - .end = 0xbffff, | |
2284 | - .flags = IORESOURCE_RAM, | |
2285 | -}; | |
2286 | - | |
2287 | -#define romsignature(x) (*(unsigned short *)(x) == 0xaa55) | |
2288 | - | |
2289 | -static int __init romchecksum(unsigned char *rom, unsigned long length) | |
2290 | -{ | |
2291 | - unsigned char *p, sum = 0; | |
2292 | - | |
2293 | - for (p = rom; p < rom + length; p++) | |
2294 | - sum += *p; | |
2295 | - return sum == 0; | |
2296 | -} | |
2297 | - | |
2298 | -static void __init probe_roms(void) | |
2299 | -{ | |
2300 | - unsigned long start, length, upper; | |
2301 | - unsigned char *rom; | |
2302 | - int i; | |
2303 | - | |
2304 | -#ifdef CONFIG_XEN | |
2305 | - /* Nothing to do if not running in dom0. */ | |
2306 | - if (!is_initial_xendomain()) | |
2307 | - return; | |
2308 | -#endif | |
2309 | - | |
2310 | - /* video rom */ | |
2311 | - upper = adapter_rom_resources[0].start; | |
2312 | - for (start = video_rom_resource.start; start < upper; start += 2048) { | |
2313 | - rom = isa_bus_to_virt(start); | |
2314 | - if (!romsignature(rom)) | |
2315 | - continue; | |
2316 | - | |
2317 | - video_rom_resource.start = start; | |
2318 | - | |
2319 | - /* 0 < length <= 0x7f * 512, historically */ | |
2320 | - length = rom[2] * 512; | |
2321 | - | |
2322 | - /* if checksum okay, trust length byte */ | |
2323 | - if (length && romchecksum(rom, length)) | |
2324 | - video_rom_resource.end = start + length - 1; | |
2325 | - | |
2326 | - request_resource(&iomem_resource, &video_rom_resource); | |
2327 | - break; | |
2328 | - } | |
2329 | - | |
2330 | - start = (video_rom_resource.end + 1 + 2047) & ~2047UL; | |
2331 | - if (start < upper) | |
2332 | - start = upper; | |
2333 | - | |
2334 | - /* system rom */ | |
2335 | - request_resource(&iomem_resource, &system_rom_resource); | |
2336 | - upper = system_rom_resource.start; | |
2337 | - | |
2338 | - /* check for extension rom (ignore length byte!) */ | |
2339 | - rom = isa_bus_to_virt(extension_rom_resource.start); | |
2340 | - if (romsignature(rom)) { | |
2341 | - length = extension_rom_resource.end - extension_rom_resource.start + 1; | |
2342 | - if (romchecksum(rom, length)) { | |
2343 | - request_resource(&iomem_resource, &extension_rom_resource); | |
2344 | - upper = extension_rom_resource.start; | |
2345 | - } | |
2346 | - } | |
2347 | - | |
2348 | - /* check for adapter roms on 2k boundaries */ | |
2349 | - for (i = 0; i < ARRAY_SIZE(adapter_rom_resources) && start < upper; | |
2350 | - start += 2048) { | |
2351 | - rom = isa_bus_to_virt(start); | |
2352 | - if (!romsignature(rom)) | |
2353 | - continue; | |
2354 | - | |
2355 | - /* 0 < length <= 0x7f * 512, historically */ | |
2356 | - length = rom[2] * 512; | |
2357 | - | |
2358 | - /* but accept any length that fits if checksum okay */ | |
2359 | - if (!length || start + length > upper || !romchecksum(rom, length)) | |
2360 | - continue; | |
2361 | - | |
2362 | - adapter_rom_resources[i].start = start; | |
2363 | - adapter_rom_resources[i].end = start + length - 1; | |
2364 | - request_resource(&iomem_resource, &adapter_rom_resources[i]); | |
2365 | - | |
2366 | - start = adapter_rom_resources[i++].end & ~2047UL; | |
2367 | - } | |
2368 | -} | |
2369 | - | |
2370 | #ifdef CONFIG_PROC_VMCORE | |
2371 | /* elfcorehdr= specifies the location of elf core header | |
2372 | * stored by the crashed kernel. This option will be passed | |
2373 | @@ -403,7 +275,7 @@ void __init setup_arch(char **cmdline_p) | |
2374 | #ifdef CONFIG_XEN | |
2375 | extern struct e820map machine_e820; | |
2376 | ||
2377 | - printk(KERN_INFO "Command line: %s\n", saved_command_line); | |
2378 | + printk(KERN_INFO "Command line: %s\n", boot_command_line); | |
2379 | ||
2380 | /* Register a call for panic conditions. */ | |
2381 | atomic_notifier_chain_register(&panic_notifier_list, &xen_panic_block); | |
2382 | @@ -430,7 +302,7 @@ void __init setup_arch(char **cmdline_p) | |
2383 | ||
2384 | ARCH_SETUP | |
2385 | #else | |
2386 | - printk(KERN_INFO "Command line: %s\n", saved_command_line); | |
2387 | + printk(KERN_INFO "Command line: %s\n", boot_command_line); | |
2388 | ||
2389 | ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV); | |
2390 | screen_info = SCREEN_INFO; | |
2391 | @@ -461,7 +333,7 @@ void __init setup_arch(char **cmdline_p) | |
2392 | ||
2393 | early_identify_cpu(&boot_cpu_data); | |
2394 | ||
2395 | - strlcpy(command_line, saved_command_line, COMMAND_LINE_SIZE); | |
2396 | + strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); | |
2397 | *cmdline_p = command_line; | |
2398 | ||
2399 | parse_early_param(); | |
2400 | @@ -531,6 +403,11 @@ void __init setup_arch(char **cmdline_p) | |
2401 | /* reserve ebda region */ | |
2402 | if (ebda_addr) | |
2403 | reserve_bootmem_generic(ebda_addr, ebda_size); | |
2404 | +#ifdef CONFIG_NUMA | |
2405 | + /* reserve nodemap region */ | |
2406 | + if (nodemap_addr) | |
2407 | + reserve_bootmem_generic(nodemap_addr, nodemap_size); | |
2408 | +#endif | |
2409 | ||
2410 | #ifdef CONFIG_SMP | |
2411 | /* | |
2412 | @@ -731,10 +608,8 @@ void __init setup_arch(char **cmdline_p) | |
2413 | #endif | |
2414 | ||
2415 | /* | |
2416 | - * Request address space for all standard RAM and ROM resources | |
2417 | - * and also for regions reported as reserved by the e820. | |
2418 | + * We trust e820 completely. No explicit ROM probing in memory. | |
2419 | */ | |
2420 | - probe_roms(); | |
2421 | #ifdef CONFIG_XEN | |
2422 | if (is_initial_xendomain()) | |
2423 | e820_reserve_resources(machine_e820.map, machine_e820.nr_map); | |
2424 | @@ -743,8 +618,6 @@ void __init setup_arch(char **cmdline_p) | |
2425 | e820_mark_nosave_regions(); | |
2426 | #endif | |
2427 | ||
2428 | - request_resource(&iomem_resource, &video_ram_resource); | |
2429 | - | |
2430 | { | |
2431 | unsigned i; | |
2432 | /* request I/O space for devices used on all i[345]86 PCs */ | |
2433 | @@ -1321,7 +1194,8 @@ static int show_cpuinfo(struct seq_file | |
2434 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2435 | NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL, | |
2436 | NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL, | |
2437 | - NULL, "fxsr_opt", NULL, "rdtscp", NULL, "lm", "3dnowext", "3dnow", | |
2438 | + NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm", | |
2439 | + "3dnowext", "3dnow", | |
2440 | ||
2441 | /* Transmeta-defined */ | |
2442 | "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL, | |
2443 | @@ -1339,7 +1213,7 @@ static int show_cpuinfo(struct seq_file | |
2444 | /* Intel-defined (#2) */ | |
2445 | "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est", | |
2446 | "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL, | |
2447 | - NULL, NULL, "dca", NULL, NULL, NULL, NULL, NULL, | |
2448 | + NULL, NULL, "dca", NULL, NULL, NULL, NULL, "popcnt", | |
2449 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2450 | ||
2451 | /* VIA/Cyrix/Centaur-defined */ | |
2452 | @@ -1349,8 +1223,10 @@ static int show_cpuinfo(struct seq_file | |
2453 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2454 | ||
2455 | /* AMD-defined (#2) */ | |
2456 | - "lahf_lm", "cmp_legacy", "svm", NULL, "cr8_legacy", NULL, NULL, NULL, | |
2457 | - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2458 | + "lahf_lm", "cmp_legacy", "svm", "extapic", "cr8_legacy", | |
2459 | + "altmovcr8", "abm", "sse4a", | |
2460 | + "misalignsse", "3dnowprefetch", | |
2461 | + "osvw", "ibs", NULL, NULL, NULL, NULL, | |
2462 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2463 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2464 | }; | |
2465 | @@ -1361,6 +1237,9 @@ static int show_cpuinfo(struct seq_file | |
2466 | "ttp", /* thermal trip */ | |
2467 | "tm", | |
2468 | "stc", | |
2469 | + "100mhzsteps", | |
2470 | + "hwpstate", | |
2471 | + NULL, /* tsc invariant mapped to constant_tsc */ | |
2472 | NULL, | |
2473 | /* nothing */ /* constant_tsc - moved to flags */ | |
2474 | }; | |
2475 | @@ -1477,26 +1356,3 @@ struct seq_operations cpuinfo_op = { | |
2476 | .stop = c_stop, | |
2477 | .show = show_cpuinfo, | |
2478 | }; | |
2479 | - | |
2480 | -#if defined(CONFIG_INPUT_PCSPKR) || defined(CONFIG_INPUT_PCSPKR_MODULE) | |
2481 | -#include <linux/platform_device.h> | |
2482 | -static __init int add_pcspkr(void) | |
2483 | -{ | |
2484 | - struct platform_device *pd; | |
2485 | - int ret; | |
2486 | - | |
2487 | - if (!is_initial_xendomain()) | |
2488 | - return 0; | |
2489 | - | |
2490 | - pd = platform_device_alloc("pcspkr", -1); | |
2491 | - if (!pd) | |
2492 | - return -ENOMEM; | |
2493 | - | |
2494 | - ret = platform_device_add(pd); | |
2495 | - if (ret) | |
2496 | - platform_device_put(pd); | |
2497 | - | |
2498 | - return ret; | |
2499 | -} | |
2500 | -device_initcall(add_pcspkr); | |
2501 | -#endif | |
2502 | --- a/arch/x86/kernel/smp_32-xen.c | |
2503 | +++ b/arch/x86/kernel/smp_32-xen.c | |
2504 | @@ -335,8 +335,7 @@ static void flush_tlb_others(cpumask_t c | |
2505 | /* | |
2506 | * i'm not happy about this global shared spinlock in the | |
2507 | * MM hot path, but we'll see how contended it is. | |
2508 | - * Temporarily this turns IRQs off, so that lockups are | |
2509 | - * detected by the NMI watchdog. | |
2510 | + * AK: x86-64 has a faster method that could be ported. | |
2511 | */ | |
2512 | spin_lock(&tlbstate_lock); | |
2513 | ||
2514 | @@ -361,7 +360,7 @@ static void flush_tlb_others(cpumask_t c | |
2515 | ||
2516 | while (!cpus_empty(flush_cpumask)) | |
2517 | /* nothing. lockup detection does not belong here */ | |
2518 | - mb(); | |
2519 | + cpu_relax(); | |
2520 | ||
2521 | flush_mm = NULL; | |
2522 | flush_va = 0; | |
2523 | --- a/arch/x86/kernel/time_32-xen.c | |
2524 | +++ b/arch/x86/kernel/time_32-xen.c | |
2525 | @@ -51,6 +51,7 @@ | |
2526 | #include <linux/kernel_stat.h> | |
2527 | #include <linux/posix-timers.h> | |
2528 | #include <linux/cpufreq.h> | |
2529 | +#include <linux/clocksource.h> | |
2530 | ||
2531 | #include <asm/io.h> | |
2532 | #include <asm/smp.h> | |
2533 | @@ -75,25 +76,17 @@ | |
2534 | #include <xen/evtchn.h> | |
2535 | #include <xen/interface/vcpu.h> | |
2536 | ||
2537 | -#if defined (__i386__) | |
2538 | -#include <asm/i8259.h> | |
2539 | +#ifdef CONFIG_X86_32 | |
2540 | #include <asm/i8253.h> | |
2541 | DEFINE_SPINLOCK(i8253_lock); | |
2542 | EXPORT_SYMBOL(i8253_lock); | |
2543 | -#endif | |
2544 | - | |
2545 | -#define XEN_SHIFT 22 | |
2546 | - | |
2547 | int pit_latch_buggy; /* extern */ | |
2548 | - | |
2549 | -#if defined(__x86_64__) | |
2550 | -unsigned long vxtime_hz = PIT_TICK_RATE; | |
2551 | -struct vxtime_data __vxtime __section_vxtime; /* for vsyscalls */ | |
2552 | +#else | |
2553 | volatile unsigned long __jiffies __section_jiffies = INITIAL_JIFFIES; | |
2554 | -struct timespec __xtime __section_xtime; | |
2555 | -struct timezone __sys_tz __section_sys_tz; | |
2556 | #endif | |
2557 | ||
2558 | +#define XEN_SHIFT 22 | |
2559 | + | |
2560 | unsigned int cpu_khz; /* Detected as we calibrate the TSC */ | |
2561 | EXPORT_SYMBOL(cpu_khz); | |
2562 | ||
2563 | @@ -113,9 +106,6 @@ static DEFINE_PER_CPU(struct shadow_time | |
2564 | static struct timespec shadow_tv; | |
2565 | static u32 shadow_tv_version; | |
2566 | ||
2567 | -static struct timeval monotonic_tv; | |
2568 | -static spinlock_t monotonic_lock = SPIN_LOCK_UNLOCKED; | |
2569 | - | |
2570 | /* Keep track of last time we did processing/updating of jiffies and xtime. */ | |
2571 | static u64 processed_system_time; /* System time (ns) at last processing. */ | |
2572 | static DEFINE_PER_CPU(u64, processed_system_time); | |
2573 | @@ -228,7 +218,7 @@ static inline u64 scale_delta(u64 delta, | |
2574 | return product; | |
2575 | } | |
2576 | ||
2577 | -void init_cpu_khz(void) | |
2578 | +static void init_cpu_khz(void) | |
2579 | { | |
2580 | u64 __cpu_khz = 1000000ULL << 32; | |
2581 | struct vcpu_time_info *info = &vcpu_info(0)->time; | |
2582 | @@ -247,16 +237,6 @@ static u64 get_nsec_offset(struct shadow | |
2583 | return scale_delta(delta, shadow->tsc_to_nsec_mul, shadow->tsc_shift); | |
2584 | } | |
2585 | ||
2586 | -#ifdef CONFIG_X86_64 | |
2587 | -static unsigned long get_usec_offset(struct shadow_time_info *shadow) | |
2588 | -{ | |
2589 | - u64 now, delta; | |
2590 | - rdtscll(now); | |
2591 | - delta = now - shadow->tsc_timestamp; | |
2592 | - return scale_delta(delta, shadow->tsc_to_usec_mul, shadow->tsc_shift); | |
2593 | -} | |
2594 | -#endif | |
2595 | - | |
2596 | static void __update_wallclock(time_t sec, long nsec) | |
2597 | { | |
2598 | long wtm_nsec, xtime_nsec; | |
2599 | @@ -371,138 +351,6 @@ void rtc_cmos_write(unsigned char val, u | |
2600 | } | |
2601 | EXPORT_SYMBOL(rtc_cmos_write); | |
2602 | ||
2603 | -#ifdef CONFIG_X86_64 | |
2604 | - | |
2605 | -/* | |
2606 | - * This version of gettimeofday has microsecond resolution | |
2607 | - * and better than microsecond precision on fast x86 machines with TSC. | |
2608 | - */ | |
2609 | -void do_gettimeofday(struct timeval *tv) | |
2610 | -{ | |
2611 | - unsigned long seq; | |
2612 | - unsigned long usec, sec; | |
2613 | - unsigned long flags; | |
2614 | - s64 nsec; | |
2615 | - unsigned int cpu; | |
2616 | - struct shadow_time_info *shadow; | |
2617 | - u32 local_time_version; | |
2618 | - | |
2619 | - cpu = get_cpu(); | |
2620 | - shadow = &per_cpu(shadow_time, cpu); | |
2621 | - | |
2622 | - do { | |
2623 | - local_time_version = shadow->version; | |
2624 | - seq = read_seqbegin(&xtime_lock); | |
2625 | - | |
2626 | - usec = get_usec_offset(shadow); | |
2627 | - | |
2628 | - sec = xtime.tv_sec; | |
2629 | - usec += (xtime.tv_nsec / NSEC_PER_USEC); | |
2630 | - | |
2631 | - nsec = shadow->system_timestamp - processed_system_time; | |
2632 | - __normalize_time(&sec, &nsec); | |
2633 | - usec += (long)nsec / NSEC_PER_USEC; | |
2634 | - | |
2635 | - if (unlikely(!time_values_up_to_date(cpu))) { | |
2636 | - /* | |
2637 | - * We may have blocked for a long time, | |
2638 | - * rendering our calculations invalid | |
2639 | - * (e.g. the time delta may have | |
2640 | - * overflowed). Detect that and recalculate | |
2641 | - * with fresh values. | |
2642 | - */ | |
2643 | - get_time_values_from_xen(cpu); | |
2644 | - continue; | |
2645 | - } | |
2646 | - } while (read_seqretry(&xtime_lock, seq) || | |
2647 | - (local_time_version != shadow->version)); | |
2648 | - | |
2649 | - put_cpu(); | |
2650 | - | |
2651 | - while (usec >= USEC_PER_SEC) { | |
2652 | - usec -= USEC_PER_SEC; | |
2653 | - sec++; | |
2654 | - } | |
2655 | - | |
2656 | - spin_lock_irqsave(&monotonic_lock, flags); | |
2657 | - if ((sec > monotonic_tv.tv_sec) || | |
2658 | - ((sec == monotonic_tv.tv_sec) && (usec > monotonic_tv.tv_usec))) | |
2659 | - { | |
2660 | - monotonic_tv.tv_sec = sec; | |
2661 | - monotonic_tv.tv_usec = usec; | |
2662 | - } else { | |
2663 | - sec = monotonic_tv.tv_sec; | |
2664 | - usec = monotonic_tv.tv_usec; | |
2665 | - } | |
2666 | - spin_unlock_irqrestore(&monotonic_lock, flags); | |
2667 | - | |
2668 | - tv->tv_sec = sec; | |
2669 | - tv->tv_usec = usec; | |
2670 | -} | |
2671 | - | |
2672 | -EXPORT_SYMBOL(do_gettimeofday); | |
2673 | - | |
2674 | -int do_settimeofday(struct timespec *tv) | |
2675 | -{ | |
2676 | - time_t sec; | |
2677 | - s64 nsec; | |
2678 | - unsigned int cpu; | |
2679 | - struct shadow_time_info *shadow; | |
2680 | - struct xen_platform_op op; | |
2681 | - | |
2682 | - if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC) | |
2683 | - return -EINVAL; | |
2684 | - | |
2685 | - cpu = get_cpu(); | |
2686 | - shadow = &per_cpu(shadow_time, cpu); | |
2687 | - | |
2688 | - write_seqlock_irq(&xtime_lock); | |
2689 | - | |
2690 | - /* | |
2691 | - * Ensure we don't get blocked for a long time so that our time delta | |
2692 | - * overflows. If that were to happen then our shadow time values would | |
2693 | - * be stale, so we can retry with fresh ones. | |
2694 | - */ | |
2695 | - for (;;) { | |
2696 | - nsec = tv->tv_nsec - get_nsec_offset(shadow); | |
2697 | - if (time_values_up_to_date(cpu)) | |
2698 | - break; | |
2699 | - get_time_values_from_xen(cpu); | |
2700 | - } | |
2701 | - sec = tv->tv_sec; | |
2702 | - __normalize_time(&sec, &nsec); | |
2703 | - | |
2704 | - if (is_initial_xendomain() && !independent_wallclock) { | |
2705 | - op.cmd = XENPF_settime; | |
2706 | - op.u.settime.secs = sec; | |
2707 | - op.u.settime.nsecs = nsec; | |
2708 | - op.u.settime.system_time = shadow->system_timestamp; | |
2709 | - WARN_ON(HYPERVISOR_platform_op(&op)); | |
2710 | - update_wallclock(); | |
2711 | - } else if (independent_wallclock) { | |
2712 | - nsec -= shadow->system_timestamp; | |
2713 | - __normalize_time(&sec, &nsec); | |
2714 | - __update_wallclock(sec, nsec); | |
2715 | - } | |
2716 | - | |
2717 | - /* Reset monotonic gettimeofday() timeval. */ | |
2718 | - spin_lock(&monotonic_lock); | |
2719 | - monotonic_tv.tv_sec = 0; | |
2720 | - monotonic_tv.tv_usec = 0; | |
2721 | - spin_unlock(&monotonic_lock); | |
2722 | - | |
2723 | - write_sequnlock_irq(&xtime_lock); | |
2724 | - | |
2725 | - put_cpu(); | |
2726 | - | |
2727 | - clock_was_set(); | |
2728 | - return 0; | |
2729 | -} | |
2730 | - | |
2731 | -EXPORT_SYMBOL(do_settimeofday); | |
2732 | - | |
2733 | -#endif | |
2734 | - | |
2735 | static void sync_xen_wallclock(unsigned long dummy); | |
2736 | static DEFINE_TIMER(sync_xen_wallclock_timer, sync_xen_wallclock, 0, 0); | |
2737 | static void sync_xen_wallclock(unsigned long dummy) | |
2738 | @@ -551,15 +399,7 @@ static int set_rtc_mmss(unsigned long no | |
2739 | return retval; | |
2740 | } | |
2741 | ||
2742 | -#ifdef CONFIG_X86_64 | |
2743 | -/* monotonic_clock(): returns # of nanoseconds passed since time_init() | |
2744 | - * Note: This function is required to return accurate | |
2745 | - * time even in the absence of multiple timer ticks. | |
2746 | - */ | |
2747 | -unsigned long long monotonic_clock(void) | |
2748 | -#else | |
2749 | unsigned long long sched_clock(void) | |
2750 | -#endif | |
2751 | { | |
2752 | unsigned int cpu = get_cpu(); | |
2753 | struct shadow_time_info *shadow = &per_cpu(shadow_time, cpu); | |
2754 | @@ -579,21 +419,18 @@ unsigned long long sched_clock(void) | |
2755 | ||
2756 | return time; | |
2757 | } | |
2758 | -#ifdef CONFIG_X86_64 | |
2759 | -EXPORT_SYMBOL(monotonic_clock); | |
2760 | - | |
2761 | -unsigned long long sched_clock(void) | |
2762 | -{ | |
2763 | - return monotonic_clock(); | |
2764 | -} | |
2765 | -#endif | |
2766 | ||
2767 | unsigned long profile_pc(struct pt_regs *regs) | |
2768 | { | |
2769 | unsigned long pc = instruction_pointer(regs); | |
2770 | ||
2771 | #if defined(CONFIG_SMP) || defined(__x86_64__) | |
2772 | - if (!user_mode_vm(regs) && in_lock_functions(pc)) { | |
2773 | +# ifdef __i386__ | |
2774 | + if (!v8086_mode(regs) && SEGMENT_IS_KERNEL_CODE(regs->xcs) | |
2775 | +# else | |
2776 | + if (!user_mode(regs) | |
2777 | +# endif | |
2778 | + && in_lock_functions(pc)) { | |
2779 | # ifdef CONFIG_FRAME_POINTER | |
2780 | # ifdef __i386__ | |
2781 | return ((unsigned long *)regs->ebp)[1]; | |
2782 | @@ -602,14 +439,11 @@ unsigned long profile_pc(struct pt_regs | |
2783 | # endif | |
2784 | # else | |
2785 | # ifdef __i386__ | |
2786 | - unsigned long *sp; | |
2787 | - if ((regs->xcs & 2) == 0) | |
2788 | - sp = (unsigned long *)®s->esp; | |
2789 | - else | |
2790 | - sp = (unsigned long *)regs->esp; | |
2791 | + unsigned long *sp = (unsigned long *)®s->esp; | |
2792 | # else | |
2793 | unsigned long *sp = (unsigned long *)regs->rsp; | |
2794 | # endif | |
2795 | + | |
2796 | /* Return address is either directly at stack pointer | |
2797 | or above a saved eflags. Eflags has bits 22-31 zero, | |
2798 | kernel addresses don't. */ | |
2799 | @@ -762,19 +596,6 @@ irqreturn_t timer_interrupt(int irq, voi | |
2800 | return IRQ_HANDLED; | |
2801 | } | |
2802 | ||
2803 | -#ifndef CONFIG_X86_64 | |
2804 | - | |
2805 | -void tsc_init(void) | |
2806 | -{ | |
2807 | - init_cpu_khz(); | |
2808 | - printk(KERN_INFO "Xen reported: %u.%03u MHz processor.\n", | |
2809 | - cpu_khz / 1000, cpu_khz % 1000); | |
2810 | - | |
2811 | - use_tsc_delay(); | |
2812 | -} | |
2813 | - | |
2814 | -#include <linux/clocksource.h> | |
2815 | - | |
2816 | void mark_tsc_unstable(void) | |
2817 | { | |
2818 | #ifndef CONFIG_XEN /* XXX Should tell the hypervisor about this fact. */ | |
2819 | @@ -830,21 +651,9 @@ static struct clocksource clocksource_xe | |
2820 | .mask = CLOCKSOURCE_MASK(64), | |
2821 | .mult = 1 << XEN_SHIFT, /* time directly in nanoseconds */ | |
2822 | .shift = XEN_SHIFT, | |
2823 | - .is_continuous = 1, | |
2824 | + .flags = CLOCK_SOURCE_IS_CONTINUOUS, | |
2825 | }; | |
2826 | ||
2827 | -static int __init init_xen_clocksource(void) | |
2828 | -{ | |
2829 | - clocksource_xen.mult = clocksource_khz2mult(cpu_khz, | |
2830 | - clocksource_xen.shift); | |
2831 | - | |
2832 | - return clocksource_register(&clocksource_xen); | |
2833 | -} | |
2834 | - | |
2835 | -module_init(init_xen_clocksource); | |
2836 | - | |
2837 | -#endif | |
2838 | - | |
2839 | static void init_missing_ticks_accounting(unsigned int cpu) | |
2840 | { | |
2841 | struct vcpu_register_runstate_memory_area area; | |
2842 | @@ -865,7 +674,7 @@ static void init_missing_ticks_accountin | |
2843 | } | |
2844 | ||
2845 | /* not static: needed by APM */ | |
2846 | -unsigned long get_cmos_time(void) | |
2847 | +unsigned long read_persistent_clock(void) | |
2848 | { | |
2849 | unsigned long retval; | |
2850 | unsigned long flags; | |
2851 | @@ -878,11 +687,11 @@ unsigned long get_cmos_time(void) | |
2852 | ||
2853 | return retval; | |
2854 | } | |
2855 | -EXPORT_SYMBOL(get_cmos_time); | |
2856 | ||
2857 | static void sync_cmos_clock(unsigned long dummy); | |
2858 | ||
2859 | static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0); | |
2860 | +int no_sync_cmos_clock; | |
2861 | ||
2862 | static void sync_cmos_clock(unsigned long dummy) | |
2863 | { | |
2864 | @@ -926,7 +735,8 @@ static void sync_cmos_clock(unsigned lon | |
2865 | ||
2866 | void notify_arch_cmos_timer(void) | |
2867 | { | |
2868 | - mod_timer(&sync_cmos_timer, jiffies + 1); | |
2869 | + if (!no_sync_cmos_clock) | |
2870 | + mod_timer(&sync_cmos_timer, jiffies + 1); | |
2871 | mod_timer(&sync_xen_wallclock_timer, jiffies + 1); | |
2872 | } | |
2873 | ||
2874 | @@ -959,29 +769,11 @@ static int time_init_device(void) | |
2875 | ||
2876 | device_initcall(time_init_device); | |
2877 | ||
2878 | -#ifdef CONFIG_HPET_TIMER | |
2879 | extern void (*late_time_init)(void); | |
2880 | -/* Duplicate of time_init() below, with hpet_enable part added */ | |
2881 | -static void __init hpet_time_init(void) | |
2882 | -{ | |
2883 | - struct timespec ts; | |
2884 | - ts.tv_sec = get_cmos_time(); | |
2885 | - ts.tv_nsec = (INITIAL_JIFFIES % HZ) * (NSEC_PER_SEC / HZ); | |
2886 | - | |
2887 | - do_settimeofday(&ts); | |
2888 | - | |
2889 | - if ((hpet_enable() >= 0) && hpet_use_timer) { | |
2890 | - printk("Using HPET for base-timer\n"); | |
2891 | - } | |
2892 | - | |
2893 | - do_time_init(); | |
2894 | -} | |
2895 | -#endif | |
2896 | ||
2897 | /* Dynamically-mapped IRQ. */ | |
2898 | DEFINE_PER_CPU(int, timer_irq); | |
2899 | ||
2900 | -extern void (*late_time_init)(void); | |
2901 | static void setup_cpu0_timer_irq(void) | |
2902 | { | |
2903 | per_cpu(timer_irq, 0) = | |
2904 | @@ -989,7 +781,7 @@ static void setup_cpu0_timer_irq(void) | |
2905 | VIRQ_TIMER, | |
2906 | 0, | |
2907 | timer_interrupt, | |
2908 | - SA_INTERRUPT, | |
2909 | + IRQF_DISABLED|IRQF_NOBALANCING, | |
2910 | "timer0", | |
2911 | NULL); | |
2912 | BUG_ON(per_cpu(timer_irq, 0) < 0); | |
2913 | @@ -1001,16 +793,9 @@ static struct vcpu_set_periodic_timer xe | |
2914 | ||
2915 | void __init time_init(void) | |
2916 | { | |
2917 | -#ifdef CONFIG_HPET_TIMER | |
2918 | - if (is_hpet_capable()) { | |
2919 | - /* | |
2920 | - * HPET initialization needs to do memory-mapped io. So, let | |
2921 | - * us do a late initialization after mem_init(). | |
2922 | - */ | |
2923 | - late_time_init = hpet_time_init; | |
2924 | - return; | |
2925 | - } | |
2926 | -#endif | |
2927 | + init_cpu_khz(); | |
2928 | + printk(KERN_INFO "Xen reported: %u.%03u MHz processor.\n", | |
2929 | + cpu_khz / 1000, cpu_khz % 1000); | |
2930 | ||
2931 | switch (HYPERVISOR_vcpu_op(VCPUOP_set_periodic_timer, 0, | |
2932 | &xen_set_periodic_tick)) { | |
2933 | @@ -1029,18 +814,12 @@ void __init time_init(void) | |
2934 | per_cpu(processed_system_time, 0) = processed_system_time; | |
2935 | init_missing_ticks_accounting(0); | |
2936 | ||
2937 | - update_wallclock(); | |
2938 | + clocksource_register(&clocksource_xen); | |
2939 | ||
2940 | -#ifdef CONFIG_X86_64 | |
2941 | - init_cpu_khz(); | |
2942 | - printk(KERN_INFO "Xen reported: %u.%03u MHz processor.\n", | |
2943 | - cpu_khz / 1000, cpu_khz % 1000); | |
2944 | + update_wallclock(); | |
2945 | ||
2946 | - vxtime.mode = VXTIME_TSC; | |
2947 | - vxtime.quot = (1000000L << 32) / vxtime_hz; | |
2948 | - vxtime.tsc_quot = (1000L << 32) / cpu_khz; | |
2949 | - sync_core(); | |
2950 | - rdtscll(vxtime.last_tsc); | |
2951 | +#ifndef CONFIG_X86_64 | |
2952 | + use_tsc_delay(); | |
2953 | #endif | |
2954 | ||
2955 | /* Cannot request_irq() until kmem is initialised. */ | |
2956 | @@ -1197,7 +976,7 @@ int __cpuinit local_setup_timer(unsigned | |
2957 | irq = bind_virq_to_irqhandler(VIRQ_TIMER, | |
2958 | cpu, | |
2959 | timer_interrupt, | |
2960 | - SA_INTERRUPT, | |
2961 | + IRQF_DISABLED|IRQF_NOBALANCING, | |
2962 | timer_name[cpu], | |
2963 | NULL); | |
2964 | if (irq < 0) | |
2965 | @@ -1286,7 +1065,7 @@ static ctl_table xen_table[] = { | |
2966 | }; | |
2967 | static int __init xen_sysctl_init(void) | |
2968 | { | |
2969 | - (void)register_sysctl_table(xen_table, 0); | |
2970 | + (void)register_sysctl_table(xen_table); | |
2971 | return 0; | |
2972 | } | |
2973 | __initcall(xen_sysctl_init); | |
2974 | --- a/arch/x86/kernel/traps_32-xen.c | |
2975 | +++ b/arch/x86/kernel/traps_32-xen.c | |
2976 | @@ -100,6 +100,7 @@ asmlinkage void fixup_4gb_segment(void); | |
2977 | asmlinkage void machine_check(void); | |
2978 | ||
2979 | int kstack_depth_to_print = 24; | |
2980 | +static unsigned int code_bytes = 64; | |
2981 | ATOMIC_NOTIFIER_HEAD(i386die_chain); | |
2982 | ||
2983 | int register_die_notifier(struct notifier_block *nb) | |
2984 | @@ -297,10 +298,11 @@ void show_registers(struct pt_regs *regs | |
2985 | int i; | |
2986 | int in_kernel = 1; | |
2987 | unsigned long esp; | |
2988 | - unsigned short ss; | |
2989 | + unsigned short ss, gs; | |
2990 | ||
2991 | esp = (unsigned long) (®s->esp); | |
2992 | savesegment(ss, ss); | |
2993 | + savesegment(gs, gs); | |
2994 | if (user_mode_vm(regs)) { | |
2995 | in_kernel = 0; | |
2996 | esp = regs->esp; | |
2997 | @@ -319,8 +321,8 @@ void show_registers(struct pt_regs *regs | |
2998 | regs->eax, regs->ebx, regs->ecx, regs->edx); | |
2999 | printk(KERN_EMERG "esi: %08lx edi: %08lx ebp: %08lx esp: %08lx\n", | |
3000 | regs->esi, regs->edi, regs->ebp, esp); | |
3001 | - printk(KERN_EMERG "ds: %04x es: %04x ss: %04x\n", | |
3002 | - regs->xds & 0xffff, regs->xes & 0xffff, ss); | |
3003 | + printk(KERN_EMERG "ds: %04x es: %04x fs: %04x gs: %04x ss: %04x\n", | |
3004 | + regs->xds & 0xffff, regs->xes & 0xffff, regs->xfs & 0xffff, gs, ss); | |
3005 | printk(KERN_EMERG "Process %.*s (pid: %d, ti=%p task=%p task.ti=%p)", | |
3006 | TASK_COMM_LEN, current->comm, current->pid, | |
3007 | current_thread_info(), current, current->thread_info); | |
3008 | @@ -330,7 +332,8 @@ void show_registers(struct pt_regs *regs | |
3009 | */ | |
3010 | if (in_kernel) { | |
3011 | u8 *eip; | |
3012 | - int code_bytes = 64; | |
3013 | + unsigned int code_prologue = code_bytes * 43 / 64; | |
3014 | + unsigned int code_len = code_bytes; | |
3015 | unsigned char c; | |
3016 | ||
3017 | printk("\n" KERN_EMERG "Stack: "); | |
3018 | @@ -338,14 +341,14 @@ void show_registers(struct pt_regs *regs | |
3019 | ||
3020 | printk(KERN_EMERG "Code: "); | |
3021 | ||
3022 | - eip = (u8 *)regs->eip - 43; | |
3023 | + eip = (u8 *)regs->eip - code_prologue; | |
3024 | if (eip < (u8 *)PAGE_OFFSET || | |
3025 | probe_kernel_address(eip, c)) { | |
3026 | /* try starting at EIP */ | |
3027 | eip = (u8 *)regs->eip; | |
3028 | - code_bytes = 32; | |
3029 | + code_len = code_len - code_prologue + 1; | |
3030 | } | |
3031 | - for (i = 0; i < code_bytes; i++, eip++) { | |
3032 | + for (i = 0; i < code_len; i++, eip++) { | |
3033 | if (eip < (u8 *)PAGE_OFFSET || | |
3034 | probe_kernel_address(eip, c)) { | |
3035 | printk(" Bad EIP value."); | |
3036 | @@ -1134,3 +1137,13 @@ static int __init kstack_setup(char *s) | |
3037 | return 1; | |
3038 | } | |
3039 | __setup("kstack=", kstack_setup); | |
3040 | + | |
3041 | +static int __init code_bytes_setup(char *s) | |
3042 | +{ | |
3043 | + code_bytes = simple_strtoul(s, NULL, 0); | |
3044 | + if (code_bytes > 8192) | |
3045 | + code_bytes = 8192; | |
3046 | + | |
3047 | + return 1; | |
3048 | +} | |
3049 | +__setup("code_bytes=", code_bytes_setup); | |
3050 | --- a/arch/x86/kernel/vsyscall_64-xen.c | |
3051 | +++ b/arch/x86/kernel/vsyscall_64-xen.c | |
3052 | @@ -26,6 +26,7 @@ | |
3053 | #include <linux/seqlock.h> | |
3054 | #include <linux/jiffies.h> | |
3055 | #include <linux/sysctl.h> | |
3056 | +#include <linux/clocksource.h> | |
3057 | #include <linux/getcpu.h> | |
3058 | #include <linux/cpu.h> | |
3059 | #include <linux/smp.h> | |
3060 | @@ -34,6 +35,7 @@ | |
3061 | #include <asm/vsyscall.h> | |
3062 | #include <asm/pgtable.h> | |
3063 | #include <asm/page.h> | |
3064 | +#include <asm/unistd.h> | |
3065 | #include <asm/fixmap.h> | |
3066 | #include <asm/errno.h> | |
3067 | #include <asm/io.h> | |
3068 | @@ -44,56 +46,41 @@ | |
3069 | #define __vsyscall(nr) __attribute__ ((unused,__section__(".vsyscall_" #nr))) | |
3070 | #define __syscall_clobber "r11","rcx","memory" | |
3071 | ||
3072 | -int __sysctl_vsyscall __section_sysctl_vsyscall = 1; | |
3073 | -seqlock_t __xtime_lock __section_xtime_lock = SEQLOCK_UNLOCKED; | |
3074 | +struct vsyscall_gtod_data_t { | |
3075 | + seqlock_t lock; | |
3076 | + int sysctl_enabled; | |
3077 | + struct timeval wall_time_tv; | |
3078 | + struct timezone sys_tz; | |
3079 | + cycle_t offset_base; | |
3080 | + struct clocksource clock; | |
3081 | +}; | |
3082 | int __vgetcpu_mode __section_vgetcpu_mode; | |
3083 | ||
3084 | -#include <asm/unistd.h> | |
3085 | - | |
3086 | -static __always_inline void timeval_normalize(struct timeval * tv) | |
3087 | +struct vsyscall_gtod_data_t __vsyscall_gtod_data __section_vsyscall_gtod_data = | |
3088 | { | |
3089 | - time_t __sec; | |
3090 | - | |
3091 | - __sec = tv->tv_usec / 1000000; | |
3092 | - if (__sec) { | |
3093 | - tv->tv_usec %= 1000000; | |
3094 | - tv->tv_sec += __sec; | |
3095 | - } | |
3096 | -} | |
3097 | + .lock = SEQLOCK_UNLOCKED, | |
3098 | + .sysctl_enabled = 1, | |
3099 | +}; | |
3100 | ||
3101 | -static __always_inline void do_vgettimeofday(struct timeval * tv) | |
3102 | +void update_vsyscall(struct timespec *wall_time, struct clocksource *clock) | |
3103 | { | |
3104 | - long sequence, t; | |
3105 | - unsigned long sec, usec; | |
3106 | + unsigned long flags; | |
3107 | ||
3108 | - do { | |
3109 | - sequence = read_seqbegin(&__xtime_lock); | |
3110 | - | |
3111 | - sec = __xtime.tv_sec; | |
3112 | - usec = __xtime.tv_nsec / 1000; | |
3113 | - | |
3114 | - if (__vxtime.mode != VXTIME_HPET) { | |
3115 | - t = get_cycles_sync(); | |
3116 | - if (t < __vxtime.last_tsc) | |
3117 | - t = __vxtime.last_tsc; | |
3118 | - usec += ((t - __vxtime.last_tsc) * | |
3119 | - __vxtime.tsc_quot) >> 32; | |
3120 | - /* See comment in x86_64 do_gettimeofday. */ | |
3121 | - } else { | |
3122 | - usec += ((readl((void __iomem *) | |
3123 | - fix_to_virt(VSYSCALL_HPET) + 0xf0) - | |
3124 | - __vxtime.last) * __vxtime.quot) >> 32; | |
3125 | - } | |
3126 | - } while (read_seqretry(&__xtime_lock, sequence)); | |
3127 | - | |
3128 | - tv->tv_sec = sec + usec / 1000000; | |
3129 | - tv->tv_usec = usec % 1000000; | |
3130 | + write_seqlock_irqsave(&vsyscall_gtod_data.lock, flags); | |
3131 | + /* copy vsyscall data */ | |
3132 | + vsyscall_gtod_data.clock = *clock; | |
3133 | + vsyscall_gtod_data.wall_time_tv.tv_sec = wall_time->tv_sec; | |
3134 | + vsyscall_gtod_data.wall_time_tv.tv_usec = wall_time->tv_nsec/1000; | |
3135 | + vsyscall_gtod_data.sys_tz = sys_tz; | |
3136 | + write_sequnlock_irqrestore(&vsyscall_gtod_data.lock, flags); | |
3137 | } | |
3138 | ||
3139 | -/* RED-PEN may want to readd seq locking, but then the variable should be write-once. */ | |
3140 | +/* RED-PEN may want to readd seq locking, but then the variable should be | |
3141 | + * write-once. | |
3142 | + */ | |
3143 | static __always_inline void do_get_tz(struct timezone * tz) | |
3144 | { | |
3145 | - *tz = __sys_tz; | |
3146 | + *tz = __vsyscall_gtod_data.sys_tz; | |
3147 | } | |
3148 | ||
3149 | static __always_inline int gettimeofday(struct timeval *tv, struct timezone *tz) | |
3150 | @@ -101,7 +88,8 @@ static __always_inline int gettimeofday( | |
3151 | int ret; | |
3152 | asm volatile("vsysc2: syscall" | |
3153 | : "=a" (ret) | |
3154 | - : "0" (__NR_gettimeofday),"D" (tv),"S" (tz) : __syscall_clobber ); | |
3155 | + : "0" (__NR_gettimeofday),"D" (tv),"S" (tz) | |
3156 | + : __syscall_clobber ); | |
3157 | return ret; | |
3158 | } | |
3159 | ||
3160 | @@ -114,10 +102,44 @@ static __always_inline long time_syscall | |
3161 | return secs; | |
3162 | } | |
3163 | ||
3164 | +static __always_inline void do_vgettimeofday(struct timeval * tv) | |
3165 | +{ | |
3166 | + cycle_t now, base, mask, cycle_delta; | |
3167 | + unsigned long seq, mult, shift, nsec_delta; | |
3168 | + cycle_t (*vread)(void); | |
3169 | + do { | |
3170 | + seq = read_seqbegin(&__vsyscall_gtod_data.lock); | |
3171 | + | |
3172 | + vread = __vsyscall_gtod_data.clock.vread; | |
3173 | + if (unlikely(!__vsyscall_gtod_data.sysctl_enabled || !vread)) { | |
3174 | + gettimeofday(tv,NULL); | |
3175 | + return; | |
3176 | + } | |
3177 | + now = vread(); | |
3178 | + base = __vsyscall_gtod_data.clock.cycle_last; | |
3179 | + mask = __vsyscall_gtod_data.clock.mask; | |
3180 | + mult = __vsyscall_gtod_data.clock.mult; | |
3181 | + shift = __vsyscall_gtod_data.clock.shift; | |
3182 | + | |
3183 | + *tv = __vsyscall_gtod_data.wall_time_tv; | |
3184 | + | |
3185 | + } while (read_seqretry(&__vsyscall_gtod_data.lock, seq)); | |
3186 | + | |
3187 | + /* calculate interval: */ | |
3188 | + cycle_delta = (now - base) & mask; | |
3189 | + /* convert to nsecs: */ | |
3190 | + nsec_delta = (cycle_delta * mult) >> shift; | |
3191 | + | |
3192 | + /* convert to usecs and add to timespec: */ | |
3193 | + tv->tv_usec += nsec_delta / NSEC_PER_USEC; | |
3194 | + while (tv->tv_usec > USEC_PER_SEC) { | |
3195 | + tv->tv_sec += 1; | |
3196 | + tv->tv_usec -= USEC_PER_SEC; | |
3197 | + } | |
3198 | +} | |
3199 | + | |
3200 | int __vsyscall(0) vgettimeofday(struct timeval * tv, struct timezone * tz) | |
3201 | { | |
3202 | - if (!__sysctl_vsyscall) | |
3203 | - return gettimeofday(tv,tz); | |
3204 | if (tv) | |
3205 | do_vgettimeofday(tv); | |
3206 | if (tz) | |
3207 | @@ -129,11 +151,11 @@ int __vsyscall(0) vgettimeofday(struct t | |
3208 | * unlikely */ | |
3209 | time_t __vsyscall(1) vtime(time_t *t) | |
3210 | { | |
3211 | - if (!__sysctl_vsyscall) | |
3212 | + if (unlikely(!__vsyscall_gtod_data.sysctl_enabled)) | |
3213 | return time_syscall(t); | |
3214 | else if (t) | |
3215 | - *t = __xtime.tv_sec; | |
3216 | - return __xtime.tv_sec; | |
3217 | + *t = __vsyscall_gtod_data.wall_time_tv.tv_sec; | |
3218 | + return __vsyscall_gtod_data.wall_time_tv.tv_sec; | |
3219 | } | |
3220 | ||
3221 | /* Fast way to get current CPU and node. | |
3222 | @@ -210,7 +232,7 @@ static int vsyscall_sysctl_change(ctl_ta | |
3223 | ret = -ENOMEM; | |
3224 | goto out; | |
3225 | } | |
3226 | - if (!sysctl_vsyscall) { | |
3227 | + if (!vsyscall_gtod_data.sysctl_enabled) { | |
3228 | writew(SYSCALL, map1); | |
3229 | writew(SYSCALL, map2); | |
3230 | } else { | |
3231 | @@ -232,16 +254,17 @@ static int vsyscall_sysctl_nostrat(ctl_t | |
3232 | ||
3233 | static ctl_table kernel_table2[] = { | |
3234 | { .ctl_name = 99, .procname = "vsyscall64", | |
3235 | - .data = &sysctl_vsyscall, .maxlen = sizeof(int), .mode = 0644, | |
3236 | + .data = &vsyscall_gtod_data.sysctl_enabled, .maxlen = sizeof(int), | |
3237 | + .mode = 0644, | |
3238 | .strategy = vsyscall_sysctl_nostrat, | |
3239 | .proc_handler = vsyscall_sysctl_change }, | |
3240 | - { 0, } | |
3241 | + {} | |
3242 | }; | |
3243 | ||
3244 | static ctl_table kernel_root_table2[] = { | |
3245 | { .ctl_name = CTL_KERN, .procname = "kernel", .mode = 0555, | |
3246 | .child = kernel_table2 }, | |
3247 | - { 0 }, | |
3248 | + {} | |
3249 | }; | |
3250 | ||
3251 | #endif | |
3252 | @@ -304,14 +327,14 @@ static int __init vsyscall_init(void) | |
3253 | BUG_ON((unsigned long) &vgetcpu != VSYSCALL_ADDR(__NR_vgetcpu)); | |
3254 | map_vsyscall(); | |
3255 | #ifdef CONFIG_XEN | |
3256 | - sysctl_vsyscall = 0; /* disable vgettimeofay() */ | |
3257 | + vsyscall_gtod_data.sysctl_enabled = 0; /* disable vgettimeofay() */ | |
3258 | if (boot_cpu_has(X86_FEATURE_RDTSCP)) | |
3259 | vgetcpu_mode = VGETCPU_RDTSCP; | |
3260 | else | |
3261 | vgetcpu_mode = VGETCPU_LSL; | |
3262 | #endif | |
3263 | #ifdef CONFIG_SYSCTL | |
3264 | - register_sysctl_table(kernel_root_table2, 0); | |
3265 | + register_sysctl_table(kernel_root_table2); | |
3266 | #endif | |
3267 | on_each_cpu(cpu_vsyscall_init, NULL, 0, 1); | |
3268 | hotcpu_notifier(cpu_vsyscall_notifier, 0); | |
3269 | --- a/arch/x86/mm/fault_32-xen.c | |
3270 | +++ b/arch/x86/mm/fault_32-xen.c | |
3271 | @@ -46,43 +46,17 @@ int unregister_page_fault_notifier(struc | |
3272 | } | |
3273 | EXPORT_SYMBOL_GPL(unregister_page_fault_notifier); | |
3274 | ||
3275 | -static inline int notify_page_fault(enum die_val val, const char *str, | |
3276 | - struct pt_regs *regs, long err, int trap, int sig) | |
3277 | +static inline int notify_page_fault(struct pt_regs *regs, long err) | |
3278 | { | |
3279 | struct die_args args = { | |
3280 | .regs = regs, | |
3281 | - .str = str, | |
3282 | + .str = "page fault", | |
3283 | .err = err, | |
3284 | - .trapnr = trap, | |
3285 | - .signr = sig | |
3286 | + .trapnr = 14, | |
3287 | + .signr = SIGSEGV | |
3288 | }; | |
3289 | - return atomic_notifier_call_chain(¬ify_page_fault_chain, val, &args); | |
3290 | -} | |
3291 | - | |
3292 | -/* | |
3293 | - * Unlock any spinlocks which will prevent us from getting the | |
3294 | - * message out | |
3295 | - */ | |
3296 | -void bust_spinlocks(int yes) | |
3297 | -{ | |
3298 | - int loglevel_save = console_loglevel; | |
3299 | - | |
3300 | - if (yes) { | |
3301 | - oops_in_progress = 1; | |
3302 | - return; | |
3303 | - } | |
3304 | -#ifdef CONFIG_VT | |
3305 | - unblank_screen(); | |
3306 | -#endif | |
3307 | - oops_in_progress = 0; | |
3308 | - /* | |
3309 | - * OK, the message is on the console. Now we call printk() | |
3310 | - * without oops_in_progress set so that printk will give klogd | |
3311 | - * a poke. Hold onto your hats... | |
3312 | - */ | |
3313 | - console_loglevel = 15; /* NMI oopser may have shut the console up */ | |
3314 | - printk(" "); | |
3315 | - console_loglevel = loglevel_save; | |
3316 | + return atomic_notifier_call_chain(¬ify_page_fault_chain, | |
3317 | + DIE_PAGE_FAULT, &args); | |
3318 | } | |
3319 | ||
3320 | /* | |
3321 | @@ -476,8 +450,7 @@ fastcall void __kprobes do_page_fault(st | |
3322 | /* Can take a spurious fault if mapping changes R/O -> R/W. */ | |
3323 | if (spurious_fault(regs, address, error_code)) | |
3324 | return; | |
3325 | - if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14, | |
3326 | - SIGSEGV) == NOTIFY_STOP) | |
3327 | + if (notify_page_fault(regs, error_code) == NOTIFY_STOP) | |
3328 | return; | |
3329 | /* | |
3330 | * Don't take the mm semaphore here. If we fixup a prefetch | |
3331 | @@ -486,8 +459,7 @@ fastcall void __kprobes do_page_fault(st | |
3332 | goto bad_area_nosemaphore; | |
3333 | } | |
3334 | ||
3335 | - if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14, | |
3336 | - SIGSEGV) == NOTIFY_STOP) | |
3337 | + if (notify_page_fault(regs, error_code) == NOTIFY_STOP) | |
3338 | return; | |
3339 | ||
3340 | /* It's safe to allow irq's after cr2 has been saved and the vmalloc | |
3341 | --- a/arch/x86/mm/fault_64-xen.c | |
3342 | +++ b/arch/x86/mm/fault_64-xen.c | |
3343 | @@ -56,38 +56,17 @@ int unregister_page_fault_notifier(struc | |
3344 | } | |
3345 | EXPORT_SYMBOL_GPL(unregister_page_fault_notifier); | |
3346 | ||
3347 | -static inline int notify_page_fault(enum die_val val, const char *str, | |
3348 | - struct pt_regs *regs, long err, int trap, int sig) | |
3349 | +static inline int notify_page_fault(struct pt_regs *regs, long err) | |
3350 | { | |
3351 | struct die_args args = { | |
3352 | .regs = regs, | |
3353 | - .str = str, | |
3354 | + .str = "page fault", | |
3355 | .err = err, | |
3356 | - .trapnr = trap, | |
3357 | - .signr = sig | |
3358 | + .trapnr = 14, | |
3359 | + .signr = SIGSEGV | |
3360 | }; | |
3361 | - return atomic_notifier_call_chain(¬ify_page_fault_chain, val, &args); | |
3362 | -} | |
3363 | - | |
3364 | -void bust_spinlocks(int yes) | |
3365 | -{ | |
3366 | - int loglevel_save = console_loglevel; | |
3367 | - if (yes) { | |
3368 | - oops_in_progress = 1; | |
3369 | - } else { | |
3370 | -#ifdef CONFIG_VT | |
3371 | - unblank_screen(); | |
3372 | -#endif | |
3373 | - oops_in_progress = 0; | |
3374 | - /* | |
3375 | - * OK, the message is on the console. Now we call printk() | |
3376 | - * without oops_in_progress set so that printk will give klogd | |
3377 | - * a poke. Hold onto your hats... | |
3378 | - */ | |
3379 | - console_loglevel = 15; /* NMI oopser may have shut the console up */ | |
3380 | - printk(" "); | |
3381 | - console_loglevel = loglevel_save; | |
3382 | - } | |
3383 | + return atomic_notifier_call_chain(¬ify_page_fault_chain, | |
3384 | + DIE_PAGE_FAULT, &args); | |
3385 | } | |
3386 | ||
3387 | /* Sometimes the CPU reports invalid exceptions on prefetch. | |
3388 | @@ -437,8 +416,7 @@ asmlinkage void __kprobes do_page_fault( | |
3389 | /* Can take a spurious fault if mapping changes R/O -> R/W. */ | |
3390 | if (spurious_fault(regs, address, error_code)) | |
3391 | return; | |
3392 | - if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14, | |
3393 | - SIGSEGV) == NOTIFY_STOP) | |
3394 | + if (notify_page_fault(regs, error_code) == NOTIFY_STOP) | |
3395 | return; | |
3396 | /* | |
3397 | * Don't take the mm semaphore here. If we fixup a prefetch | |
3398 | @@ -447,8 +425,7 @@ asmlinkage void __kprobes do_page_fault( | |
3399 | goto bad_area_nosemaphore; | |
3400 | } | |
3401 | ||
3402 | - if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14, | |
3403 | - SIGSEGV) == NOTIFY_STOP) | |
3404 | + if (notify_page_fault(regs, error_code) == NOTIFY_STOP) | |
3405 | return; | |
3406 | ||
3407 | if (likely(regs->eflags & X86_EFLAGS_IF)) | |
3408 | --- a/arch/x86/mm/highmem_32-xen.c | |
3409 | +++ b/arch/x86/mm/highmem_32-xen.c | |
3410 | @@ -33,14 +33,16 @@ static void *__kmap_atomic(struct page * | |
3411 | ||
3412 | /* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */ | |
3413 | pagefault_disable(); | |
3414 | + | |
3415 | + idx = type + KM_TYPE_NR*smp_processor_id(); | |
3416 | + BUG_ON(!pte_none(*(kmap_pte-idx))); | |
3417 | + | |
3418 | if (!PageHighMem(page)) | |
3419 | return page_address(page); | |
3420 | ||
3421 | - idx = type + KM_TYPE_NR*smp_processor_id(); | |
3422 | vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx); | |
3423 | - if (!pte_none(*(kmap_pte-idx))) | |
3424 | - BUG(); | |
3425 | set_pte_at(&init_mm, vaddr, kmap_pte-idx, mk_pte(page, prot)); | |
3426 | + /*arch_flush_lazy_mmu_mode();*/ | |
3427 | ||
3428 | return (void*) vaddr; | |
3429 | } | |
3430 | @@ -94,6 +96,7 @@ void *kmap_atomic_pfn(unsigned long pfn, | |
3431 | idx = type + KM_TYPE_NR*smp_processor_id(); | |
3432 | vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx); | |
3433 | set_pte(kmap_pte-idx, pfn_pte(pfn, kmap_prot)); | |
3434 | + /*arch_flush_lazy_mmu_mode();*/ | |
3435 | ||
3436 | return (void*) vaddr; | |
3437 | } | |
3438 | --- a/arch/x86/mm/init_32-xen.c | |
3439 | +++ b/arch/x86/mm/init_32-xen.c | |
3440 | @@ -66,6 +66,7 @@ static pmd_t * __init one_md_table_init( | |
3441 | ||
3442 | #ifdef CONFIG_X86_PAE | |
3443 | pmd_table = (pmd_t *) alloc_bootmem_low_pages(PAGE_SIZE); | |
3444 | + paravirt_alloc_pd(__pa(pmd_table) >> PAGE_SHIFT); | |
3445 | make_lowmem_page_readonly(pmd_table, XENFEAT_writable_page_tables); | |
3446 | set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT)); | |
3447 | pud = pud_offset(pgd, 0); | |
3448 | @@ -87,6 +88,7 @@ static pte_t * __init one_page_table_ini | |
3449 | { | |
3450 | if (pmd_none(*pmd)) { | |
3451 | pte_t *page_table = (pte_t *) alloc_bootmem_low_pages(PAGE_SIZE); | |
3452 | + paravirt_alloc_pt(__pa(page_table) >> PAGE_SHIFT); | |
3453 | make_lowmem_page_readonly(page_table, | |
3454 | XENFEAT_writable_page_tables); | |
3455 | set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE)); | |
3456 | --- a/arch/x86/mm/init_64-xen.c | |
3457 | +++ b/arch/x86/mm/init_64-xen.c | |
3458 | @@ -1110,20 +1110,30 @@ int kern_addr_valid(unsigned long addr) | |
3459 | extern int exception_trace, page_fault_trace; | |
3460 | ||
3461 | static ctl_table debug_table2[] = { | |
3462 | - { 99, "exception-trace", &exception_trace, sizeof(int), 0644, NULL, | |
3463 | - proc_dointvec }, | |
3464 | - { 0, } | |
3465 | + { | |
3466 | + .ctl_name = 99, | |
3467 | + .procname = "exception-trace", | |
3468 | + .data = &exception_trace, | |
3469 | + .maxlen = sizeof(int), | |
3470 | + .mode = 0644, | |
3471 | + .proc_handler = proc_dointvec | |
3472 | + }, | |
3473 | + {} | |
3474 | }; | |
3475 | ||
3476 | static ctl_table debug_root_table2[] = { | |
3477 | - { .ctl_name = CTL_DEBUG, .procname = "debug", .mode = 0555, | |
3478 | - .child = debug_table2 }, | |
3479 | - { 0 }, | |
3480 | + { | |
3481 | + .ctl_name = CTL_DEBUG, | |
3482 | + .procname = "debug", | |
3483 | + .mode = 0555, | |
3484 | + .child = debug_table2 | |
3485 | + }, | |
3486 | + {} | |
3487 | }; | |
3488 | ||
3489 | static __init int x8664_sysctl_init(void) | |
3490 | { | |
3491 | - register_sysctl_table(debug_root_table2, 1); | |
3492 | + register_sysctl_table(debug_root_table2); | |
3493 | return 0; | |
3494 | } | |
3495 | __initcall(x8664_sysctl_init); | |
3496 | --- a/arch/x86/mm/pageattr_64-xen.c | |
3497 | +++ b/arch/x86/mm/pageattr_64-xen.c | |
3498 | @@ -350,8 +350,8 @@ static void flush_kernel_map(void *arg) | |
3499 | void *adr = page_address(pg); | |
3500 | if (cpu_has_clflush) | |
3501 | cache_flush_page(adr); | |
3502 | - __flush_tlb_one(adr); | |
3503 | } | |
3504 | + __flush_tlb_all(); | |
3505 | } | |
3506 | ||
3507 | static inline void flush_map(struct list_head *l) | |
3508 | @@ -376,6 +376,7 @@ static void revert_page(unsigned long ad | |
3509 | pud_t *pud; | |
3510 | pmd_t *pmd; | |
3511 | pte_t large_pte; | |
3512 | + unsigned long pfn; | |
3513 | ||
3514 | pgd = pgd_offset_k(address); | |
3515 | BUG_ON(pgd_none(*pgd)); | |
3516 | @@ -383,7 +384,8 @@ static void revert_page(unsigned long ad | |
3517 | BUG_ON(pud_none(*pud)); | |
3518 | pmd = pmd_offset(pud, address); | |
3519 | BUG_ON(__pmd_val(*pmd) & _PAGE_PSE); | |
3520 | - large_pte = mk_pte_phys(__pa(address) & LARGE_PAGE_MASK, ref_prot); | |
3521 | + pfn = (__pa(address) & LARGE_PAGE_MASK) >> PAGE_SHIFT; | |
3522 | + large_pte = pfn_pte(pfn, ref_prot); | |
3523 | large_pte = pte_mkhuge(large_pte); | |
3524 | set_pte((pte_t *)pmd, large_pte); | |
3525 | } | |
3526 | --- a/arch/x86/mm/pgtable_32-xen.c | |
3527 | +++ b/arch/x86/mm/pgtable_32-xen.c | |
3528 | @@ -149,6 +149,8 @@ void __set_fixmap (enum fixed_addresses | |
3529 | void __init reserve_top_address(unsigned long reserve) | |
3530 | { | |
3531 | BUG_ON(fixmaps > 0); | |
3532 | + printk(KERN_INFO "Reserving virtual address space above 0x%08x\n", | |
3533 | + (int)-reserve); | |
3534 | __FIXADDR_TOP = -reserve - PAGE_SIZE; | |
3535 | __VMALLOC_RESERVE += reserve; | |
3536 | } | |
3537 | @@ -258,6 +260,12 @@ void pgd_ctor(void *pgd, struct kmem_cac | |
3538 | swapper_pg_dir + USER_PTRS_PER_PGD, | |
3539 | KERNEL_PGD_PTRS); | |
3540 | memset(pgd, 0, USER_PTRS_PER_PGD*sizeof(pgd_t)); | |
3541 | + | |
3542 | + /* must happen under lock */ | |
3543 | + paravirt_alloc_pd_clone(__pa(pgd) >> PAGE_SHIFT, | |
3544 | + __pa(swapper_pg_dir) >> PAGE_SHIFT, | |
3545 | + USER_PTRS_PER_PGD, PTRS_PER_PGD - USER_PTRS_PER_PGD); | |
3546 | + | |
3547 | pgd_list_add(pgd); | |
3548 | spin_unlock_irqrestore(&pgd_lock, flags); | |
3549 | } | |
3550 | @@ -268,6 +276,7 @@ void pgd_dtor(void *pgd, struct kmem_cac | |
3551 | { | |
3552 | unsigned long flags; /* can be called from interrupt context */ | |
3553 | ||
3554 | + paravirt_release_pd(__pa(pgd) >> PAGE_SHIFT); | |
3555 | spin_lock_irqsave(&pgd_lock, flags); | |
3556 | pgd_list_del(pgd); | |
3557 | spin_unlock_irqrestore(&pgd_lock, flags); | |
3558 | @@ -292,6 +301,7 @@ pgd_t *pgd_alloc(struct mm_struct *mm) | |
3559 | pmd_t *pmd = kmem_cache_alloc(pmd_cache, GFP_KERNEL); | |
3560 | if (!pmd) | |
3561 | goto out_oom; | |
3562 | + paravirt_alloc_pd(__pa(pmd) >> PAGE_SHIFT); | |
3563 | set_pgd(&pgd[i], __pgd(1 + __pa(pmd))); | |
3564 | } | |
3565 | return pgd; | |
3566 | @@ -314,6 +324,7 @@ pgd_t *pgd_alloc(struct mm_struct *mm) | |
3567 | pmd[i] = kmem_cache_alloc(pmd_cache, GFP_KERNEL); | |
3568 | if (!pmd[i]) | |
3569 | goto out_oom; | |
3570 | + paravirt_alloc_pd(__pa(pmd) >> PAGE_SHIFT); | |
3571 | } | |
3572 | ||
3573 | spin_lock_irqsave(&pgd_lock, flags); | |
3574 | @@ -354,12 +365,17 @@ pgd_t *pgd_alloc(struct mm_struct *mm) | |
3575 | ||
3576 | out_oom: | |
3577 | if (HAVE_SHARED_KERNEL_PMD) { | |
3578 | - for (i--; i >= 0; i--) | |
3579 | - kmem_cache_free(pmd_cache, | |
3580 | - (void *)__va(pgd_val(pgd[i])-1)); | |
3581 | + for (i--; i >= 0; i--) { | |
3582 | + pgd_t pgdent = pgd[i]; | |
3583 | + void* pmd = (void *)__va(pgd_val(pgdent)-1); | |
3584 | + paravirt_release_pd(__pa(pmd) >> PAGE_SHIFT); | |
3585 | + kmem_cache_free(pmd_cache, pmd); | |
3586 | + } | |
3587 | } else { | |
3588 | - for (i--; i >= 0; i--) | |
3589 | + for (i--; i >= 0; i--) { | |
3590 | + paravirt_release_pd(__pa(pmd[i]) >> PAGE_SHIFT); | |
3591 | kmem_cache_free(pmd_cache, pmd[i]); | |
3592 | + } | |
3593 | kfree(pmd); | |
3594 | } | |
3595 | kmem_cache_free(pgd_cache, pgd); | |
3596 | @@ -383,7 +399,9 @@ void pgd_free(pgd_t *pgd) | |
3597 | /* in the PAE case user pgd entries are overwritten before usage */ | |
3598 | if (PTRS_PER_PMD > 1) { | |
3599 | for (i = 0; i < USER_PTRS_PER_PGD; ++i) { | |
3600 | - pmd_t *pmd = (void *)__va(pgd_val(pgd[i])-1); | |
3601 | + pgd_t pgdent = pgd[i]; | |
3602 | + void* pmd = (void *)__va(pgd_val(pgdent)-1); | |
3603 | + paravirt_release_pd(__pa(pmd) >> PAGE_SHIFT); | |
3604 | kmem_cache_free(pmd_cache, pmd); | |
3605 | } | |
3606 | ||
3607 | --- a/drivers/acpi/processor_extcntl.c | |
3608 | +++ b/drivers/acpi/processor_extcntl.c | |
3609 | @@ -32,9 +32,8 @@ | |
3610 | ||
3611 | #define ACPI_PROCESSOR_COMPONENT 0x01000000 | |
3612 | #define ACPI_PROCESSOR_CLASS "processor" | |
3613 | -#define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver" | |
3614 | #define _COMPONENT ACPI_PROCESSOR_COMPONENT | |
3615 | -ACPI_MODULE_NAME("acpi_processor") | |
3616 | +ACPI_MODULE_NAME("processor_extcntl") | |
3617 | ||
3618 | static int processor_extcntl_parse_csd(struct acpi_processor *pr); | |
3619 | static int processor_extcntl_get_performance(struct acpi_processor *pr); | |
3620 | @@ -56,24 +55,17 @@ static int processor_notify_smm(void) | |
3621 | return 0; | |
3622 | ||
3623 | /* Can't write pstate_cnt to smi_cmd if either value is zero */ | |
3624 | - if ((!acpi_fadt.smi_cmd) || (!acpi_fadt.pstate_cnt)) { | |
3625 | + if (!acpi_gbl_FADT.smi_command || !acpi_gbl_FADT.pstate_control) { | |
3626 | ACPI_DEBUG_PRINT((ACPI_DB_INFO,"No SMI port or pstate_cnt\n")); | |
3627 | return 0; | |
3628 | } | |
3629 | ||
3630 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, | |
3631 | "Writing pstate_cnt [0x%x] to smi_cmd [0x%x]\n", | |
3632 | - acpi_fadt.pstate_cnt, acpi_fadt.smi_cmd)); | |
3633 | + acpi_gbl_FADT.pstate_control, acpi_gbl_FADT.smi_command)); | |
3634 | ||
3635 | - /* FADT v1 doesn't support pstate_cnt, many BIOS vendors use | |
3636 | - * it anyway, so we need to support it... */ | |
3637 | - if (acpi_fadt_is_v1) { | |
3638 | - ACPI_DEBUG_PRINT((ACPI_DB_INFO, | |
3639 | - "Using v1.0 FADT reserved value for pstate_cnt\n")); | |
3640 | - } | |
3641 | - | |
3642 | - status = acpi_os_write_port(acpi_fadt.smi_cmd, | |
3643 | - (u32) acpi_fadt.pstate_cnt, 8); | |
3644 | + status = acpi_os_write_port(acpi_gbl_FADT.smi_command, | |
3645 | + acpi_gbl_FADT.pstate_control, 8); | |
3646 | if (ACPI_FAILURE(status)) | |
3647 | return status; | |
3648 | ||
3649 | --- a/drivers/char/tpm/tpm_xen.c | |
3650 | +++ b/drivers/char/tpm/tpm_xen.c | |
3651 | @@ -481,7 +481,6 @@ static struct xenbus_device_id tpmfront_ | |
3652 | ||
3653 | static struct xenbus_driver tpmfront = { | |
3654 | .name = "vtpm", | |
3655 | - .owner = THIS_MODULE, | |
3656 | .ids = tpmfront_ids, | |
3657 | .probe = tpmfront_probe, | |
3658 | .remove = tpmfront_remove, | |
3659 | @@ -491,9 +490,9 @@ static struct xenbus_driver tpmfront = { | |
3660 | .suspend_cancel = tpmfront_suspend_cancel, | |
3661 | }; | |
3662 | ||
3663 | -static void __init init_tpm_xenbus(void) | |
3664 | +static int __init init_tpm_xenbus(void) | |
3665 | { | |
3666 | - xenbus_register_frontend(&tpmfront); | |
3667 | + return xenbus_register_frontend(&tpmfront); | |
3668 | } | |
3669 | ||
3670 | static int tpmif_allocate_tx_buffers(struct tpm_private *tp) | |
3671 | --- a/drivers/pci/msi-xen.c | |
3672 | +++ b/drivers/pci/msi-xen.c | |
3673 | @@ -44,6 +44,36 @@ struct msi_pirq_entry { | |
3674 | int entry_nr; | |
3675 | }; | |
3676 | ||
3677 | +static void msi_set_enable(struct pci_dev *dev, int enable) | |
3678 | +{ | |
3679 | + int pos; | |
3680 | + u16 control; | |
3681 | + | |
3682 | + pos = pci_find_capability(dev, PCI_CAP_ID_MSI); | |
3683 | + if (pos) { | |
3684 | + pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &control); | |
3685 | + control &= ~PCI_MSI_FLAGS_ENABLE; | |
3686 | + if (enable) | |
3687 | + control |= PCI_MSI_FLAGS_ENABLE; | |
3688 | + pci_write_config_word(dev, pos + PCI_MSI_FLAGS, control); | |
3689 | + } | |
3690 | +} | |
3691 | + | |
3692 | +static void msix_set_enable(struct pci_dev *dev, int enable) | |
3693 | +{ | |
3694 | + int pos; | |
3695 | + u16 control; | |
3696 | + | |
3697 | + pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); | |
3698 | + if (pos) { | |
3699 | + pci_read_config_word(dev, pos + PCI_MSIX_FLAGS, &control); | |
3700 | + control &= ~PCI_MSIX_FLAGS_ENABLE; | |
3701 | + if (enable) | |
3702 | + control |= PCI_MSIX_FLAGS_ENABLE; | |
3703 | + pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control); | |
3704 | + } | |
3705 | +} | |
3706 | + | |
3707 | static struct msi_dev_list *get_msi_dev_pirq_list(struct pci_dev *dev) | |
3708 | { | |
3709 | struct msi_dev_list *msi_dev_list, *ret = NULL; | |
3710 | @@ -235,85 +265,13 @@ static int msi_map_vector(struct pci_dev | |
3711 | ||
3712 | static int msi_init(void) | |
3713 | { | |
3714 | - static int status = 0; | |
3715 | - | |
3716 | - if (pci_msi_quirk) { | |
3717 | - pci_msi_enable = 0; | |
3718 | - printk(KERN_WARNING "PCI: MSI quirk detected. MSI disabled.\n"); | |
3719 | - status = -EINVAL; | |
3720 | - } | |
3721 | - | |
3722 | - return status; | |
3723 | -} | |
3724 | - | |
3725 | -void pci_scan_msi_device(struct pci_dev *dev) { } | |
3726 | - | |
3727 | -void disable_msi_mode(struct pci_dev *dev, int pos, int type) | |
3728 | -{ | |
3729 | - u16 control; | |
3730 | - | |
3731 | - pci_read_config_word(dev, msi_control_reg(pos), &control); | |
3732 | - if (type == PCI_CAP_ID_MSI) { | |
3733 | - /* Set enabled bits to single MSI & enable MSI_enable bit */ | |
3734 | - msi_disable(control); | |
3735 | - pci_write_config_word(dev, msi_control_reg(pos), control); | |
3736 | - dev->msi_enabled = 0; | |
3737 | - } else { | |
3738 | - msix_disable(control); | |
3739 | - pci_write_config_word(dev, msi_control_reg(pos), control); | |
3740 | - dev->msix_enabled = 0; | |
3741 | - } | |
3742 | - | |
3743 | - pci_intx(dev, 1); /* enable intx */ | |
3744 | -} | |
3745 | - | |
3746 | -static void enable_msi_mode(struct pci_dev *dev, int pos, int type) | |
3747 | -{ | |
3748 | - u16 control; | |
3749 | - | |
3750 | - pci_read_config_word(dev, msi_control_reg(pos), &control); | |
3751 | - if (type == PCI_CAP_ID_MSI) { | |
3752 | - /* Set enabled bits to single MSI & enable MSI_enable bit */ | |
3753 | - msi_enable(control, 1); | |
3754 | - pci_write_config_word(dev, msi_control_reg(pos), control); | |
3755 | - dev->msi_enabled = 1; | |
3756 | - } else { | |
3757 | - msix_enable(control); | |
3758 | - pci_write_config_word(dev, msi_control_reg(pos), control); | |
3759 | - dev->msix_enabled = 1; | |
3760 | - } | |
3761 | - | |
3762 | - pci_intx(dev, 0); /* disable intx */ | |
3763 | -} | |
3764 | - | |
3765 | -#ifdef CONFIG_PM | |
3766 | -int pci_save_msi_state(struct pci_dev *dev) | |
3767 | -{ | |
3768 | - int pos; | |
3769 | - | |
3770 | - pos = pci_find_capability(dev, PCI_CAP_ID_MSI); | |
3771 | - if (pos <= 0 || dev->no_msi) | |
3772 | - return 0; | |
3773 | - | |
3774 | - if (!dev->msi_enabled) | |
3775 | - return 0; | |
3776 | - | |
3777 | - /* Restore dev->irq to its default pin-assertion vector */ | |
3778 | - msi_unmap_pirq(dev, dev->irq); | |
3779 | - /* Disable MSI mode */ | |
3780 | - disable_msi_mode(dev, pos, PCI_CAP_ID_MSI); | |
3781 | - /* Set the flags for use of restore */ | |
3782 | - dev->msi_enabled = 1; | |
3783 | return 0; | |
3784 | } | |
3785 | ||
3786 | -void pci_restore_msi_state(struct pci_dev *dev) | |
3787 | +#ifdef CONFIG_PM | |
3788 | +static void __pci_restore_msi_state(struct pci_dev *dev) | |
3789 | { | |
3790 | - int pos, pirq; | |
3791 | - | |
3792 | - pos = pci_find_capability(dev, PCI_CAP_ID_MSI); | |
3793 | - if (pos <= 0) | |
3794 | - return; | |
3795 | + int pirq; | |
3796 | ||
3797 | if (!dev->msi_enabled) | |
3798 | return; | |
3799 | @@ -321,40 +279,12 @@ void pci_restore_msi_state(struct pci_de | |
3800 | pirq = msi_map_pirq_to_vector(dev, dev->irq, 0, 0); | |
3801 | if (pirq < 0) | |
3802 | return; | |
3803 | - enable_msi_mode(dev, pos, PCI_CAP_ID_MSI); | |
3804 | -} | |
3805 | - | |
3806 | -int pci_save_msix_state(struct pci_dev *dev) | |
3807 | -{ | |
3808 | - int pos; | |
3809 | - unsigned long flags; | |
3810 | - struct msi_dev_list *msi_dev_entry; | |
3811 | - struct msi_pirq_entry *pirq_entry, *tmp; | |
3812 | ||
3813 | - pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); | |
3814 | - if (pos <= 0 || dev->no_msi) | |
3815 | - return 0; | |
3816 | - | |
3817 | - /* save the capability */ | |
3818 | - if (!dev->msix_enabled) | |
3819 | - return 0; | |
3820 | - | |
3821 | - msi_dev_entry = get_msi_dev_pirq_list(dev); | |
3822 | - | |
3823 | - spin_lock_irqsave(&msi_dev_entry->pirq_list_lock, flags); | |
3824 | - list_for_each_entry_safe(pirq_entry, tmp, | |
3825 | - &msi_dev_entry->pirq_list_head, list) | |
3826 | - msi_unmap_pirq(dev, pirq_entry->pirq); | |
3827 | - spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); | |
3828 | - | |
3829 | - disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); | |
3830 | - /* Set the flags for use of restore */ | |
3831 | - dev->msix_enabled = 1; | |
3832 | - | |
3833 | - return 0; | |
3834 | + pci_intx(dev, 0); /* disable intx */ | |
3835 | + msi_set_enable(dev, 0); | |
3836 | } | |
3837 | ||
3838 | -void pci_restore_msix_state(struct pci_dev *dev) | |
3839 | +static void __pci_restore_msix_state(struct pci_dev *dev) | |
3840 | { | |
3841 | int pos; | |
3842 | unsigned long flags; | |
3843 | @@ -387,9 +317,16 @@ void pci_restore_msix_state(struct pci_d | |
3844 | } | |
3845 | spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); | |
3846 | ||
3847 | - enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); | |
3848 | + pci_intx(dev, 0); /* disable intx */ | |
3849 | + msix_set_enable(dev, 0); | |
3850 | } | |
3851 | -#endif | |
3852 | + | |
3853 | +void pci_restore_msi_state(struct pci_dev *dev) | |
3854 | +{ | |
3855 | + __pci_restore_msi_state(dev); | |
3856 | + __pci_restore_msix_state(dev); | |
3857 | +} | |
3858 | +#endif /* CONFIG_PM */ | |
3859 | ||
3860 | /** | |
3861 | * msi_capability_init - configure device's MSI capability structure | |
3862 | @@ -405,6 +342,8 @@ static int msi_capability_init(struct pc | |
3863 | int pos, pirq; | |
3864 | u16 control; | |
3865 | ||
3866 | + msi_set_enable(dev, 0); /* Ensure msi is disabled as I set it up */ | |
3867 | + | |
3868 | pos = pci_find_capability(dev, PCI_CAP_ID_MSI); | |
3869 | pci_read_config_word(dev, msi_control_reg(pos), &control); | |
3870 | ||
3871 | @@ -413,7 +352,8 @@ static int msi_capability_init(struct pc | |
3872 | return -EBUSY; | |
3873 | ||
3874 | /* Set MSI enabled bits */ | |
3875 | - enable_msi_mode(dev, pos, PCI_CAP_ID_MSI); | |
3876 | + pci_intx(dev, 0); /* disable intx */ | |
3877 | + msi_set_enable(dev, 1); | |
3878 | dev->msi_enabled = 1; | |
3879 | ||
3880 | dev->irq = pirq; | |
3881 | @@ -441,6 +381,8 @@ static int msix_capability_init(struct p | |
3882 | if (!msi_dev_entry) | |
3883 | return -ENOMEM; | |
3884 | ||
3885 | + msix_set_enable(dev, 0);/* Ensure msix is disabled as I set it up */ | |
3886 | + | |
3887 | pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); | |
3888 | table_base = find_table_base(dev, pos); | |
3889 | if (!table_base) | |
3890 | @@ -484,7 +426,8 @@ static int msix_capability_init(struct p | |
3891 | return avail; | |
3892 | } | |
3893 | ||
3894 | - enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); | |
3895 | + pci_intx(dev, 0); /* disable intx */ | |
3896 | + msix_set_enable(dev, 1); | |
3897 | dev->msix_enabled = 1; | |
3898 | ||
3899 | return 0; | |
3900 | @@ -572,17 +515,14 @@ int pci_enable_msi(struct pci_dev* dev) | |
3901 | /* Check whether driver already requested for MSI-X irqs */ | |
3902 | if (dev->msix_enabled) { | |
3903 | printk(KERN_INFO "PCI: %s: Can't enable MSI. " | |
3904 | - "Device already has MSI-X irq assigned\n", | |
3905 | - pci_name(dev)); | |
3906 | - dev->irq = temp; | |
3907 | + "Device already has MSI-X enabled\n", | |
3908 | + pci_name(dev)); | |
3909 | return -EINVAL; | |
3910 | } | |
3911 | ||
3912 | status = msi_capability_init(dev); | |
3913 | if ( !status ) | |
3914 | dev->irq_old = temp; | |
3915 | - else | |
3916 | - dev->irq = temp; | |
3917 | ||
3918 | return status; | |
3919 | } | |
3920 | @@ -590,7 +530,6 @@ int pci_enable_msi(struct pci_dev* dev) | |
3921 | extern void pci_frontend_disable_msi(struct pci_dev* dev); | |
3922 | void pci_disable_msi(struct pci_dev* dev) | |
3923 | { | |
3924 | - int pos; | |
3925 | int pirq; | |
3926 | ||
3927 | if (!pci_msi_enable) | |
3928 | @@ -607,8 +546,7 @@ void pci_disable_msi(struct pci_dev* dev | |
3929 | } | |
3930 | #endif | |
3931 | ||
3932 | - pos = pci_find_capability(dev, PCI_CAP_ID_MSI); | |
3933 | - if (!pos) | |
3934 | + if (!dev->msi_enabled) | |
3935 | return; | |
3936 | ||
3937 | pirq = dev->irq; | |
3938 | @@ -617,7 +555,9 @@ void pci_disable_msi(struct pci_dev* dev | |
3939 | msi_unmap_pirq(dev, pirq); | |
3940 | ||
3941 | /* Disable MSI mode */ | |
3942 | - disable_msi_mode(dev, pos, PCI_CAP_ID_MSI); | |
3943 | + msi_set_enable(dev, 0); | |
3944 | + pci_intx(dev, 1); /* enable intx */ | |
3945 | + dev->msi_enabled = 0; | |
3946 | } | |
3947 | ||
3948 | /** | |
3949 | @@ -710,7 +650,6 @@ int pci_enable_msix(struct pci_dev* dev, | |
3950 | printk(KERN_INFO "PCI: %s: Can't enable MSI-X. " | |
3951 | "Device already has an MSI irq assigned\n", | |
3952 | pci_name(dev)); | |
3953 | - dev->irq = temp; | |
3954 | return -EINVAL; | |
3955 | } | |
3956 | ||
3957 | @@ -718,8 +657,6 @@ int pci_enable_msix(struct pci_dev* dev, | |
3958 | ||
3959 | if ( !status ) | |
3960 | dev->irq_old = temp; | |
3961 | - else | |
3962 | - dev->irq = temp; | |
3963 | ||
3964 | return status; | |
3965 | } | |
3966 | @@ -727,10 +664,6 @@ int pci_enable_msix(struct pci_dev* dev, | |
3967 | extern void pci_frontend_disable_msix(struct pci_dev* dev); | |
3968 | void pci_disable_msix(struct pci_dev* dev) | |
3969 | { | |
3970 | - int pos; | |
3971 | - u16 control; | |
3972 | - | |
3973 | - | |
3974 | if (!pci_msi_enable) | |
3975 | return; | |
3976 | if (!dev) | |
3977 | @@ -756,18 +689,15 @@ void pci_disable_msix(struct pci_dev* de | |
3978 | } | |
3979 | #endif | |
3980 | ||
3981 | - pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); | |
3982 | - if (!pos) | |
3983 | - return; | |
3984 | - | |
3985 | - pci_read_config_word(dev, msi_control_reg(pos), &control); | |
3986 | - if (!(control & PCI_MSIX_FLAGS_ENABLE)) | |
3987 | + if (!dev->msix_enabled) | |
3988 | return; | |
3989 | ||
3990 | msi_remove_pci_irq_vectors(dev); | |
3991 | ||
3992 | /* Disable MSI mode */ | |
3993 | - disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); | |
3994 | + msix_set_enable(dev, 0); | |
3995 | + pci_intx(dev, 1); /* enable intx */ | |
3996 | + dev->msix_enabled = 0; | |
3997 | } | |
3998 | ||
3999 | /** | |
4000 | --- a/drivers/xen/balloon/sysfs.c | |
4001 | +++ b/drivers/xen/balloon/sysfs.c | |
4002 | @@ -34,6 +34,7 @@ | |
4003 | #include <linux/stat.h> | |
4004 | #include <linux/string.h> | |
4005 | #include <linux/sysdev.h> | |
4006 | +#include <linux/module.h> | |
4007 | #include "common.h" | |
4008 | ||
4009 | #ifdef HAVE_XEN_PLATFORM_COMPAT_H | |
4010 | --- a/drivers/xen/blkback/xenbus.c | |
4011 | +++ b/drivers/xen/blkback/xenbus.c | |
4012 | @@ -527,7 +527,6 @@ static const struct xenbus_device_id blk | |
4013 | ||
4014 | static struct xenbus_driver blkback = { | |
4015 | .name = "vbd", | |
4016 | - .owner = THIS_MODULE, | |
4017 | .ids = blkback_ids, | |
4018 | .probe = blkback_probe, | |
4019 | .remove = blkback_remove, | |
4020 | @@ -537,5 +536,6 @@ static struct xenbus_driver blkback = { | |
4021 | ||
4022 | void blkif_xenbus_init(void) | |
4023 | { | |
4024 | - xenbus_register_backend(&blkback); | |
4025 | + if (xenbus_register_backend(&blkback)) | |
4026 | + BUG(); | |
4027 | } | |
4028 | --- a/drivers/xen/blkfront/blkfront.c | |
4029 | +++ b/drivers/xen/blkfront/blkfront.c | |
4030 | @@ -907,7 +907,6 @@ MODULE_ALIAS("xen:vbd"); | |
4031 | ||
4032 | static struct xenbus_driver blkfront = { | |
4033 | .name = "vbd", | |
4034 | - .owner = THIS_MODULE, | |
4035 | .ids = blkfront_ids, | |
4036 | .probe = blkfront_probe, | |
4037 | .remove = blkfront_remove, | |
4038 | --- a/drivers/xen/blktap/xenbus.c | |
4039 | +++ b/drivers/xen/blktap/xenbus.c | |
4040 | @@ -465,7 +465,6 @@ static const struct xenbus_device_id blk | |
4041 | ||
4042 | static struct xenbus_driver blktap = { | |
4043 | .name = "tap", | |
4044 | - .owner = THIS_MODULE, | |
4045 | .ids = blktap_ids, | |
4046 | .probe = blktap_probe, | |
4047 | .remove = blktap_remove, | |
4048 | @@ -475,5 +474,6 @@ static struct xenbus_driver blktap = { | |
4049 | ||
4050 | void tap_blkif_xenbus_init(void) | |
4051 | { | |
4052 | - xenbus_register_backend(&blktap); | |
4053 | + if (xenbus_register_backend(&blktap)) | |
4054 | + BUG(); | |
4055 | } | |
4056 | --- a/drivers/xen/core/evtchn.c | |
4057 | +++ b/drivers/xen/core/evtchn.c | |
4058 | @@ -144,7 +144,7 @@ static void bind_evtchn_to_cpu(unsigned | |
4059 | BUG_ON(!test_bit(chn, s->evtchn_mask)); | |
4060 | ||
4061 | if (irq != -1) | |
4062 | - set_native_irq_info(irq, cpumask_of_cpu(cpu)); | |
4063 | + irq_desc[irq].affinity = cpumask_of_cpu(cpu); | |
4064 | ||
4065 | clear_bit(chn, (unsigned long *)cpu_evtchn_mask[cpu_evtchn[chn]]); | |
4066 | set_bit(chn, (unsigned long *)cpu_evtchn_mask[cpu]); | |
4067 | @@ -157,7 +157,7 @@ static void init_evtchn_cpu_bindings(voi | |
4068 | ||
4069 | /* By default all event channels notify CPU#0. */ | |
4070 | for (i = 0; i < NR_IRQS; i++) | |
4071 | - set_native_irq_info(i, cpumask_of_cpu(0)); | |
4072 | + irq_desc[i].affinity = cpumask_of_cpu(0); | |
4073 | ||
4074 | memset(cpu_evtchn, 0, sizeof(cpu_evtchn)); | |
4075 | memset(cpu_evtchn_mask[0], ~0, sizeof(cpu_evtchn_mask[0])); | |
4076 | --- a/drivers/xen/core/smpboot.c | |
4077 | +++ b/drivers/xen/core/smpboot.c | |
4078 | @@ -121,7 +121,7 @@ static int __cpuinit xen_smp_intr_init(u | |
4079 | rc = bind_ipi_to_irqhandler(RESCHEDULE_VECTOR, | |
4080 | cpu, | |
4081 | smp_reschedule_interrupt, | |
4082 | - SA_INTERRUPT, | |
4083 | + IRQF_DISABLED|IRQF_NOBALANCING, | |
4084 | resched_name[cpu], | |
4085 | NULL); | |
4086 | if (rc < 0) | |
4087 | @@ -132,7 +132,7 @@ static int __cpuinit xen_smp_intr_init(u | |
4088 | rc = bind_ipi_to_irqhandler(CALL_FUNCTION_VECTOR, | |
4089 | cpu, | |
4090 | smp_call_function_interrupt, | |
4091 | - SA_INTERRUPT, | |
4092 | + IRQF_DISABLED|IRQF_NOBALANCING, | |
4093 | callfunc_name[cpu], | |
4094 | NULL); | |
4095 | if (rc < 0) | |
4096 | @@ -261,7 +261,7 @@ void __init smp_prepare_cpus(unsigned in | |
4097 | { | |
4098 | unsigned int cpu; | |
4099 | struct task_struct *idle; | |
4100 | - int apicid, acpiid; | |
4101 | + int apicid; | |
4102 | struct vcpu_get_physid cpu_id; | |
4103 | #ifdef __x86_64__ | |
4104 | struct desc_ptr *gdt_descr; | |
4105 | @@ -270,14 +270,8 @@ void __init smp_prepare_cpus(unsigned in | |
4106 | #endif | |
4107 | ||
4108 | apicid = 0; | |
4109 | - if (HYPERVISOR_vcpu_op(VCPUOP_get_physid, 0, &cpu_id) == 0) { | |
4110 | + if (HYPERVISOR_vcpu_op(VCPUOP_get_physid, 0, &cpu_id) == 0) | |
4111 | apicid = xen_vcpu_physid_to_x86_apicid(cpu_id.phys_id); | |
4112 | - acpiid = xen_vcpu_physid_to_x86_acpiid(cpu_id.phys_id); | |
4113 | -#ifdef CONFIG_ACPI | |
4114 | - if (acpiid != 0xff) | |
4115 | - x86_acpiid_to_apicid[acpiid] = apicid; | |
4116 | -#endif | |
4117 | - } | |
4118 | boot_cpu_data.apicid = apicid; | |
4119 | cpu_data[0] = boot_cpu_data; | |
4120 | ||
4121 | @@ -333,14 +327,8 @@ void __init smp_prepare_cpus(unsigned in | |
4122 | XENFEAT_writable_descriptor_tables); | |
4123 | ||
4124 | apicid = cpu; | |
4125 | - if (HYPERVISOR_vcpu_op(VCPUOP_get_physid, cpu, &cpu_id) == 0) { | |
4126 | + if (HYPERVISOR_vcpu_op(VCPUOP_get_physid, cpu, &cpu_id) == 0) | |
4127 | apicid = xen_vcpu_physid_to_x86_apicid(cpu_id.phys_id); | |
4128 | - acpiid = xen_vcpu_physid_to_x86_acpiid(cpu_id.phys_id); | |
4129 | -#ifdef CONFIG_ACPI | |
4130 | - if (acpiid != 0xff) | |
4131 | - x86_acpiid_to_apicid[acpiid] = apicid; | |
4132 | -#endif | |
4133 | - } | |
4134 | cpu_data[cpu] = boot_cpu_data; | |
4135 | cpu_data[cpu].apicid = apicid; | |
4136 | ||
4137 | --- a/drivers/xen/fbfront/xenfb.c | |
4138 | +++ b/drivers/xen/fbfront/xenfb.c | |
4139 | @@ -856,7 +856,6 @@ MODULE_ALIAS("xen:vfb"); | |
4140 | ||
4141 | static struct xenbus_driver xenfb_driver = { | |
4142 | .name = "vfb", | |
4143 | - .owner = THIS_MODULE, | |
4144 | .ids = xenfb_ids, | |
4145 | .probe = xenfb_probe, | |
4146 | .remove = xenfb_remove, | |
4147 | --- a/drivers/xen/fbfront/xenkbd.c | |
4148 | +++ b/drivers/xen/fbfront/xenkbd.c | |
4149 | @@ -323,7 +323,6 @@ MODULE_ALIAS("xen:vkbd"); | |
4150 | ||
4151 | static struct xenbus_driver xenkbd_driver = { | |
4152 | .name = "vkbd", | |
4153 | - .owner = THIS_MODULE, | |
4154 | .ids = xenkbd_ids, | |
4155 | .probe = xenkbd_probe, | |
4156 | .remove = xenkbd_remove, | |
4157 | --- a/drivers/xen/netback/xenbus.c | |
4158 | +++ b/drivers/xen/netback/xenbus.c | |
4159 | @@ -439,7 +439,6 @@ static const struct xenbus_device_id net | |
4160 | ||
4161 | static struct xenbus_driver netback = { | |
4162 | .name = "vif", | |
4163 | - .owner = THIS_MODULE, | |
4164 | .ids = netback_ids, | |
4165 | .probe = netback_probe, | |
4166 | .remove = netback_remove, | |
4167 | @@ -450,5 +449,6 @@ static struct xenbus_driver netback = { | |
4168 | ||
4169 | void netif_xenbus_init(void) | |
4170 | { | |
4171 | - xenbus_register_backend(&netback); | |
4172 | + if (xenbus_register_backend(&netback)) | |
4173 | + BUG(); | |
4174 | } | |
4175 | --- a/drivers/xen/netfront/netfront.c | |
4176 | +++ b/drivers/xen/netfront/netfront.c | |
4177 | @@ -1892,20 +1892,19 @@ static struct ethtool_ops network_ethtoo | |
4178 | }; | |
4179 | ||
4180 | #ifdef CONFIG_SYSFS | |
4181 | -static ssize_t show_rxbuf_min(struct class_device *cd, char *buf) | |
4182 | +static ssize_t show_rxbuf_min(struct device *dev, | |
4183 | + struct device_attribute *attr, char *buf) | |
4184 | { | |
4185 | - struct net_device *netdev = container_of(cd, struct net_device, | |
4186 | - class_dev); | |
4187 | - struct netfront_info *info = netdev_priv(netdev); | |
4188 | + struct netfront_info *info = netdev_priv(to_net_dev(dev)); | |
4189 | ||
4190 | return sprintf(buf, "%u\n", info->rx_min_target); | |
4191 | } | |
4192 | ||
4193 | -static ssize_t store_rxbuf_min(struct class_device *cd, | |
4194 | +static ssize_t store_rxbuf_min(struct device *dev, | |
4195 | + struct device_attribute *attr, | |
4196 | const char *buf, size_t len) | |
4197 | { | |
4198 | - struct net_device *netdev = container_of(cd, struct net_device, | |
4199 | - class_dev); | |
4200 | + struct net_device *netdev = to_net_dev(dev); | |
4201 | struct netfront_info *np = netdev_priv(netdev); | |
4202 | char *endp; | |
4203 | unsigned long target; | |
4204 | @@ -1935,20 +1934,19 @@ static ssize_t store_rxbuf_min(struct cl | |
4205 | return len; | |
4206 | } | |
4207 | ||
4208 | -static ssize_t show_rxbuf_max(struct class_device *cd, char *buf) | |
4209 | +static ssize_t show_rxbuf_max(struct device *dev, | |
4210 | + struct device_attribute *attr, char *buf) | |
4211 | { | |
4212 | - struct net_device *netdev = container_of(cd, struct net_device, | |
4213 | - class_dev); | |
4214 | - struct netfront_info *info = netdev_priv(netdev); | |
4215 | + struct netfront_info *info = netdev_priv(to_net_dev(dev)); | |
4216 | ||
4217 | return sprintf(buf, "%u\n", info->rx_max_target); | |
4218 | } | |
4219 | ||
4220 | -static ssize_t store_rxbuf_max(struct class_device *cd, | |
4221 | +static ssize_t store_rxbuf_max(struct device *dev, | |
4222 | + struct device_attribute *attr, | |
4223 | const char *buf, size_t len) | |
4224 | { | |
4225 | - struct net_device *netdev = container_of(cd, struct net_device, | |
4226 | - class_dev); | |
4227 | + struct net_device *netdev = to_net_dev(dev); | |
4228 | struct netfront_info *np = netdev_priv(netdev); | |
4229 | char *endp; | |
4230 | unsigned long target; | |
4231 | @@ -1978,16 +1976,15 @@ static ssize_t store_rxbuf_max(struct cl | |
4232 | return len; | |
4233 | } | |
4234 | ||
4235 | -static ssize_t show_rxbuf_cur(struct class_device *cd, char *buf) | |
4236 | +static ssize_t show_rxbuf_cur(struct device *dev, | |
4237 | + struct device_attribute *attr, char *buf) | |
4238 | { | |
4239 | - struct net_device *netdev = container_of(cd, struct net_device, | |
4240 | - class_dev); | |
4241 | - struct netfront_info *info = netdev_priv(netdev); | |
4242 | + struct netfront_info *info = netdev_priv(to_net_dev(dev)); | |
4243 | ||
4244 | return sprintf(buf, "%u\n", info->rx_target); | |
4245 | } | |
4246 | ||
4247 | -static const struct class_device_attribute xennet_attrs[] = { | |
4248 | +static struct device_attribute xennet_attrs[] = { | |
4249 | __ATTR(rxbuf_min, S_IRUGO|S_IWUSR, show_rxbuf_min, store_rxbuf_min), | |
4250 | __ATTR(rxbuf_max, S_IRUGO|S_IWUSR, show_rxbuf_max, store_rxbuf_max), | |
4251 | __ATTR(rxbuf_cur, S_IRUGO, show_rxbuf_cur, NULL), | |
4252 | @@ -1999,8 +1996,8 @@ static int xennet_sysfs_addif(struct net | |
4253 | int error = 0; | |
4254 | ||
4255 | for (i = 0; i < ARRAY_SIZE(xennet_attrs); i++) { | |
4256 | - error = class_device_create_file(&netdev->class_dev, | |
4257 | - &xennet_attrs[i]); | |
4258 | + error = device_create_file(&netdev->dev, | |
4259 | + &xennet_attrs[i]); | |
4260 | if (error) | |
4261 | goto fail; | |
4262 | } | |
4263 | @@ -2008,8 +2005,7 @@ static int xennet_sysfs_addif(struct net | |
4264 | ||
4265 | fail: | |
4266 | while (--i >= 0) | |
4267 | - class_device_remove_file(&netdev->class_dev, | |
4268 | - &xennet_attrs[i]); | |
4269 | + device_remove_file(&netdev->dev, &xennet_attrs[i]); | |
4270 | return error; | |
4271 | } | |
4272 | ||
4273 | @@ -2017,10 +2013,8 @@ static void xennet_sysfs_delif(struct ne | |
4274 | { | |
4275 | int i; | |
4276 | ||
4277 | - for (i = 0; i < ARRAY_SIZE(xennet_attrs); i++) { | |
4278 | - class_device_remove_file(&netdev->class_dev, | |
4279 | - &xennet_attrs[i]); | |
4280 | - } | |
4281 | + for (i = 0; i < ARRAY_SIZE(xennet_attrs); i++) | |
4282 | + device_remove_file(&netdev->dev, &xennet_attrs[i]); | |
4283 | } | |
4284 | ||
4285 | #endif /* CONFIG_SYSFS */ | |
4286 | @@ -2186,7 +2180,6 @@ MODULE_ALIAS("xen:vif"); | |
4287 | ||
4288 | static struct xenbus_driver netfront_driver = { | |
4289 | .name = "vif", | |
4290 | - .owner = THIS_MODULE, | |
4291 | .ids = netfront_ids, | |
4292 | .probe = netfront_probe, | |
4293 | .remove = __devexit_p(netfront_remove), | |
4294 | --- a/drivers/xen/pciback/xenbus.c | |
4295 | +++ b/drivers/xen/pciback/xenbus.c | |
4296 | @@ -682,7 +682,6 @@ static const struct xenbus_device_id xen | |
4297 | ||
4298 | static struct xenbus_driver xenbus_pciback_driver = { | |
4299 | .name = "pciback", | |
4300 | - .owner = THIS_MODULE, | |
4301 | .ids = xenpci_ids, | |
4302 | .probe = pciback_xenbus_probe, | |
4303 | .remove = pciback_xenbus_remove, | |
4304 | --- a/drivers/xen/pcifront/xenbus.c | |
4305 | +++ b/drivers/xen/pcifront/xenbus.c | |
4306 | @@ -436,7 +436,6 @@ MODULE_ALIAS("xen:pci"); | |
4307 | ||
4308 | static struct xenbus_driver xenbus_pcifront_driver = { | |
4309 | .name = "pcifront", | |
4310 | - .owner = THIS_MODULE, | |
4311 | .ids = xenpci_ids, | |
4312 | .probe = pcifront_xenbus_probe, | |
4313 | .remove = pcifront_xenbus_remove, | |
4314 | --- a/drivers/xen/scsiback/xenbus.c | |
4315 | +++ b/drivers/xen/scsiback/xenbus.c | |
4316 | @@ -350,7 +350,6 @@ static struct xenbus_device_id scsiback_ | |
4317 | ||
4318 | static struct xenbus_driver scsiback = { | |
4319 | .name = "vscsi", | |
4320 | - .owner = THIS_MODULE, | |
4321 | .ids = scsiback_ids, | |
4322 | .probe = scsiback_probe, | |
4323 | .remove = scsiback_remove, | |
4324 | --- a/drivers/xen/scsifront/xenbus.c | |
4325 | +++ b/drivers/xen/scsifront/xenbus.c | |
4326 | @@ -401,7 +401,6 @@ static struct xenbus_device_id scsifront | |
4327 | ||
4328 | static struct xenbus_driver scsifront_driver = { | |
4329 | .name = "vscsi", | |
4330 | - .owner = THIS_MODULE, | |
4331 | .ids = scsifront_ids, | |
4332 | .probe = scsifront_probe, | |
4333 | .remove = scsifront_remove, | |
4334 | --- a/drivers/xen/tpmback/common.h | |
4335 | +++ b/drivers/xen/tpmback/common.h | |
4336 | @@ -54,11 +54,11 @@ typedef struct tpmif_st { | |
4337 | ||
4338 | void tpmif_disconnect_complete(tpmif_t * tpmif); | |
4339 | tpmif_t *tpmif_find(domid_t domid, struct backend_info *bi); | |
4340 | -void tpmif_interface_init(void); | |
4341 | +int tpmif_interface_init(void); | |
4342 | void tpmif_interface_exit(void); | |
4343 | void tpmif_schedule_work(tpmif_t * tpmif); | |
4344 | void tpmif_deschedule_work(tpmif_t * tpmif); | |
4345 | -void tpmif_xenbus_init(void); | |
4346 | +int tpmif_xenbus_init(void); | |
4347 | void tpmif_xenbus_exit(void); | |
4348 | int tpmif_map(tpmif_t *tpmif, unsigned long shared_page, unsigned int evtchn); | |
4349 | irqreturn_t tpmif_be_int(int irq, void *dev_id); | |
4350 | --- a/drivers/xen/tpmback/interface.c | |
4351 | +++ b/drivers/xen/tpmback/interface.c | |
4352 | @@ -156,13 +156,14 @@ void tpmif_disconnect_complete(tpmif_t * | |
4353 | free_tpmif(tpmif); | |
4354 | } | |
4355 | ||
4356 | -void __init tpmif_interface_init(void) | |
4357 | +int __init tpmif_interface_init(void) | |
4358 | { | |
4359 | tpmif_cachep = kmem_cache_create("tpmif_cache", sizeof (tpmif_t), | |
4360 | 0, 0, NULL, NULL); | |
4361 | + return tpmif_cachep ? 0 : -ENOMEM; | |
4362 | } | |
4363 | ||
4364 | -void __exit tpmif_interface_exit(void) | |
4365 | +void tpmif_interface_exit(void) | |
4366 | { | |
4367 | kmem_cache_destroy(tpmif_cachep); | |
4368 | } | |
4369 | --- a/drivers/xen/tpmback/tpmback.c | |
4370 | +++ b/drivers/xen/tpmback/tpmback.c | |
4371 | @@ -923,22 +923,30 @@ static int __init tpmback_init(void) | |
4372 | spin_lock_init(&tpm_schedule_list_lock); | |
4373 | INIT_LIST_HEAD(&tpm_schedule_list); | |
4374 | ||
4375 | - tpmif_interface_init(); | |
4376 | - tpmif_xenbus_init(); | |
4377 | + rc = tpmif_interface_init(); | |
4378 | + if (!rc) { | |
4379 | + rc = tpmif_xenbus_init(); | |
4380 | + if (rc) | |
4381 | + tpmif_interface_exit(); | |
4382 | + } | |
4383 | + if (rc) { | |
4384 | + misc_deregister(&vtpms_miscdevice); | |
4385 | + return rc; | |
4386 | + } | |
4387 | ||
4388 | printk(KERN_ALERT "Successfully initialized TPM backend driver.\n"); | |
4389 | ||
4390 | return 0; | |
4391 | } | |
4392 | - | |
4393 | module_init(tpmback_init); | |
4394 | ||
4395 | -void __exit tpmback_exit(void) | |
4396 | +static void __exit tpmback_exit(void) | |
4397 | { | |
4398 | vtpm_release_packets(NULL, 0); | |
4399 | tpmif_xenbus_exit(); | |
4400 | tpmif_interface_exit(); | |
4401 | misc_deregister(&vtpms_miscdevice); | |
4402 | } | |
4403 | +module_exit(tpmback_exit) | |
4404 | ||
4405 | MODULE_LICENSE("Dual BSD/GPL"); | |
4406 | --- a/drivers/xen/tpmback/xenbus.c | |
4407 | +++ b/drivers/xen/tpmback/xenbus.c | |
4408 | @@ -270,7 +270,6 @@ static const struct xenbus_device_id tpm | |
4409 | ||
4410 | static struct xenbus_driver tpmback = { | |
4411 | .name = "vtpm", | |
4412 | - .owner = THIS_MODULE, | |
4413 | .ids = tpmback_ids, | |
4414 | .probe = tpmback_probe, | |
4415 | .remove = tpmback_remove, | |
4416 | @@ -278,9 +277,9 @@ static struct xenbus_driver tpmback = { | |
4417 | }; | |
4418 | ||
4419 | ||
4420 | -void tpmif_xenbus_init(void) | |
4421 | +int tpmif_xenbus_init(void) | |
4422 | { | |
4423 | - xenbus_register_backend(&tpmback); | |
4424 | + return xenbus_register_backend(&tpmback); | |
4425 | } | |
4426 | ||
4427 | void tpmif_xenbus_exit(void) | |
4428 | --- a/drivers/xen/xenbus/xenbus_probe_backend.c | |
4429 | +++ b/drivers/xen/xenbus/xenbus_probe_backend.c | |
4430 | @@ -172,13 +172,15 @@ static int xenbus_uevent_backend(struct | |
4431 | return 0; | |
4432 | } | |
4433 | ||
4434 | -int xenbus_register_backend(struct xenbus_driver *drv) | |
4435 | +int __xenbus_register_backend(struct xenbus_driver *drv, | |
4436 | + struct module *owner, const char *mod_name) | |
4437 | { | |
4438 | drv->read_otherend_details = read_frontend_details; | |
4439 | ||
4440 | - return xenbus_register_driver_common(drv, &xenbus_backend); | |
4441 | + return xenbus_register_driver_common(drv, &xenbus_backend, | |
4442 | + owner, mod_name); | |
4443 | } | |
4444 | -EXPORT_SYMBOL_GPL(xenbus_register_backend); | |
4445 | +EXPORT_SYMBOL_GPL(__xenbus_register_backend); | |
4446 | ||
4447 | /* backend/<typename>/<frontend-uuid>/<name> */ | |
4448 | static int xenbus_probe_backend_unit(const char *dir, | |
4449 | --- a/drivers/xen/xenbus/xenbus_probe.c | |
4450 | +++ b/drivers/xen/xenbus/xenbus_probe.c | |
4451 | @@ -365,7 +365,9 @@ static void xenbus_dev_shutdown(struct d | |
4452 | } | |
4453 | ||
4454 | int xenbus_register_driver_common(struct xenbus_driver *drv, | |
4455 | - struct xen_bus_type *bus) | |
4456 | + struct xen_bus_type *bus, | |
4457 | + struct module *owner, | |
4458 | + const char *mod_name) | |
4459 | { | |
4460 | int ret; | |
4461 | ||
4462 | @@ -375,7 +377,10 @@ int xenbus_register_driver_common(struct | |
4463 | drv->driver.name = drv->name; | |
4464 | drv->driver.bus = &bus->bus; | |
4465 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) | |
4466 | - drv->driver.owner = drv->owner; | |
4467 | + drv->driver.owner = owner; | |
4468 | +#endif | |
4469 | +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21) | |
4470 | + drv->driver.mod_name = mod_name; | |
4471 | #endif | |
4472 | #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) | |
4473 | drv->driver.probe = xenbus_dev_probe; | |
4474 | @@ -389,13 +394,15 @@ int xenbus_register_driver_common(struct | |
4475 | return ret; | |
4476 | } | |
4477 | ||
4478 | -int xenbus_register_frontend(struct xenbus_driver *drv) | |
4479 | +int __xenbus_register_frontend(struct xenbus_driver *drv, | |
4480 | + struct module *owner, const char *mod_name) | |
4481 | { | |
4482 | int ret; | |
4483 | ||
4484 | drv->read_otherend_details = read_backend_details; | |
4485 | ||
4486 | - ret = xenbus_register_driver_common(drv, &xenbus_frontend); | |
4487 | + ret = xenbus_register_driver_common(drv, &xenbus_frontend, | |
4488 | + owner, mod_name); | |
4489 | if (ret) | |
4490 | return ret; | |
4491 | ||
4492 | @@ -404,7 +411,7 @@ int xenbus_register_frontend(struct xenb | |
4493 | ||
4494 | return 0; | |
4495 | } | |
4496 | -EXPORT_SYMBOL_GPL(xenbus_register_frontend); | |
4497 | +EXPORT_SYMBOL_GPL(__xenbus_register_frontend); | |
4498 | ||
4499 | void xenbus_unregister_driver(struct xenbus_driver *drv) | |
4500 | { | |
4501 | --- a/drivers/xen/xenbus/xenbus_probe.h | |
4502 | +++ b/drivers/xen/xenbus/xenbus_probe.h | |
4503 | @@ -63,7 +63,9 @@ extern int xenbus_match(struct device *_ | |
4504 | extern int xenbus_dev_probe(struct device *_dev); | |
4505 | extern int xenbus_dev_remove(struct device *_dev); | |
4506 | extern int xenbus_register_driver_common(struct xenbus_driver *drv, | |
4507 | - struct xen_bus_type *bus); | |
4508 | + struct xen_bus_type *bus, | |
4509 | + struct module *owner, | |
4510 | + const char *mod_name); | |
4511 | extern int xenbus_probe_node(struct xen_bus_type *bus, | |
4512 | const char *type, | |
4513 | const char *nodename); | |
4514 | --- a/drivers/xen/xenoprof/xenoprofile.c | |
4515 | +++ b/drivers/xen/xenoprof/xenoprofile.c | |
4516 | @@ -235,7 +235,7 @@ static int bind_virq(void) | |
4517 | result = bind_virq_to_irqhandler(VIRQ_XENOPROF, | |
4518 | i, | |
4519 | xenoprof_ovf_interrupt, | |
4520 | - SA_INTERRUPT, | |
4521 | + IRQF_DISABLED|IRQF_NOBALANCING, | |
4522 | "xenoprof", | |
4523 | NULL); | |
4524 | ||
4525 | --- a/include/asm-x86/i8253.h | |
4526 | +++ b/include/asm-x86/i8253.h | |
4527 | @@ -8,10 +8,14 @@ | |
4528 | ||
4529 | extern spinlock_t i8253_lock; | |
4530 | ||
4531 | +#ifdef CONFIG_GENERIC_CLOCKEVENTS | |
4532 | + | |
4533 | extern struct clock_event_device *global_clock_event; | |
4534 | ||
4535 | extern void setup_pit_timer(void); | |
4536 | ||
4537 | +#endif | |
4538 | + | |
4539 | #define inb_pit inb_p | |
4540 | #define outb_pit outb_p | |
4541 | ||
4542 | --- a/include/asm-x86/mach-xen/asm/desc_32.h | |
4543 | +++ b/include/asm-x86/mach-xen/asm/desc_32.h | |
4544 | @@ -21,7 +21,7 @@ struct Xgt_desc_struct { | |
4545 | ||
4546 | extern struct Xgt_desc_struct idt_descr; | |
4547 | DECLARE_PER_CPU(struct Xgt_desc_struct, cpu_gdt_descr); | |
4548 | - | |
4549 | +extern struct Xgt_desc_struct early_gdt_descr; | |
4550 | ||
4551 | static inline struct desc_struct *get_cpu_gdt_table(unsigned int cpu) | |
4552 | { | |
4553 | --- a/include/asm-x86/mach-xen/asm/dma-mapping_64.h | |
4554 | +++ b/include/asm-x86/mach-xen/asm/dma-mapping_64.h | |
4555 | @@ -9,7 +9,6 @@ | |
4556 | ||
4557 | #include <asm/scatterlist.h> | |
4558 | #include <asm/io.h> | |
4559 | -#include <asm/swiotlb.h> | |
4560 | ||
4561 | struct dma_mapping_ops { | |
4562 | int (*mapping_error)(dma_addr_t dma_addr); | |
4563 | @@ -67,6 +66,9 @@ static inline int dma_mapping_error(dma_ | |
4564 | #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f) | |
4565 | #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h) | |
4566 | ||
4567 | +#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f) | |
4568 | +#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h) | |
4569 | + | |
4570 | extern void *dma_alloc_coherent(struct device *dev, size_t size, | |
4571 | dma_addr_t *dma_handle, gfp_t gfp); | |
4572 | extern void dma_free_coherent(struct device *dev, size_t size, void *vaddr, | |
4573 | --- a/include/asm-x86/mach-xen/asm/hypervisor.h | |
4574 | +++ b/include/asm-x86/mach-xen/asm/hypervisor.h | |
4575 | @@ -158,6 +158,19 @@ static inline void arch_leave_lazy_mmu_m | |
4576 | #define arch_use_lazy_mmu_mode() unlikely(__get_cpu_var(xen_lazy_mmu)) | |
4577 | #endif | |
4578 | ||
4579 | +#if 0 /* All uses are in places potentially called asynchronously, but | |
4580 | + * asynchronous code should rather not make use of lazy mode at all. | |
4581 | + * Therefore, all uses of this function get commented out, proper | |
4582 | + * detection of asynchronous invocations is added whereever needed, | |
4583 | + * and this function is disabled to catch any new (improper) uses. | |
4584 | + */ | |
4585 | +static inline void arch_flush_lazy_mmu_mode(void) | |
4586 | +{ | |
4587 | + if (arch_use_lazy_mmu_mode()) | |
4588 | + xen_multicall_flush(false); | |
4589 | +} | |
4590 | +#endif | |
4591 | + | |
4592 | #else /* CONFIG_XEN */ | |
4593 | ||
4594 | static inline void xen_multicall_flush(bool ignore) {} | |
4595 | @@ -215,7 +228,7 @@ HYPERVISOR_block( | |
4596 | return rc; | |
4597 | } | |
4598 | ||
4599 | -static inline void /*__noreturn*/ | |
4600 | +static inline void __noreturn | |
4601 | HYPERVISOR_shutdown( | |
4602 | unsigned int reason) | |
4603 | { | |
4604 | --- a/include/asm-x86/mach-xen/asm/io_32.h | |
4605 | +++ b/include/asm-x86/mach-xen/asm/io_32.h | |
4606 | @@ -232,12 +232,6 @@ static inline void memcpy_toio(volatile | |
4607 | #define __ISA_IO_base ((char __iomem *)(fix_to_virt(FIX_ISAMAP_BEGIN))) | |
4608 | ||
4609 | /* | |
4610 | - * Again, i386 does not require mem IO specific function. | |
4611 | - */ | |
4612 | - | |
4613 | -#define eth_io_copy_and_sum(a,b,c,d) eth_copy_and_sum((a),(void __force *)(b),(c),(d)) | |
4614 | - | |
4615 | -/* | |
4616 | * Cache management | |
4617 | * | |
4618 | * This needed for two cases | |
4619 | --- a/include/asm-x86/mach-xen/asm/io_64.h | |
4620 | +++ b/include/asm-x86/mach-xen/asm/io_64.h | |
4621 | @@ -101,7 +101,7 @@ __OUTS(l) | |
4622 | ||
4623 | #define IO_SPACE_LIMIT 0xffff | |
4624 | ||
4625 | -#if defined(__KERNEL__) && __x86_64__ | |
4626 | +#if defined(__KERNEL__) && defined(__x86_64__) | |
4627 | ||
4628 | #include <linux/vmalloc.h> | |
4629 | ||
4630 | @@ -267,12 +267,6 @@ void memset_io(volatile void __iomem *a, | |
4631 | */ | |
4632 | #define __ISA_IO_base ((char __iomem *)(fix_to_virt(FIX_ISAMAP_BEGIN))) | |
4633 | ||
4634 | -/* | |
4635 | - * Again, x86-64 does not require mem IO specific function. | |
4636 | - */ | |
4637 | - | |
4638 | -#define eth_io_copy_and_sum(a,b,c,d) eth_copy_and_sum((a),(void *)(b),(c),(d)) | |
4639 | - | |
4640 | /* Nothing to do */ | |
4641 | ||
4642 | #define dma_cache_inv(_start,_size) do { } while (0) | |
4643 | --- a/include/asm-x86/mach-xen/asm/mmu_context_32.h | |
4644 | +++ b/include/asm-x86/mach-xen/asm/mmu_context_32.h | |
4645 | @@ -27,13 +27,13 @@ static inline void enter_lazy_tlb(struct | |
4646 | static inline void __prepare_arch_switch(void) | |
4647 | { | |
4648 | /* | |
4649 | - * Save away %fs. No need to save %gs, as it was saved on the | |
4650 | + * Save away %gs. No need to save %fs, as it was saved on the | |
4651 | * stack on entry. No need to save %es and %ds, as those are | |
4652 | * always kernel segments while inside the kernel. | |
4653 | */ | |
4654 | - asm volatile ( "mov %%fs,%0" | |
4655 | - : "=m" (current->thread.fs)); | |
4656 | - asm volatile ( "movl %0,%%fs" | |
4657 | + asm volatile ( "mov %%gs,%0" | |
4658 | + : "=m" (current->thread.gs)); | |
4659 | + asm volatile ( "movl %0,%%gs" | |
4660 | : : "r" (0) ); | |
4661 | } | |
4662 | ||
4663 | @@ -95,7 +95,7 @@ static inline void switch_mm(struct mm_s | |
4664 | } | |
4665 | ||
4666 | #define deactivate_mm(tsk, mm) \ | |
4667 | - asm("movl %0,%%fs": :"r" (0)); | |
4668 | + asm("movl %0,%%gs": :"r" (0)); | |
4669 | ||
4670 | static inline void activate_mm(struct mm_struct *prev, struct mm_struct *next) | |
4671 | { | |
4672 | --- a/include/asm-x86/mach-xen/asm/pgalloc_32.h | |
4673 | +++ b/include/asm-x86/mach-xen/asm/pgalloc_32.h | |
4674 | @@ -6,12 +6,23 @@ | |
4675 | #include <linux/mm.h> /* for struct page */ | |
4676 | #include <asm/io.h> /* for phys_to_virt and page_to_pseudophys */ | |
4677 | ||
4678 | -#define pmd_populate_kernel(mm, pmd, pte) \ | |
4679 | - set_pmd(pmd, __pmd(_PAGE_TABLE + __pa(pte))) | |
4680 | +#define paravirt_alloc_pt(pfn) do { } while (0) | |
4681 | +#define paravirt_alloc_pd(pfn) do { } while (0) | |
4682 | +#define paravirt_alloc_pd(pfn) do { } while (0) | |
4683 | +#define paravirt_alloc_pd_clone(pfn, clonepfn, start, count) do { } while (0) | |
4684 | +#define paravirt_release_pt(pfn) do { } while (0) | |
4685 | +#define paravirt_release_pd(pfn) do { } while (0) | |
4686 | + | |
4687 | +#define pmd_populate_kernel(mm, pmd, pte) \ | |
4688 | +do { \ | |
4689 | + paravirt_alloc_pt(__pa(pte) >> PAGE_SHIFT); \ | |
4690 | + set_pmd(pmd, __pmd(_PAGE_TABLE + __pa(pte))); \ | |
4691 | +} while (0) | |
4692 | ||
4693 | #define pmd_populate(mm, pmd, pte) \ | |
4694 | do { \ | |
4695 | unsigned long pfn = page_to_pfn(pte); \ | |
4696 | + paravirt_alloc_pt(pfn); \ | |
4697 | if (test_bit(PG_pinned, &virt_to_page((mm)->pgd)->flags)) { \ | |
4698 | if (!PageHighMem(pte)) \ | |
4699 | BUG_ON(HYPERVISOR_update_va_mapping( \ | |
4700 | @@ -42,7 +53,11 @@ static inline void pte_free_kernel(pte_t | |
4701 | ||
4702 | extern void pte_free(struct page *pte); | |
4703 | ||
4704 | -#define __pte_free_tlb(tlb,pte) tlb_remove_page((tlb),(pte)) | |
4705 | +#define __pte_free_tlb(tlb,pte) \ | |
4706 | +do { \ | |
4707 | + paravirt_release_pt(page_to_pfn(pte)); \ | |
4708 | + tlb_remove_page((tlb),(pte)); \ | |
4709 | +} while (0) | |
4710 | ||
4711 | #ifdef CONFIG_X86_PAE | |
4712 | /* | |
4713 | --- a/include/asm-x86/mach-xen/asm/pgtable_32.h | |
4714 | +++ b/include/asm-x86/mach-xen/asm/pgtable_32.h | |
4715 | @@ -275,6 +275,7 @@ static inline pte_t pte_mkhuge(pte_t pte | |
4716 | */ | |
4717 | #define pte_update(mm, addr, ptep) do { } while (0) | |
4718 | #define pte_update_defer(mm, addr, ptep) do { } while (0) | |
4719 | +#define paravirt_map_pt_hook(slot, va, pfn) do { } while (0) | |
4720 | ||
4721 | /* | |
4722 | * We only update the dirty/accessed state if we set | |
4723 | @@ -490,12 +491,24 @@ extern pte_t *lookup_address(unsigned lo | |
4724 | #endif | |
4725 | ||
4726 | #if defined(CONFIG_HIGHPTE) | |
4727 | -#define pte_offset_map(dir, address) \ | |
4728 | - ((pte_t *)kmap_atomic_pte(pmd_page(*(dir)),KM_PTE0) + \ | |
4729 | - pte_index(address)) | |
4730 | -#define pte_offset_map_nested(dir, address) \ | |
4731 | - ((pte_t *)kmap_atomic_pte(pmd_page(*(dir)),KM_PTE1) + \ | |
4732 | - pte_index(address)) | |
4733 | +#define pte_offset_map(dir, address) \ | |
4734 | +({ \ | |
4735 | + pte_t *__ptep; \ | |
4736 | + unsigned pfn = pmd_val(*(dir)) >> PAGE_SHIFT; \ | |
4737 | + __ptep = (pte_t *)kmap_atomic_pte(pfn_to_page(pfn),KM_PTE0); \ | |
4738 | + paravirt_map_pt_hook(KM_PTE0,__ptep, pfn); \ | |
4739 | + __ptep = __ptep + pte_index(address); \ | |
4740 | + __ptep; \ | |
4741 | +}) | |
4742 | +#define pte_offset_map_nested(dir, address) \ | |
4743 | +({ \ | |
4744 | + pte_t *__ptep; \ | |
4745 | + unsigned pfn = pmd_val(*(dir)) >> PAGE_SHIFT; \ | |
4746 | + __ptep = (pte_t *)kmap_atomic_pte(pfn_to_page(pfn),KM_PTE1); \ | |
4747 | + paravirt_map_pt_hook(KM_PTE1,__ptep, pfn); \ | |
4748 | + __ptep = __ptep + pte_index(address); \ | |
4749 | + __ptep; \ | |
4750 | +}) | |
4751 | #define pte_unmap(pte) kunmap_atomic(pte, KM_PTE0) | |
4752 | #define pte_unmap_nested(pte) kunmap_atomic(pte, KM_PTE1) | |
4753 | #else | |
4754 | --- a/include/asm-x86/mach-xen/asm/pgtable_64.h | |
4755 | +++ b/include/asm-x86/mach-xen/asm/pgtable_64.h | |
4756 | @@ -414,15 +414,6 @@ static inline int pmd_large(pmd_t pte) { | |
4757 | #define mk_pte(page, pgprot) pfn_pte(page_to_pfn(page), (pgprot)) | |
4758 | #define mk_pte_huge(entry) (__pte_val(entry) |= _PAGE_PRESENT | _PAGE_PSE) | |
4759 | ||
4760 | -/* physical address -> PTE */ | |
4761 | -static inline pte_t mk_pte_phys(unsigned long physpage, pgprot_t pgprot) | |
4762 | -{ | |
4763 | - unsigned long pteval; | |
4764 | - pteval = physpage | pgprot_val(pgprot); | |
4765 | - pteval &= __supported_pte_mask; | |
4766 | - return __pte(pteval); | |
4767 | -} | |
4768 | - | |
4769 | /* Change flags of a PTE */ | |
4770 | static inline pte_t pte_modify(pte_t pte, pgprot_t newprot) | |
4771 | { | |
4772 | --- a/include/asm-x86/mach-xen/asm/processor_32.h | |
4773 | +++ b/include/asm-x86/mach-xen/asm/processor_32.h | |
4774 | @@ -431,7 +431,7 @@ struct thread_struct { | |
4775 | .vm86_info = NULL, \ | |
4776 | .sysenter_cs = __KERNEL_CS, \ | |
4777 | .io_bitmap_ptr = NULL, \ | |
4778 | - .gs = __KERNEL_PDA, \ | |
4779 | + .fs = __KERNEL_PDA, \ | |
4780 | } | |
4781 | ||
4782 | /* | |
4783 | @@ -449,8 +449,8 @@ struct thread_struct { | |
4784 | } | |
4785 | ||
4786 | #define start_thread(regs, new_eip, new_esp) do { \ | |
4787 | - __asm__("movl %0,%%fs": :"r" (0)); \ | |
4788 | - regs->xgs = 0; \ | |
4789 | + __asm__("movl %0,%%gs": :"r" (0)); \ | |
4790 | + regs->xfs = 0; \ | |
4791 | set_fs(USER_DS); \ | |
4792 | regs->xds = __USER_DS; \ | |
4793 | regs->xes = __USER_DS; \ | |
4794 | --- a/include/asm-x86/mach-xen/asm/segment_32.h | |
4795 | +++ b/include/asm-x86/mach-xen/asm/segment_32.h | |
4796 | @@ -83,14 +83,8 @@ | |
4797 | * The GDT has 32 entries | |
4798 | */ | |
4799 | #define GDT_ENTRIES 32 | |
4800 | - | |
4801 | #define GDT_SIZE (GDT_ENTRIES * 8) | |
4802 | ||
4803 | -/* Matches __KERNEL_CS and __USER_CS (they must be 2 entries apart) */ | |
4804 | -#define SEGMENT_IS_FLAT_CODE(x) (((x) & 0xec) == GDT_ENTRY_KERNEL_CS * 8) | |
4805 | -/* Matches PNP_CS32 and PNP_CS16 (they must be consecutive) */ | |
4806 | -#define SEGMENT_IS_PNP_CODE(x) (((x) & 0xf4) == GDT_ENTRY_PNPBIOS_BASE * 8) | |
4807 | - | |
4808 | /* Simple and small GDT entries for booting only */ | |
4809 | ||
4810 | #define GDT_ENTRY_BOOT_CS 2 | |
4811 | @@ -132,4 +126,21 @@ | |
4812 | #define SEGMENT_GDT 0x0 | |
4813 | ||
4814 | #define get_kernel_rpl() (xen_feature(XENFEAT_supervisor_mode_kernel)?0:1) | |
4815 | + | |
4816 | +/* | |
4817 | + * Matching rules for certain types of segments. | |
4818 | + */ | |
4819 | + | |
4820 | +/* Matches only __KERNEL_CS, ignoring PnP / USER / APM segments */ | |
4821 | +#define SEGMENT_IS_KERNEL_CODE(x) (((x) & ~3) == GDT_ENTRY_KERNEL_CS * 8 \ | |
4822 | + || ((x) & ~3) == (FLAT_KERNEL_CS & ~3)) | |
4823 | + | |
4824 | +/* Matches __KERNEL_CS and __USER_CS (they must be 2 entries apart) */ | |
4825 | +#define SEGMENT_IS_FLAT_CODE(x) (((x) & ~0x13) == GDT_ENTRY_KERNEL_CS * 8 \ | |
4826 | + || ((x) & ~3) == (FLAT_KERNEL_CS & ~3) \ | |
4827 | + || ((x) & ~3) == (FLAT_USER_CS & ~3)) | |
4828 | + | |
4829 | +/* Matches PNP_CS32 and PNP_CS16 (they must be consecutive) */ | |
4830 | +#define SEGMENT_IS_PNP_CODE(x) (((x) & ~0x0b) == GDT_ENTRY_PNPBIOS_BASE * 8) | |
4831 | + | |
4832 | #endif | |
4833 | --- a/include/asm-x86/mach-xen/asm/smp_32.h | |
4834 | +++ b/include/asm-x86/mach-xen/asm/smp_32.h | |
4835 | @@ -52,6 +52,11 @@ extern void cpu_exit_clear(void); | |
4836 | extern void cpu_uninit(void); | |
4837 | #endif | |
4838 | ||
4839 | +#ifndef CONFIG_PARAVIRT | |
4840 | +#define startup_ipi_hook(phys_apicid, start_eip, start_esp) \ | |
4841 | +do { } while (0) | |
4842 | +#endif | |
4843 | + | |
4844 | /* | |
4845 | * This function is needed by all SMP systems. It must _always_ be valid | |
4846 | * from the initial startup. We map APIC_BASE very early in page_setup(), | |
4847 | --- a/include/asm-x86/mach-xen/asm/smp_64.h | |
4848 | +++ b/include/asm-x86/mach-xen/asm/smp_64.h | |
4849 | @@ -7,6 +7,7 @@ | |
4850 | #include <linux/threads.h> | |
4851 | #include <linux/cpumask.h> | |
4852 | #include <linux/bitops.h> | |
4853 | +#include <linux/init.h> | |
4854 | extern int disable_apic; | |
4855 | ||
4856 | #ifdef CONFIG_X86_LOCAL_APIC | |
4857 | @@ -73,7 +74,7 @@ extern int __cpu_disable(void); | |
4858 | extern void __cpu_die(unsigned int cpu); | |
4859 | extern void prefill_possible_map(void); | |
4860 | extern unsigned num_processors; | |
4861 | -extern unsigned disabled_cpus; | |
4862 | +extern unsigned __cpuinitdata disabled_cpus; | |
4863 | ||
4864 | #define NO_PROC_ID 0xFF /* No processor magic marker */ | |
4865 | ||
4866 | --- a/include/xen/xenbus.h | |
4867 | +++ b/include/xen/xenbus.h | |
4868 | @@ -93,8 +93,7 @@ struct xenbus_device_id | |
4869 | ||
4870 | /* A xenbus driver. */ | |
4871 | struct xenbus_driver { | |
4872 | - char *name; | |
4873 | - struct module *owner; | |
4874 | + const char *name; | |
4875 | const struct xenbus_device_id *ids; | |
4876 | int (*probe)(struct xenbus_device *dev, | |
4877 | const struct xenbus_device_id *id); | |
4878 | @@ -115,8 +114,25 @@ static inline struct xenbus_driver *to_x | |
4879 | return container_of(drv, struct xenbus_driver, driver); | |
4880 | } | |
4881 | ||
4882 | -int xenbus_register_frontend(struct xenbus_driver *drv); | |
4883 | -int xenbus_register_backend(struct xenbus_driver *drv); | |
4884 | +int __must_check __xenbus_register_frontend(struct xenbus_driver *drv, | |
4885 | + struct module *owner, | |
4886 | + const char *mod_name); | |
4887 | + | |
4888 | +static inline int __must_check | |
4889 | +xenbus_register_frontend(struct xenbus_driver *drv) | |
4890 | +{ | |
4891 | + return __xenbus_register_frontend(drv, THIS_MODULE, KBUILD_MODNAME); | |
4892 | +} | |
4893 | + | |
4894 | +int __must_check __xenbus_register_backend(struct xenbus_driver *drv, | |
4895 | + struct module *owner, | |
4896 | + const char *mod_name); | |
4897 | +static inline int __must_check | |
4898 | +xenbus_register_backend(struct xenbus_driver *drv) | |
4899 | +{ | |
4900 | + return __xenbus_register_backend(drv, THIS_MODULE, KBUILD_MODNAME); | |
4901 | +} | |
4902 | + | |
4903 | void xenbus_unregister_driver(struct xenbus_driver *drv); | |
4904 | ||
4905 | struct xenbus_transaction | |
4906 | --- a/lib/swiotlb-xen.c | |
4907 | +++ b/lib/swiotlb-xen.c | |
4908 | @@ -135,8 +135,8 @@ __setup("swiotlb=", setup_io_tlb_npages) | |
4909 | * Statically reserve bounce buffer space and initialize bounce buffer data | |
4910 | * structures for the software IO TLB used to implement the PCI DMA API. | |
4911 | */ | |
4912 | -void | |
4913 | -swiotlb_init_with_default_size (size_t default_size) | |
4914 | +void __init | |
4915 | +swiotlb_init_with_default_size(size_t default_size) | |
4916 | { | |
4917 | unsigned long i, bytes; | |
4918 | int rc; | |
4919 | @@ -221,7 +221,7 @@ swiotlb_init_with_default_size (size_t d | |
4920 | dma_bits); | |
4921 | } | |
4922 | ||
4923 | -void | |
4924 | +void __init | |
4925 | swiotlb_init(void) | |
4926 | { | |
4927 | long ram_end; | |
4928 | @@ -457,7 +457,7 @@ swiotlb_full(struct device *dev, size_t | |
4929 | * When the mapping is small enough return a static buffer to limit | |
4930 | * the damage, or panic when the transfer is too big. | |
4931 | */ | |
4932 | - printk(KERN_ERR "PCI-DMA: Out of SW-IOMMU space for %lu bytes at " | |
4933 | + printk(KERN_ERR "PCI-DMA: Out of SW-IOMMU space for %zu bytes at " | |
4934 | "device %s\n", (unsigned long)size, dev ? dev->bus_id : "?"); | |
4935 | ||
4936 | if (size > io_tlb_overflow && do_panic) { | |
4937 | @@ -602,7 +602,7 @@ swiotlb_map_sg(struct device *hwdev, str | |
4938 | sg[0].dma_length = 0; | |
4939 | return 0; | |
4940 | } | |
4941 | - sg->dma_address = (dma_addr_t)virt_to_bus(map); | |
4942 | + sg->dma_address = virt_to_bus(map); | |
4943 | } else | |
4944 | sg->dma_address = dev_addr; | |
4945 | sg->dma_length = sg->length; | |
4946 | @@ -624,8 +624,7 @@ swiotlb_unmap_sg(struct device *hwdev, s | |
4947 | ||
4948 | for (i = 0; i < nelems; i++, sg++) | |
4949 | if (in_swiotlb_aperture(sg->dma_address)) | |
4950 | - unmap_single(hwdev, | |
4951 | - (void *)bus_to_virt(sg->dma_address), | |
4952 | + unmap_single(hwdev, bus_to_virt(sg->dma_address), | |
4953 | sg->dma_length, dir); | |
4954 | else | |
4955 | gnttab_dma_unmap_page(sg->dma_address); | |
4956 | @@ -648,8 +647,7 @@ swiotlb_sync_sg_for_cpu(struct device *h | |
4957 | ||
4958 | for (i = 0; i < nelems; i++, sg++) | |
4959 | if (in_swiotlb_aperture(sg->dma_address)) | |
4960 | - sync_single(hwdev, | |
4961 | - (void *)bus_to_virt(sg->dma_address), | |
4962 | + sync_single(hwdev, bus_to_virt(sg->dma_address), | |
4963 | sg->dma_length, dir); | |
4964 | } | |
4965 | ||
4966 | @@ -663,8 +661,7 @@ swiotlb_sync_sg_for_device(struct device | |
4967 | ||
4968 | for (i = 0; i < nelems; i++, sg++) | |
4969 | if (in_swiotlb_aperture(sg->dma_address)) | |
4970 | - sync_single(hwdev, | |
4971 | - (void *)bus_to_virt(sg->dma_address), | |
4972 | + sync_single(hwdev, bus_to_virt(sg->dma_address), | |
4973 | sg->dma_length, dir); | |
4974 | } | |
4975 |