arch/x86/xen/enlighten_pv.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Core of Xen paravirt_ops implementation.
   4  *
   5  * This file contains the xen_paravirt_ops structure itself, and the
   6  * implementations for:
   7  * - privileged instructions
   8  * - interrupt flags
   9  * - segment operations
  10  * - booting and setup
  11  *
  12  * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
  13  */
  14
  15 #include <linux/cpu.h>
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/smp.h>
  19 #include <linux/preempt.h>
  20 #include <linux/hardirq.h>
  21 #include <linux/percpu.h>
  22 #include <linux/delay.h>
  23 #include <linux/start_kernel.h>
  24 #include <linux/sched.h>
  25 #include <linux/kprobes.h>
  26 #include <linux/memblock.h>
  27 #include <linux/export.h>
  28 #include <linux/mm.h>
  29 #include <linux/page-flags.h>
  30 #include <linux/highmem.h>
  31 #include <linux/console.h>
  32 #include <linux/pci.h>
  33 #include <linux/gfp.h>
  34 #include <linux/edd.h>
  35 #include <linux/objtool.h>
  36
  37 #include <xen/xen.h>
  38 #include <xen/events.h>
  39 #include <xen/interface/xen.h>
  40 #include <xen/interface/version.h>
  41 #include <xen/interface/physdev.h>
  42 #include <xen/interface/vcpu.h>
  43 #include <xen/interface/memory.h>
  44 #include <xen/interface/nmi.h>
  45 #include <xen/interface/xen-mca.h>
  46 #include <xen/features.h>
  47 #include <xen/page.h>
  48 #include <xen/hvc-console.h>
  49 #include <xen/acpi.h>
  50
  51 #include <asm/paravirt.h>
  52 #include <asm/apic.h>
  53 #include <asm/page.h>
  54 #include <asm/xen/pci.h>
  55 #include <asm/xen/hypercall.h>
  56 #include <asm/xen/hypervisor.h>
  57 #include <asm/xen/cpuid.h>
  58 #include <asm/fixmap.h>
  59 #include <asm/processor.h>
  60 #include <asm/proto.h>
  61 #include <asm/msr-index.h>
  62 #include <asm/traps.h>
  63 #include <asm/setup.h>
  64 #include <asm/desc.h>
  65 #include <asm/pgalloc.h>
  66 #include <asm/tlbflush.h>
  67 #include <asm/reboot.h>
  68 #include <asm/stackprotector.h>
  69 #include <asm/hypervisor.h>
  70 #include <asm/mach_traps.h>
  71 #include <asm/mwait.h>
  72 #include <asm/pci_x86.h>
  73 #include <asm/cpu.h>
  74 #ifdef CONFIG_X86_IOPL_IOPERM
  75 #include <asm/io_bitmap.h>
  76 #endif
  77
  78 #ifdef CONFIG_ACPI
  79 #include <linux/acpi.h>
  80 #include <asm/acpi.h>
  81 #include <acpi/pdc_intel.h>
  82 #include <acpi/processor.h>
  83 #include <xen/interface/platform.h>
  84 #endif
  85
  86 #include "xen-ops.h"
  87 #include "mmu.h"
  88 #include "smp.h"
  89 #include "multicalls.h"
  90 #include "pmu.h"
  91
  92 #include "../kernel/cpu/cpu.h" /* get_cpu_cap() */
  93
  94 void *xen_initial_gdt;
  95
  96 static int xen_cpu_up_prepare_pv(unsigned int cpu);
  97 static int xen_cpu_dead_pv(unsigned int cpu);
  98
  99 struct tls_descs {
 100         struct desc_struct desc[3];
 101 };
 102
 103 /*
 104  * Updating the 3 TLS descriptors in the GDT on every task switch is
 105  * surprisingly expensive so we avoid updating them if they haven't
 106  * changed.  Since Xen writes different descriptors than the one
 107  * passed in the update_descriptor hypercall we keep shadow copies to
 108  * compare against.
 109  */
 110 static DEFINE_PER_CPU(struct tls_descs, shadow_tls_desc);
 111
 112 static void __init xen_banner(void)
 113 {
 114         unsigned version = HYPERVISOR_xen_version(XENVER_version, NULL);
 115         struct xen_extraversion extra;
 116         HYPERVISOR_xen_version(XENVER_extraversion, &extra);
 117
 118         pr_info("Booting paravirtualized kernel on %s\n", pv_info.name);
 119         pr_info("Xen version: %d.%d%s (preserve-AD)\n",
 120                 version >> 16, version & 0xffff, extra.extraversion);
 121 }
 122
 123 static void __init xen_pv_init_platform(void)
 124 {
 125         populate_extra_pte(fix_to_virt(FIX_PARAVIRT_BOOTMAP));
 126
 127         set_fixmap(FIX_PARAVIRT_BOOTMAP, xen_start_info->shared_info);
 128         HYPERVISOR_shared_info = (void *)fix_to_virt(FIX_PARAVIRT_BOOTMAP);
 129
 130         /* xen clock uses per-cpu vcpu_info, need to init it for boot cpu */
 131         xen_vcpu_info_reset(0);
 132
 133         /* pvclock is in shared info area */
 134         xen_init_time_ops();
 135 }
 136
 137 static void __init xen_pv_guest_late_init(void)
 138 {
 139 #ifndef CONFIG_SMP
 140         /* Setup shared vcpu info for non-smp configurations */
 141         xen_setup_vcpu_info_placement();
 142 #endif
 143 }
 144
 145 static __read_mostly unsigned int cpuid_leaf5_ecx_val;
 146 static __read_mostly unsigned int cpuid_leaf5_edx_val;
 147
 148 static void xen_cpuid(unsigned int *ax, unsigned int *bx,
 149                       unsigned int *cx, unsigned int *dx)
 150 {
 151         unsigned maskebx = ~0;
 152
 153         /*
 154          * Mask out inconvenient features, to try and disable as many
 155          * unsupported kernel subsystems as possible.
 156          */
 157         switch (*ax) {
 158         case CPUID_MWAIT_LEAF:
 159                 /* Synthesize the values.. */
 160                 *ax = 0;
 161                 *bx = 0;
 162                 *cx = cpuid_leaf5_ecx_val;
 163                 *dx = cpuid_leaf5_edx_val;
 164                 return;
 165
 166         case 0xb:
 167                 /* Suppress extended topology stuff */
 168                 maskebx = 0;
 169                 break;
 170         }
 171
 172         asm(XEN_EMULATE_PREFIX "cpuid"
 173                 : "=a" (*ax),
 174                   "=b" (*bx),
 175                   "=c" (*cx),
 176                   "=d" (*dx)
 177                 : "0" (*ax), "2" (*cx));
 178
 179         *bx &= maskebx;
 180 }
 181 STACK_FRAME_NON_STANDARD(xen_cpuid); /* XEN_EMULATE_PREFIX */
 182
 183 static bool __init xen_check_mwait(void)
 184 {
 185 #ifdef CONFIG_ACPI
 186         struct xen_platform_op op = {
 187                 .cmd                    = XENPF_set_processor_pminfo,
 188                 .u.set_pminfo.id        = -1,
 189                 .u.set_pminfo.type      = XEN_PM_PDC,
 190         };
 191         uint32_t buf[3];
 192         unsigned int ax, bx, cx, dx;
 193         unsigned int mwait_mask;
 194
 195         /* We need to determine whether it is OK to expose the MWAIT
 196          * capability to the kernel to harvest deeper than C3 states from ACPI
 197          * _CST using the processor_harvest_xen.c module. For this to work, we
 198          * need to gather the MWAIT_LEAF values (which the cstate.c code
 199          * checks against). The hypervisor won't expose the MWAIT flag because
 200          * it would break backwards compatibility; so we will find out directly
 201          * from the hardware and hypercall.
 202          */
 203         if (!xen_initial_domain())
 204                 return false;
 205
 206         /*
 207          * When running under platform earlier than Xen4.2, do not expose
 208          * mwait, to avoid the risk of loading native acpi pad driver
 209          */
 210         if (!xen_running_on_version_or_later(4, 2))
 211                 return false;
 212
 213         ax = 1;
 214         cx = 0;
 215
 216         native_cpuid(&ax, &bx, &cx, &dx);
 217
 218         mwait_mask = (1 << (X86_FEATURE_EST % 32)) |
 219                      (1 << (X86_FEATURE_MWAIT % 32));
 220
 221         if ((cx & mwait_mask) != mwait_mask)
 222                 return false;
 223
 224         /* We need to emulate the MWAIT_LEAF and for that we need both
 225          * ecx and edx. The hypercall provides only partial information.
 226          */
 227
 228         ax = CPUID_MWAIT_LEAF;
 229         bx = 0;
 230         cx = 0;
 231         dx = 0;
 232
 233         native_cpuid(&ax, &bx, &cx, &dx);
 234
 235         /* Ask the Hypervisor whether to clear ACPI_PDC_C_C2C3_FFH. If so,
 236          * don't expose MWAIT_LEAF and let ACPI pick the IOPORT version of C3.
 237          */
 238         buf[0] = ACPI_PDC_REVISION_ID;
 239         buf[1] = 1;
 240         buf[2] = (ACPI_PDC_C_CAPABILITY_SMP | ACPI_PDC_EST_CAPABILITY_SWSMP);
 241
 242         set_xen_guest_handle(op.u.set_pminfo.pdc, buf);
 243
 244         if ((HYPERVISOR_platform_op(&op) == 0) &&
 245             (buf[2] & (ACPI_PDC_C_C1_FFH | ACPI_PDC_C_C2C3_FFH))) {
 246                 cpuid_leaf5_ecx_val = cx;
 247                 cpuid_leaf5_edx_val = dx;
 248         }
 249         return true;
 250 #else
 251         return false;
 252 #endif
 253 }
 254
 255 static bool __init xen_check_xsave(void)
 256 {
 257         unsigned int cx, xsave_mask;
 258
 259         cx = cpuid_ecx(1);
 260
 261         xsave_mask = (1 << (X86_FEATURE_XSAVE % 32)) |
 262                      (1 << (X86_FEATURE_OSXSAVE % 32));
 263
 264         /* Xen will set CR4.OSXSAVE if supported and not disabled by force */
 265         return (cx & xsave_mask) == xsave_mask;
 266 }
 267
 268 static void __init xen_init_capabilities(void)
 269 {
 270         setup_force_cpu_cap(X86_FEATURE_XENPV);
 271         setup_clear_cpu_cap(X86_FEATURE_DCA);
 272         setup_clear_cpu_cap(X86_FEATURE_APERFMPERF);
 273         setup_clear_cpu_cap(X86_FEATURE_MTRR);
 274         setup_clear_cpu_cap(X86_FEATURE_ACC);
 275         setup_clear_cpu_cap(X86_FEATURE_X2APIC);
 276         setup_clear_cpu_cap(X86_FEATURE_SME);
 277
 278         /*
 279          * Xen PV would need some work to support PCID: CR3 handling as well
 280          * as xen_flush_tlb_others() would need updating.
 281          */
 282         setup_clear_cpu_cap(X86_FEATURE_PCID);
 283
 284         if (!xen_initial_domain())
 285                 setup_clear_cpu_cap(X86_FEATURE_ACPI);
 286
 287         if (xen_check_mwait())
 288                 setup_force_cpu_cap(X86_FEATURE_MWAIT);
 289         else
 290                 setup_clear_cpu_cap(X86_FEATURE_MWAIT);
 291
 292         if (!xen_check_xsave()) {
 293                 setup_clear_cpu_cap(X86_FEATURE_XSAVE);
 294                 setup_clear_cpu_cap(X86_FEATURE_OSXSAVE);
 295         }
 296 }
 297
 298 static void xen_set_debugreg(int reg, unsigned long val)
 299 {
 300         HYPERVISOR_set_debugreg(reg, val);
 301 }
 302
 303 static unsigned long xen_get_debugreg(int reg)
 304 {
 305         return HYPERVISOR_get_debugreg(reg);
 306 }
 307
 308 static void xen_end_context_switch(struct task_struct *next)
 309 {
 310         xen_mc_flush();
 311         paravirt_end_context_switch(next);
 312 }
 313
 314 static unsigned long xen_store_tr(void)
 315 {
 316         return 0;
 317 }
 318
 319 /*
 320  * Set the page permissions for a particular virtual address.  If the
 321  * address is a vmalloc mapping (or other non-linear mapping), then
 322  * find the linear mapping of the page and also set its protections to
 323  * match.
 324  */
 325 static void set_aliased_prot(void *v, pgprot_t prot)
 326 {
 327         int level;
 328         pte_t *ptep;
 329         pte_t pte;
 330         unsigned long pfn;
 331         unsigned char dummy;
 332         void *va;
 333
 334         ptep = lookup_address((unsigned long)v, &level);
 335         BUG_ON(ptep == NULL);
 336
 337         pfn = pte_pfn(*ptep);
 338         pte = pfn_pte(pfn, prot);
 339
 340         /*
 341          * Careful: update_va_mapping() will fail if the virtual address
 342          * we're poking isn't populated in the page tables.  We don't
 343          * need to worry about the direct map (that's always in the page
 344          * tables), but we need to be careful about vmap space.  In
 345          * particular, the top level page table can lazily propagate
 346          * entries between processes, so if we've switched mms since we
 347          * vmapped the target in the first place, we might not have the
 348          * top-level page table entry populated.
 349          *
 350          * We disable preemption because we want the same mm active when
 351          * we probe the target and when we issue the hypercall.  We'll
 352          * have the same nominal mm, but if we're a kernel thread, lazy
 353          * mm dropping could change our pgd.
 354          *
 355          * Out of an abundance of caution, this uses __get_user() to fault
 356          * in the target address just in case there's some obscure case
 357          * in which the target address isn't readable.
 358          */
 359
 360         preempt_disable();
 361
 362         copy_from_kernel_nofault(&dummy, v, 1);
 363
 364         if (HYPERVISOR_update_va_mapping((unsigned long)v, pte, 0))
 365                 BUG();
 366
 367         va = __va(PFN_PHYS(pfn));
 368
 369         if (va != v && HYPERVISOR_update_va_mapping((unsigned long)va, pte, 0))
 370                 BUG();
 371
 372         preempt_enable();
 373 }
 374
 375 static void xen_alloc_ldt(struct desc_struct *ldt, unsigned entries)
 376 {
 377         const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
 378         int i;
 379
 380         /*
 381          * We need to mark the all aliases of the LDT pages RO.  We
 382          * don't need to call vm_flush_aliases(), though, since that's
 383          * only responsible for flushing aliases out the TLBs, not the
 384          * page tables, and Xen will flush the TLB for us if needed.
 385          *
 386          * To avoid confusing future readers: none of this is necessary
 387          * to load the LDT.  The hypervisor only checks this when the
 388          * LDT is faulted in due to subsequent descriptor access.
 389          */
 390
 391         for (i = 0; i < entries; i += entries_per_page)
 392                 set_aliased_prot(ldt + i, PAGE_KERNEL_RO);
 393 }
 394
 395 static void xen_free_ldt(struct desc_struct *ldt, unsigned entries)
 396 {
 397         const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
 398         int i;
 399
 400         for (i = 0; i < entries; i += entries_per_page)
 401                 set_aliased_prot(ldt + i, PAGE_KERNEL);
 402 }
 403
 404 static void xen_set_ldt(const void *addr, unsigned entries)
 405 {
 406         struct mmuext_op *op;
 407         struct multicall_space mcs = xen_mc_entry(sizeof(*op));
 408
 409         trace_xen_cpu_set_ldt(addr, entries);
 410
 411         op = mcs.args;
 412         op->cmd = MMUEXT_SET_LDT;
 413         op->arg1.linear_addr = (unsigned long)addr;
 414         op->arg2.nr_ents = entries;
 415
 416         MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
 417
 418         xen_mc_issue(PARAVIRT_LAZY_CPU);
 419 }
 420
 421 static void xen_load_gdt(const struct desc_ptr *dtr)
 422 {
 423         unsigned long va = dtr->address;
 424         unsigned int size = dtr->size + 1;
 425         unsigned long pfn, mfn;
 426         int level;
 427         pte_t *ptep;
 428         void *virt;
 429
 430         /* @size should be at most GDT_SIZE which is smaller than PAGE_SIZE. */
 431         BUG_ON(size > PAGE_SIZE);
 432         BUG_ON(va & ~PAGE_MASK);
 433
 434         /*
 435          * The GDT is per-cpu and is in the percpu data area.
 436          * That can be virtually mapped, so we need to do a
 437          * page-walk to get the underlying MFN for the
 438          * hypercall.  The page can also be in the kernel's
 439          * linear range, so we need to RO that mapping too.
 440          */
 441         ptep = lookup_address(va, &level);
 442         BUG_ON(ptep == NULL);
 443
 444         pfn = pte_pfn(*ptep);
 445         mfn = pfn_to_mfn(pfn);
 446         virt = __va(PFN_PHYS(pfn));
 447
 448         make_lowmem_page_readonly((void *)va);
 449         make_lowmem_page_readonly(virt);
 450
 451         if (HYPERVISOR_set_gdt(&mfn, size / sizeof(struct desc_struct)))
 452                 BUG();
 453 }
 454
 455 /*
 456  * load_gdt for early boot, when the gdt is only mapped once
 457  */
 458 static void __init xen_load_gdt_boot(const struct desc_ptr *dtr)
 459 {
 460         unsigned long va = dtr->address;
 461         unsigned int size = dtr->size + 1;
 462         unsigned long pfn, mfn;
 463         pte_t pte;
 464
 465         /* @size should be at most GDT_SIZE which is smaller than PAGE_SIZE. */
 466         BUG_ON(size > PAGE_SIZE);
 467         BUG_ON(va & ~PAGE_MASK);
 468
 469         pfn = virt_to_pfn(va);
 470         mfn = pfn_to_mfn(pfn);
 471
 472         pte = pfn_pte(pfn, PAGE_KERNEL_RO);
 473
 474         if (HYPERVISOR_update_va_mapping((unsigned long)va, pte, 0))
 475                 BUG();
 476
 477         if (HYPERVISOR_set_gdt(&mfn, size / sizeof(struct desc_struct)))
 478                 BUG();
 479 }
 480
 481 static inline bool desc_equal(const struct desc_struct *d1,
 482                               const struct desc_struct *d2)
 483 {
 484         return !memcmp(d1, d2, sizeof(*d1));
 485 }
 486
 487 static void load_TLS_descriptor(struct thread_struct *t,
 488                                 unsigned int cpu, unsigned int i)
 489 {
 490         struct desc_struct *shadow = &per_cpu(shadow_tls_desc, cpu).desc[i];
 491         struct desc_struct *gdt;
 492         xmaddr_t maddr;
 493         struct multicall_space mc;
 494
 495         if (desc_equal(shadow, &t->tls_array[i]))
 496                 return;
 497
 498         *shadow = t->tls_array[i];
 499
 500         gdt = get_cpu_gdt_rw(cpu);
 501         maddr = arbitrary_virt_to_machine(&gdt[GDT_ENTRY_TLS_MIN+i]);
 502         mc = __xen_mc_entry(0);
 503
 504         MULTI_update_descriptor(mc.mc, maddr.maddr, t->tls_array[i]);
 505 }
 506
 507 static void xen_load_tls(struct thread_struct *t, unsigned int cpu)
 508 {
 509         /*
 510          * In lazy mode we need to zero %fs, otherwise we may get an
 511          * exception between the new %fs descriptor being loaded and
 512          * %fs being effectively cleared at __switch_to().
 513          */
 514         if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU)
 515                 loadsegment(fs, 0);
 516
 517         xen_mc_batch();
 518
 519         load_TLS_descriptor(t, cpu, 0);
 520         load_TLS_descriptor(t, cpu, 1);
 521         load_TLS_descriptor(t, cpu, 2);
 522
 523         xen_mc_issue(PARAVIRT_LAZY_CPU);
 524 }
 525
 526 static void xen_load_gs_index(unsigned int idx)
 527 {
 528         if (HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, idx))
 529                 BUG();
 530 }
 531
 532 static void xen_write_ldt_entry(struct desc_struct *dt, int entrynum,
 533                                 const void *ptr)
 534 {
 535         xmaddr_t mach_lp = arbitrary_virt_to_machine(&dt[entrynum]);
 536         u64 entry = *(u64 *)ptr;
 537
 538         trace_xen_cpu_write_ldt_entry(dt, entrynum, entry);
 539
 540         preempt_disable();
 541
 542         xen_mc_flush();
 543         if (HYPERVISOR_update_descriptor(mach_lp.maddr, entry))
 544                 BUG();
 545
 546         preempt_enable();
 547 }
 548
 549 void noist_exc_debug(struct pt_regs *regs);
 550
 551 DEFINE_IDTENTRY_RAW(xenpv_exc_nmi)
 552 {
 553         /* On Xen PV, NMI doesn't use IST.  The C part is the same as native. */
 554         exc_nmi(regs);
 555 }
 556
 557 DEFINE_IDTENTRY_RAW_ERRORCODE(xenpv_exc_double_fault)
 558 {
 559         /* On Xen PV, DF doesn't use IST.  The C part is the same as native. */
 560         exc_double_fault(regs, error_code);
 561 }
 562
 563 DEFINE_IDTENTRY_RAW(xenpv_exc_debug)
 564 {
 565         /*
 566          * There's no IST on Xen PV, but we still need to dispatch
 567          * to the correct handler.
 568          */
 569         if (user_mode(regs))
 570                 noist_exc_debug(regs);
 571         else
 572                 exc_debug(regs);
 573 }
 574
 575 DEFINE_IDTENTRY_RAW(exc_xen_unknown_trap)
 576 {
 577         /* This should never happen and there is no way to handle it. */
 578         instrumentation_begin();
 579         pr_err("Unknown trap in Xen PV mode.");
 580         BUG();
 581         instrumentation_end();
 582 }
 583
 584 #ifdef CONFIG_X86_MCE
 585 DEFINE_IDTENTRY_RAW(xenpv_exc_machine_check)
 586 {
 587         /*
 588          * There's no IST on Xen PV, but we still need to dispatch
 589          * to the correct handler.
 590          */
 591         if (user_mode(regs))
 592                 noist_exc_machine_check(regs);
 593         else
 594                 exc_machine_check(regs);
 595 }
 596 #endif
 597
 598 struct trap_array_entry {
 599         void (*orig)(void);
 600         void (*xen)(void);
 601         bool ist_okay;
 602 };
 603
 604 #define TRAP_ENTRY(func, ist_ok) {                      \
 605         .orig           = asm_##func,                   \
 606         .xen            = xen_asm_##func,               \
 607         .ist_okay       = ist_ok }
 608
 609 #define TRAP_ENTRY_REDIR(func, ist_ok) {                \
 610         .orig           = asm_##func,                   \
 611         .xen            = xen_asm_xenpv_##func,         \
 612         .ist_okay       = ist_ok }
 613
 614 static struct trap_array_entry trap_array[] = {
 615         TRAP_ENTRY_REDIR(exc_debug,                     true  ),
 616         TRAP_ENTRY_REDIR(exc_double_fault,              true  ),
 617 #ifdef CONFIG_X86_MCE
 618         TRAP_ENTRY_REDIR(exc_machine_check,             true  ),
 619 #endif
 620         TRAP_ENTRY_REDIR(exc_nmi,                       true  ),
 621         TRAP_ENTRY(exc_int3,                            false ),
 622         TRAP_ENTRY(exc_overflow,                        false ),
 623 #ifdef CONFIG_IA32_EMULATION
 624         { entry_INT80_compat,          xen_entry_INT80_compat,          false },
 625 #endif
 626         TRAP_ENTRY(exc_page_fault,                      false ),
 627         TRAP_ENTRY(exc_divide_error,                    false ),
 628         TRAP_ENTRY(exc_bounds,                          false ),
 629         TRAP_ENTRY(exc_invalid_op,                      false ),
 630         TRAP_ENTRY(exc_device_not_available,            false ),
 631         TRAP_ENTRY(exc_coproc_segment_overrun,          false ),
 632         TRAP_ENTRY(exc_invalid_tss,                     false ),
 633         TRAP_ENTRY(exc_segment_not_present,             false ),
 634         TRAP_ENTRY(exc_stack_segment,                   false ),
 635         TRAP_ENTRY(exc_general_protection,              false ),
 636         TRAP_ENTRY(exc_spurious_interrupt_bug,          false ),
 637         TRAP_ENTRY(exc_coprocessor_error,               false ),
 638         TRAP_ENTRY(exc_alignment_check,                 false ),
 639         TRAP_ENTRY(exc_simd_coprocessor_error,          false ),
 640 };
 641
 642 static bool __ref get_trap_addr(void **addr, unsigned int ist)
 643 {
 644         unsigned int nr;
 645         bool ist_okay = false;
 646         bool found = false;
 647
 648         /*
 649          * Replace trap handler addresses by Xen specific ones.
 650          * Check for known traps using IST and whitelist them.
 651          * The debugger ones are the only ones we care about.
 652          * Xen will handle faults like double_fault, so we should never see
 653          * them.  Warn if there's an unexpected IST-using fault handler.
 654          */
 655         for (nr = 0; nr < ARRAY_SIZE(trap_array); nr++) {
 656                 struct trap_array_entry *entry = trap_array + nr;
 657
 658                 if (*addr == entry->orig) {
 659                         *addr = entry->xen;
 660                         ist_okay = entry->ist_okay;
 661                         found = true;
 662                         break;
 663                 }
 664         }
 665
 666         if (nr == ARRAY_SIZE(trap_array) &&
 667             *addr >= (void *)early_idt_handler_array[0] &&
 668             *addr < (void *)early_idt_handler_array[NUM_EXCEPTION_VECTORS]) {
 669                 nr = (*addr - (void *)early_idt_handler_array[0]) /
 670                      EARLY_IDT_HANDLER_SIZE;
 671                 *addr = (void *)xen_early_idt_handler_array[nr];
 672                 found = true;
 673         }
 674
 675         if (!found)
 676                 *addr = (void *)xen_asm_exc_xen_unknown_trap;
 677
 678         if (WARN_ON(found && ist != 0 && !ist_okay))
 679                 return false;
 680
 681         return true;
 682 }
 683
 684 static int cvt_gate_to_trap(int vector, const gate_desc *val,
 685                             struct trap_info *info)
 686 {
 687         unsigned long addr;
 688
 689         if (val->bits.type != GATE_TRAP && val->bits.type != GATE_INTERRUPT)
 690                 return 0;
 691
 692         info->vector = vector;
 693
 694         addr = gate_offset(val);
 695         if (!get_trap_addr((void **)&addr, val->bits.ist))
 696                 return 0;
 697         info->address = addr;
 698
 699         info->cs = gate_segment(val);
 700         info->flags = val->bits.dpl;
 701         /* interrupt gates clear IF */
 702         if (val->bits.type == GATE_INTERRUPT)
 703                 info->flags |= 1 << 2;
 704
 705         return 1;
 706 }
 707
 708 /* Locations of each CPU's IDT */
 709 static DEFINE_PER_CPU(struct desc_ptr, idt_desc);
 710
 711 /* Set an IDT entry.  If the entry is part of the current IDT, then
 712    also update Xen. */
 713 static void xen_write_idt_entry(gate_desc *dt, int entrynum, const gate_desc *g)
 714 {
 715         unsigned long p = (unsigned long)&dt[entrynum];
 716         unsigned long start, end;
 717
 718         trace_xen_cpu_write_idt_entry(dt, entrynum, g);
 719
 720         preempt_disable();
 721
 722         start = __this_cpu_read(idt_desc.address);
 723         end = start + __this_cpu_read(idt_desc.size) + 1;
 724
 725         xen_mc_flush();
 726
 727         native_write_idt_entry(dt, entrynum, g);
 728
 729         if (p >= start && (p + 8) <= end) {
 730                 struct trap_info info[2];
 731
 732                 info[1].address = 0;
 733
 734                 if (cvt_gate_to_trap(entrynum, g, &info[0]))
 735                         if (HYPERVISOR_set_trap_table(info))
 736                                 BUG();
 737         }
 738
 739         preempt_enable();
 740 }
 741
 742 static unsigned xen_convert_trap_info(const struct desc_ptr *desc,
 743                                       struct trap_info *traps, bool full)
 744 {
 745         unsigned in, out, count;
 746
 747         count = (desc->size+1) / sizeof(gate_desc);
 748         BUG_ON(count > 256);
 749
 750         for (in = out = 0; in < count; in++) {
 751                 gate_desc *entry = (gate_desc *)(desc->address) + in;
 752
 753                 if (cvt_gate_to_trap(in, entry, &traps[out]) || full)
 754                         out++;
 755         }
 756
 757         return out;
 758 }
 759
 760 void xen_copy_trap_info(struct trap_info *traps)
 761 {
 762         const struct desc_ptr *desc = this_cpu_ptr(&idt_desc);
 763
 764         xen_convert_trap_info(desc, traps, true);
 765 }
 766
 767 /* Load a new IDT into Xen.  In principle this can be per-CPU, so we
 768    hold a spinlock to protect the static traps[] array (static because
 769    it avoids allocation, and saves stack space). */
 770 static void xen_load_idt(const struct desc_ptr *desc)
 771 {
 772         static DEFINE_SPINLOCK(lock);
 773         static struct trap_info traps[257];
 774         unsigned out;
 775
 776         trace_xen_cpu_load_idt(desc);
 777
 778         spin_lock(&lock);
 779
 780         memcpy(this_cpu_ptr(&idt_desc), desc, sizeof(idt_desc));
 781
 782         out = xen_convert_trap_info(desc, traps, false);
 783         memset(&traps[out], 0, sizeof(traps[0]));
 784
 785         xen_mc_flush();
 786         if (HYPERVISOR_set_trap_table(traps))
 787                 BUG();
 788
 789         spin_unlock(&lock);
 790 }
 791
 792 /* Write a GDT descriptor entry.  Ignore LDT descriptors, since
 793    they're handled differently. */
 794 static void xen_write_gdt_entry(struct desc_struct *dt, int entry,
 795                                 const void *desc, int type)
 796 {
 797         trace_xen_cpu_write_gdt_entry(dt, entry, desc, type);
 798
 799         preempt_disable();
 800
 801         switch (type) {
 802         case DESC_LDT:
 803         case DESC_TSS:
 804                 /* ignore */
 805                 break;
 806
 807         default: {
 808                 xmaddr_t maddr = arbitrary_virt_to_machine(&dt[entry]);
 809
 810                 xen_mc_flush();
 811                 if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
 812                         BUG();
 813         }
 814
 815         }
 816
 817         preempt_enable();
 818 }
 819
 820 /*
 821  * Version of write_gdt_entry for use at early boot-time needed to
 822  * update an entry as simply as possible.
 823  */
 824 static void __init xen_write_gdt_entry_boot(struct desc_struct *dt, int entry,
 825                                             const void *desc, int type)
 826 {
 827         trace_xen_cpu_write_gdt_entry(dt, entry, desc, type);
 828
 829         switch (type) {
 830         case DESC_LDT:
 831         case DESC_TSS:
 832                 /* ignore */
 833                 break;
 834
 835         default: {
 836                 xmaddr_t maddr = virt_to_machine(&dt[entry]);
 837
 838                 if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
 839                         dt[entry] = *(struct desc_struct *)desc;
 840         }
 841
 842         }
 843 }
 844
 845 static void xen_load_sp0(unsigned long sp0)
 846 {
 847         struct multicall_space mcs;
 848
 849         mcs = xen_mc_entry(0);
 850         MULTI_stack_switch(mcs.mc, __KERNEL_DS, sp0);
 851         xen_mc_issue(PARAVIRT_LAZY_CPU);
 852         this_cpu_write(cpu_tss_rw.x86_tss.sp0, sp0);
 853 }
 854
 855 #ifdef CONFIG_X86_IOPL_IOPERM
 856 static void xen_invalidate_io_bitmap(void)
 857 {
 858         struct physdev_set_iobitmap iobitmap = {
 859                 .bitmap = NULL,
 860                 .nr_ports = 0,
 861         };
 862
 863         native_tss_invalidate_io_bitmap();
 864         HYPERVISOR_physdev_op(PHYSDEVOP_set_iobitmap, &iobitmap);
 865 }
 866
 867 static void xen_update_io_bitmap(void)
 868 {
 869         struct physdev_set_iobitmap iobitmap;
 870         struct tss_struct *tss = this_cpu_ptr(&cpu_tss_rw);
 871
 872         native_tss_update_io_bitmap();
 873
 874         iobitmap.bitmap = (uint8_t *)(&tss->x86_tss) +
 875                           tss->x86_tss.io_bitmap_base;
 876         if (tss->x86_tss.io_bitmap_base == IO_BITMAP_OFFSET_INVALID)
 877                 iobitmap.nr_ports = 0;
 878         else
 879                 iobitmap.nr_ports = IO_BITMAP_BITS;
 880
 881         HYPERVISOR_physdev_op(PHYSDEVOP_set_iobitmap, &iobitmap);
 882 }
 883 #endif
 884
 885 static void xen_io_delay(void)
 886 {
 887 }
 888
 889 static DEFINE_PER_CPU(unsigned long, xen_cr0_value);
 890
 891 static unsigned long xen_read_cr0(void)
 892 {
 893         unsigned long cr0 = this_cpu_read(xen_cr0_value);
 894
 895         if (unlikely(cr0 == 0)) {
 896                 cr0 = native_read_cr0();
 897                 this_cpu_write(xen_cr0_value, cr0);
 898         }
 899
 900         return cr0;
 901 }
 902
 903 static void xen_write_cr0(unsigned long cr0)
 904 {
 905         struct multicall_space mcs;
 906
 907         this_cpu_write(xen_cr0_value, cr0);
 908
 909         /* Only pay attention to cr0.TS; everything else is
 910            ignored. */
 911         mcs = xen_mc_entry(0);
 912
 913         MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);
 914
 915         xen_mc_issue(PARAVIRT_LAZY_CPU);
 916 }
 917
 918 static void xen_write_cr4(unsigned long cr4)
 919 {
 920         cr4 &= ~(X86_CR4_PGE | X86_CR4_PSE | X86_CR4_PCE);
 921
 922         native_write_cr4(cr4);
 923 }
 924
 925 static u64 xen_read_msr_safe(unsigned int msr, int *err)
 926 {
 927         u64 val;
 928
 929         if (pmu_msr_read(msr, &val, err))
 930                 return val;
 931
 932         val = native_read_msr_safe(msr, err);
 933         switch (msr) {
 934         case MSR_IA32_APICBASE:
 935                 val &= ~X2APIC_ENABLE;
 936                 break;
 937         }
 938         return val;
 939 }
 940
 941 static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
 942 {
 943         int ret;
 944         unsigned int which;
 945         u64 base;
 946
 947         ret = 0;
 948
 949         switch (msr) {
 950         case MSR_FS_BASE:               which = SEGBASE_FS; goto set;
 951         case MSR_KERNEL_GS_BASE:        which = SEGBASE_GS_USER; goto set;
 952         case MSR_GS_BASE:               which = SEGBASE_GS_KERNEL; goto set;
 953
 954         set:
 955                 base = ((u64)high << 32) | low;
 956                 if (HYPERVISOR_set_segment_base(which, base) != 0)
 957                         ret = -EIO;
 958                 break;
 959
 960         case MSR_STAR:
 961         case MSR_CSTAR:
 962         case MSR_LSTAR:
 963         case MSR_SYSCALL_MASK:
 964         case MSR_IA32_SYSENTER_CS:
 965         case MSR_IA32_SYSENTER_ESP:
 966         case MSR_IA32_SYSENTER_EIP:
 967                 /* Fast syscall setup is all done in hypercalls, so
 968                    these are all ignored.  Stub them out here to stop
 969                    Xen console noise. */
 970                 break;
 971
 972         default:
 973                 if (!pmu_msr_write(msr, low, high, &ret))
 974                         ret = native_write_msr_safe(msr, low, high);
 975         }
 976
 977         return ret;
 978 }
 979
 980 static u64 xen_read_msr(unsigned int msr)
 981 {
 982         /*
 983          * This will silently swallow a #GP from RDMSR.  It may be worth
 984          * changing that.
 985          */
 986         int err;
 987
 988         return xen_read_msr_safe(msr, &err);
 989 }
 990
 991 static void xen_write_msr(unsigned int msr, unsigned low, unsigned high)
 992 {
 993         /*
 994          * This will silently swallow a #GP from WRMSR.  It may be worth
 995          * changing that.
 996          */
 997         xen_write_msr_safe(msr, low, high);
 998 }
 999
