xref: /linux/arch/x86/xen/enlighten.c (revision d91517839e5d95adc0cf4b28caa7af62a71de526)
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/cpu.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/smp.h>
18 #include <linux/preempt.h>
19 #include <linux/hardirq.h>
20 #include <linux/percpu.h>
21 #include <linux/delay.h>
22 #include <linux/start_kernel.h>
23 #include <linux/sched.h>
24 #include <linux/kprobes.h>
25 #include <linux/bootmem.h>
26 #include <linux/module.h>
27 #include <linux/mm.h>
28 #include <linux/page-flags.h>
29 #include <linux/highmem.h>
30 #include <linux/console.h>
31 #include <linux/pci.h>
32 #include <linux/gfp.h>
33 #include <linux/memblock.h>
34 #include <linux/edd.h>
35 
36 #include <xen/xen.h>
37 #include <xen/events.h>
38 #include <xen/interface/xen.h>
39 #include <xen/interface/version.h>
40 #include <xen/interface/physdev.h>
41 #include <xen/interface/vcpu.h>
42 #include <xen/interface/memory.h>
43 #include <xen/interface/xen-mca.h>
44 #include <xen/features.h>
45 #include <xen/page.h>
46 #include <xen/hvm.h>
47 #include <xen/hvc-console.h>
48 #include <xen/acpi.h>
49 
50 #include <asm/paravirt.h>
51 #include <asm/apic.h>
52 #include <asm/page.h>
53 #include <asm/xen/pci.h>
54 #include <asm/xen/hypercall.h>
55 #include <asm/xen/hypervisor.h>
56 #include <asm/fixmap.h>
57 #include <asm/processor.h>
58 #include <asm/proto.h>
59 #include <asm/msr-index.h>
60 #include <asm/traps.h>
61 #include <asm/setup.h>
62 #include <asm/desc.h>
63 #include <asm/pgalloc.h>
64 #include <asm/pgtable.h>
65 #include <asm/tlbflush.h>
66 #include <asm/reboot.h>
67 #include <asm/stackprotector.h>
68 #include <asm/hypervisor.h>
69 #include <asm/mwait.h>
70 #include <asm/pci_x86.h>
71 #include <asm/pat.h>
72 
73 #ifdef CONFIG_ACPI
74 #include <linux/acpi.h>
75 #include <asm/acpi.h>
76 #include <acpi/pdc_intel.h>
77 #include <acpi/processor.h>
78 #include <xen/interface/platform.h>
79 #endif
80 
81 #include "xen-ops.h"
82 #include "mmu.h"
83 #include "smp.h"
84 #include "multicalls.h"
85 
86 EXPORT_SYMBOL_GPL(hypercall_page);
87 
88 /*
89  * Pointer to the xen_vcpu_info structure or
90  * &HYPERVISOR_shared_info->vcpu_info[cpu]. See xen_hvm_init_shared_info
91  * and xen_vcpu_setup for details. By default it points to share_info->vcpu_info
92  * but if the hypervisor supports VCPUOP_register_vcpu_info then it can point
93  * to xen_vcpu_info. The pointer is used in __xen_evtchn_do_upcall to
94  * acknowledge pending events.
95  * Also more subtly it is used by the patched version of irq enable/disable
96  * e.g. xen_irq_enable_direct and xen_iret in PV mode.
97  *
98  * The desire to be able to do those mask/unmask operations as a single
99  * instruction by using the per-cpu offset held in %gs is the real reason
100  * vcpu info is in a per-cpu pointer and the original reason for this
101  * hypercall.
102  *
103  */
104 DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);
105 
106 /*
107  * Per CPU pages used if hypervisor supports VCPUOP_register_vcpu_info
108  * hypercall. This can be used both in PV and PVHVM mode. The structure
109  * overrides the default per_cpu(xen_vcpu, cpu) value.
110  */
111 DEFINE_PER_CPU(struct vcpu_info, xen_vcpu_info);
112 
113 enum xen_domain_type xen_domain_type = XEN_NATIVE;
114 EXPORT_SYMBOL_GPL(xen_domain_type);
115 
116 unsigned long *machine_to_phys_mapping = (void *)MACH2PHYS_VIRT_START;
117 EXPORT_SYMBOL(machine_to_phys_mapping);
118 unsigned long  machine_to_phys_nr;
119 EXPORT_SYMBOL(machine_to_phys_nr);
120 
121 struct start_info *xen_start_info;
122 EXPORT_SYMBOL_GPL(xen_start_info);
123 
124 struct shared_info xen_dummy_shared_info;
125 
126 void *xen_initial_gdt;
127 
128 RESERVE_BRK(shared_info_page_brk, PAGE_SIZE);
129 __read_mostly int xen_have_vector_callback;
130 EXPORT_SYMBOL_GPL(xen_have_vector_callback);
131 
132 /*
133  * Point at some empty memory to start with. We map the real shared_info
134  * page as soon as fixmap is up and running.
135  */
136 struct shared_info *HYPERVISOR_shared_info = &xen_dummy_shared_info;
137 
138 /*
139  * Flag to determine whether vcpu info placement is available on all
140  * VCPUs.  We assume it is to start with, and then set it to zero on
141  * the first failure.  This is because it can succeed on some VCPUs
142  * and not others, since it can involve hypervisor memory allocation,
143  * or because the guest failed to guarantee all the appropriate
144  * constraints on all VCPUs (ie buffer can't cross a page boundary).
145  *
146  * Note that any particular CPU may be using a placed vcpu structure,
147  * but we can only optimise if the all are.
148  *
149  * 0: not available, 1: available
150  */
151 static int have_vcpu_info_placement = 1;
152 
153 struct tls_descs {
154 	struct desc_struct desc[3];
155 };
156 
157 /*
158  * Updating the 3 TLS descriptors in the GDT on every task switch is
159  * surprisingly expensive so we avoid updating them if they haven't
160  * changed.  Since Xen writes different descriptors than the one
161  * passed in the update_descriptor hypercall we keep shadow copies to
162  * compare against.
163  */
164 static DEFINE_PER_CPU(struct tls_descs, shadow_tls_desc);
165 
166 static void clamp_max_cpus(void)
167 {
168 #ifdef CONFIG_SMP
169 	if (setup_max_cpus > MAX_VIRT_CPUS)
170 		setup_max_cpus = MAX_VIRT_CPUS;
171 #endif
172 }
173 
174 static void xen_vcpu_setup(int cpu)
175 {
176 	struct vcpu_register_vcpu_info info;
177 	int err;
178 	struct vcpu_info *vcpup;
179 
180 	BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
181 
182 	/*
183 	 * This path is called twice on PVHVM - first during bootup via
184 	 * smp_init -> xen_hvm_cpu_notify, and then if the VCPU is being
185 	 * hotplugged: cpu_up -> xen_hvm_cpu_notify.
186 	 * As we can only do the VCPUOP_register_vcpu_info once lets
187 	 * not over-write its result.
188 	 *
189 	 * For PV it is called during restore (xen_vcpu_restore) and bootup
190 	 * (xen_setup_vcpu_info_placement). The hotplug mechanism does not
191 	 * use this function.
192 	 */
193 	if (xen_hvm_domain()) {
194 		if (per_cpu(xen_vcpu, cpu) == &per_cpu(xen_vcpu_info, cpu))
195 			return;
196 	}
197 	if (cpu < MAX_VIRT_CPUS)
198 		per_cpu(xen_vcpu,cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
199 
200 	if (!have_vcpu_info_placement) {
201 		if (cpu >= MAX_VIRT_CPUS)
202 			clamp_max_cpus();
203 		return;
204 	}
205 
206 	vcpup = &per_cpu(xen_vcpu_info, cpu);
207 	info.mfn = arbitrary_virt_to_mfn(vcpup);
208 	info.offset = offset_in_page(vcpup);
209 
210 	/* Check to see if the hypervisor will put the vcpu_info
211 	   structure where we want it, which allows direct access via
212 	   a percpu-variable.
213 	   N.B. This hypercall can _only_ be called once per CPU. Subsequent
214 	   calls will error out with -EINVAL. This is due to the fact that
215 	   hypervisor has no unregister variant and this hypercall does not
216 	   allow to over-write info.mfn and info.offset.
217 	 */
218 	err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info, cpu, &info);
219 
220 	if (err) {
221 		printk(KERN_DEBUG "register_vcpu_info failed: err=%d\n", err);
222 		have_vcpu_info_placement = 0;
223 		clamp_max_cpus();
224 	} else {
225 		/* This cpu is using the registered vcpu info, even if
226 		   later ones fail to. */
227 		per_cpu(xen_vcpu, cpu) = vcpup;
228 	}
229 }
230 
231 /*
232  * On restore, set the vcpu placement up again.
233  * If it fails, then we're in a bad state, since
234  * we can't back out from using it...
235  */
236 void xen_vcpu_restore(void)
237 {
238 	int cpu;
239 
240 	for_each_possible_cpu(cpu) {
241 		bool other_cpu = (cpu != smp_processor_id());
242 		bool is_up = HYPERVISOR_vcpu_op(VCPUOP_is_up, cpu, NULL);
243 
244 		if (other_cpu && is_up &&
245 		    HYPERVISOR_vcpu_op(VCPUOP_down, cpu, NULL))
246 			BUG();
247 
248 		xen_setup_runstate_info(cpu);
249 
250 		if (have_vcpu_info_placement)
251 			xen_vcpu_setup(cpu);
252 
253 		if (other_cpu && is_up &&
254 		    HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL))
255 			BUG();
256 	}
257 }
258 
259 static void __init xen_banner(void)
260 {
261 	unsigned version = HYPERVISOR_xen_version(XENVER_version, NULL);
262 	struct xen_extraversion extra;
263 	HYPERVISOR_xen_version(XENVER_extraversion, &extra);
264 
265 	pr_info("Booting paravirtualized kernel %son %s\n",
266 		xen_feature(XENFEAT_auto_translated_physmap) ?
267 			"with PVH extensions " : "", pv_info.name);
268 	printk(KERN_INFO "Xen version: %d.%d%s%s\n",
269 	       version >> 16, version & 0xffff, extra.extraversion,
270 	       xen_feature(XENFEAT_mmu_pt_update_preserve_ad) ? " (preserve-AD)" : "");
271 }
272 /* Check if running on Xen version (major, minor) or later */
273 bool
274 xen_running_on_version_or_later(unsigned int major, unsigned int minor)
275 {
276 	unsigned int version;
277 
278 	if (!xen_domain())
279 		return false;
280 
281 	version = HYPERVISOR_xen_version(XENVER_version, NULL);
282 	if ((((version >> 16) == major) && ((version & 0xffff) >= minor)) ||
283 		((version >> 16) > major))
284 		return true;
285 	return false;
286 }
287 
288 #define CPUID_THERM_POWER_LEAF 6
289 #define APERFMPERF_PRESENT 0
290 
291 static __read_mostly unsigned int cpuid_leaf1_edx_mask = ~0;
292 static __read_mostly unsigned int cpuid_leaf1_ecx_mask = ~0;
293 
294 static __read_mostly unsigned int cpuid_leaf1_ecx_set_mask;
295 static __read_mostly unsigned int cpuid_leaf5_ecx_val;
296 static __read_mostly unsigned int cpuid_leaf5_edx_val;
297 
298 static void xen_cpuid(unsigned int *ax, unsigned int *bx,
299 		      unsigned int *cx, unsigned int *dx)
300 {
301 	unsigned maskebx = ~0;
302 	unsigned maskecx = ~0;
303 	unsigned maskedx = ~0;
304 	unsigned setecx = 0;
305 	/*
306 	 * Mask out inconvenient features, to try and disable as many
307 	 * unsupported kernel subsystems as possible.
308 	 */
309 	switch (*ax) {
310 	case 1:
311 		maskecx = cpuid_leaf1_ecx_mask;
312 		setecx = cpuid_leaf1_ecx_set_mask;
313 		maskedx = cpuid_leaf1_edx_mask;
314 		break;
315 
316 	case CPUID_MWAIT_LEAF:
317 		/* Synthesize the values.. */
318 		*ax = 0;
319 		*bx = 0;
320 		*cx = cpuid_leaf5_ecx_val;
321 		*dx = cpuid_leaf5_edx_val;
322 		return;
323 
324 	case CPUID_THERM_POWER_LEAF:
325 		/* Disabling APERFMPERF for kernel usage */
326 		maskecx = ~(1 << APERFMPERF_PRESENT);
327 		break;
328 
329 	case 0xb:
330 		/* Suppress extended topology stuff */
331 		maskebx = 0;
332 		break;
333 	}
334 
335 	asm(XEN_EMULATE_PREFIX "cpuid"
336 		: "=a" (*ax),
337 		  "=b" (*bx),
338 		  "=c" (*cx),
339 		  "=d" (*dx)
340 		: "0" (*ax), "2" (*cx));
341 
342 	*bx &= maskebx;
343 	*cx &= maskecx;
344 	*cx |= setecx;
345 	*dx &= maskedx;
346 
347 }
348 
349 static bool __init xen_check_mwait(void)
350 {
351 #ifdef CONFIG_ACPI
352 	struct xen_platform_op op = {
353 		.cmd			= XENPF_set_processor_pminfo,
354 		.u.set_pminfo.id	= -1,
355 		.u.set_pminfo.type	= XEN_PM_PDC,
356 	};
357 	uint32_t buf[3];
358 	unsigned int ax, bx, cx, dx;
359 	unsigned int mwait_mask;
360 
361 	/* We need to determine whether it is OK to expose the MWAIT
362 	 * capability to the kernel to harvest deeper than C3 states from ACPI
363 	 * _CST using the processor_harvest_xen.c module. For this to work, we
364 	 * need to gather the MWAIT_LEAF values (which the cstate.c code
365 	 * checks against). The hypervisor won't expose the MWAIT flag because
366 	 * it would break backwards compatibility; so we will find out directly
367 	 * from the hardware and hypercall.
368 	 */
369 	if (!xen_initial_domain())
370 		return false;
371 
372 	/*
373 	 * When running under platform earlier than Xen4.2, do not expose
374 	 * mwait, to avoid the risk of loading native acpi pad driver
375 	 */
376 	if (!xen_running_on_version_or_later(4, 2))
377 		return false;
378 
379 	ax = 1;
380 	cx = 0;
381 
382 	native_cpuid(&ax, &bx, &cx, &dx);
383 
384 	mwait_mask = (1 << (X86_FEATURE_EST % 32)) |
385 		     (1 << (X86_FEATURE_MWAIT % 32));
386 
387 	if ((cx & mwait_mask) != mwait_mask)
388 		return false;
389 
390 	/* We need to emulate the MWAIT_LEAF and for that we need both
391 	 * ecx and edx. The hypercall provides only partial information.
392 	 */
393 
394 	ax = CPUID_MWAIT_LEAF;
395 	bx = 0;
396 	cx = 0;
397 	dx = 0;
398 
399 	native_cpuid(&ax, &bx, &cx, &dx);
400 
401 	/* Ask the Hypervisor whether to clear ACPI_PDC_C_C2C3_FFH. If so,
402 	 * don't expose MWAIT_LEAF and let ACPI pick the IOPORT version of C3.
403 	 */
404 	buf[0] = ACPI_PDC_REVISION_ID;
405 	buf[1] = 1;
406 	buf[2] = (ACPI_PDC_C_CAPABILITY_SMP | ACPI_PDC_EST_CAPABILITY_SWSMP);
407 
408 	set_xen_guest_handle(op.u.set_pminfo.pdc, buf);
409 
410 	if ((HYPERVISOR_dom0_op(&op) == 0) &&
411 	    (buf[2] & (ACPI_PDC_C_C1_FFH | ACPI_PDC_C_C2C3_FFH))) {
412 		cpuid_leaf5_ecx_val = cx;
413 		cpuid_leaf5_edx_val = dx;
414 	}
415 	return true;
416 #else
417 	return false;
418 #endif
419 }
420 static void __init xen_init_cpuid_mask(void)
421 {
422 	unsigned int ax, bx, cx, dx;
423 	unsigned int xsave_mask;
424 
425 	cpuid_leaf1_edx_mask =
426 		~((1 << X86_FEATURE_MTRR) |  /* disable MTRR */
427 		  (1 << X86_FEATURE_ACC));   /* thermal monitoring */
428 
429 	if (!xen_initial_domain())
430 		cpuid_leaf1_edx_mask &=
431 			~((1 << X86_FEATURE_ACPI));  /* disable ACPI */
432 
433 	cpuid_leaf1_ecx_mask &= ~(1 << (X86_FEATURE_X2APIC % 32));
434 
435 	ax = 1;
436 	cx = 0;
437 	cpuid(1, &ax, &bx, &cx, &dx);
438 
439 	xsave_mask =
440 		(1 << (X86_FEATURE_XSAVE % 32)) |
441 		(1 << (X86_FEATURE_OSXSAVE % 32));
442 
443 	/* Xen will set CR4.OSXSAVE if supported and not disabled by force */
444 	if ((cx & xsave_mask) != xsave_mask)
445 		cpuid_leaf1_ecx_mask &= ~xsave_mask; /* disable XSAVE & OSXSAVE */
446 	if (xen_check_mwait())
447 		cpuid_leaf1_ecx_set_mask = (1 << (X86_FEATURE_MWAIT % 32));
448 }
449 
450 static void xen_set_debugreg(int reg, unsigned long val)
451 {
452 	HYPERVISOR_set_debugreg(reg, val);
453 }
454 
455 static unsigned long xen_get_debugreg(int reg)
456 {
457 	return HYPERVISOR_get_debugreg(reg);
458 }
459 
460 static void xen_end_context_switch(struct task_struct *next)
461 {
462 	xen_mc_flush();
463 	paravirt_end_context_switch(next);
464 }
465 
466 static unsigned long xen_store_tr(void)
467 {
468 	return 0;
469 }
470 
471 /*
472  * Set the page permissions for a particular virtual address.  If the
473  * address is a vmalloc mapping (or other non-linear mapping), then
474  * find the linear mapping of the page and also set its protections to
475  * match.
476  */
477 static void set_aliased_prot(void *v, pgprot_t prot)
478 {
479 	int level;
480 	pte_t *ptep;
481 	pte_t pte;
482 	unsigned long pfn;
483 	struct page *page;
484 
485 	ptep = lookup_address((unsigned long)v, &level);
486 	BUG_ON(ptep == NULL);
487 
488 	pfn = pte_pfn(*ptep);
489 	page = pfn_to_page(pfn);
490 
491 	pte = pfn_pte(pfn, prot);
492 
493 	if (HYPERVISOR_update_va_mapping((unsigned long)v, pte, 0))
494 		BUG();
495 
496 	if (!PageHighMem(page)) {
497 		void *av = __va(PFN_PHYS(pfn));
498 
499 		if (av != v)
500 			if (HYPERVISOR_update_va_mapping((unsigned long)av, pte, 0))
501 				BUG();
502 	} else
503 		kmap_flush_unused();
504 }
505 
506 static void xen_alloc_ldt(struct desc_struct *ldt, unsigned entries)
507 {
508 	const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
509 	int i;
510 
511 	for(i = 0; i < entries; i += entries_per_page)
512 		set_aliased_prot(ldt + i, PAGE_KERNEL_RO);
513 }
514 
515 static void xen_free_ldt(struct desc_struct *ldt, unsigned entries)
516 {
517 	const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
518 	int i;
519 
520 	for(i = 0; i < entries; i += entries_per_page)
521 		set_aliased_prot(ldt + i, PAGE_KERNEL);
522 }
523 
524 static void xen_set_ldt(const void *addr, unsigned entries)
525 {
526 	struct mmuext_op *op;
527 	struct multicall_space mcs = xen_mc_entry(sizeof(*op));
528 
529 	trace_xen_cpu_set_ldt(addr, entries);
530 
531 	op = mcs.args;
532 	op->cmd = MMUEXT_SET_LDT;
533 	op->arg1.linear_addr = (unsigned long)addr;
534 	op->arg2.nr_ents = entries;
535 
536 	MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);
537 
538 	xen_mc_issue(PARAVIRT_LAZY_CPU);
539 }
540 
541 static void xen_load_gdt(const struct desc_ptr *dtr)
542 {
543 	unsigned long va = dtr->address;
544 	unsigned int size = dtr->size + 1;
545 	unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
546 	unsigned long frames[pages];
547 	int f;
548 
549 	/*
550 	 * A GDT can be up to 64k in size, which corresponds to 8192
551 	 * 8-byte entries, or 16 4k pages..
552 	 */
553 
554 	BUG_ON(size > 65536);
555 	BUG_ON(va & ~PAGE_MASK);
556 
557 	for (f = 0; va < dtr->address + size; va += PAGE_SIZE, f++) {
558 		int level;
559 		pte_t *ptep;
560 		unsigned long pfn, mfn;
561 		void *virt;
562 
563 		/*
564 		 * The GDT is per-cpu and is in the percpu data area.
565 		 * That can be virtually mapped, so we need to do a
566 		 * page-walk to get the underlying MFN for the
567 		 * hypercall.  The page can also be in the kernel's
568 		 * linear range, so we need to RO that mapping too.
569 		 */
570 		ptep = lookup_address(va, &level);
571 		BUG_ON(ptep == NULL);
572 
573 		pfn = pte_pfn(*ptep);
574 		mfn = pfn_to_mfn(pfn);
575 		virt = __va(PFN_PHYS(pfn));
576 
577 		frames[f] = mfn;
578 
579 		make_lowmem_page_readonly((void *)va);
580 		make_lowmem_page_readonly(virt);
581 	}
582 
583 	if (HYPERVISOR_set_gdt(frames, size / sizeof(struct desc_struct)))
584 		BUG();
585 }
586 
587 /*
588  * load_gdt for early boot, when the gdt is only mapped once
589  */
590 static void __init xen_load_gdt_boot(const struct desc_ptr *dtr)
591 {
592 	unsigned long va = dtr->address;
593 	unsigned int size = dtr->size + 1;
594 	unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
595 	unsigned long frames[pages];
596 	int f;
597 
598 	/*
599 	 * A GDT can be up to 64k in size, which corresponds to 8192
600 	 * 8-byte entries, or 16 4k pages..
601 	 */
602 
603 	BUG_ON(size > 65536);
604 	BUG_ON(va & ~PAGE_MASK);
605 
606 	for (f = 0; va < dtr->address + size; va += PAGE_SIZE, f++) {
607 		pte_t pte;
608 		unsigned long pfn, mfn;
609 
610 		pfn = virt_to_pfn(va);
611 		mfn = pfn_to_mfn(pfn);
612 
613 		pte = pfn_pte(pfn, PAGE_KERNEL_RO);
614 
615 		if (HYPERVISOR_update_va_mapping((unsigned long)va, pte, 0))
616 			BUG();
617 
618 		frames[f] = mfn;
619 	}
620 
621 	if (HYPERVISOR_set_gdt(frames, size / sizeof(struct desc_struct)))
622 		BUG();
623 }
624 
625 static inline bool desc_equal(const struct desc_struct *d1,
626 			      const struct desc_struct *d2)
627 {
628 	return d1->a == d2->a && d1->b == d2->b;
629 }
630 
631 static void load_TLS_descriptor(struct thread_struct *t,
632 				unsigned int cpu, unsigned int i)
633 {
634 	struct desc_struct *shadow = &per_cpu(shadow_tls_desc, cpu).desc[i];
635 	struct desc_struct *gdt;
636 	xmaddr_t maddr;
637 	struct multicall_space mc;
638 
639 	if (desc_equal(shadow, &t->tls_array[i]))
640 		return;
641 
642 	*shadow = t->tls_array[i];
643 
644 	gdt = get_cpu_gdt_table(cpu);
645 	maddr = arbitrary_virt_to_machine(&gdt[GDT_ENTRY_TLS_MIN+i]);
646 	mc = __xen_mc_entry(0);
647 
648 	MULTI_update_descriptor(mc.mc, maddr.maddr, t->tls_array[i]);
649 }
650 
651 static void xen_load_tls(struct thread_struct *t, unsigned int cpu)
652 {
653 	/*
654 	 * XXX sleazy hack: If we're being called in a lazy-cpu zone
655 	 * and lazy gs handling is enabled, it means we're in a
656 	 * context switch, and %gs has just been saved.  This means we
657 	 * can zero it out to prevent faults on exit from the
658 	 * hypervisor if the next process has no %gs.  Either way, it
659 	 * has been saved, and the new value will get loaded properly.
660 	 * This will go away as soon as Xen has been modified to not
661 	 * save/restore %gs for normal hypercalls.
662 	 *
663 	 * On x86_64, this hack is not used for %gs, because gs points
664 	 * to KERNEL_GS_BASE (and uses it for PDA references), so we
665 	 * must not zero %gs on x86_64
666 	 *
667 	 * For x86_64, we need to zero %fs, otherwise we may get an
668 	 * exception between the new %fs descriptor being loaded and
669 	 * %fs being effectively cleared at __switch_to().
670 	 */
671 	if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU) {
672 #ifdef CONFIG_X86_32
673 		lazy_load_gs(0);
674 #else
675 		loadsegment(fs, 0);
676 #endif
677 	}
678 
679 	xen_mc_batch();
680 
681 	load_TLS_descriptor(t, cpu, 0);
682 	load_TLS_descriptor(t, cpu, 1);
683 	load_TLS_descriptor(t, cpu, 2);
684 
685 	xen_mc_issue(PARAVIRT_LAZY_CPU);
686 }
687 
688 #ifdef CONFIG_X86_64
689 static void xen_load_gs_index(unsigned int idx)
690 {
691 	if (HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, idx))
692 		BUG();
693 }
694 #endif
695 
696 static void xen_write_ldt_entry(struct desc_struct *dt, int entrynum,
697 				const void *ptr)
698 {
699 	xmaddr_t mach_lp = arbitrary_virt_to_machine(&dt[entrynum]);
700 	u64 entry = *(u64 *)ptr;
701 
702 	trace_xen_cpu_write_ldt_entry(dt, entrynum, entry);
703 
704 	preempt_disable();
705 
706 	xen_mc_flush();
707 	if (HYPERVISOR_update_descriptor(mach_lp.maddr, entry))
708 		BUG();
709 
710 	preempt_enable();
711 }
712 
713 static int cvt_gate_to_trap(int vector, const gate_desc *val,
714 			    struct trap_info *info)
715 {
716 	unsigned long addr;
717 
718 	if (val->type != GATE_TRAP && val->type != GATE_INTERRUPT)
719 		return 0;
720 
721 	info->vector = vector;
722 
723 	addr = gate_offset(*val);
724 #ifdef CONFIG_X86_64
725 	/*
726 	 * Look for known traps using IST, and substitute them
727 	 * appropriately.  The debugger ones are the only ones we care
728 	 * about.  Xen will handle faults like double_fault,
729 	 * so we should never see them.  Warn if
730 	 * there's an unexpected IST-using fault handler.
731 	 */
732 	if (addr == (unsigned long)debug)
733 		addr = (unsigned long)xen_debug;
734 	else if (addr == (unsigned long)int3)
735 		addr = (unsigned long)xen_int3;
736 	else if (addr == (unsigned long)stack_segment)
737 		addr = (unsigned long)xen_stack_segment;
738 	else if (addr == (unsigned long)double_fault) {
739 		/* Don't need to handle these */
740 		return 0;
741 #ifdef CONFIG_X86_MCE
742 	} else if (addr == (unsigned long)machine_check) {
743 		/*
744 		 * when xen hypervisor inject vMCE to guest,
745 		 * use native mce handler to handle it
746 		 */
747 		;
748 #endif
749 	} else if (addr == (unsigned long)nmi)
750 		/*
751 		 * Use the native version as well.
752 		 */
753 		;
754 	else {
755 		/* Some other trap using IST? */
756 		if (WARN_ON(val->ist != 0))
757 			return 0;
758 	}
759 #endif	/* CONFIG_X86_64 */
760 	info->address = addr;
761 
762 	info->cs = gate_segment(*val);
763 	info->flags = val->dpl;
764 	/* interrupt gates clear IF */
765 	if (val->type == GATE_INTERRUPT)
766 		info->flags |= 1 << 2;
767 
768 	return 1;
769 }
770 
771 /* Locations of each CPU's IDT */
772 static DEFINE_PER_CPU(struct desc_ptr, idt_desc);
773 
774 /* Set an IDT entry.  If the entry is part of the current IDT, then
775    also update Xen. */
776 static void xen_write_idt_entry(gate_desc *dt, int entrynum, const gate_desc *g)
777 {
778 	unsigned long p = (unsigned long)&dt[entrynum];
779 	unsigned long start, end;
780 
781 	trace_xen_cpu_write_idt_entry(dt, entrynum, g);
782 
783 	preempt_disable();
784 
785 	start = __this_cpu_read(idt_desc.address);
786 	end = start + __this_cpu_read(idt_desc.size) + 1;
787 
788 	xen_mc_flush();
789 
790 	native_write_idt_entry(dt, entrynum, g);
791 
792 	if (p >= start && (p + 8) <= end) {
793 		struct trap_info info[2];
794 
795 		info[1].address = 0;
796 
797 		if (cvt_gate_to_trap(entrynum, g, &info[0]))
798 			if (HYPERVISOR_set_trap_table(info))
799 				BUG();
800 	}
801 
802 	preempt_enable();
803 }
804 
805 static void xen_convert_trap_info(const struct desc_ptr *desc,
806 				  struct trap_info *traps)
807 {
808 	unsigned in, out, count;
809 
810 	count = (desc->size+1) / sizeof(gate_desc);
811 	BUG_ON(count > 256);
812 
813 	for (in = out = 0; in < count; in++) {
814 		gate_desc *entry = (gate_desc*)(desc->address) + in;
815 
816 		if (cvt_gate_to_trap(in, entry, &traps[out]))
817 			out++;
818 	}
819 	traps[out].address = 0;
820 }
821 
822 void xen_copy_trap_info(struct trap_info *traps)
823 {
824 	const struct desc_ptr *desc = &__get_cpu_var(idt_desc);
825 
826 	xen_convert_trap_info(desc, traps);
827 }
828 
829 /* Load a new IDT into Xen.  In principle this can be per-CPU, so we
830    hold a spinlock to protect the static traps[] array (static because
831    it avoids allocation, and saves stack space). */
832 static void xen_load_idt(const struct desc_ptr *desc)
833 {
834 	static DEFINE_SPINLOCK(lock);
835 	static struct trap_info traps[257];
836 
837 	trace_xen_cpu_load_idt(desc);
838 
839 	spin_lock(&lock);
840 
841 	__get_cpu_var(idt_desc) = *desc;
842 
843 	xen_convert_trap_info(desc, traps);
844 
845 	xen_mc_flush();
846 	if (HYPERVISOR_set_trap_table(traps))
847 		BUG();
848 
849 	spin_unlock(&lock);
850 }
851 
852 /* Write a GDT descriptor entry.  Ignore LDT descriptors, since
853    they're handled differently. */
854 static void xen_write_gdt_entry(struct desc_struct *dt, int entry,
855 				const void *desc, int type)
856 {
857 	trace_xen_cpu_write_gdt_entry(dt, entry, desc, type);
858 
859 	preempt_disable();
860 
861 	switch (type) {
862 	case DESC_LDT:
863 	case DESC_TSS:
864 		/* ignore */
865 		break;
866 
867 	default: {
868 		xmaddr_t maddr = arbitrary_virt_to_machine(&dt[entry]);
869 
870 		xen_mc_flush();
871 		if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
872 			BUG();
873 	}
874 
875 	}
876 
877 	preempt_enable();
878 }
879 
880 /*
881  * Version of write_gdt_entry for use at early boot-time needed to
882  * update an entry as simply as possible.
883  */
884 static void __init xen_write_gdt_entry_boot(struct desc_struct *dt, int entry,
885 					    const void *desc, int type)
886 {
887 	trace_xen_cpu_write_gdt_entry(dt, entry, desc, type);
888 
889 	switch (type) {
890 	case DESC_LDT:
891 	case DESC_TSS:
892 		/* ignore */
893 		break;
894 
895 	default: {
896 		xmaddr_t maddr = virt_to_machine(&dt[entry]);
897 
898 		if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
899 			dt[entry] = *(struct desc_struct *)desc;
900 	}
901 
902 	}
903 }
904 
905 static void xen_load_sp0(struct tss_struct *tss,
906 			 struct thread_struct *thread)
907 {
908 	struct multicall_space mcs;
909 
910 	mcs = xen_mc_entry(0);
911 	MULTI_stack_switch(mcs.mc, __KERNEL_DS, thread->sp0);
912 	xen_mc_issue(PARAVIRT_LAZY_CPU);
913 }
914 
915 static void xen_set_iopl_mask(unsigned mask)
916 {
917 	struct physdev_set_iopl set_iopl;
918 
919 	/* Force the change at ring 0. */
920 	set_iopl.iopl = (mask == 0) ? 1 : (mask >> 12) & 3;
921 	HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
922 }
923 
924 static void xen_io_delay(void)
925 {
926 }
927 
928 #ifdef CONFIG_X86_LOCAL_APIC
929 static unsigned long xen_set_apic_id(unsigned int x)
930 {
931 	WARN_ON(1);
932 	return x;
933 }
934 static unsigned int xen_get_apic_id(unsigned long x)
935 {
936 	return ((x)>>24) & 0xFFu;
937 }
938 static u32 xen_apic_read(u32 reg)
939 {
940 	struct xen_platform_op op = {
941 		.cmd = XENPF_get_cpuinfo,
942 		.interface_version = XENPF_INTERFACE_VERSION,
943 		.u.pcpu_info.xen_cpuid = 0,
944 	};
945 	int ret = 0;
946 
947 	/* Shouldn't need this as APIC is turned off for PV, and we only
948 	 * get called on the bootup processor. But just in case. */
949 	if (!xen_initial_domain() || smp_processor_id())
950 		return 0;
951 
952 	if (reg == APIC_LVR)
953 		return 0x10;
954 
955 	if (reg != APIC_ID)
956 		return 0;
957 
958 	ret = HYPERVISOR_dom0_op(&op);
959 	if (ret)
960 		return 0;
961 
962 	return op.u.pcpu_info.apic_id << 24;
963 }
964 
965 static void xen_apic_write(u32 reg, u32 val)
966 {
967 	/* Warn to see if there's any stray references */
968 	WARN_ON(1);
969 }
970 
971 static u64 xen_apic_icr_read(void)
972 {
973 	return 0;
974 }
975 
976 static void xen_apic_icr_write(u32 low, u32 id)
977 {
978 	/* Warn to see if there's any stray references */
979 	WARN_ON(1);
980 }
981 
982 static void xen_apic_wait_icr_idle(void)
983 {
984         return;
985 }
986 
987 static u32 xen_safe_apic_wait_icr_idle(void)
988 {
989         return 0;
990 }
991 
992 static void set_xen_basic_apic_ops(void)
993 {
994 	apic->read = xen_apic_read;
995 	apic->write = xen_apic_write;
996 	apic->icr_read = xen_apic_icr_read;
997 	apic->icr_write = xen_apic_icr_write;
998 	apic->wait_icr_idle = xen_apic_wait_icr_idle;
999 	apic->safe_wait_icr_idle = xen_safe_apic_wait_icr_idle;
1000 	apic->set_apic_id = xen_set_apic_id;
1001 	apic->get_apic_id = xen_get_apic_id;
1002 
1003 #ifdef CONFIG_SMP
1004 	apic->send_IPI_allbutself = xen_send_IPI_allbutself;
1005 	apic->send_IPI_mask_allbutself = xen_send_IPI_mask_allbutself;
1006 	apic->send_IPI_mask = xen_send_IPI_mask;
1007 	apic->send_IPI_all = xen_send_IPI_all;
1008 	apic->send_IPI_self = xen_send_IPI_self;
1009 #endif
1010 }
1011 
1012 #endif
1013 
1014 static void xen_clts(void)
1015 {
1016 	struct multicall_space mcs;
1017 
1018 	mcs = xen_mc_entry(0);
1019 
1020 	MULTI_fpu_taskswitch(mcs.mc, 0);
1021 
1022 	xen_mc_issue(PARAVIRT_LAZY_CPU);
1023 }
1024 
1025 static DEFINE_PER_CPU(unsigned long, xen_cr0_value);
1026 
1027 static unsigned long xen_read_cr0(void)
1028 {
1029 	unsigned long cr0 = this_cpu_read(xen_cr0_value);
1030 
1031 	if (unlikely(cr0 == 0)) {
1032 		cr0 = native_read_cr0();
1033 		this_cpu_write(xen_cr0_value, cr0);
1034 	}
1035 
1036 	return cr0;
1037 }
1038 
1039 static void xen_write_cr0(unsigned long cr0)
1040 {
1041 	struct multicall_space mcs;
1042 
1043 	this_cpu_write(xen_cr0_value, cr0);
1044 
1045 	/* Only pay attention to cr0.TS; everything else is
1046 	   ignored. */
1047 	mcs = xen_mc_entry(0);
1048 
1049 	MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);
1050 
1051 	xen_mc_issue(PARAVIRT_LAZY_CPU);
1052 }
1053 
1054 static void xen_write_cr4(unsigned long cr4)
1055 {
1056 	cr4 &= ~X86_CR4_PGE;
1057 	cr4 &= ~X86_CR4_PSE;
1058 
1059 	native_write_cr4(cr4);
1060 }
1061 #ifdef CONFIG_X86_64
1062 static inline unsigned long xen_read_cr8(void)
1063 {
1064 	return 0;
1065 }
1066 static inline void xen_write_cr8(unsigned long val)
1067 {
1068 	BUG_ON(val);
1069 }
1070 #endif
1071 static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
1072 {
1073 	int ret;
1074 
1075 	ret = 0;
1076 
1077 	switch (msr) {
1078 #ifdef CONFIG_X86_64
1079 		unsigned which;
1080 		u64 base;
1081 
1082 	case MSR_FS_BASE:		which = SEGBASE_FS; goto set;
1083 	case MSR_KERNEL_GS_BASE:	which = SEGBASE_GS_USER; goto set;
1084 	case MSR_GS_BASE:		which = SEGBASE_GS_KERNEL; goto set;
1085 
1086 	set:
1087 		base = ((u64)high << 32) | low;
1088 		if (HYPERVISOR_set_segment_base(which, base) != 0)
1089 			ret = -EIO;
1090 		break;
1091 #endif
1092 
1093 	case MSR_STAR:
1094 	case MSR_CSTAR:
1095 	case MSR_LSTAR:
1096 	case MSR_SYSCALL_MASK:
1097 	case MSR_IA32_SYSENTER_CS:
1098 	case MSR_IA32_SYSENTER_ESP:
1099 	case MSR_IA32_SYSENTER_EIP:
1100 		/* Fast syscall setup is all done in hypercalls, so
1101 		   these are all ignored.  Stub them out here to stop
1102 		   Xen console noise. */
1103 		break;
1104 
1105 	case MSR_IA32_CR_PAT:
1106 		if (smp_processor_id() == 0)
1107 			xen_set_pat(((u64)high << 32) | low);
1108 		break;
1109 
1110 	default:
1111 		ret = native_write_msr_safe(msr, low, high);
1112 	}
1113 
1114 	return ret;
1115 }
1116 
1117 void xen_setup_shared_info(void)
1118 {
1119 	if (!xen_feature(XENFEAT_auto_translated_physmap)) {
1120 		set_fixmap(FIX_PARAVIRT_BOOTMAP,
1121 			   xen_start_info->shared_info);
1122 
1123 		HYPERVISOR_shared_info =
1124 			(struct shared_info *)fix_to_virt(FIX_PARAVIRT_BOOTMAP);
1125 	} else
1126 		HYPERVISOR_shared_info =
1127 			(struct shared_info *)__va(xen_start_info->shared_info);
1128 
1129 #ifndef CONFIG_SMP
1130 	/* In UP this is as good a place as any to set up shared info */
1131 	xen_setup_vcpu_info_placement();
1132 #endif
1133 
1134 	xen_setup_mfn_list_list();
1135 }
1136 
1137 /* This is called once we have the cpu_possible_mask */
1138 void xen_setup_vcpu_info_placement(void)
1139 {
1140 	int cpu;
1141 
1142 	for_each_possible_cpu(cpu)
1143 		xen_vcpu_setup(cpu);
1144 
1145 	/* xen_vcpu_setup managed to place the vcpu_info within the
1146 	 * percpu area for all cpus, so make use of it. Note that for
1147 	 * PVH we want to use native IRQ mechanism. */
1148 	if (have_vcpu_info_placement && !xen_pvh_domain()) {
1149 		pv_irq_ops.save_fl = __PV_IS_CALLEE_SAVE(xen_save_fl_direct);
1150 		pv_irq_ops.restore_fl = __PV_IS_CALLEE_SAVE(xen_restore_fl_direct);
1151 		pv_irq_ops.irq_disable = __PV_IS_CALLEE_SAVE(xen_irq_disable_direct);
1152 		pv_irq_ops.irq_enable = __PV_IS_CALLEE_SAVE(xen_irq_enable_direct);
1153 		pv_mmu_ops.read_cr2 = xen_read_cr2_direct;
1154 	}
1155 }
1156 
1157 static unsigned xen_patch(u8 type, u16 clobbers, void *insnbuf,
1158 			  unsigned long addr, unsigned len)
1159 {
1160 	char *start, *end, *reloc;
1161 	unsigned ret;
1162 
1163 	start = end = reloc = NULL;
1164 
1165 #define SITE(op, x)							\
1166 	case PARAVIRT_PATCH(op.x):					\
1167 	if (have_vcpu_info_placement) {					\
1168 		start = (char *)xen_##x##_direct;			\
1169 		end = xen_##x##_direct_end;				\
1170 		reloc = xen_##x##_direct_reloc;				\
1171 	}								\
1172 	goto patch_site
1173 
1174 	switch (type) {
1175 		SITE(pv_irq_ops, irq_enable);
1176 		SITE(pv_irq_ops, irq_disable);
1177 		SITE(pv_irq_ops, save_fl);
1178 		SITE(pv_irq_ops, restore_fl);
1179 #undef SITE
1180 
1181 	patch_site:
1182 		if (start == NULL || (end-start) > len)
1183 			goto default_patch;
1184 
1185 		ret = paravirt_patch_insns(insnbuf, len, start, end);
1186 
1187 		/* Note: because reloc is assigned from something that
1188 		   appears to be an array, gcc assumes it's non-null,
1189 		   but doesn't know its relationship with start and
1190 		   end. */
1191 		if (reloc > start && reloc < end) {
1192 			int reloc_off = reloc - start;
1193 			long *relocp = (long *)(insnbuf + reloc_off);
1194 			long delta = start - (char *)addr;
1195 
1196 			*relocp += delta;
1197 		}
1198 		break;
1199 
1200 	default_patch:
1201 	default:
1202 		ret = paravirt_patch_default(type, clobbers, insnbuf,
1203 					     addr, len);
1204 		break;
1205 	}
1206 
1207 	return ret;
1208 }
1209 
1210 static const struct pv_info xen_info __initconst = {
1211 	.paravirt_enabled = 1,
1212 	.shared_kernel_pmd = 0,
1213 
1214 #ifdef CONFIG_X86_64
1215 	.extra_user_64bit_cs = FLAT_USER_CS64,
1216 #endif
1217 
1218 	.name = "Xen",
1219 };
1220 
1221 static const struct pv_init_ops xen_init_ops __initconst = {
1222 	.patch = xen_patch,
1223 };
1224 
1225 static const struct pv_cpu_ops xen_cpu_ops __initconst = {
1226 	.cpuid = xen_cpuid,
1227 
1228 	.set_debugreg = xen_set_debugreg,
1229 	.get_debugreg = xen_get_debugreg,
1230 
1231 	.clts = xen_clts,
1232 
1233 	.read_cr0 = xen_read_cr0,
1234 	.write_cr0 = xen_write_cr0,
1235 
1236 	.read_cr4 = native_read_cr4,
1237 	.read_cr4_safe = native_read_cr4_safe,
1238 	.write_cr4 = xen_write_cr4,
1239 
1240 #ifdef CONFIG_X86_64
1241 	.read_cr8 = xen_read_cr8,
1242 	.write_cr8 = xen_write_cr8,
1243 #endif
1244 
1245 	.wbinvd = native_wbinvd,
1246 
1247 	.read_msr = native_read_msr_safe,
1248 	.write_msr = xen_write_msr_safe,
1249 
1250 	.read_tsc = native_read_tsc,
1251 	.read_pmc = native_read_pmc,
1252 
1253 	.read_tscp = native_read_tscp,
1254 
1255 	.iret = xen_iret,
1256 	.irq_enable_sysexit = xen_sysexit,
1257 #ifdef CONFIG_X86_64
1258 	.usergs_sysret32 = xen_sysret32,
1259 	.usergs_sysret64 = xen_sysret64,
1260 #endif
1261 
1262 	.load_tr_desc = paravirt_nop,
1263 	.set_ldt = xen_set_ldt,
1264 	.load_gdt = xen_load_gdt,
1265 	.load_idt = xen_load_idt,
1266 	.load_tls = xen_load_tls,
1267 #ifdef CONFIG_X86_64
1268 	.load_gs_index = xen_load_gs_index,
1269 #endif
1270 
1271 	.alloc_ldt = xen_alloc_ldt,
1272 	.free_ldt = xen_free_ldt,
1273 
1274 	.store_idt = native_store_idt,
1275 	.store_tr = xen_store_tr,
1276 
1277 	.write_ldt_entry = xen_write_ldt_entry,
1278 	.write_gdt_entry = xen_write_gdt_entry,
1279 	.write_idt_entry = xen_write_idt_entry,
1280 	.load_sp0 = xen_load_sp0,
1281 
1282 	.set_iopl_mask = xen_set_iopl_mask,
1283 	.io_delay = xen_io_delay,
1284 
1285 	/* Xen takes care of %gs when switching to usermode for us */
1286 	.swapgs = paravirt_nop,
1287 
1288 	.start_context_switch = paravirt_start_context_switch,
1289 	.end_context_switch = xen_end_context_switch,
1290 };
1291 
1292 static const struct pv_apic_ops xen_apic_ops __initconst = {
1293 #ifdef CONFIG_X86_LOCAL_APIC
1294 	.startup_ipi_hook = paravirt_nop,
1295 #endif
1296 };
1297 
1298 static void xen_reboot(int reason)
1299 {
1300 	struct sched_shutdown r = { .reason = reason };
1301 
1302 	if (HYPERVISOR_sched_op(SCHEDOP_shutdown, &r))
1303 		BUG();
1304 }
1305 
1306 static void xen_restart(char *msg)
1307 {
1308 	xen_reboot(SHUTDOWN_reboot);
1309 }
1310 
1311 static void xen_emergency_restart(void)
1312 {
1313 	xen_reboot(SHUTDOWN_reboot);
1314 }
1315 
1316 static void xen_machine_halt(void)
1317 {
1318 	xen_reboot(SHUTDOWN_poweroff);
1319 }
1320 
1321 static void xen_machine_power_off(void)
1322 {
1323 	if (pm_power_off)
1324 		pm_power_off();
1325 	xen_reboot(SHUTDOWN_poweroff);
1326 }
1327 
1328 static void xen_crash_shutdown(struct pt_regs *regs)
1329 {
1330 	xen_reboot(SHUTDOWN_crash);
1331 }
1332 
1333 static int
1334 xen_panic_event(struct notifier_block *this, unsigned long event, void *ptr)
1335 {
1336 	xen_reboot(SHUTDOWN_crash);
1337 	return NOTIFY_DONE;
1338 }
1339 
1340 static struct notifier_block xen_panic_block = {
1341 	.notifier_call= xen_panic_event,
1342 };
1343 
1344 int xen_panic_handler_init(void)
1345 {
1346 	atomic_notifier_chain_register(&panic_notifier_list, &xen_panic_block);
1347 	return 0;
1348 }
1349 
1350 static const struct machine_ops xen_machine_ops __initconst = {
1351 	.restart = xen_restart,
1352 	.halt = xen_machine_halt,
1353 	.power_off = xen_machine_power_off,
1354 	.shutdown = xen_machine_halt,
1355 	.crash_shutdown = xen_crash_shutdown,
1356 	.emergency_restart = xen_emergency_restart,
1357 };
1358 
1359 static void __init xen_boot_params_init_edd(void)
1360 {
1361 #if IS_ENABLED(CONFIG_EDD)
1362 	struct xen_platform_op op;
1363 	struct edd_info *edd_info;
1364 	u32 *mbr_signature;
1365 	unsigned nr;
1366 	int ret;
1367 
1368 	edd_info = boot_params.eddbuf;
1369 	mbr_signature = boot_params.edd_mbr_sig_buffer;
1370 
1371 	op.cmd = XENPF_firmware_info;
1372 
1373 	op.u.firmware_info.type = XEN_FW_DISK_INFO;
1374 	for (nr = 0; nr < EDDMAXNR; nr++) {
1375 		struct edd_info *info = edd_info + nr;
1376 
1377 		op.u.firmware_info.index = nr;
1378 		info->params.length = sizeof(info->params);
1379 		set_xen_guest_handle(op.u.firmware_info.u.disk_info.edd_params,
1380 				     &info->params);
1381 		ret = HYPERVISOR_dom0_op(&op);
1382 		if (ret)
1383 			break;
1384 
1385 #define C(x) info->x = op.u.firmware_info.u.disk_info.x
1386 		C(device);
1387 		C(version);
1388 		C(interface_support);
1389 		C(legacy_max_cylinder);
1390 		C(legacy_max_head);
1391 		C(legacy_sectors_per_track);
1392 #undef C
1393 	}
1394 	boot_params.eddbuf_entries = nr;
1395 
1396 	op.u.firmware_info.type = XEN_FW_DISK_MBR_SIGNATURE;
1397 	for (nr = 0; nr < EDD_MBR_SIG_MAX; nr++) {
1398 		op.u.firmware_info.index = nr;
1399 		ret = HYPERVISOR_dom0_op(&op);
1400 		if (ret)
1401 			break;
1402 		mbr_signature[nr] = op.u.firmware_info.u.disk_mbr_signature.mbr_signature;
1403 	}
1404 	boot_params.edd_mbr_sig_buf_entries = nr;
1405 #endif
1406 }
1407 
1408 /*
1409  * Set up the GDT and segment registers for -fstack-protector.  Until
1410  * we do this, we have to be careful not to call any stack-protected
1411  * function, which is most of the kernel.
1412  *
1413  * Note, that it is __ref because the only caller of this after init
1414  * is PVH which is not going to use xen_load_gdt_boot or other
1415  * __init functions.
1416  */
1417 static void __ref xen_setup_gdt(int cpu)
1418 {
1419 	if (xen_feature(XENFEAT_auto_translated_physmap)) {
1420 #ifdef CONFIG_X86_64
1421 		unsigned long dummy;
1422 
1423 		load_percpu_segment(cpu); /* We need to access per-cpu area */
1424 		switch_to_new_gdt(cpu); /* GDT and GS set */
1425 
1426 		/* We are switching of the Xen provided GDT to our HVM mode
1427 		 * GDT. The new GDT has  __KERNEL_CS with CS.L = 1
1428 		 * and we are jumping to reload it.
1429 		 */
1430 		asm volatile ("pushq %0\n"
1431 			      "leaq 1f(%%rip),%0\n"
1432 			      "pushq %0\n"
1433 			      "lretq\n"
1434 			      "1:\n"
1435 			      : "=&r" (dummy) : "0" (__KERNEL_CS));
1436 
1437 		/*
1438 		 * While not needed, we also set the %es, %ds, and %fs
1439 		 * to zero. We don't care about %ss as it is NULL.
1440 		 * Strictly speaking this is not needed as Xen zeros those
1441 		 * out (and also MSR_FS_BASE, MSR_GS_BASE, MSR_KERNEL_GS_BASE)
1442 		 *
1443 		 * Linux zeros them in cpu_init() and in secondary_startup_64
1444 		 * (for BSP).
1445 		 */
1446 		loadsegment(es, 0);
1447 		loadsegment(ds, 0);
1448 		loadsegment(fs, 0);
1449 #else
1450 		/* PVH: TODO Implement. */
1451 		BUG();
1452 #endif
1453 		return; /* PVH does not need any PV GDT ops. */
1454 	}
1455 	pv_cpu_ops.write_gdt_entry = xen_write_gdt_entry_boot;
1456 	pv_cpu_ops.load_gdt = xen_load_gdt_boot;
1457 
1458 	setup_stack_canary_segment(0);
1459 	switch_to_new_gdt(0);
1460 
1461 	pv_cpu_ops.write_gdt_entry = xen_write_gdt_entry;
1462 	pv_cpu_ops.load_gdt = xen_load_gdt;
1463 }
1464 
1465 /*
1466  * A PV guest starts with default flags that are not set for PVH, set them
1467  * here asap.
1468  */
1469 static void xen_pvh_set_cr_flags(int cpu)
1470 {
1471 
1472 	/* Some of these are setup in 'secondary_startup_64'. The others:
1473 	 * X86_CR0_TS, X86_CR0_PE, X86_CR0_ET are set by Xen for HVM guests
1474 	 * (which PVH shared codepaths), while X86_CR0_PG is for PVH. */
1475 	write_cr0(read_cr0() | X86_CR0_MP | X86_CR0_NE | X86_CR0_WP | X86_CR0_AM);
1476 }
1477 
1478 /*
1479  * Note, that it is ref - because the only caller of this after init
1480  * is PVH which is not going to use xen_load_gdt_boot or other
1481  * __init functions.
1482  */
1483 void __ref xen_pvh_secondary_vcpu_init(int cpu)
1484 {
1485 	xen_setup_gdt(cpu);
1486 	xen_pvh_set_cr_flags(cpu);
1487 }
1488 
1489 static void __init xen_pvh_early_guest_init(void)
1490 {
1491 	if (!xen_feature(XENFEAT_auto_translated_physmap))
1492 		return;
1493 
1494 	if (!xen_feature(XENFEAT_hvm_callback_vector))
1495 		return;
1496 
1497 	xen_have_vector_callback = 1;
1498 	xen_pvh_set_cr_flags(0);
1499 
1500 #ifdef CONFIG_X86_32
1501 	BUG(); /* PVH: Implement proper support. */
1502 #endif
1503 }
1504 
1505 /* First C function to be called on Xen boot */
1506 asmlinkage void __init xen_start_kernel(void)
1507 {
1508 	struct physdev_set_iopl set_iopl;
1509 	int rc;
1510 
1511 	if (!xen_start_info)
1512 		return;
1513 
1514 	xen_domain_type = XEN_PV_DOMAIN;
1515 
1516 	xen_setup_features();
1517 	xen_pvh_early_guest_init();
1518 	xen_setup_machphys_mapping();
1519 
1520 	/* Install Xen paravirt ops */
1521 	pv_info = xen_info;
1522 	pv_init_ops = xen_init_ops;
1523 	pv_apic_ops = xen_apic_ops;
1524 	if (!xen_pvh_domain())
1525 		pv_cpu_ops = xen_cpu_ops;
1526 
1527 	x86_init.resources.memory_setup = xen_memory_setup;
1528 	x86_init.oem.arch_setup = xen_arch_setup;
1529 	x86_init.oem.banner = xen_banner;
1530 
1531 	xen_init_time_ops();
1532 
1533 	/*
1534 	 * Set up some pagetable state before starting to set any ptes.
1535 	 */
1536 
1537 	xen_init_mmu_ops();
1538 
1539 	/* Prevent unwanted bits from being set in PTEs. */
1540 	__supported_pte_mask &= ~_PAGE_GLOBAL;
1541 #if 0
1542 	if (!xen_initial_domain())
1543 #endif
1544 		__supported_pte_mask &= ~(_PAGE_PWT | _PAGE_PCD);
1545 
1546 	__supported_pte_mask |= _PAGE_IOMAP;
1547 
1548 	/*
1549 	 * Prevent page tables from being allocated in highmem, even
1550 	 * if CONFIG_HIGHPTE is enabled.
1551 	 */
1552 	__userpte_alloc_gfp &= ~__GFP_HIGHMEM;
1553 
1554 	/* Work out if we support NX */
1555 	x86_configure_nx();
1556 
1557 	/* Get mfn list */
1558 	xen_build_dynamic_phys_to_machine();
1559 
1560 	/*
1561 	 * Set up kernel GDT and segment registers, mainly so that
1562 	 * -fstack-protector code can be executed.
1563 	 */
1564 	xen_setup_gdt(0);
1565 
1566 	xen_init_irq_ops();
1567 	xen_init_cpuid_mask();
1568 
1569 #ifdef CONFIG_X86_LOCAL_APIC
1570 	/*
1571 	 * set up the basic apic ops.
1572 	 */
1573 	set_xen_basic_apic_ops();
1574 #endif
1575 
1576 	if (xen_feature(XENFEAT_mmu_pt_update_preserve_ad)) {
1577 		pv_mmu_ops.ptep_modify_prot_start = xen_ptep_modify_prot_start;
1578 		pv_mmu_ops.ptep_modify_prot_commit = xen_ptep_modify_prot_commit;
1579 	}
1580 
1581 	machine_ops = xen_machine_ops;
1582 
1583 	/*
1584 	 * The only reliable way to retain the initial address of the
1585 	 * percpu gdt_page is to remember it here, so we can go and
1586 	 * mark it RW later, when the initial percpu area is freed.
1587 	 */
1588 	xen_initial_gdt = &per_cpu(gdt_page, 0);
1589 
1590 	xen_smp_init();
1591 
1592 #ifdef CONFIG_ACPI_NUMA
1593 	/*
1594 	 * The pages we from Xen are not related to machine pages, so
1595 	 * any NUMA information the kernel tries to get from ACPI will
1596 	 * be meaningless.  Prevent it from trying.
1597 	 */
1598 	acpi_numa = -1;
1599 #endif
1600 #ifdef CONFIG_X86_PAT
1601 	/*
1602 	 * For right now disable the PAT. We should remove this once
1603 	 * git commit 8eaffa67b43e99ae581622c5133e20b0f48bcef1
1604 	 * (xen/pat: Disable PAT support for now) is reverted.
1605 	 */
1606 	pat_enabled = 0;
1607 #endif
1608 	/* Don't do the full vcpu_info placement stuff until we have a
1609 	   possible map and a non-dummy shared_info. */
1610 	per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
1611 
1612 	local_irq_disable();
1613 	early_boot_irqs_disabled = true;
1614 
1615 	xen_raw_console_write("mapping kernel into physical memory\n");
1616 	xen_setup_kernel_pagetable((pgd_t *)xen_start_info->pt_base, xen_start_info->nr_pages);
1617 
1618 	/* Allocate and initialize top and mid mfn levels for p2m structure */
1619 	xen_build_mfn_list_list();
1620 
1621 	/* keep using Xen gdt for now; no urgent need to change it */
1622 
1623 #ifdef CONFIG_X86_32
1624 	pv_info.kernel_rpl = 1;
1625 	if (xen_feature(XENFEAT_supervisor_mode_kernel))
1626 		pv_info.kernel_rpl = 0;
1627 #else
1628 	pv_info.kernel_rpl = 0;
1629 #endif
1630 	/* set the limit of our address space */
1631 	xen_reserve_top();
1632 
1633 	/* PVH: runs at default kernel iopl of 0 */
1634 	if (!xen_pvh_domain()) {
1635 		/*
1636 		 * We used to do this in xen_arch_setup, but that is too late
1637 		 * on AMD were early_cpu_init (run before ->arch_setup()) calls
1638 		 * early_amd_init which pokes 0xcf8 port.
1639 		 */
1640 		set_iopl.iopl = 1;
1641 		rc = HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
1642 		if (rc != 0)
1643 			xen_raw_printk("physdev_op failed %d\n", rc);
1644 	}
1645 
1646 #ifdef CONFIG_X86_32
1647 	/* set up basic CPUID stuff */
1648 	cpu_detect(&new_cpu_data);
1649 	set_cpu_cap(&new_cpu_data, X86_FEATURE_FPU);
1650 	new_cpu_data.wp_works_ok = 1;
1651 	new_cpu_data.x86_capability[0] = cpuid_edx(1);
1652 #endif
1653 
1654 	/* Poke various useful things into boot_params */
1655 	boot_params.hdr.type_of_loader = (9 << 4) | 0;
1656 	boot_params.hdr.ramdisk_image = xen_start_info->mod_start
1657 		? __pa(xen_start_info->mod_start) : 0;
1658 	boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
1659 	boot_params.hdr.cmd_line_ptr = __pa(xen_start_info->cmd_line);
1660 
1661 	if (!xen_initial_domain()) {
1662 		add_preferred_console("xenboot", 0, NULL);
1663 		add_preferred_console("tty", 0, NULL);
1664 		add_preferred_console("hvc", 0, NULL);
1665 		if (pci_xen)
1666 			x86_init.pci.arch_init = pci_xen_init;
1667 	} else {
1668 		const struct dom0_vga_console_info *info =
1669 			(void *)((char *)xen_start_info +
1670 				 xen_start_info->console.dom0.info_off);
1671 		struct xen_platform_op op = {
1672 			.cmd = XENPF_firmware_info,
1673 			.interface_version = XENPF_INTERFACE_VERSION,
1674 			.u.firmware_info.type = XEN_FW_KBD_SHIFT_FLAGS,
1675 		};
1676 
1677 		xen_init_vga(info, xen_start_info->console.dom0.info_size);
1678 		xen_start_info->console.domU.mfn = 0;
1679 		xen_start_info->console.domU.evtchn = 0;
1680 
1681 		if (HYPERVISOR_dom0_op(&op) == 0)
1682 			boot_params.kbd_status = op.u.firmware_info.u.kbd_shift_flags;
1683 
1684 		xen_init_apic();
1685 
1686 		/* Make sure ACS will be enabled */
1687 		pci_request_acs();
1688 
1689 		xen_acpi_sleep_register();
1690 
1691 		/* Avoid searching for BIOS MP tables */
1692 		x86_init.mpparse.find_smp_config = x86_init_noop;
1693 		x86_init.mpparse.get_smp_config = x86_init_uint_noop;
1694 
1695 		xen_boot_params_init_edd();
1696 	}
1697 #ifdef CONFIG_PCI
1698 	/* PCI BIOS service won't work from a PV guest. */
1699 	pci_probe &= ~PCI_PROBE_BIOS;
1700 #endif
1701 	xen_raw_console_write("about to get started...\n");
1702 
1703 	xen_setup_runstate_info(0);
1704 
1705 	/* Start the world */
1706 #ifdef CONFIG_X86_32
1707 	i386_start_kernel();
1708 #else
1709 	x86_64_start_reservations((char *)__pa_symbol(&boot_params));
1710 #endif
1711 }
1712 
1713 void __ref xen_hvm_init_shared_info(void)
1714 {
1715 	int cpu;
1716 	struct xen_add_to_physmap xatp;
1717 	static struct shared_info *shared_info_page = 0;
1718 
1719 	if (!shared_info_page)
1720 		shared_info_page = (struct shared_info *)
1721 			extend_brk(PAGE_SIZE, PAGE_SIZE);
1722 	xatp.domid = DOMID_SELF;
1723 	xatp.idx = 0;
1724 	xatp.space = XENMAPSPACE_shared_info;
1725 	xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT;
1726 	if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
1727 		BUG();
1728 
1729 	HYPERVISOR_shared_info = (struct shared_info *)shared_info_page;
1730 
1731 	/* xen_vcpu is a pointer to the vcpu_info struct in the shared_info
1732 	 * page, we use it in the event channel upcall and in some pvclock
1733 	 * related functions. We don't need the vcpu_info placement
1734 	 * optimizations because we don't use any pv_mmu or pv_irq op on
1735 	 * HVM.
1736 	 * When xen_hvm_init_shared_info is run at boot time only vcpu 0 is
1737 	 * online but xen_hvm_init_shared_info is run at resume time too and
1738 	 * in that case multiple vcpus might be online. */
1739 	for_each_online_cpu(cpu) {
1740 		/* Leave it to be NULL. */
1741 		if (cpu >= MAX_VIRT_CPUS)
1742 			continue;
1743 		per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
1744 	}
1745 }
1746 
1747 #ifdef CONFIG_XEN_PVHVM
1748 static void __init init_hvm_pv_info(void)
1749 {
1750 	int major, minor;
1751 	uint32_t eax, ebx, ecx, edx, pages, msr, base;
1752 	u64 pfn;
1753 
1754 	base = xen_cpuid_base();
1755 	cpuid(base + 1, &eax, &ebx, &ecx, &edx);
1756 
1757 	major = eax >> 16;
1758 	minor = eax & 0xffff;
1759 	printk(KERN_INFO "Xen version %d.%d.\n", major, minor);
1760 
1761 	cpuid(base + 2, &pages, &msr, &ecx, &edx);
1762 
1763 	pfn = __pa(hypercall_page);
1764 	wrmsr_safe(msr, (u32)pfn, (u32)(pfn >> 32));
1765 
1766 	xen_setup_features();
1767 
1768 	pv_info.name = "Xen HVM";
1769 
1770 	xen_domain_type = XEN_HVM_DOMAIN;
1771 }
1772 
1773 static int xen_hvm_cpu_notify(struct notifier_block *self, unsigned long action,
1774 			      void *hcpu)
1775 {
1776 	int cpu = (long)hcpu;
1777 	switch (action) {
1778 	case CPU_UP_PREPARE:
1779 		xen_vcpu_setup(cpu);
1780 		if (xen_have_vector_callback) {
1781 			if (xen_feature(XENFEAT_hvm_safe_pvclock))
1782 				xen_setup_timer(cpu);
1783 		}
1784 		break;
1785 	default:
1786 		break;
1787 	}
1788 	return NOTIFY_OK;
1789 }
1790 
1791 static struct notifier_block xen_hvm_cpu_notifier = {
1792 	.notifier_call	= xen_hvm_cpu_notify,
1793 };
1794 
1795 static void __init xen_hvm_guest_init(void)
1796 {
1797 	init_hvm_pv_info();
1798 
1799 	xen_hvm_init_shared_info();
1800 
1801 	xen_panic_handler_init();
1802 
1803 	if (xen_feature(XENFEAT_hvm_callback_vector))
1804 		xen_have_vector_callback = 1;
1805 	xen_hvm_smp_init();
1806 	register_cpu_notifier(&xen_hvm_cpu_notifier);
1807 	xen_unplug_emulated_devices();
1808 	x86_init.irqs.intr_init = xen_init_IRQ;
1809 	xen_hvm_init_time_ops();
1810 	xen_hvm_init_mmu_ops();
1811 }
1812 
1813 static uint32_t __init xen_hvm_platform(void)
1814 {
1815 	if (xen_pv_domain())
1816 		return 0;
1817 
1818 	return xen_cpuid_base();
1819 }
1820 
1821 bool xen_hvm_need_lapic(void)
1822 {
1823 	if (xen_pv_domain())
1824 		return false;
1825 	if (!xen_hvm_domain())
1826 		return false;
1827 	if (xen_feature(XENFEAT_hvm_pirqs) && xen_have_vector_callback)
1828 		return false;
1829 	return true;
1830 }
1831 EXPORT_SYMBOL_GPL(xen_hvm_need_lapic);
1832 
1833 const struct hypervisor_x86 x86_hyper_xen_hvm __refconst = {
1834 	.name			= "Xen HVM",
1835 	.detect			= xen_hvm_platform,
1836 	.init_platform		= xen_hvm_guest_init,
1837 	.x2apic_available	= xen_x2apic_para_available,
1838 };
1839 EXPORT_SYMBOL(x86_hyper_xen_hvm);
1840 #endif
1841