enlighten.c 32.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * Core of Xen paravirt_ops implementation.
 *
 * This file contains the xen_paravirt_ops structure itself, and the
 * implementations for:
 * - privileged instructions
 * - interrupt flags
 * - segment operations
 * - booting and setup
 *
 * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
 */

14
#include <linux/cpu.h>
15 16 17 18
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/smp.h>
#include <linux/preempt.h>
19
#include <linux/hardirq.h>
20 21 22 23
#include <linux/percpu.h>
#include <linux/delay.h>
#include <linux/start_kernel.h>
#include <linux/sched.h>
24
#include <linux/kprobes.h>
25 26
#include <linux/bootmem.h>
#include <linux/module.h>
27 28 29
#include <linux/mm.h>
#include <linux/page-flags.h>
#include <linux/highmem.h>
30
#include <linux/console.h>
C
Chris Wright 已提交
31
#include <linux/pci.h>
32
#include <linux/gfp.h>
33
#include <linux/memblock.h>
34

35
#include <xen/xen.h>
36
#include <xen/interface/xen.h>
37
#include <xen/interface/version.h>
38 39
#include <xen/interface/physdev.h>
#include <xen/interface/vcpu.h>
40
#include <xen/interface/memory.h>
41 42
#include <xen/features.h>
#include <xen/page.h>
43
#include <xen/hvm.h>
J
Jeremy Fitzhardinge 已提交
44
#include <xen/hvc-console.h>
45 46

#include <asm/paravirt.h>
I
Ingo Molnar 已提交
47
#include <asm/apic.h>
48
#include <asm/page.h>
49
#include <asm/xen/pci.h>
50 51 52 53
#include <asm/xen/hypercall.h>
#include <asm/xen/hypervisor.h>
#include <asm/fixmap.h>
#include <asm/processor.h>
54
#include <asm/proto.h>
55
#include <asm/msr-index.h>
56
#include <asm/traps.h>
57 58
#include <asm/setup.h>
#include <asm/desc.h>
59
#include <asm/pgalloc.h>
60
#include <asm/pgtable.h>
J
Jeremy Fitzhardinge 已提交
61
#include <asm/tlbflush.h>
J
Jeremy Fitzhardinge 已提交
62
#include <asm/reboot.h>
63
#include <asm/stackprotector.h>
64
#include <asm/hypervisor.h>
65 66

#include "xen-ops.h"
J
Jeremy Fitzhardinge 已提交
67
#include "mmu.h"
68 69 70 71 72 73
#include "multicalls.h"

EXPORT_SYMBOL_GPL(hypercall_page);

DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);
DEFINE_PER_CPU(struct vcpu_info, xen_vcpu_info);
74

75 76 77
enum xen_domain_type xen_domain_type = XEN_NATIVE;
EXPORT_SYMBOL_GPL(xen_domain_type);

78 79 80 81 82
unsigned long *machine_to_phys_mapping = (void *)MACH2PHYS_VIRT_START;
EXPORT_SYMBOL(machine_to_phys_mapping);
unsigned int   machine_to_phys_order;
EXPORT_SYMBOL(machine_to_phys_order);

83 84 85
struct start_info *xen_start_info;
EXPORT_SYMBOL_GPL(xen_start_info);

86
struct shared_info xen_dummy_shared_info;
87

88 89
void *xen_initial_gdt;

90
RESERVE_BRK(shared_info_page_brk, PAGE_SIZE);
91 92
__read_mostly int xen_have_vector_callback;
EXPORT_SYMBOL_GPL(xen_have_vector_callback);
93

94 95 96 97
/*
 * Point at some empty memory to start with. We map the real shared_info
 * page as soon as fixmap is up and running.
 */
98
struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info;
99 100 101 102 103 104 105 106 107 108 109 110 111 112

/*
 * Flag to determine whether vcpu info placement is available on all
 * VCPUs.  We assume it is to start with, and then set it to zero on
 * the first failure.  This is because it can succeed on some VCPUs
 * and not others, since it can involve hypervisor memory allocation,
 * or because the guest failed to guarantee all the appropriate
 * constraints on all VCPUs (ie buffer can't cross a page boundary).
 *
 * Note that any particular CPU may be using a placed vcpu structure,
 * but we can only optimise if the all are.
 *
 * 0: not available, 1: available
 */
113
static int have_vcpu_info_placement = 1;
114

115 116 117 118 119 120 121 122
static void clamp_max_cpus(void)
{
#ifdef CONFIG_SMP
	if (setup_max_cpus > MAX_VIRT_CPUS)
		setup_max_cpus = MAX_VIRT_CPUS;
#endif
}

123
static void xen_vcpu_setup(int cpu)
124
{
125 126 127 128
	struct vcpu_register_vcpu_info info;
	int err;
	struct vcpu_info *vcpup;

129
	BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
130

131 132
	if (cpu < MAX_VIRT_CPUS)
		per_cpu(xen_vcpu,cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
133

134 135 136 137 138
	if (!have_vcpu_info_placement) {
		if (cpu >= MAX_VIRT_CPUS)
			clamp_max_cpus();
		return;
	}
139

140
	vcpup = &per_cpu(xen_vcpu_info, cpu);
141
	info.mfn = arbitrary_virt_to_mfn(vcpup);
142 143 144 145 146 147 148 149 150 151
	info.offset = offset_in_page(vcpup);

	/* Check to see if the hypervisor will put the vcpu_info
	   structure where we want it, which allows direct access via
	   a percpu-variable. */
	err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info, cpu, &info);

	if (err) {
		printk(KERN_DEBUG "register_vcpu_info failed: err=%d\n", err);
		have_vcpu_info_placement = 0;
152
		clamp_max_cpus();
153 154 155 156 157
	} else {
		/* This cpu is using the registered vcpu info, even if
		   later ones fail to. */
		per_cpu(xen_vcpu, cpu) = vcpup;
	}
158 159
}

160 161 162 163 164 165 166
/*
 * On restore, set the vcpu placement up again.
 * If it fails, then we're in a bad state, since
 * we can't back out from using it...
 */