1000 /* This is called once we have the cpu_possible_mask */
1001 void __init xen_setup_vcpu_info_placement(void)
1002 {
1003         int cpu;
1004
1005         for_each_possible_cpu(cpu) {
1006                 /* Set up direct vCPU id mapping for PV guests. */
1007                 per_cpu(xen_vcpu_id, cpu) = cpu;
1008
1009                 /*
1010                  * xen_vcpu_setup(cpu) can fail  -- in which case it
1011                  * falls back to the shared_info version for cpus
1012                  * where xen_vcpu_nr(cpu) < MAX_VIRT_CPUS.
1013                  *
1014                  * xen_cpu_up_prepare_pv() handles the rest by failing
1015                  * them in hotplug.
1016                  */
1017                 (void) xen_vcpu_setup(cpu);
1018         }
1019
1020         /*
1021          * xen_vcpu_setup managed to place the vcpu_info within the
1022          * percpu area for all cpus, so make use of it.
1023          */
1024         if (xen_have_vcpu_info_placement) {
1025                 pv_ops.irq.save_fl = __PV_IS_CALLEE_SAVE(xen_save_fl_direct);
1026                 pv_ops.irq.irq_disable =
1027                         __PV_IS_CALLEE_SAVE(xen_irq_disable_direct);
1028                 pv_ops.irq.irq_enable =
1029                         __PV_IS_CALLEE_SAVE(xen_irq_enable_direct);
1030                 pv_ops.mmu.read_cr2 =
1031                         __PV_IS_CALLEE_SAVE(xen_read_cr2_direct);
1032         }
1033 }
1034
1035 static const struct pv_info xen_info __initconst = {
1036         .extra_user_64bit_cs = FLAT_USER_CS64,
1037         .name = "Xen",
1038 };
1039
1040 static const struct pv_cpu_ops xen_cpu_ops __initconst = {
1041         .cpuid = xen_cpuid,
1042
1043         .set_debugreg = xen_set_debugreg,
1044         .get_debugreg = xen_get_debugreg,
1045
1046         .read_cr0 = xen_read_cr0,
1047         .write_cr0 = xen_write_cr0,
1048
1049         .write_cr4 = xen_write_cr4,
1050
1051         .wbinvd = native_wbinvd,
1052
1053         .read_msr = xen_read_msr,
1054         .write_msr = xen_write_msr,
1055
1056         .read_msr_safe = xen_read_msr_safe,
1057         .write_msr_safe = xen_write_msr_safe,
1058
1059         .read_pmc = xen_read_pmc,
1060
1061         .load_tr_desc = paravirt_nop,
1062         .set_ldt = xen_set_ldt,
1063         .load_gdt = xen_load_gdt,
1064         .load_idt = xen_load_idt,
1065         .load_tls = xen_load_tls,
1066         .load_gs_index = xen_load_gs_index,
1067
1068         .alloc_ldt = xen_alloc_ldt,
1069         .free_ldt = xen_free_ldt,
1070
1071         .store_tr = xen_store_tr,
1072
1073         .write_ldt_entry = xen_write_ldt_entry,
1074         .write_gdt_entry = xen_write_gdt_entry,
1075         .write_idt_entry = xen_write_idt_entry,
1076         .load_sp0 = xen_load_sp0,
1077
1078 #ifdef CONFIG_X86_IOPL_IOPERM
1079         .invalidate_io_bitmap = xen_invalidate_io_bitmap,
1080         .update_io_bitmap = xen_update_io_bitmap,
1081 #endif
1082         .io_delay = xen_io_delay,
1083
1084         .start_context_switch = paravirt_start_context_switch,
1085         .end_context_switch = xen_end_context_switch,
1086 };
1087
1088 static void xen_restart(char *msg)
1089 {
1090         xen_reboot(SHUTDOWN_reboot);
1091 }
1092
1093 static void xen_machine_halt(void)
1094 {
1095         xen_reboot(SHUTDOWN_poweroff);
1096 }
1097
1098 static void xen_machine_power_off(void)
1099 {
1100         if (pm_power_off)
1101                 pm_power_off();
1102         xen_reboot(SHUTDOWN_poweroff);
1103 }
1104
1105 static void xen_crash_shutdown(struct pt_regs *regs)
1106 {
1107         xen_reboot(SHUTDOWN_crash);
1108 }
1109
1110 static const struct machine_ops xen_machine_ops __initconst = {
1111         .restart = xen_restart,
1112         .halt = xen_machine_halt,
1113         .power_off = xen_machine_power_off,
1114         .shutdown = xen_machine_halt,
1115         .crash_shutdown = xen_crash_shutdown,
1116         .emergency_restart = xen_emergency_restart,
1117 };
1118
1119 static unsigned char xen_get_nmi_reason(void)
1120 {
1121         unsigned char reason = 0;
1122
1123         /* Construct a value which looks like it came from port 0x61. */
1124         if (test_bit(_XEN_NMIREASON_io_error,
1125                      &HYPERVISOR_shared_info->arch.nmi_reason))
1126                 reason |= NMI_REASON_IOCHK;
1127         if (test_bit(_XEN_NMIREASON_pci_serr,
1128                      &HYPERVISOR_shared_info->arch.nmi_reason))
1129                 reason |= NMI_REASON_SERR;
1130
1131         return reason;
1132 }
1133
1134 static void __init xen_boot_params_init_edd(void)
1135 {
1136 #if IS_ENABLED(CONFIG_EDD)
1137         struct xen_platform_op op;
1138         struct edd_info *edd_info;
1139         u32 *mbr_signature;
1140         unsigned nr;
1141         int ret;
1142
1143         edd_info = boot_params.eddbuf;
1144         mbr_signature = boot_params.edd_mbr_sig_buffer;
1145
1146         op.cmd = XENPF_firmware_info;
1147
1148         op.u.firmware_info.type = XEN_FW_DISK_INFO;
1149         for (nr = 0; nr < EDDMAXNR; nr++) {
1150                 struct edd_info *info = edd_info + nr;
1151
1152                 op.u.firmware_info.index = nr;
1153                 info->params.length = sizeof(info->params);
1154                 set_xen_guest_handle(op.u.firmware_info.u.disk_info.edd_params,
1155                                      &info->params);
1156                 ret = HYPERVISOR_platform_op(&op);
1157                 if (ret)
1158                         break;
1159
1160 #define C(x) info->x = op.u.firmware_info.u.disk_info.x
1161                 C(device);
1162                 C(version);
1163                 C(interface_support);
1164                 C(legacy_max_cylinder);
1165                 C(legacy_max_head);
1166                 C(legacy_sectors_per_track);
1167 #undef C
1168         }
1169         boot_params.eddbuf_entries = nr;
1170
1171         op.u.firmware_info.type = XEN_FW_DISK_MBR_SIGNATURE;
1172         for (nr = 0; nr < EDD_MBR_SIG_MAX; nr++) {
1173                 op.u.firmware_info.index = nr;
1174                 ret = HYPERVISOR_platform_op(&op);
1175                 if (ret)
1176                         break;
1177                 mbr_signature[nr] = op.u.firmware_info.u.disk_mbr_signature.mbr_signature;
1178         }
1179         boot_params.edd_mbr_sig_buf_entries = nr;
1180 #endif
1181 }
1182
1183 /*
1184  * Set up the GDT and segment registers for -fstack-protector.  Until
1185  * we do this, we have to be careful not to call any stack-protected
1186  * function, which is most of the kernel.
1187  */
1188 static void __init xen_setup_gdt(int cpu)
1189 {
1190         pv_ops.cpu.write_gdt_entry = xen_write_gdt_entry_boot;
1191         pv_ops.cpu.load_gdt = xen_load_gdt_boot;
1192
1193         switch_to_new_gdt(cpu);
1194
1195         pv_ops.cpu.write_gdt_entry = xen_write_gdt_entry;
1196         pv_ops.cpu.load_gdt = xen_load_gdt;
1197 }
1198
1199 static void __init xen_dom0_set_legacy_features(void)
1200 {
1201         x86_platform.legacy.rtc = 1;
1202 }
1203
1204 static void __init xen_domu_set_legacy_features(void)
1205 {
1206         x86_platform.legacy.rtc = 0;
1207 }
1208
1209 /* First C function to be called on Xen boot */
1210 asmlinkage __visible void __init xen_start_kernel(void)
1211 {
1212         struct physdev_set_iopl set_iopl;
1213         unsigned long initrd_start = 0;
1214         int rc;
1215
1216         if (!xen_start_info)
1217                 return;
1218
1219         xen_domain_type = XEN_PV_DOMAIN;
1220         xen_start_flags = xen_start_info->flags;
1221
1222         xen_setup_features();
1223
1224         /* Install Xen paravirt ops */
1225         pv_info = xen_info;
1226         pv_ops.cpu = xen_cpu_ops;
1227         paravirt_iret = xen_iret;
1228         xen_init_irq_ops();
1229
1230         /*
1231          * Setup xen_vcpu early because it is needed for
1232          * local_irq_disable(), irqs_disabled(), e.g. in printk().
1233          *
1234          * Don't do the full vcpu_info placement stuff until we have
1235          * the cpu_possible_mask and a non-dummy shared_info.
1236          */
1237         xen_vcpu_info_reset(0);
1238
1239         x86_platform.get_nmi_reason = xen_get_nmi_reason;
1240
1241         x86_init.resources.memory_setup = xen_memory_setup;
1242         x86_init.irqs.intr_mode_select  = x86_init_noop;
1243         x86_init.irqs.intr_mode_init    = x86_init_noop;
1244         x86_init.oem.arch_setup = xen_arch_setup;
1245         x86_init.oem.banner = xen_banner;
1246         x86_init.hyper.init_platform = xen_pv_init_platform;
1247         x86_init.hyper.guest_late_init = xen_pv_guest_late_init;
1248
1249         /*
1250          * Set up some pagetable state before starting to set any ptes.
1251          */
1252
1253         xen_setup_machphys_mapping();
1254         xen_init_mmu_ops();
1255
1256         /* Prevent unwanted bits from being set in PTEs. */
1257         __supported_pte_mask &= ~_PAGE_GLOBAL;
1258         __default_kernel_pte_mask &= ~_PAGE_GLOBAL;
1259
1260         /*
1261          * Prevent page tables from being allocated in highmem, even
1262          * if CONFIG_HIGHPTE is enabled.
1263          */
1264         __userpte_alloc_gfp &= ~__GFP_HIGHMEM;
1265
1266         /* Get mfn list */
1267         xen_build_dynamic_phys_to_machine();
1268
1269         /* Work out if we support NX */
1270         get_cpu_cap(&boot_cpu_data);
1271         x86_configure_nx();
1272
1273         /*
1274          * Set up kernel GDT and segment registers, mainly so that
1275          * -fstack-protector code can be executed.
1276          */
1277         xen_setup_gdt(0);
1278
1279         /* Determine virtual and physical address sizes */
1280         get_cpu_address_sizes(&boot_cpu_data);
1281
1282         /* Let's presume PV guests always boot on vCPU with id 0. */
1283         per_cpu(xen_vcpu_id, 0) = 0;
1284
1285         idt_setup_early_handler();
1286
1287         xen_init_capabilities();
1288
1289 #ifdef CONFIG_X86_LOCAL_APIC
1290         /*
1291          * set up the basic apic ops.
1292          */
1293         xen_init_apic();
1294 #endif
1295
1296         machine_ops = xen_machine_ops;
1297
1298         /*
1299          * The only reliable way to retain the initial address of the
1300          * percpu gdt_page is to remember it here, so we can go and
1301          * mark it RW later, when the initial percpu area is freed.
1302          */
1303         xen_initial_gdt = &per_cpu(gdt_page, 0);
1304
1305         xen_smp_init();
1306
1307 #ifdef CONFIG_ACPI_NUMA
1308         /*
1309          * The pages we from Xen are not related to machine pages, so
1310          * any NUMA information the kernel tries to get from ACPI will
1311          * be meaningless.  Prevent it from trying.
1312          */
1313         disable_srat();
1314 #endif
1315         WARN_ON(xen_cpuhp_setup(xen_cpu_up_prepare_pv, xen_cpu_dead_pv));
1316
1317         local_irq_disable();
1318         early_boot_irqs_disabled = true;
1319
1320         xen_raw_console_write("mapping kernel into physical memory\n");
1321         xen_setup_kernel_pagetable((pgd_t *)xen_start_info->pt_base,
1322                                    xen_start_info->nr_pages);
1323         xen_reserve_special_pages();
1324
1325         /*
1326          * We used to do this in xen_arch_setup, but that is too late
1327          * on AMD were early_cpu_init (run before ->arch_setup()) calls
1328          * early_amd_init which pokes 0xcf8 port.
1329          */
1330         set_iopl.iopl = 1;
1331         rc = HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
1332         if (rc != 0)
1333                 xen_raw_printk("physdev_op failed %d\n", rc);
1334
1335
1336         if (xen_start_info->mod_start) {
1337             if (xen_start_info->flags & SIF_MOD_START_PFN)
1338                 initrd_start = PFN_PHYS(xen_start_info->mod_start);
1339             else
1340                 initrd_start = __pa(xen_start_info->mod_start);
1341         }
1342
1343         /* Poke various useful things into boot_params */
1344         boot_params.hdr.type_of_loader = (9 << 4) | 0;
1345         boot_params.hdr.ramdisk_image = initrd_start;
1346         boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
1347         boot_params.hdr.cmd_line_ptr = __pa(xen_start_info->cmd_line);
1348         boot_params.hdr.hardware_subarch = X86_SUBARCH_XEN;
1349
1350         if (!xen_initial_domain()) {
1351                 add_preferred_console("xenboot", 0, NULL);
1352                 if (pci_xen)
1353                         x86_init.pci.arch_init = pci_xen_init;
1354                 x86_platform.set_legacy_features =
1355                                 xen_domu_set_legacy_features;
1356         } else {
1357                 const struct dom0_vga_console_info *info =
1358                         (void *)((char *)xen_start_info +
1359                                  xen_start_info->console.dom0.info_off);
1360                 struct xen_platform_op op = {
1361                         .cmd = XENPF_firmware_info,
1362                         .interface_version = XENPF_INTERFACE_VERSION,
1363                         .u.firmware_info.type = XEN_FW_KBD_SHIFT_FLAGS,
1364                 };
1365
1366                 x86_platform.set_legacy_features =
1367                                 xen_dom0_set_legacy_features;
1368                 xen_init_vga(info, xen_start_info->console.dom0.info_size);
1369                 xen_start_info->console.domU.mfn = 0;
1370                 xen_start_info->console.domU.evtchn = 0;
1371
1372                 if (HYPERVISOR_platform_op(&op) == 0)
1373                         boot_params.kbd_status = op.u.firmware_info.u.kbd_shift_flags;
1374
1375                 /* Make sure ACS will be enabled */
1376                 pci_request_acs();
1377
1378                 xen_acpi_sleep_register();
1379
1380                 /* Avoid searching for BIOS MP tables */
1381                 x86_init.mpparse.find_smp_config = x86_init_noop;
1382                 x86_init.mpparse.get_smp_config = x86_init_uint_noop;
1383
1384                 xen_boot_params_init_edd();
1385
1386 #ifdef CONFIG_ACPI
1387                 /*
1388                  * Disable selecting "Firmware First mode" for correctable
1389                  * memory errors, as this is the duty of the hypervisor to
1390                  * decide.
1391                  */
1392                 acpi_disable_cmcff = 1;
1393 #endif
1394         }
1395
1396         if (!boot_params.screen_info.orig_video_isVGA)
1397                 add_preferred_console("tty", 0, NULL);
1398         add_preferred_console("hvc", 0, NULL);
1399         if (boot_params.screen_info.orig_video_isVGA)
1400                 add_preferred_console("tty", 0, NULL);
1401
1402 #ifdef CONFIG_PCI
1403         /* PCI BIOS service won't work from a PV guest. */
1404         pci_probe &= ~PCI_PROBE_BIOS;
1405 #endif
1406         xen_raw_console_write("about to get started...\n");
1407
1408         /* We need this for printk timestamps */
1409         xen_setup_runstate_info(0);
1410
1411         xen_efi_init(&boot_params);
1412
1413         /* Start the world */
1414         cr4_init_shadow(); /* 32b kernel does this in i386_start_kernel() */
1415         x86_64_start_reservations((char *)__pa_symbol(&boot_params));
1416 }
1417
1418 static int xen_cpu_up_prepare_pv(unsigned int cpu)
1419 {
1420         int rc;
1421
1422         if (per_cpu(xen_vcpu, cpu) == NULL)
1423                 return -ENODEV;
1424
1425         xen_setup_timer(cpu);
1426
1427         rc = xen_smp_intr_init(cpu);
1428         if (rc) {
1429                 WARN(1, "xen_smp_intr_init() for CPU %d failed: %d\n",
1430                      cpu, rc);
1431                 return rc;
1432         }
1433
1434         rc = xen_smp_intr_init_pv(cpu);
1435         if (rc) {
1436                 WARN(1, "xen_smp_intr_init_pv() for CPU %d failed: %d\n",
1437                      cpu, rc);
1438                 return rc;
1439         }
1440
1441         return 0;
1442 }
1443
1444 static int xen_cpu_dead_pv(unsigned int cpu)
1445 {
1446         xen_smp_intr_free(cpu);
1447         xen_smp_intr_free_pv(cpu);
1448
1449         xen_teardown_timer(cpu);
1450
1451         return 0;
1452 }
1453
1454 static uint32_t __init xen_platform_pv(void)
1455 {
1456         if (xen_pv_domain())
1457                 return xen_cpuid_base();
1458
1459         return 0;
1460 }
1461
1462 const __initconst struct hypervisor_x86 x86_hyper_xen_pv = {
1463         .name                   = "Xen PV",
1464         .detect                 = xen_platform_pv,
1465         .type                   = X86_HYPER_XEN_PV,
1466         .runtime.pin_vcpu       = xen_pin_vcpu,
1467         .ignore_nopv            = true,
1468 };