b62ccb840cfb1a6a3a64735781249f2ef412d179
[linux-2.6.git] / arch / x86 / xen / enlighten.c
1 /*
2  * Core of Xen paravirt_ops implementation.
3  *
4  * This file contains the xen_paravirt_ops structure itself, and the
5  * implementations for:
6  * - privileged instructions
7  * - interrupt flags
8  * - segment operations
9  * - booting and setup
10  *
11  * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
12  */
13
14 #include <linux/kernel.h>
15 #include <linux/init.h>
16 #include <linux/smp.h>
17 #include <linux/preempt.h>
18 #include <linux/hardirq.h>
19 #include <linux/percpu.h>
20 #include <linux/delay.h>
21 #include <linux/start_kernel.h>
22 #include <linux/sched.h>
23 #include <linux/kprobes.h>
24 #include <linux/bootmem.h>
25 #include <linux/module.h>
26 #include <linux/mm.h>
27 #include <linux/page-flags.h>
28 #include <linux/highmem.h>
29 #include <linux/console.h>
30
31 #include <xen/interface/xen.h>
32 #include <xen/interface/version.h>
33 #include <xen/interface/physdev.h>
34 #include <xen/interface/vcpu.h>
35 #include <xen/features.h>
36 #include <xen/page.h>
37 #include <xen/hvc-console.h>
38
39 #include <asm/paravirt.h>
40 #include <asm/apic.h>
41 #include <asm/page.h>
42 #include <asm/xen/hypercall.h>
43 #include <asm/xen/hypervisor.h>
44 #include <asm/fixmap.h>
45 #include <asm/processor.h>
46 #include <asm/proto.h>
47 #include <asm/msr-index.h>
48 #include <asm/traps.h>
49 #include <asm/setup.h>
50 #include <asm/desc.h>
51 #include <asm/pgtable.h>
52 #include <asm/tlbflush.h>
53 #include <asm/reboot.h>
54
55 #include "xen-ops.h"
56 #include "mmu.h"
57 #include "multicalls.h"
58
59 EXPORT_SYMBOL_GPL(hypercall_page);
60
61 DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);
62 DEFINE_PER_CPU(struct vcpu_info, xen_vcpu_info);
63
64 enum xen_domain_type xen_domain_type = XEN_NATIVE;
65 EXPORT_SYMBOL_GPL(xen_domain_type);
66
67 struct start_info *xen_start_info;
68 EXPORT_SYMBOL_GPL(xen_start_info);
69
70 struct shared_info xen_dummy_shared_info;
71
72 void *xen_initial_gdt;
73
74 /*
75  * Point at some empty memory to start with. We map the real shared_info
76  * page as soon as fixmap is up and running.
77  */
78 struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info;
79
80 /*
81  * Flag to determine whether vcpu info placement is available on all
82  * VCPUs.  We assume it is to start with, and then set it to zero on
83  * the first failure.  This is because it can succeed on some VCPUs
84  * and not others, since it can involve hypervisor memory allocation,
85  * or because the guest failed to guarantee all the appropriate
86  * constraints on all VCPUs (ie buffer can't cross a page boundary).
87  *
88  * Note that any particular CPU may be using a placed vcpu structure,
89  * but we can only optimise if the all are.
90  *
91  * 0: not available, 1: available
92  */
93 static int have_vcpu_info_placement = 1;
94
95 static void xen_vcpu_setup(int cpu)
96 {
97         struct vcpu_register_vcpu_info info;
98         int err;
99         struct vcpu_info *vcpup;
100
101         BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
102         per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
103
104         if (!have_vcpu_info_placement)
105                 return;         /* already tested, not available */
106
107         vcpup = &per_cpu(xen_vcpu_info, cpu);
108
109         info.mfn = arbitrary_virt_to_mfn(vcpup);
110         info.offset = offset_in_page(vcpup);
111
112         printk(KERN_DEBUG "trying to map vcpu_info %d at %p, mfn %llx, offset %d\n",
113                cpu, vcpup, info.mfn, info.offset);
114
115         /* Check to see if the hypervisor will put the vcpu_info
116            structure where we want it, which allows direct access via
117            a percpu-variable. */
118         err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info, cpu, &info);
119
120         if (err) {
121                 printk(KERN_DEBUG "register_vcpu_info failed: err=%d\n", err);
122                 have_vcpu_info_placement = 0;
123         } else {
124                 /* This cpu is using the registered vcpu info, even if
125                    later ones fail to. */
126                 per_cpu(xen_vcpu, cpu) = vcpup;
127
128                 printk(KERN_DEBUG "cpu %d using vcpu_info at %p\n",
129                        cpu, vcpup);
130         }
131 }
132
133 /*
134  * On restore, set the vcpu placement up again.
135  * If it fails, then we're in a bad state, since
136  * we can't back out from using it...
137  */
138 void xen_vcpu_restore(void)
139 {
140         if (have_vcpu_info_placement) {
141                 int cpu;
142
143                 for_each_online_cpu(cpu) {
144                         bool other_cpu = (cpu != smp_processor_id());
145
146                         if (other_cpu &&
147                             HYPERVISOR_vcpu_op(VCPUOP_down, cpu, NULL))
148                                 BUG();
149
150                         xen_vcpu_setup(cpu);
151
152                         if (other_cpu &&
153                             HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL))
154                                 BUG();
155                 }
156
157                 BUG_ON(!have_vcpu_info_placement);
158         }
159 }
160
161 static void __init xen_banner(void)
162 {
163         unsigned version = HYPERVISOR_xen_version(XENVER_version, NULL);
164         struct xen_extraversion extra;
165         HYPERVISOR_xen_version(XENVER_extraversion, &extra);
166
167         printk(KERN_INFO "Booting paravirtualized kernel on %s\n",
168                pv_info.name);
169         printk(KERN_INFO "Xen version: %d.%d%s%s\n",
170                version >> 16, version & 0xffff, extra.extraversion,
171                xen_feature(XENFEAT_mmu_pt_update_preserve_ad) ? " (preserve-AD)" : "");
172 }
173
174 static __read_mostly unsigned int cpuid_leaf1_edx_mask = ~0;
175 static __read_mostly unsigned int cpuid_leaf1_ecx_mask = ~0;
176
177 static void xen_cpuid(unsigned int *ax, unsigned int *bx,
178                       unsigned int *cx, unsigned int *dx)
179 {
180         unsigned maskecx = ~0;
181         unsigned maskedx = ~0;
182
183         /*
184          * Mask out inconvenient features, to try and disable as many
185          * unsupported kernel subsystems as possible.
186          */
187         if (*ax == 1) {
188                 maskecx = cpuid_leaf1_ecx_mask;
189                 maskedx = cpuid_leaf1_edx_mask;
190         }
191
192         asm(XEN_EMULATE_PREFIX "cpuid"
193                 : "=a" (*ax),
194                   "=b" (*bx),
195                   "=c" (*cx),
196                   "=d" (*dx)
197                 : "0" (*ax), "2" (*cx));
198
199         *cx &= maskecx;
200         *dx &= maskedx;
201 }
202
203 static __init void xen_init_cpuid_mask(void)
204 {
205         unsigned int ax, bx, cx, dx;
206
207         cpuid_leaf1_edx_mask =
208                 ~((1 << X86_FEATURE_MCE)  |  /* disable MCE */
209                   (1 << X86_FEATURE_MCA)  |  /* disable MCA */
210                   (1 << X86_FEATURE_ACC));   /* thermal monitoring */
211
212         if (!xen_initial_domain())
213                 cpuid_leaf1_edx_mask &=
214                         ~((1 << X86_FEATURE_APIC) |  /* disable local APIC */
215                           (1 << X86_FEATURE_ACPI));  /* disable ACPI */
216
217         ax = 1;
218         cx = 0;
219         xen_cpuid(&ax, &bx, &cx, &dx);
220
221         /* cpuid claims we support xsave; try enabling it to see what happens */
222         if (cx & (1 << (X86_FEATURE_XSAVE % 32))) {
223                 unsigned long cr4;
224
225                 set_in_cr4(X86_CR4_OSXSAVE);
226                 
227                 cr4 = read_cr4();
228
229                 if ((cr4 & X86_CR4_OSXSAVE) == 0)
230                         cpuid_leaf1_ecx_mask &= ~(1 << (X86_FEATURE_XSAVE % 32));
231
232                 clear_in_cr4(X86_CR4_OSXSAVE);
233         }
234 }
235
236 static void xen_set_debugreg(int reg, unsigned long val)
237 {
238         HYPERVISOR_set_debugreg(reg, val);
239 }
240
241 static unsigned long xen_get_debugreg(int reg)
242 {
243         return HYPERVISOR_get_debugreg(reg);
244 }
245
246 static void xen_end_context_switch(struct task_struct *next)
247 {
248         xen_mc_flush();
249         paravirt_end_context_switch(next);
250 }
251
252 static unsigned long xen_store_tr(void)
253 {
254         return 0;
255 }
256
257 /*
258  * Set the page permissions for a particular virtual address.  If the
259  * address is a vmalloc mapping (or other non-linear mapping), then
260  * find the linear mapping of the page and also set its protections to
261  * match.
262  */
263 static void set_aliased_prot(void *v, pgprot_t prot)
264 {
265         int level;
266         pte_t *ptep;
267         pte_t pte;
268         unsigned long pfn;
269         struct page *page;
270
271         ptep = lookup_address((unsigned long)v, &level);
272         BUG_ON(ptep == NULL);
273
274         pfn = pte_pfn(*ptep);
275         page = pfn_to_page(pfn);
276
277         pte = pfn_pte(pfn, prot);
278
279         if (HYPERVISOR_update_va_mapping((unsigned long)v, pte, 0))
280                 BUG();
281
282         if (!PageHighMem(page)) {
283                 void *av = __va(PFN_PHYS(pfn));
284
285                 if (av != v)
286                         if (HYPERVISOR_update_va_mapping((unsigned long)av, pte, 0))
287                                 BUG();
288         } else
289                 kmap_flush_unused();
290 }
291
292 static void xen_alloc_ldt(struct desc_struct *ldt, unsigned entries)
293 {
294         const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
295         int i;
296
297         for(i = 0; i < entries; i += entries_per_page)
298                 set_aliased_prot(ldt + i, PAGE_KERNEL_RO);
299 }
300
301 static void xen_free_ldt(struct desc_struct *ldt, unsigned entries)
302 {
303         const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
304         int i;
305
306         for(i = 0; i < entries; i += entries_per_page)
307                 set_aliased_prot(ldt + i, PAGE_KERNEL);
308 }
309
310 static void xen_set_ldt(const void *addr, unsigned entries)
311 {
312         struct mmuext_op *op;
313         struct multicall_space mcs = xen_mc_entry(sizeof(*op));
314
315         op = mcs.args;
316         op->cmd = MMUEXT_SET_LDT;
317         op->arg1.linear_addr = (unsigned long)addr;
318         op->arg2.nr_ents = entries;
319
320         MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
321
322         xen_mc_issue(PARAVIRT_LAZY_CPU);
323 }
324
325 static void xen_load_gdt(const struct desc_ptr *dtr)
326 {
327         unsigned long va = dtr->address;
328         unsigned int size = dtr->size + 1;
329         unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
330         unsigned long frames[pages];
331         int f;
332
333         /* A GDT can be up to 64k in size, which corresponds to 8192
334            8-byte entries, or 16 4k pages.. */
335
336         BUG_ON(size > 65536);
337         BUG_ON(va & ~PAGE_MASK);
338
339         for (f = 0; va < dtr->address + size; va += PAGE_SIZE, f++) {
340                 int level;
341                 pte_t *ptep = lookup_address(va, &level);
342                 unsigned long pfn, mfn;
343                 void *virt;
344
345                 BUG_ON(ptep == NULL);
346
347                 pfn = pte_pfn(*ptep);
348                 mfn = pfn_to_mfn(pfn);
349                 virt = __va(PFN_PHYS(pfn));
350
351                 frames[f] = mfn;
352
353                 make_lowmem_page_readonly((void *)va);
354                 make_lowmem_page_readonly(virt);
355         }
356
357         if (HYPERVISOR_set_gdt(frames, size / sizeof(struct desc_struct)))
358                 BUG();
359 }
360
361 static void load_TLS_descriptor(struct thread_struct *t,
362                                 unsigned int cpu, unsigned int i)
363 {
364         struct desc_struct *gdt = get_cpu_gdt_table(cpu);
365         xmaddr_t maddr = arbitrary_virt_to_machine(&gdt[GDT_ENTRY_TLS_MIN+i]);
366         struct multicall_space mc = __xen_mc_entry(0);
367
368         MULTI_update_descriptor(mc.mc, maddr.maddr, t->tls_array[i]);
369 }
370
371 static void xen_load_tls(struct thread_struct *t, unsigned int cpu)
372 {
373         /*
374          * XXX sleazy hack: If we're being called in a lazy-cpu zone
375          * and lazy gs handling is enabled, it means we're in a
376          * context switch, and %gs has just been saved.  This means we
377          * can zero it out to prevent faults on exit from the
378          * hypervisor if the next process has no %gs.  Either way, it
379          * has been saved, and the new value will get loaded properly.
380          * This will go away as soon as Xen has been modified to not
381          * save/restore %gs for normal hypercalls.
382          *
383          * On x86_64, this hack is not used for %gs, because gs points
384          * to KERNEL_GS_BASE (and uses it for PDA references), so we
385          * must not zero %gs on x86_64
386          *
387          * For x86_64, we need to zero %fs, otherwise we may get an
388          * exception between the new %fs descriptor being loaded and
389          * %fs being effectively cleared at __switch_to().
390          */
391         if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU) {
392 #ifdef CONFIG_X86_32
393                 lazy_load_gs(0);
394 #else
395                 loadsegment(fs, 0);
396 #endif
397         }
398
399         xen_mc_batch();
400
401         load_TLS_descriptor(t, cpu, 0);
402         load_TLS_descriptor(t, cpu, 1);
403         load_TLS_descriptor(t, cpu, 2);
404
405         xen_mc_issue(PARAVIRT_LAZY_CPU);
406 }
407
408 #ifdef CONFIG_X86_64
409 static void xen_load_gs_index(unsigned int idx)
410 {
411         if (HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, idx))
412                 BUG();
413 }
414 #endif
415
416 static void xen_write_ldt_entry(struct desc_struct *dt, int entrynum,
417                                 const void *ptr)
418 {
419         xmaddr_t mach_lp = arbitrary_virt_to_machine(&dt[entrynum]);
420         u64 entry = *(u64 *)ptr;
421
422         preempt_disable();
423
424         xen_mc_flush();
425         if (HYPERVISOR_update_descriptor(mach_lp.maddr, entry))
426                 BUG();
427
428         preempt_enable();
429 }
430
431 static int cvt_gate_to_trap(int vector, const gate_desc *val,
432                             struct trap_info *info)
433 {
434         unsigned long addr;
435
436         if (val->type != GATE_TRAP && val->type != GATE_INTERRUPT)
437                 return 0;
438
439         info->vector = vector;
440
441         addr = gate_offset(*val);
442 #ifdef CONFIG_X86_64
443         /*
444          * Look for known traps using IST, and substitute them
445          * appropriately.  The debugger ones are the only ones we care
446          * about.  Xen will handle faults like double_fault and
447          * machine_check, so we should never see them.  Warn if
448          * there's an unexpected IST-using fault handler.
449          */
450         if (addr == (unsigned long)debug)
451                 addr = (unsigned long)xen_debug;
452         else if (addr == (unsigned long)int3)
453                 addr = (unsigned long)xen_int3;
454         else if (addr == (unsigned long)stack_segment)
455                 addr = (unsigned long)xen_stack_segment;
456         else if (addr == (unsigned long)double_fault ||
457                  addr == (unsigned long)nmi) {
458                 /* Don't need to handle these */
459                 return 0;
460 #ifdef CONFIG_X86_MCE
461         } else if (addr == (unsigned long)machine_check) {
462                 return 0;
463 #endif
464         } else {
465                 /* Some other trap using IST? */
466                 if (WARN_ON(val->ist != 0))
467                         return 0;
468         }
469 #endif  /* CONFIG_X86_64 */
470         info->address = addr;
471
472         info->cs = gate_segment(*val);
473         info->flags = val->dpl;
474         /* interrupt gates clear IF */
475         if (val->type == GATE_INTERRUPT)
476                 info->flags |= 1 << 2;
477
478         return 1;
479 }
480
481 /* Locations of each CPU's IDT */
482 static DEFINE_PER_CPU(struct desc_ptr, idt_desc);
483
484 /* Set an IDT entry.  If the entry is part of the current IDT, then
485    also update Xen. */
486 static void xen_write_idt_entry(gate_desc *dt, int entrynum, const gate_desc *g)
487 {
488         unsigned long p = (unsigned long)&dt[entrynum];
489         unsigned long start, end;
490
491         preempt_disable();
492
493         start = __get_cpu_var(idt_desc).address;
494         end = start + __get_cpu_var(idt_desc).size + 1;
495
496         xen_mc_flush();
497
498         native_write_idt_entry(dt, entrynum, g);
499
500         if (p >= start && (p + 8) <= end) {
501                 struct trap_info info[2];
502
503                 info[1].address = 0;
504
505                 if (cvt_gate_to_trap(entrynum, g, &info[0]))
506                         if (HYPERVISOR_set_trap_table(info))
507                                 BUG();
508         }
509
510         preempt_enable();
511 }
512
513 static void xen_convert_trap_info(const struct desc_ptr *desc,
514                                   struct trap_info *traps)
515 {
516         unsigned in, out, count;
517
518         count = (desc->size+1) / sizeof(gate_desc);
519         BUG_ON(count > 256);
520
521         for (in = out = 0; in < count; in++) {
522                 gate_desc *entry = (gate_desc*)(desc->address) + in;
523
524                 if (cvt_gate_to_trap(in, entry, &traps[out]))
525                         out++;
526         }
527         traps[out].address = 0;
528 }
529
530 void xen_copy_trap_info(struct trap_info *traps)
531 {
532         const struct desc_ptr *desc = &__get_cpu_var(idt_desc);
533
534         xen_convert_trap_info(desc, traps);
535 }
536
537 /* Load a new IDT into Xen.  In principle this can be per-CPU, so we
538    hold a spinlock to protect the static traps[] array (static because
539    it avoids allocation, and saves stack space). */
540 static void xen_load_idt(const struct desc_ptr *desc)
541 {
542         static DEFINE_SPINLOCK(lock);
543         static struct trap_info traps[257];
544
545         spin_lock(&lock);
546
547         __get_cpu_var(idt_desc) = *desc;
548
549         xen_convert_trap_info(desc, traps);
550
551         xen_mc_flush();
552         if (HYPERVISOR_set_trap_table(traps))
553                 BUG();
554
555         spin_unlock(&lock);
556 }
557
558 /* Write a GDT descriptor entry.  Ignore LDT descriptors, since
559    they're handled differently. */
560 static void xen_write_gdt_entry(struct desc_struct *dt, int entry,
561                                 const void *desc, int type)
562 {
563         preempt_disable();
564
565         switch (type) {
566         case DESC_LDT:
567         case DESC_TSS:
568                 /* ignore */
569                 break;
570
571         default: {
572                 xmaddr_t maddr = arbitrary_virt_to_machine(&dt[entry]);
573
574                 xen_mc_flush();
575                 if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
576                         BUG();
577         }
578
579         }
580
581         preempt_enable();
582 }
583
584 static void xen_load_sp0(struct tss_struct *tss,
585                          struct thread_struct *thread)
586 {
587         struct multicall_space mcs = xen_mc_entry(0);
588         MULTI_stack_switch(mcs.mc, __KERNEL_DS, thread->sp0);
589         xen_mc_issue(PARAVIRT_LAZY_CPU);
590 }
591
592 static void xen_set_iopl_mask(unsigned mask)
593 {
594         struct physdev_set_iopl set_iopl;
595
596         /* Force the change at ring 0. */
597         set_iopl.iopl = (mask == 0) ? 1 : (mask >> 12) & 3;
598         HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
599 }
600
601 static void xen_io_delay(void)
602 {
603 }
604
605 #ifdef CONFIG_X86_LOCAL_APIC
606 static u32 xen_apic_read(u32 reg)
607 {
608         return 0;
609 }
610
611 static void xen_apic_write(u32 reg, u32 val)
612 {
613         /* Warn to see if there's any stray references */
614         WARN_ON(1);
615 }
616
617 static u64 xen_apic_icr_read(void)
618 {
619         return 0;
620 }
621
622 static void xen_apic_icr_write(u32 low, u32 id)
623 {
624         /* Warn to see if there's any stray references */
625         WARN_ON(1);
626 }
627
628 static void xen_apic_wait_icr_idle(void)
629 {
630         return;
631 }
632
633 static u32 xen_safe_apic_wait_icr_idle(void)
634 {
635         return 0;
636 }
637
638 static void set_xen_basic_apic_ops(void)
639 {
640         apic->read = xen_apic_read;
641         apic->write = xen_apic_write;
642         apic->icr_read = xen_apic_icr_read;
643         apic->icr_write = xen_apic_icr_write;
644         apic->wait_icr_idle = xen_apic_wait_icr_idle;
645         apic->safe_wait_icr_idle = xen_safe_apic_wait_icr_idle;
646 }
647
648 #endif
649
650
651 static void xen_clts(void)
652 {
653         struct multicall_space mcs;
654
655         mcs = xen_mc_entry(0);
656
657         MULTI_fpu_taskswitch(mcs.mc, 0);
658
659         xen_mc_issue(PARAVIRT_LAZY_CPU);
660 }
661
662 static DEFINE_PER_CPU(unsigned long, xen_cr0_value);
663
664 static unsigned long xen_read_cr0(void)
665 {
666         unsigned long cr0 = percpu_read(xen_cr0_value);
667
668         if (unlikely(cr0 == 0)) {
669                 cr0 = native_read_cr0();
670                 percpu_write(xen_cr0_value, cr0);
671         }
672
673         return cr0;
674 }
675
676 static void xen_write_cr0(unsigned long cr0)
677 {
678         struct multicall_space mcs;
679
680         percpu_write(xen_cr0_value, cr0);
681
682         /* Only pay attention to cr0.TS; everything else is
683            ignored. */
684         mcs = xen_mc_entry(0);
685
686         MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);
687
688         xen_mc_issue(PARAVIRT_LAZY_CPU);
689 }
690
691 static void xen_write_cr4(unsigned long cr4)
692 {
693         cr4 &= ~X86_CR4_PGE;
694         cr4 &= ~X86_CR4_PSE;
695
696         native_write_cr4(cr4);
697 }
698
699 static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
700 {
701         int ret;
702
703         ret = 0;
704
705         switch (msr) {
706 #ifdef CONFIG_X86_64
707                 unsigned which;
708                 u64 base;
709
710         case MSR_FS_BASE:               which = SEGBASE_FS; goto set;
711         case MSR_KERNEL_GS_BASE:        which = SEGBASE_GS_USER; goto set;
712         case MSR_GS_BASE:               which = SEGBASE_GS_KERNEL; goto set;
713
714         set:
715                 base = ((u64)high << 32) | low;
716                 if (HYPERVISOR_set_segment_base(which, base) != 0)
717                         ret = -EIO;
718                 break;
719 #endif
720
721         case MSR_STAR:
722         case MSR_CSTAR:
723         case MSR_LSTAR:
724         case MSR_SYSCALL_MASK:
725         case MSR_IA32_SYSENTER_CS:
726         case MSR_IA32_SYSENTER_ESP:
727         case MSR_IA32_SYSENTER_EIP:
728                 /* Fast syscall setup is all done in hypercalls, so
729                    these are all ignored.  Stub them out here to stop
730                    Xen console noise. */
731                 break;
732
733         default:
734                 ret = native_write_msr_safe(msr, low, high);
735         }
736
737         return ret;
738 }
739
740 void xen_setup_shared_info(void)
741 {
742         if (!xen_feature(XENFEAT_auto_translated_physmap)) {
743                 set_fixmap(FIX_PARAVIRT_BOOTMAP,
744                            xen_start_info->shared_info);
745
746                 HYPERVISOR_shared_info =
747                         (struct shared_info *)fix_to_virt(FIX_PARAVIRT_BOOTMAP);
748         } else
749                 HYPERVISOR_shared_info =
750                         (struct shared_info *)__va(xen_start_info->shared_info);
751
752 #ifndef CONFIG_SMP
753         /* In UP this is as good a place as any to set up shared info */
754         xen_setup_vcpu_info_placement();
755 #endif
756
757         xen_setup_mfn_list_list();
758 }
759
760 /* This is called once we have the cpu_possible_map */
761 void xen_setup_vcpu_info_placement(void)
762 {
763         int cpu;
764
765         for_each_possible_cpu(cpu)
766                 xen_vcpu_setup(cpu);
767
768         /* xen_vcpu_setup managed to place the vcpu_info within the
769            percpu area for all cpus, so make use of it */
770         if (have_vcpu_info_placement) {
771                 printk(KERN_INFO "Xen: using vcpu_info placement\n");
772
773                 pv_irq_ops.save_fl = __PV_IS_CALLEE_SAVE(xen_save_fl_direct);
774                 pv_irq_ops.restore_fl = __PV_IS_CALLEE_SAVE(xen_restore_fl_direct);
775                 pv_irq_ops.irq_disable = __PV_IS_CALLEE_SAVE(xen_irq_disable_direct);
776                 pv_irq_ops.irq_enable = __PV_IS_CALLEE_SAVE(xen_irq_enable_direct);
777                 pv_mmu_ops.read_cr2 = xen_read_cr2_direct;
778         }
779 }
780
781 static unsigned xen_patch(u8 type, u16 clobbers, void *insnbuf,
782                           unsigned long addr, unsigned len)
783 {
784         char *start, *end, *reloc;
785         unsigned ret;
786
787         start = end = reloc = NULL;
788
789 #define SITE(op, x)                                                     \
790         case PARAVIRT_PATCH(op.x):                                      \
791         if (have_vcpu_info_placement) {                                 \
792                 start = (char *)xen_##x##_direct;                       \
793                 end = xen_##x##_direct_end;                             \
794                 reloc = xen_##x##_direct_reloc;                         \
795         }                                                               \
796         goto patch_site
797
798         switch (type) {
799                 SITE(pv_irq_ops, irq_enable);
800                 SITE(pv_irq_ops, irq_disable);
801                 SITE(pv_irq_ops, save_fl);
802                 SITE(pv_irq_ops, restore_fl);
803 #undef SITE
804
805         patch_site:
806                 if (start == NULL || (end-start) > len)
807                         goto default_patch;
808
809                 ret = paravirt_patch_insns(insnbuf, len, start, end);
810
811                 /* Note: because reloc is assigned from something that
812                    appears to be an array, gcc assumes it's non-null,
813                    but doesn't know its relationship with start and
814                    end. */
815                 if (reloc > start && reloc < end) {
816                         int reloc_off = reloc - start;
817                         long *relocp = (long *)(insnbuf + reloc_off);
818                         long delta = start - (char *)addr;
819
820                         *relocp += delta;
821                 }
822                 break;
823
824         default_patch:
825         default:
826                 ret = paravirt_patch_default(type, clobbers, insnbuf,
827                                              addr, len);
828                 break;
829         }
830
831         return ret;
832 }
833
834 static const struct pv_info xen_info __initdata = {
835         .paravirt_enabled = 1,
836         .shared_kernel_pmd = 0,
837
838         .name = "Xen",
839 };
840
841 static const struct pv_init_ops xen_init_ops __initdata = {
842         .patch = xen_patch,
843
844         .banner = xen_banner,
845         .memory_setup = xen_memory_setup,
846         .arch_setup = xen_arch_setup,
847         .post_allocator_init = xen_post_allocator_init,
848 };
849
850 static const struct pv_time_ops xen_time_ops __initdata = {
851         .time_init = xen_time_init,
852
853         .set_wallclock = xen_set_wallclock,
854         .get_wallclock = xen_get_wallclock,
855         .get_tsc_khz = xen_tsc_khz,
856         .sched_clock = xen_sched_clock,
857 };
858
859 static const struct pv_cpu_ops xen_cpu_ops __initdata = {
860         .cpuid = xen_cpuid,
861
862         .set_debugreg = xen_set_debugreg,
863         .get_debugreg = xen_get_debugreg,
864
865         .clts = xen_clts,
866
867         .read_cr0 = xen_read_cr0,
868         .write_cr0 = xen_write_cr0,
869
870         .read_cr4 = native_read_cr4,
871         .read_cr4_safe = native_read_cr4_safe,
872         .write_cr4 = xen_write_cr4,
873
874         .wbinvd = native_wbinvd,
875
876         .read_msr = native_read_msr_safe,
877         .write_msr = xen_write_msr_safe,
878         .read_tsc = native_read_tsc,
879         .read_pmc = native_read_pmc,
880
881         .iret = xen_iret,
882         .irq_enable_sysexit = xen_sysexit,
883 #ifdef CONFIG_X86_64
884         .usergs_sysret32 = xen_sysret32,
885         .usergs_sysret64 = xen_sysret64,
886 #endif
887
888         .load_tr_desc = paravirt_nop,
889         .set_ldt = xen_set_ldt,
890         .load_gdt = xen_load_gdt,
891         .load_idt = xen_load_idt,
892         .load_tls = xen_load_tls,
893 #ifdef CONFIG_X86_64
894         .load_gs_index = xen_load_gs_index,
895 #endif
896
897         .alloc_ldt = xen_alloc_ldt,
898         .free_ldt = xen_free_ldt,
899
900         .store_gdt = native_store_gdt,
901         .store_idt = native_store_idt,
902         .store_tr = xen_store_tr,
903
904         .write_ldt_entry = xen_write_ldt_entry,
905         .write_gdt_entry = xen_write_gdt_entry,
906         .write_idt_entry = xen_write_idt_entry,
907         .load_sp0 = xen_load_sp0,
908
909         .set_iopl_mask = xen_set_iopl_mask,
910         .io_delay = xen_io_delay,
911
912         /* Xen takes care of %gs when switching to usermode for us */
913         .swapgs = paravirt_nop,
914
915         .start_context_switch = paravirt_start_context_switch,
916         .end_context_switch = xen_end_context_switch,
917 };
918
919 static const struct pv_apic_ops xen_apic_ops __initdata = {
920 #ifdef CONFIG_X86_LOCAL_APIC
921         .setup_boot_clock = paravirt_nop,
922         .setup_secondary_clock = paravirt_nop,
923         .startup_ipi_hook = paravirt_nop,
924 #endif
925 };
926
927 static void xen_reboot(int reason)
928 {
929         struct sched_shutdown r = { .reason = reason };
930
931 #ifdef CONFIG_SMP
932         smp_send_stop();
933 #endif
934
935         if (HYPERVISOR_sched_op(SCHEDOP_shutdown, &r))
936                 BUG();
937 }
938
939 static void xen_restart(char *msg)
940 {
941         xen_reboot(SHUTDOWN_reboot);
942 }
943
944 static void xen_emergency_restart(void)
945 {
946         xen_reboot(SHUTDOWN_reboot);
947 }
948
949 static void xen_machine_halt(void)
950 {
951         xen_reboot(SHUTDOWN_poweroff);
952 }
953
954 static void xen_crash_shutdown(struct pt_regs *regs)
955 {
956         xen_reboot(SHUTDOWN_crash);
957 }
958
959 static const struct machine_ops __initdata xen_machine_ops = {
960         .restart = xen_restart,
961         .halt = xen_machine_halt,
962         .power_off = xen_machine_halt,
963         .shutdown = xen_machine_halt,
964         .crash_shutdown = xen_crash_shutdown,
965         .emergency_restart = xen_emergency_restart,
966 };
967
968 /* First C function to be called on Xen boot */
969 asmlinkage void __init xen_start_kernel(void)
970 {
971         pgd_t *pgd;
972
973         if (!xen_start_info)
974                 return;
975
976         xen_domain_type = XEN_PV_DOMAIN;
977
978         /* Install Xen paravirt ops */
979         pv_info = xen_info;
980         pv_init_ops = xen_init_ops;
981         pv_time_ops = xen_time_ops;
982         pv_cpu_ops = xen_cpu_ops;
983         pv_apic_ops = xen_apic_ops;
984         pv_mmu_ops = xen_mmu_ops;
985
986 #ifdef CONFIG_X86_64
987         /*
988          * Setup percpu state.  We only need to do this for 64-bit
989          * because 32-bit already has %fs set properly.
990          */
991         load_percpu_segment(0);
992 #endif
993
994         xen_init_irq_ops();
995         xen_init_cpuid_mask();
996
997 #ifdef CONFIG_X86_LOCAL_APIC
998         /*
999          * set up the basic apic ops.
1000          */
1001         set_xen_basic_apic_ops();
1002 #endif
1003
1004         xen_setup_features();
1005
1006         if (xen_feature(XENFEAT_mmu_pt_update_preserve_ad)) {
1007                 pv_mmu_ops.ptep_modify_prot_start = xen_ptep_modify_prot_start;
1008                 pv_mmu_ops.ptep_modify_prot_commit = xen_ptep_modify_prot_commit;
1009         }
1010
1011         machine_ops = xen_machine_ops;
1012
1013         /*
1014          * The only reliable way to retain the initial address of the
1015          * percpu gdt_page is to remember it here, so we can go and
1016          * mark it RW later, when the initial percpu area is freed.
1017          */
1018         xen_initial_gdt = &per_cpu(gdt_page, 0);
1019
1020         xen_smp_init();
1021
1022         /* Get mfn list */
1023         if (!xen_feature(XENFEAT_auto_translated_physmap))
1024                 xen_build_dynamic_phys_to_machine();
1025
1026         pgd = (pgd_t *)xen_start_info->pt_base;
1027
1028         /* Prevent unwanted bits from being set in PTEs. */
1029         __supported_pte_mask &= ~_PAGE_GLOBAL;
1030         if (!xen_initial_domain())
1031                 __supported_pte_mask &= ~(_PAGE_PWT | _PAGE_PCD);
1032
1033 #ifdef CONFIG_X86_64
1034         /* Work out if we support NX */
1035         check_efer();
1036 #endif
1037
1038         /* Don't do the full vcpu_info placement stuff until we have a
1039            possible map and a non-dummy shared_info. */
1040         per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
1041
1042         local_irq_disable();
1043         early_boot_irqs_off();
1044
1045         xen_raw_console_write("mapping kernel into physical memory\n");
1046         pgd = xen_setup_kernel_pagetable(pgd, xen_start_info->nr_pages);
1047
1048         init_mm.pgd = pgd;
1049
1050         /* keep using Xen gdt for now; no urgent need to change it */
1051
1052         pv_info.kernel_rpl = 1;
1053         if (xen_feature(XENFEAT_supervisor_mode_kernel))
1054                 pv_info.kernel_rpl = 0;
1055
1056         /* set the limit of our address space */
1057         xen_reserve_top();
1058
1059 #ifdef CONFIG_X86_32
1060         /* set up basic CPUID stuff */
1061         cpu_detect(&new_cpu_data);
1062         new_cpu_data.hard_math = 1;
1063         new_cpu_data.wp_works_ok = 1;
1064         new_cpu_data.x86_capability[0] = cpuid_edx(1);
1065 #endif
1066
1067         /* Poke various useful things into boot_params */
1068         boot_params.hdr.type_of_loader = (9 << 4) | 0;
1069         boot_params.hdr.ramdisk_image = xen_start_info->mod_start
1070                 ? __pa(xen_start_info->mod_start) : 0;
1071         boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
1072         boot_params.hdr.cmd_line_ptr = __pa(xen_start_info->cmd_line);
1073
1074         if (!xen_initial_domain()) {
1075                 add_preferred_console("xenboot", 0, NULL);
1076                 add_preferred_console("tty", 0, NULL);
1077                 add_preferred_console("hvc", 0, NULL);
1078         }
1079
1080         xen_raw_console_write("about to get started...\n");
1081
1082         /* Start the world */
1083 #ifdef CONFIG_X86_32
1084         i386_start_kernel();
1085 #else
1086         x86_64_start_reservations((char *)__pa_symbol(&boot_params));
1087 #endif
1088 }