void xen_vcpu_restore(void)
{
167
	int cpu;
168

169 170
	for_each_online_cpu(cpu) {
		bool other_cpu = (cpu != smp_processor_id());
171

172 173 174
		if (other_cpu &&
		    HYPERVISOR_vcpu_op(VCPUOP_down, cpu, NULL))
			BUG();
175

176
		xen_setup_runstate_info(cpu);
177

178
		if (have_vcpu_info_placement)
179 180
			xen_vcpu_setup(cpu);

181 182 183
		if (other_cpu &&
		    HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL))
			BUG();
184 185 186
	}
}

187 188
static void __init xen_banner(void)
{
189 190 191 192
	unsigned version = HYPERVISOR_xen_version(XENVER_version, NULL);
	struct xen_extraversion extra;
	HYPERVISOR_xen_version(XENVER_extraversion, &extra);

193
	printk(KERN_INFO "Booting paravirtualized kernel on %s\n",
194
	       pv_info.name);
195 196
	printk(KERN_INFO "Xen version: %d.%d%s%s\n",
	       version >> 16, version & 0xffff, extra.extraversion,
197
	       xen_feature(XENFEAT_mmu_pt_update_preserve_ad) ? " (preserve-AD)" : "");
198 199
}

J
Jeremy Fitzhardinge 已提交
200 201 202
static __read_mostly unsigned int cpuid_leaf1_edx_mask = ~0;
static __read_mostly unsigned int cpuid_leaf1_ecx_mask = ~0;

203 204
static void xen_cpuid(unsigned int *ax, unsigned int *bx,
		      unsigned int *cx, unsigned int *dx)
205
{
206
	unsigned maskebx = ~0;
J
Jeremy Fitzhardinge 已提交
207
	unsigned maskecx = ~0;
208 209 210 211 212 213
	unsigned maskedx = ~0;

	/*
	 * Mask out inconvenient features, to try and disable as many
	 * unsupported kernel subsystems as possible.
	 */
214 215
	switch (*ax) {
	case 1:
J
Jeremy Fitzhardinge 已提交
216 217
		maskecx = cpuid_leaf1_ecx_mask;
		maskedx = cpuid_leaf1_edx_mask;
218 219 220 221 222 223
		break;

	case 0xb:
		/* Suppress extended topology stuff */
		maskebx = 0;
		break;
J
Jeremy Fitzhardinge 已提交
224
	}
225 226

	asm(XEN_EMULATE_PREFIX "cpuid"
227 228 229 230 231
		: "=a" (*ax),
		  "=b" (*bx),
		  "=c" (*cx),
		  "=d" (*dx)
		: "0" (*ax), "2" (*cx));
J
Jeremy Fitzhardinge 已提交
232

233
	*bx &= maskebx;
J
Jeremy Fitzhardinge 已提交
234
	*cx &= maskecx;
235
	*dx &= maskedx;
236 237
}

J
Jeremy Fitzhardinge 已提交
238 239 240 241 242 243 244
static __init void xen_init_cpuid_mask(void)
{
	unsigned int ax, bx, cx, dx;

	cpuid_leaf1_edx_mask =
		~((1 << X86_FEATURE_MCE)  |  /* disable MCE */
		  (1 << X86_FEATURE_MCA)  |  /* disable MCA */
245
		  (1 << X86_FEATURE_MTRR) |  /* disable MTRR */
J
Jeremy Fitzhardinge 已提交
246 247 248 249 250 251 252 253
		  (1 << X86_FEATURE_ACC));   /* thermal monitoring */

	if (!xen_initial_domain())
		cpuid_leaf1_edx_mask &=
			~((1 << X86_FEATURE_APIC) |  /* disable local APIC */
			  (1 << X86_FEATURE_ACPI));  /* disable ACPI */

	ax = 1;
254
	cx = 0;
J
Jeremy Fitzhardinge 已提交
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
	xen_cpuid(&ax, &bx, &cx, &dx);

	/* cpuid claims we support xsave; try enabling it to see what happens */
	if (cx & (1 << (X86_FEATURE_XSAVE % 32))) {
		unsigned long cr4;

		set_in_cr4(X86_CR4_OSXSAVE);
		
		cr4 = read_cr4();

		if ((cr4 & X86_CR4_OSXSAVE) == 0)
			cpuid_leaf1_ecx_mask &= ~(1 << (X86_FEATURE_XSAVE % 32));

		clear_in_cr4(X86_CR4_OSXSAVE);
	}
}

272 273 274 275 276 277 278 279 280 281
static void xen_set_debugreg(int reg, unsigned long val)
{
	HYPERVISOR_set_debugreg(reg, val);
}

static unsigned long xen_get_debugreg(int reg)
{
	return HYPERVISOR_get_debugreg(reg);
}

282
static void xen_end_context_switch(struct task_struct *next)
283 284
{
	xen_mc_flush();
285
	paravirt_end_context_switch(next);
286 287 288 289 290 291 292
}

static unsigned long xen_store_tr(void)
{
	return 0;
}

293
/*
294 295 296 297
 * Set the page permissions for a particular virtual address.  If the
 * address is a vmalloc mapping (or other non-linear mapping), then
 * find the linear mapping of the page and also set its protections to
 * match.
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
 */
static void set_aliased_prot(void *v, pgprot_t prot)
{
	int level;
	pte_t *ptep;
	pte_t pte;
	unsigned long pfn;
	struct page *page;

	ptep = lookup_address((unsigned long)v, &level);
	BUG_ON(ptep == NULL);

	pfn = pte_pfn(*ptep);
	page = pfn_to_page(pfn);

	pte = pfn_pte(pfn, prot);

	if (HYPERVISOR_update_va_mapping((unsigned long)v, pte, 0))
		BUG();

	if (!PageHighMem(page)) {
		void *av = __va(PFN_PHYS(pfn));

		if (av != v)
			if (HYPERVISOR_update_va_mapping((unsigned long)av, pte, 0))
				BUG();
	} else
		kmap_flush_unused();
}

328 329
static void xen_alloc_ldt(struct desc_struct *ldt, unsigned entries)
{
330
	const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
331 332
	int i;

333 334
	for(i = 0; i < entries; i += entries_per_page)
		set_aliased_prot(ldt + i, PAGE_KERNEL_RO);
335 336 337 338
}

static void xen_free_ldt(struct desc_struct *ldt, unsigned entries)
{
339
	const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
340 341
	int i;

342 343
	for(i = 0; i < entries; i += entries_per_page)
		set_aliased_prot(ldt + i, PAGE_KERNEL);
344 345
}

346 347 348 349 350 351 352
static void xen_set_ldt(const void *addr, unsigned entries)
{
	struct mmuext_op *op;
	struct multicall_space mcs = xen_mc_entry(sizeof(*op));

	op = mcs.args;
	op->cmd = MMUEXT_SET_LDT;
353
	op->arg1.linear_addr = (unsigned long)addr;
354 355 356 357 358 359 360
	op->arg2.nr_ents = entries;

	MULTI_mmuext_op(mcs.mc, op, 1, NULL, DOMID_SELF);

	xen_mc_issue(PARAVIRT_LAZY_CPU);
}

361
static void xen_load_gdt(const struct desc_ptr *dtr)
362 363 364 365
{
	unsigned long va = dtr->address;
	unsigned int size = dtr->size + 1;
	unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
366
	unsigned long frames[pages];
367 368
	int f;

369 370 371 372
	/*
	 * A GDT can be up to 64k in size, which corresponds to 8192
	 * 8-byte entries, or 16 4k pages..
	 */
373 374 375 376 377

	BUG_ON(size > 65536);
	BUG_ON(va & ~PAGE_MASK);

	for (f = 0; va < dtr->address + size; va += PAGE_SIZE, f++) {
J
Jeremy Fitzhardinge 已提交
378
		int level;
379
		pte_t *ptep;
J
Jeremy Fitzhardinge 已提交
380 381 382
		unsigned long pfn, mfn;
		void *virt;

383 384 385 386 387 388 389 390
		/*
		 * The GDT is per-cpu and is in the percpu data area.
		 * That can be virtually mapped, so we need to do a
		 * page-walk to get the underlying MFN for the
		 * hypercall.  The page can also be in the kernel's
		 * linear range, so we need to RO that mapping too.
		 */
		ptep = lookup_address(va, &level);
J
Jeremy Fitzhardinge 已提交
391 392 393 394 395 396 397
		BUG_ON(ptep == NULL);

		pfn = pte_pfn(*ptep);
		mfn = pfn_to_mfn(pfn);
		virt = __va(PFN_PHYS(pfn));

		frames[f] = mfn;
398

399
		make_lowmem_page_readonly((void *)va);
J
Jeremy Fitzhardinge 已提交
400
		make_lowmem_page_readonly(virt);
401 402
	}

403 404
	if (HYPERVISOR_set_gdt(frames, size / sizeof(struct desc_struct)))
		BUG();
405 406
}

407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
/*
 * load_gdt for early boot, when the gdt is only mapped once
 */
static __init void xen_load_gdt_boot(const struct desc_ptr *dtr)
{
	unsigned long va = dtr->address;
	unsigned int size = dtr->size + 1;
	unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
	unsigned long frames[pages];
	int f;

	/*
	 * A GDT can be up to 64k in size, which corresponds to 8192
	 * 8-byte entries, or 16 4k pages..
	 */

	BUG_ON(size > 65536);
	BUG_ON(va & ~PAGE_MASK);

	for (f = 0; va < dtr->address + size; va += PAGE_SIZE, f++) {
		pte_t pte;
		unsigned long pfn, mfn;

		pfn = virt_to_pfn(va);
		mfn = pfn_to_mfn(pfn);

		pte = pfn_pte(pfn, PAGE_KERNEL_RO);

		if (HYPERVISOR_update_va_mapping((unsigned long)va, pte, 0))
			BUG();

		frames[f] = mfn;
	}

	if (HYPERVISOR_set_gdt(frames, size / sizeof(struct desc_struct)))
		BUG();
}

445 446 447 448
static void load_TLS_descriptor(struct thread_struct *t,
				unsigned int cpu, unsigned int i)
{
	struct desc_struct *gdt = get_cpu_gdt_table(cpu);
449
	xmaddr_t maddr = arbitrary_virt_to_machine(&gdt[GDT_ENTRY_TLS_MIN+i]);
450 451 452 453 454 455 456
	struct multicall_space mc = __xen_mc_entry(0);

	MULTI_update_descriptor(mc.mc, maddr.maddr, t->tls_array[i]);
}

static void xen_load_tls(struct thread_struct *t, unsigned int cpu)
{
457
	/*
458 459 460 461 462 463 464 465
	 * XXX sleazy hack: If we're being called in a lazy-cpu zone
	 * and lazy gs handling is enabled, it means we're in a
	 * context switch, and %gs has just been saved.  This means we
	 * can zero it out to prevent faults on exit from the
	 * hypervisor if the next process has no %gs.  Either way, it
	 * has been saved, and the new value will get loaded properly.
	 * This will go away as soon as Xen has been modified to not
	 * save/restore %gs for normal hypercalls.
466 467 468 469 470 471 472 473
	 *
	 * On x86_64, this hack is not used for %gs, because gs points
	 * to KERNEL_GS_BASE (and uses it for PDA references), so we
	 * must not zero %gs on x86_64
	 *
	 * For x86_64, we need to zero %fs, otherwise we may get an
	 * exception between the new %fs descriptor being loaded and
	 * %fs being effectively cleared at __switch_to().
474
	 */
475 476
	if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU) {
#ifdef CONFIG_X86_32
477
		lazy_load_gs(0);
478 479 480 481 482 483 484 485 486 487 488 489
#else
		loadsegment(fs, 0);
#endif
	}

	xen_mc_batch();

	load_TLS_descriptor(t, cpu, 0);
	load_TLS_descriptor(t, cpu, 1);
	load_TLS_descriptor(t, cpu, 2);

	xen_mc_issue(PARAVIRT_LAZY_CPU);
490 491
}

492 493 494 495 496
#ifdef CONFIG_X86_64
static void xen_load_gs_index(unsigned int idx)
{
	if (HYPERVISOR_set_segment_base(SEGBASE_GS_USER_SEL, idx))
		BUG();
497
}
498
#endif
499 500

static void xen_write_ldt_entry(struct desc_struct *dt, int entrynum,
501
				const void *ptr)
502
{
503
	xmaddr_t mach_lp = arbitrary_virt_to_machine(&dt[entrynum]);
504
	u64 entry = *(u64 *)ptr;
505

506 507
	preempt_disable();

508 509 510
	xen_mc_flush();
	if (HYPERVISOR_update_descriptor(mach_lp.maddr, entry))
		BUG();
511 512

	preempt_enable();
513 514
}

515
static int cvt_gate_to_trap(int vector, const gate_desc *val,
516 517
			    struct trap_info *info)
{
518 519
	unsigned long addr;

520
	if (val->type != GATE_TRAP && val->type != GATE_INTERRUPT)
521 522 523
		return 0;

	info->vector = vector;
524 525 526

	addr = gate_offset(*val);
#ifdef CONFIG_X86_64
527 528 529 530 531 532 533
	/*
	 * Look for known traps using IST, and substitute them
	 * appropriately.  The debugger ones are the only ones we care
	 * about.  Xen will handle faults like double_fault and
	 * machine_check, so we should never see them.  Warn if
	 * there's an unexpected IST-using fault handler.
	 */
534 535 536 537 538 539
	if (addr == (unsigned long)debug)
		addr = (unsigned long)xen_debug;
	else if (addr == (unsigned long)int3)
		addr = (unsigned long)xen_int3;
	else if (addr == (unsigned long)stack_segment)
		addr = (unsigned long)xen_stack_segment;
540 541 542 543 544 545 546 547 548 549 550 551 552
	else if (addr == (unsigned long)double_fault ||
		 addr == (unsigned long)nmi) {
		/* Don't need to handle these */
		return 0;
#ifdef CONFIG_X86_MCE
	} else if (addr == (unsigned long)machine_check) {
		return 0;
#endif
	} else {
		/* Some other trap using IST? */
		if (WARN_ON(val->ist != 0))
			return 0;
	}
553 554 555
#endif	/* CONFIG_X86_64 */
	info->address = addr;

556 557
	info->cs = gate_segment(*val);
	info->flags = val->dpl;
558
	/* interrupt gates clear IF */
559 560
	if (val->type == GATE_INTERRUPT)
		info->flags |= 1 << 2;
561 562 563 564 565

	return 1;
}

/* Locations of each CPU's IDT */
566
static DEFINE_PER_CPU(struct desc_ptr, idt_desc);
567 568 569

/* Set an IDT entry.  If the entry is part of the current IDT, then
   also update Xen. */
570
static void xen_write_idt_entry(gate_desc *dt, int entrynum, const gate_desc *g)
571 572
{
	unsigned long p = (unsigned long)&dt[entrynum];
573 574 575 576 577 578
	unsigned long start, end;

	preempt_disable();

	start = __get_cpu_var(idt_desc).address;
	end = start + __get_cpu_var(idt_desc).size + 1;
579 580 581

	xen_mc_flush();

582
	native_write_idt_entry(dt, entrynum, g);
583 584 585 586 587 588

	if (p >= start && (p + 8) <= end) {
		struct trap_info info[2];

		info[1].address = 0;

589
		if (cvt_gate_to_trap(entrynum, g, &info[0]))
590 591 592
			if (HYPERVISOR_set_trap_table(info))
				BUG();
	}
593 594

	preempt_enable();
595 596
}

597
static void xen_convert_trap_info(const struct desc_ptr *desc,
J
Jeremy Fitzhardinge 已提交
598
				  struct trap_info *traps)
599 600 601
{
	unsigned in, out, count;

602
	count = (desc->size+1) / sizeof(gate_desc);
603 604 605
	BUG_ON(count > 256);

	for (in = out = 0; in < count; in++) {
606
		gate_desc *entry = (gate_desc*)(desc->address) + in;
607

608
		if (cvt_gate_to_trap(in, entry, &traps[out]))
609 610 611
			out++;
	}
	traps[out].address = 0;
J
Jeremy Fitzhardinge 已提交
612 613 614 615
}

void xen_copy_trap_info(struct trap_info *traps)
{
616
	const struct desc_ptr *desc = &__get_cpu_var(idt_desc);
J
Jeremy Fitzhardinge 已提交
617 618 619 620 621 622 623

	xen_convert_trap_info(desc, traps);
}

/* Load a new IDT into Xen.  In principle this can be per-CPU, so we
   hold a spinlock to protect the static traps[] array (static because
   it avoids allocation, and saves stack space). */
624
static void xen_load_idt(const struct desc_ptr *desc)
J
Jeremy Fitzhardinge 已提交
625 626 627 628 629 630
{
	static DEFINE_SPINLOCK(lock);
	static struct trap_info traps[257];

	spin_lock(&lock);

631 632
	__get_cpu_var(idt_desc) = *desc;

J
Jeremy Fitzhardinge 已提交
633
	xen_convert_trap_info(desc, traps);
634 635 636 637 638 639 640 641 642 643 644

	xen_mc_flush();
	if (HYPERVISOR_set_trap_table(traps))
		BUG();

	spin_unlock(&lock);
}

/* Write a GDT descriptor entry.  Ignore LDT descriptors, since
   they're handled differently. */
static void xen_write_gdt_entry(struct desc_struct *dt, int entry,
645
				const void *desc, int type)
646
{
647 648
	preempt_disable();

649 650 651
	switch (type) {
	case DESC_LDT:
	case DESC_TSS:
652 653 654 655
		/* ignore */
		break;

	default: {
656
		xmaddr_t maddr = arbitrary_virt_to_machine(&dt[entry]);
657 658

		xen_mc_flush();
659
		if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
660 661 662 663
			BUG();
	}

	}
664 665

	preempt_enable();
666 667
}

668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
/*
 * Version of write_gdt_entry for use at early boot-time needed to
 * update an entry as simply as possible.
 */
static __init void xen_write_gdt_entry_boot(struct desc_struct *dt, int entry,
					    const void *desc, int type)
{
	switch (type) {
	case DESC_LDT:
	case DESC_TSS:
		/* ignore */
		break;

	default: {
		xmaddr_t maddr = virt_to_machine(&dt[entry]);

		if (HYPERVISOR_update_descriptor(maddr.maddr, *(u64 *)desc))
			dt[entry] = *(struct desc_struct *)desc;
	}

	}
}

691
static void xen_load_sp0(struct tss_struct *tss,
692
			 struct thread_struct *thread)
693 694
{
	struct multicall_space mcs = xen_mc_entry(0);
695
	MULTI_stack_switch(mcs.mc, __KERNEL_DS, thread->sp0);
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
	xen_mc_issue(PARAVIRT_LAZY_CPU);
}

static void xen_set_iopl_mask(unsigned mask)
{
	struct physdev_set_iopl set_iopl;

	/* Force the change at ring 0. */
	set_iopl.iopl = (mask == 0) ? 1 : (mask >> 12) & 3;
	HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
}

static void xen_io_delay(void)
{
}

#ifdef CONFIG_X86_LOCAL_APIC
713
static u32 xen_apic_read(u32 reg)
714 715 716
{
	return 0;
}
J
Jeremy Fitzhardinge 已提交
717

718
static void xen_apic_write(u32 reg, u32 val)
J
Jeremy Fitzhardinge 已提交
719 720 721 722
{
	/* Warn to see if there's any stray references */
	WARN_ON(1);
}
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739

static u64 xen_apic_icr_read(void)
{
	return 0;
}

static void xen_apic_icr_write(u32 low, u32 id)
{
	/* Warn to see if there's any stray references */
	WARN_ON(1);
}

static void xen_apic_wait_icr_idle(void)
{
        return;
}

740 741 742 743 744
static u32 xen_safe_apic_wait_icr_idle(void)
{
        return 0;
}

Y
Yinghai Lu 已提交
745 746 747 748 749 750 751 752 753
static void set_xen_basic_apic_ops(void)
{
	apic->read = xen_apic_read;
	apic->write = xen_apic_write;
	apic->icr_read = xen_apic_icr_read;
	apic->icr_write = xen_apic_icr_write;
	apic->wait_icr_idle = xen_apic_wait_icr_idle;
	apic->safe_wait_icr_idle = xen_safe_apic_wait_icr_idle;
}
754

755 756
#endif

757 758 759 760 761 762 763 764 765 766 767
static void xen_clts(void)
{
	struct multicall_space mcs;

	mcs = xen_mc_entry(0);

	MULTI_fpu_taskswitch(mcs.mc, 0);

	xen_mc_issue(PARAVIRT_LAZY_CPU);
}

768 769 770 771 772 773 774 775 776 777 778 779 780 781
static DEFINE_PER_CPU(unsigned long, xen_cr0_value);

static unsigned long xen_read_cr0(void)
{
	unsigned long cr0 = percpu_read(xen_cr0_value);

	if (unlikely(cr0 == 0)) {
		cr0 = native_read_cr0();
		percpu_write(xen_cr0_value, cr0);
	}

	return cr0;
}

782 783 784 785
static void xen_write_cr0(unsigned long cr0)
{
	struct multicall_space mcs;

786 787
	percpu_write(xen_cr0_value, cr0);

788 789 790 791 792 793 794 795 796
	/* Only pay attention to cr0.TS; everything else is
	   ignored. */
	mcs = xen_mc_entry(0);

	MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);

	xen_mc_issue(PARAVIRT_LAZY_CPU);
}

797 798
static void xen_write_cr4(unsigned long cr4)
{
799 800 801 802
	cr4 &= ~X86_CR4_PGE;
	cr4 &= ~X86_CR4_PSE;

	native_write_cr4(cr4);
803 804
}

805 806 807 808 809 810
static int xen_write_msr_safe(unsigned int msr, unsigned low, unsigned high)
{
	int ret;

	ret = 0;

T
Tej 已提交
811
	switch (msr) {
812 813 814 815 816 817 818 819 820 821 822
#ifdef CONFIG_X86_64
		unsigned which;
		u64 base;

	case MSR_FS_BASE:		which = SEGBASE_FS; goto set;
	case MSR_KERNEL_GS_BASE:	which = SEGBASE_GS_USER; goto set;
	case MSR_GS_BASE:		which = SEGBASE_GS_KERNEL; goto set;

	set:
		base = ((u64)high << 32) | low;
		if (HYPERVISOR_set_segment_base(which, base) != 0)
823
			ret = -EIO;
824 825
		break;
#endif
J
Jeremy Fitzhardinge 已提交
826 827 828 829 830 831 832 833 834 835 836 837 838

	case MSR_STAR:
	case MSR_CSTAR:
	case MSR_LSTAR:
	case MSR_SYSCALL_MASK:
	case MSR_IA32_SYSENTER_CS:
	case MSR_IA32_SYSENTER_ESP:
	case MSR_IA32_SYSENTER_EIP:
		/* Fast syscall setup is all done in hypercalls, so
		   these are all ignored.  Stub them out here to stop
		   Xen console noise. */
		break;

J
Jeremy Fitzhardinge 已提交
839 840 841 842 843
	case MSR_IA32_CR_PAT:
		if (smp_processor_id() == 0)
			xen_set_pat(((u64)high << 32) | low);
		break;

844 845 846 847 848 849 850
	default:
		ret = native_write_msr_safe(msr, low, high);
	}

	return ret;
}

851
void xen_setup_shared_info(void)
852 853
{
	if (!xen_feature(XENFEAT_auto_translated_physmap)) {
854 855 856 857 858
		set_fixmap(FIX_PARAVIRT_BOOTMAP,
			   xen_start_info->shared_info);

		HYPERVISOR_shared_info =
			(struct shared_info *)fix_to_virt(FIX_PARAVIRT_BOOTMAP);
859 860 861 862
	} else
		HYPERVISOR_shared_info =
			(struct shared_info *)__va(xen_start_info->shared_info);

863 864 865 866
#ifndef CONFIG_SMP
	/* In UP this is as good a place as any to set up shared info */
	xen_setup_vcpu_info_placement();
#endif
J
Jeremy Fitzhardinge 已提交
867 868

	xen_setup_mfn_list_list();
869 870
}

871
/* This is called once we have the cpu_possible_map */
872
void xen_setup_vcpu_info_placement(void)
873 874 875 876 877 878 879 880 881
{
	int cpu;

	for_each_possible_cpu(cpu)
		xen_vcpu_setup(cpu);

	/* xen_vcpu_setup managed to place the vcpu_info within the
	   percpu area for all cpus, so make use of it */
	if (have_vcpu_info_placement) {
882 883 884 885
		pv_irq_ops.save_fl = __PV_IS_CALLEE_SAVE(xen_save_fl_direct);
		pv_irq_ops.restore_fl = __PV_IS_CALLEE_SAVE(xen_restore_fl_direct);
		pv_irq_ops.irq_disable = __PV_IS_CALLEE_SAVE(xen_irq_disable_direct);
		pv_irq_ops.irq_enable = __PV_IS_CALLEE_SAVE(xen_irq_enable_direct);
886
		pv_mmu_ops.read_cr2 = xen_read_cr2_direct;
887
	}
888 889
}

890 891
static unsigned xen_patch(u8 type, u16 clobbers, void *insnbuf,
			  unsigned long addr, unsigned len)
892 893 894 895 896 897
{
	char *start, *end, *reloc;
	unsigned ret;

	start = end = reloc = NULL;

898 899
#define SITE(op, x)							\
	case PARAVIRT_PATCH(op.x):					\
900 901 902 903 904 905 906 907
	if (have_vcpu_info_placement) {					\
		start = (char *)xen_##x##_direct;			\
		end = xen_##x##_direct_end;				\
		reloc = xen_##x##_direct_reloc;				\
	}								\
	goto patch_site

	switch (type) {
908 909 910 911
		SITE(pv_irq_ops, irq_enable);
		SITE(pv_irq_ops, irq_disable);
		SITE(pv_irq_ops, save_fl);
		SITE(pv_irq_ops, restore_fl);
912 913 914 915 916 917
#undef SITE

	patch_site:
		if (start == NULL || (end-start) > len)
			goto default_patch;

918
		ret = paravirt_patch_insns(insnbuf, len, start, end);
919 920 921 922 923 924 925

		/* Note: because reloc is assigned from something that
		   appears to be an array, gcc assumes it's non-null,
		   but doesn't know its relationship with start and
		   end. */
		if (reloc > start && reloc < end) {
			int reloc_off = reloc - start;
926 927
			long *relocp = (long *)(insnbuf + reloc_off);
			long delta = start - (char *)addr;
928 929 930 931 932 933 934

			*relocp += delta;
		}
		break;

	default_patch:
	default:
935 936
		ret = paravirt_patch_default(type, clobbers, insnbuf,
					     addr, len);
937 938 939 940 941 942
		break;
	}

	return ret;
}

943
static const struct pv_info xen_info __initdata = {
944 945 946 947
	.paravirt_enabled = 1,
	.shared_kernel_pmd = 0,

	.name = "Xen",
948
};
949

950
static const struct pv_init_ops xen_init_ops __initdata = {
951
	.patch = xen_patch,
952
};
953

954
static const struct pv_cpu_ops xen_cpu_ops __initdata = {
955 956 957 958 959
	.cpuid = xen_cpuid,

	.set_debugreg = xen_set_debugreg,
	.get_debugreg = xen_get_debugreg,

960
	.clts = xen_clts,
961

962
	.read_cr0 = xen_read_cr0,
963
	.write_cr0 = xen_write_cr0,
964 965 966 967 968 969 970 971

	.read_cr4 = native_read_cr4,
	.read_cr4_safe = native_read_cr4_safe,
	.write_cr4 = xen_write_cr4,

	.wbinvd = native_wbinvd,

	.read_msr = native_read_msr_safe,
972
	.write_msr = xen_write_msr_safe,
973 974 975
	.read_tsc = native_read_tsc,
	.read_pmc = native_read_pmc,

976
	.iret = xen_iret,
977
	.irq_enable_sysexit = xen_sysexit,
978 979 980 981
#ifdef CONFIG_X86_64
	.usergs_sysret32 = xen_sysret32,
	.usergs_sysret64 = xen_sysret64,
#endif
982 983 984 985 986 987

	.load_tr_desc = paravirt_nop,
	.set_ldt = xen_set_ldt,
	.load_gdt = xen_load_gdt,
	.load_idt = xen_load_idt,
	.load_tls = xen_load_tls,
988 989 990
#ifdef CONFIG_X86_64
	.load_gs_index = xen_load_gs_index,
#endif
991

992 993 994
	.alloc_ldt = xen_alloc_ldt,
	.free_ldt = xen_free_ldt,

995 996 997 998 999 1000 1001
	.store_gdt = native_store_gdt,
	.store_idt = native_store_idt,
	.store_tr = xen_store_tr,

	.write_ldt_entry = xen_write_ldt_entry,
	.write_gdt_entry = xen_write_gdt_entry,
	.write_idt_entry = xen_write_idt_entry,
1002
	.load_sp0 = xen_load_sp0,
1003 1004 1005 1006

	.set_iopl_mask = xen_set_iopl_mask,
	.io_delay = xen_io_delay,

J
Jeremy Fitzhardinge 已提交
1007 1008 1009
	/* Xen takes care of %gs when switching to usermode for us */
	.swapgs = paravirt_nop,

1010 1011
	.start_context_switch = paravirt_start_context_switch,
	.end_context_switch = xen_end_context_switch,
1012 1013 1014
};

static const struct pv_apic_ops xen_apic_ops __initdata = {
1015 1016 1017
#ifdef CONFIG_X86_LOCAL_APIC
	.startup_ipi_hook = paravirt_nop,
#endif
1018 1019
};

J
Jeremy Fitzhardinge 已提交
1020 1021
static void xen_reboot(int reason)
{
J
Jeremy Fitzhardinge 已提交
1022 1023 1024
	struct sched_shutdown r = { .reason = reason };

	if (HYPERVISOR_sched_op(SCHEDOP_shutdown, &r))
J
Jeremy Fitzhardinge 已提交
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
		BUG();
}

static void xen_restart(char *msg)
{
	xen_reboot(SHUTDOWN_reboot);
}

static void xen_emergency_restart(void)
{
	xen_reboot(SHUTDOWN_reboot);
}

static void xen_machine_halt(void)
{
	xen_reboot(SHUTDOWN_poweroff);
}

static void xen_crash_shutdown(struct pt_regs *regs)
{
	xen_reboot(SHUTDOWN_crash);
}

1048 1049 1050
static int
xen_panic_event(struct notifier_block *this, unsigned long event, void *ptr)
{
1051
	xen_reboot(SHUTDOWN_crash);
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	return NOTIFY_DONE;
}

static struct notifier_block xen_panic_block = {
	.notifier_call= xen_panic_event,
};

int xen_panic_handler_init(void)
{
	atomic_notifier_chain_register(&panic_notifier_list, &xen_panic_block);
	return 0;
}

J
Jeremy Fitzhardinge 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073
static const struct machine_ops __initdata xen_machine_ops = {
	.restart = xen_restart,
	.halt = xen_machine_halt,
	.power_off = xen_machine_halt,
	.shutdown = xen_machine_halt,
	.crash_shutdown = xen_crash_shutdown,
	.emergency_restart = xen_emergency_restart,
};

1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
/*
 * Set up the GDT and segment registers for -fstack-protector.  Until
 * we do this, we have to be careful not to call any stack-protected
 * function, which is most of the kernel.
 */
static void __init xen_setup_stackprotector(void)
{
	pv_cpu_ops.write_gdt_entry = xen_write_gdt_entry_boot;
	pv_cpu_ops.load_gdt = xen_load_gdt_boot;

	setup_stack_canary_segment(0);
	switch_to_new_gdt(0);

	pv_cpu_ops.write_gdt_entry = xen_write_gdt_entry;
	pv_cpu_ops.load_gdt = xen_load_gdt;
}

1091 1092 1093
/* First C function to be called on Xen boot */
asmlinkage void __init xen_start_kernel(void)
{
1094 1095
	struct physdev_set_iopl set_iopl;
	int rc;
1096 1097 1098 1099 1100
	pgd_t *pgd;

	if (!xen_start_info)
		return;

1101 1102
	xen_domain_type = XEN_PV_DOMAIN;

1103 1104
	xen_setup_machphys_mapping();

1105
	/* Install Xen paravirt ops */
1106 1107 1108 1109 1110
	pv_info = xen_info;
	pv_init_ops = xen_init_ops;
	pv_cpu_ops = xen_cpu_ops;
	pv_apic_ops = xen_apic_ops;

1111
	x86_init.resources.memory_setup = xen_memory_setup;
1112
	x86_init.oem.arch_setup = xen_arch_setup;
1113
	x86_init.oem.banner = xen_banner;
1114

1115
	xen_init_time_ops();
1116

1117
	/*
1118
	 * Set up some pagetable state before starting to set any ptes.
1119
	 */
1120

1121 1122
	xen_init_mmu_ops();

1123 1124 1125 1126 1127 1128 1129
	/* Prevent unwanted bits from being set in PTEs. */
	__supported_pte_mask &= ~_PAGE_GLOBAL;
	if (!xen_initial_domain())
		__supported_pte_mask &= ~(_PAGE_PWT | _PAGE_PCD);

	__supported_pte_mask |= _PAGE_IOMAP;

1130 1131 1132 1133 1134 1135
	/*
	 * Prevent page tables from being allocated in highmem, even
	 * if CONFIG_HIGHPTE is enabled.
	 */
	__userpte_alloc_gfp &= ~__GFP_HIGHMEM;

1136
	/* Work out if we support NX */
1137
	x86_configure_nx();
1138

1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
	xen_setup_features();

	/* Get mfn list */
	if (!xen_feature(XENFEAT_auto_translated_physmap))
		xen_build_dynamic_phys_to_machine();

	/*
	 * Set up kernel GDT and segment registers, mainly so that
	 * -fstack-protector code can be executed.
	 */
	xen_setup_stackprotector();
1150

1151
	xen_init_irq_ops();
J
Jeremy Fitzhardinge 已提交
1152 1153
	xen_init_cpuid_mask();

1154
#ifdef CONFIG_X86_LOCAL_APIC
1155
	/*
1156
	 * set up the basic apic ops.
1157
	 */
Y
Yinghai Lu 已提交
1158
	set_xen_basic_apic_ops();
1159
#endif
1160

1161 1162 1163 1164 1165
	if (xen_feature(XENFEAT_mmu_pt_update_preserve_ad)) {
		pv_mmu_ops.ptep_modify_prot_start = xen_ptep_modify_prot_start;
		pv_mmu_ops.ptep_modify_prot_commit = xen_ptep_modify_prot_commit;
	}

J
Jeremy Fitzhardinge 已提交
1166 1167
	machine_ops = xen_machine_ops;

1168 1169 1170 1171 1172 1173
	/*
	 * The only reliable way to retain the initial address of the
	 * percpu gdt_page is to remember it here, so we can go and
	 * mark it RW later, when the initial percpu area is freed.
	 */
	xen_initial_gdt = &per_cpu(gdt_page, 0);
1174

1175
	xen_smp_init();
1176 1177 1178

	pgd = (pgd_t *)xen_start_info->pt_base;

1179 1180 1181 1182
	if (!xen_initial_domain())
		__supported_pte_mask &= ~(_PAGE_PWT | _PAGE_PCD);

	__supported_pte_mask |= _PAGE_IOMAP;
1183
	/* Don't do the full vcpu_info placement stuff until we have a
1184
	   possible map and a non-dummy shared_info. */
1185
	per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
1186

1187 1188 1189
	local_irq_disable();
	early_boot_irqs_off();

1190 1191
	memblock_init();

J
Jeremy Fitzhardinge 已提交
1192
	xen_raw_console_write("mapping kernel into physical memory\n");
1193
	pgd = xen_setup_kernel_pagetable(pgd, xen_start_info->nr_pages);
1194
	xen_ident_map_ISA();
1195

1196 1197 1198
	/* Allocate and initialize top and mid mfn levels for p2m structure */
	xen_build_mfn_list_list();

1199 1200
	/* keep using Xen gdt for now; no urgent need to change it */

1201
#ifdef CONFIG_X86_32
1202
	pv_info.kernel_rpl = 1;
1203
	if (xen_feature(XENFEAT_supervisor_mode_kernel))
1204
		pv_info.kernel_rpl = 0;
1205 1206 1207
#else
	pv_info.kernel_rpl = 0;
#endif
1208
	/* set the limit of our address space */
1209
	xen_reserve_top();
1210

1211 1212 1213 1214 1215 1216 1217 1218 1219
	/* We used to do this in xen_arch_setup, but that is too late on AMD
	 * were early_cpu_init (run before ->arch_setup()) calls early_amd_init
	 * which pokes 0xcf8 port.
	 */
	set_iopl.iopl = 1;
	rc = HYPERVISOR_physdev_op(PHYSDEVOP_set_iopl, &set_iopl);
	if (rc != 0)
		xen_raw_printk("physdev_op failed %d\n", rc);

1220
#ifdef CONFIG_X86_32
1221 1222 1223
	/* set up basic CPUID stuff */
	cpu_detect(&new_cpu_data);
	new_cpu_data.hard_math = 1;
1224
	new_cpu_data.wp_works_ok = 1;
1225
	new_cpu_data.x86_capability[0] = cpuid_edx(1);
1226
#endif
1227 1228

	/* Poke various useful things into boot_params */
1229 1230 1231 1232
	boot_params.hdr.type_of_loader = (9 << 4) | 0;
	boot_params.hdr.ramdisk_image = xen_start_info->mod_start
		? __pa(xen_start_info->mod_start) : 0;
	boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
1233
	boot_params.hdr.cmd_line_ptr = __pa(xen_start_info->cmd_line);
1234

1235
	if (!xen_initial_domain()) {
1236
		add_preferred_console("xenboot", 0, NULL);
1237
		add_preferred_console("tty", 0, NULL);
1238
		add_preferred_console("hvc", 0, NULL);
1239 1240
		if (pci_xen)
			x86_init.pci.arch_init = pci_xen_init;
C
Chris Wright 已提交
1241 1242 1243
	} else {
		/* Make sure ACS will be enabled */
		pci_request_acs();
1244
	}
C
Chris Wright 已提交
1245
		
1246

J
Jeremy Fitzhardinge 已提交
1247 1248
	xen_raw_console_write("about to get started...\n");

1249 1250
	xen_setup_runstate_info(0);

1251
	/* Start the world */
1252
#ifdef CONFIG_X86_32
1253
	i386_start_kernel();
1254
#else
J
Jeremy Fitzhardinge 已提交
1255
	x86_64_start_reservations((char *)__pa_symbol(&boot_params));
1256
#endif
1257
}
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

static uint32_t xen_cpuid_base(void)
{
	uint32_t base, eax, ebx, ecx, edx;
	char signature[13];

	for (base = 0x40000000; base < 0x40010000; base += 0x100) {
		cpuid(base, &eax, &ebx, &ecx, &edx);
		*(uint32_t *)(signature + 0) = ebx;
		*(uint32_t *)(signature + 4) = ecx;
		*(uint32_t *)(signature + 8) = edx;
		signature[12] = 0;

		if (!strcmp("XenVMMXenVMM", signature) && ((eax - base) >= 2))
			return base;
	}

	return 0;
}

static int init_hvm_pv_info(int *major, int *minor)
{
	uint32_t eax, ebx, ecx, edx, pages, msr, base;
	u64 pfn;

	base = xen_cpuid_base();
	cpuid(base + 1, &eax, &ebx, &ecx, &edx);

	*major = eax >> 16;
	*minor = eax & 0xffff;
	printk(KERN_INFO "Xen version %d.%d.\n", *major, *minor);

	cpuid(base + 2, &pages, &msr, &ecx, &edx);

	pfn = __pa(hypercall_page);
	wrmsr_safe(msr, (u32)pfn, (u32)(pfn >> 32));

	xen_setup_features();

	pv_info = xen_info;
	pv_info.kernel_rpl = 0;

	xen_domain_type = XEN_HVM_DOMAIN;

	return 0;
}

1305
void xen_hvm_init_shared_info(void)
1306
{
1307
	int cpu;
1308
	struct xen_add_to_physmap xatp;
1309
	static struct shared_info *shared_info_page = 0;
1310

1311 1312 1313
	if (!shared_info_page)
		shared_info_page = (struct shared_info *)
			extend_brk(PAGE_SIZE, PAGE_SIZE);
1314 1315 1316 1317 1318 1319 1320 1321 1322
	xatp.domid = DOMID_SELF;
	xatp.idx = 0;
	xatp.space = XENMAPSPACE_shared_info;
	xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT;
	if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
		BUG();

	HYPERVISOR_shared_info = (struct shared_info *)shared_info_page;

1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
	/* xen_vcpu is a pointer to the vcpu_info struct in the shared_info
	 * page, we use it in the event channel upcall and in some pvclock
	 * related functions. We don't need the vcpu_info placement
	 * optimizations because we don't use any pv_mmu or pv_irq op on
	 * HVM.
	 * When xen_hvm_init_shared_info is run at boot time only vcpu 0 is
	 * online but xen_hvm_init_shared_info is run at resume time too and
	 * in that case multiple vcpus might be online. */
	for_each_online_cpu(cpu) {
		per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
	}
1334 1335
}

1336
#ifdef CONFIG_XEN_PVHVM
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
static int __cpuinit xen_hvm_cpu_notify(struct notifier_block *self,
				    unsigned long action, void *hcpu)
{
	int cpu = (long)hcpu;
	switch (action) {
	case CPU_UP_PREPARE:
		per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
		break;
	default:
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block __cpuinitdata xen_hvm_cpu_notifier = {
	.notifier_call	= xen_hvm_cpu_notify,
};

1355 1356 1357 1358 1359 1360 1361 1362 1363
static void __init xen_hvm_guest_init(void)
{
	int r;
	int major, minor;

	r = init_hvm_pv_info(&major, &minor);
	if (r < 0)
		return;

1364
	xen_hvm_init_shared_info();
1365 1366 1367 1368

	if (xen_feature(XENFEAT_hvm_callback_vector))
		xen_have_vector_callback = 1;
	register_cpu_notifier(&xen_hvm_cpu_notifier);
1369
	xen_unplug_emulated_devices();
1370 1371
	have_vcpu_info_placement = 0;
	x86_init.irqs.intr_init = xen_init_IRQ;
1372
	xen_hvm_init_time_ops();
1373
	xen_hvm_init_mmu_ops();
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392
}

static bool __init xen_hvm_platform(void)
{
	if (xen_pv_domain())
		return false;

	if (!xen_cpuid_base())
		return false;

	return true;
}

const __refconst struct hypervisor_x86 x86_hyper_xen_hvm = {
	.name			= "Xen HVM",
	.detect			= xen_hvm_platform,
	.init_platform		= xen_hvm_guest_init,
};
EXPORT_SYMBOL(x86_hyper_xen_hvm);
1393
#endif