core.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718
  1. /*
  2. * Copyright (C) 2006, Rusty Russell <rusty@rustcorp.com.au> IBM Corporation.
  3. * Copyright (C) 2007, Jes Sorensen <jes@sgi.com> SGI.
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful, but
  11. * WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  13. * NON INFRINGEMENT. See the GNU General Public License for more
  14. * details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  20. /*P:450
  21. * This file contains the x86-specific lguest code. It used to be all
  22. * mixed in with drivers/lguest/core.c but several foolhardy code slashers
  23. * wrestled most of the dependencies out to here in preparation for porting
  24. * lguest to other architectures (see what I mean by foolhardy?).
  25. *
  26. * This also contains a couple of non-obvious setup and teardown pieces which
  27. * were implemented after days of debugging pain.
  28. :*/
  29. #include <linux/kernel.h>
  30. #include <linux/start_kernel.h>
  31. #include <linux/string.h>
  32. #include <linux/console.h>
  33. #include <linux/screen_info.h>
  34. #include <linux/irq.h>
  35. #include <linux/interrupt.h>
  36. #include <linux/clocksource.h>
  37. #include <linux/clockchips.h>
  38. #include <linux/cpu.h>
  39. #include <linux/lguest.h>
  40. #include <linux/lguest_launcher.h>
  41. #include <asm/paravirt.h>
  42. #include <asm/param.h>
  43. #include <asm/page.h>
  44. #include <asm/pgtable.h>
  45. #include <asm/desc.h>
  46. #include <asm/setup.h>
  47. #include <asm/lguest.h>
  48. #include <asm/uaccess.h>
  49. #include <asm/i387.h>
  50. #include "../lg.h"
  51. static int cpu_had_pge;
  52. static struct {
  53. unsigned long offset;
  54. unsigned short segment;
  55. } lguest_entry;
  56. /* Offset from where switcher.S was compiled to where we've copied it */
  57. static unsigned long switcher_offset(void)
  58. {
  59. return switcher_addr - (unsigned long)start_switcher_text;
  60. }
  61. /* This cpu's struct lguest_pages (after the Switcher text page) */
  62. static struct lguest_pages *lguest_pages(unsigned int cpu)
  63. {
  64. return &(((struct lguest_pages *)(switcher_addr + PAGE_SIZE))[cpu]);
  65. }
  66. static DEFINE_PER_CPU(struct lg_cpu *, lg_last_cpu);
  67. /*S:010
  68. * We approach the Switcher.
  69. *
  70. * Remember that each CPU has two pages which are visible to the Guest when it
  71. * runs on that CPU. This has to contain the state for that Guest: we copy the
  72. * state in just before we run the Guest.
  73. *
  74. * Each Guest has "changed" flags which indicate what has changed in the Guest
  75. * since it last ran. We saw this set in interrupts_and_traps.c and
  76. * segments.c.
  77. */
  78. static void copy_in_guest_info(struct lg_cpu *cpu, struct lguest_pages *pages)
  79. {
  80. /*
  81. * Copying all this data can be quite expensive. We usually run the
  82. * same Guest we ran last time (and that Guest hasn't run anywhere else
  83. * meanwhile). If that's not the case, we pretend everything in the
  84. * Guest has changed.
  85. */
  86. if (__this_cpu_read(lg_last_cpu) != cpu || cpu->last_pages != pages) {
  87. __this_cpu_write(lg_last_cpu, cpu);
  88. cpu->last_pages = pages;
  89. cpu->changed = CHANGED_ALL;
  90. }
  91. /*
  92. * These copies are pretty cheap, so we do them unconditionally: */
  93. /* Save the current Host top-level page directory.
  94. */
  95. pages->state.host_cr3 = __pa(current->mm->pgd);
  96. /*
  97. * Set up the Guest's page tables to see this CPU's pages (and no
  98. * other CPU's pages).
  99. */
  100. map_switcher_in_guest(cpu, pages);
  101. /*
  102. * Set up the two "TSS" members which tell the CPU what stack to use
  103. * for traps which do directly into the Guest (ie. traps at privilege
  104. * level 1).
  105. */
  106. pages->state.guest_tss.sp1 = cpu->esp1;
  107. pages->state.guest_tss.ss1 = cpu->ss1;
  108. /* Copy direct-to-Guest trap entries. */
  109. if (cpu->changed & CHANGED_IDT)
  110. copy_traps(cpu, pages->state.guest_idt, default_idt_entries);
  111. /* Copy all GDT entries which the Guest can change. */
  112. if (cpu->changed & CHANGED_GDT)
  113. copy_gdt(cpu, pages->state.guest_gdt);
  114. /* If only the TLS entries have changed, copy them. */
  115. else if (cpu->changed & CHANGED_GDT_TLS)
  116. copy_gdt_tls(cpu, pages->state.guest_gdt);
  117. /* Mark the Guest as unchanged for next time. */
  118. cpu->changed = 0;
  119. }
  120. /* Finally: the code to actually call into the Switcher to run the Guest. */
  121. static void run_guest_once(struct lg_cpu *cpu, struct lguest_pages *pages)
  122. {
  123. /* This is a dummy value we need for GCC's sake. */
  124. unsigned int clobber;
  125. /*
  126. * Copy the guest-specific information into this CPU's "struct
  127. * lguest_pages".
  128. */
  129. copy_in_guest_info(cpu, pages);
  130. /*
  131. * Set the trap number to 256 (impossible value). If we fault while
  132. * switching to the Guest (bad segment registers or bug), this will
  133. * cause us to abort the Guest.
  134. */
  135. cpu->regs->trapnum = 256;
  136. /*
  137. * Now: we push the "eflags" register on the stack, then do an "lcall".
  138. * This is how we change from using the kernel code segment to using
  139. * the dedicated lguest code segment, as well as jumping into the
  140. * Switcher.
  141. *
  142. * The lcall also pushes the old code segment (KERNEL_CS) onto the
  143. * stack, then the address of this call. This stack layout happens to
  144. * exactly match the stack layout created by an interrupt...
  145. */
  146. asm volatile("pushf; lcall *lguest_entry"
  147. /*
  148. * This is how we tell GCC that %eax ("a") and %ebx ("b")
  149. * are changed by this routine. The "=" means output.
  150. */
  151. : "=a"(clobber), "=b"(clobber)
  152. /*
  153. * %eax contains the pages pointer. ("0" refers to the
  154. * 0-th argument above, ie "a"). %ebx contains the
  155. * physical address of the Guest's top-level page
  156. * directory.
  157. */
  158. : "0"(pages), "1"(__pa(cpu->lg->pgdirs[cpu->cpu_pgd].pgdir))
  159. /*
  160. * We tell gcc that all these registers could change,
  161. * which means we don't have to save and restore them in
  162. * the Switcher.
  163. */
  164. : "memory", "%edx", "%ecx", "%edi", "%esi");
  165. }
  166. /*:*/
  167. /*M:002
  168. * There are hooks in the scheduler which we can register to tell when we
  169. * get kicked off the CPU (preempt_notifier_register()). This would allow us
  170. * to lazily disable SYSENTER which would regain some performance, and should
  171. * also simplify copy_in_guest_info(). Note that we'd still need to restore
  172. * things when we exit to Launcher userspace, but that's fairly easy.
  173. *
  174. * We could also try using these hooks for PGE, but that might be too expensive.
  175. *
  176. * The hooks were designed for KVM, but we can also put them to good use.
  177. :*/
  178. /*H:040
  179. * This is the i386-specific code to setup and run the Guest. Interrupts
  180. * are disabled: we own the CPU.
  181. */
  182. void lguest_arch_run_guest(struct lg_cpu *cpu)
  183. {
  184. /*
  185. * Remember the awfully-named TS bit? If the Guest has asked to set it
  186. * we set it now, so we can trap and pass that trap to the Guest if it
  187. * uses the FPU.
  188. */
  189. if (cpu->ts && user_has_fpu())
  190. stts();
  191. /*
  192. * SYSENTER is an optimized way of doing system calls. We can't allow
  193. * it because it always jumps to privilege level 0. A normal Guest
  194. * won't try it because we don't advertise it in CPUID, but a malicious
  195. * Guest (or malicious Guest userspace program) could, so we tell the
  196. * CPU to disable it before running the Guest.
  197. */
  198. if (boot_cpu_has(X86_FEATURE_SEP))
  199. wrmsr(MSR_IA32_SYSENTER_CS, 0, 0);
  200. /*
  201. * Now we actually run the Guest. It will return when something
  202. * interesting happens, and we can examine its registers to see what it
  203. * was doing.
  204. */
  205. run_guest_once(cpu, lguest_pages(raw_smp_processor_id()));
  206. /*
  207. * Note that the "regs" structure contains two extra entries which are
  208. * not really registers: a trap number which says what interrupt or
  209. * trap made the switcher code come back, and an error code which some
  210. * traps set.
  211. */
  212. /* Restore SYSENTER if it's supposed to be on. */
  213. if (boot_cpu_has(X86_FEATURE_SEP))
  214. wrmsr(MSR_IA32_SYSENTER_CS, __KERNEL_CS, 0);
  215. /* Clear the host TS bit if it was set above. */
  216. if (cpu->ts && user_has_fpu())
  217. clts();
  218. /*
  219. * If the Guest page faulted, then the cr2 register will tell us the
  220. * bad virtual address. We have to grab this now, because once we
  221. * re-enable interrupts an interrupt could fault and thus overwrite
  222. * cr2, or we could even move off to a different CPU.
  223. */
  224. if (cpu->regs->trapnum == 14)
  225. cpu->arch.last_pagefault = read_cr2();
  226. /*
  227. * Similarly, if we took a trap because the Guest used the FPU,
  228. * we have to restore the FPU it expects to see.
  229. * math_state_restore() may sleep and we may even move off to
  230. * a different CPU. So all the critical stuff should be done
  231. * before this.
  232. */
  233. else if (cpu->regs->trapnum == 7 && !user_has_fpu())
  234. math_state_restore();
  235. }
  236. /*H:130
  237. * Now we've examined the hypercall code; our Guest can make requests.
  238. * Our Guest is usually so well behaved; it never tries to do things it isn't
  239. * allowed to, and uses hypercalls instead. Unfortunately, Linux's paravirtual
  240. * infrastructure isn't quite complete, because it doesn't contain replacements
  241. * for the Intel I/O instructions. As a result, the Guest sometimes fumbles
  242. * across one during the boot process as it probes for various things which are
  243. * usually attached to a PC.
  244. *
  245. * When the Guest uses one of these instructions, we get a trap (General
  246. * Protection Fault) and come here. We see if it's one of those troublesome
  247. * instructions and skip over it. We return true if we did.
  248. */
  249. static int emulate_insn(struct lg_cpu *cpu)
  250. {
  251. u8 insn;
  252. unsigned int insnlen = 0, in = 0, small_operand = 0;
  253. /*
  254. * The eip contains the *virtual* address of the Guest's instruction:
  255. * walk the Guest's page tables to find the "physical" address.
  256. */
  257. unsigned long physaddr = guest_pa(cpu, cpu->regs->eip);
  258. /*
  259. * This must be the Guest kernel trying to do something, not userspace!
  260. * The bottom two bits of the CS segment register are the privilege
  261. * level.
  262. */
  263. if ((cpu->regs->cs & 3) != GUEST_PL)
  264. return 0;
  265. /* Decoding x86 instructions is icky. */
  266. insn = lgread(cpu, physaddr, u8);
  267. /*
  268. * Around 2.6.33, the kernel started using an emulation for the
  269. * cmpxchg8b instruction in early boot on many configurations. This
  270. * code isn't paravirtualized, and it tries to disable interrupts.
  271. * Ignore it, which will Mostly Work.
  272. */
  273. if (insn == 0xfa) {
  274. /* "cli", or Clear Interrupt Enable instruction. Skip it. */
  275. cpu->regs->eip++;
  276. return 1;
  277. }
  278. /*
  279. * 0x66 is an "operand prefix". It means a 16, not 32 bit in/out.
  280. */
  281. if (insn == 0x66) {
  282. small_operand = 1;
  283. /* The instruction is 1 byte so far, read the next byte. */
  284. insnlen = 1;
  285. insn = lgread(cpu, physaddr + insnlen, u8);
  286. }
  287. /*
  288. * We can ignore the lower bit for the moment and decode the 4 opcodes
  289. * we need to emulate.
  290. */
  291. switch (insn & 0xFE) {
  292. case 0xE4: /* in <next byte>,%al */
  293. insnlen += 2;
  294. in = 1;
  295. break;
  296. case 0xEC: /* in (%dx),%al */
  297. insnlen += 1;
  298. in = 1;
  299. break;
  300. case 0xE6: /* out %al,<next byte> */
  301. insnlen += 2;
  302. break;
  303. case 0xEE: /* out %al,(%dx) */
  304. insnlen += 1;
  305. break;
  306. default:
  307. /* OK, we don't know what this is, can't emulate. */
  308. return 0;
  309. }
  310. /*
  311. * If it was an "IN" instruction, they expect the result to be read
  312. * into %eax, so we change %eax. We always return all-ones, which
  313. * traditionally means "there's nothing there".
  314. */
  315. if (in) {
  316. /* Lower bit tells means it's a 32/16 bit access */
  317. if (insn & 0x1) {
  318. if (small_operand)
  319. cpu->regs->eax |= 0xFFFF;
  320. else
  321. cpu->regs->eax = 0xFFFFFFFF;
  322. } else
  323. cpu->regs->eax |= 0xFF;
  324. }
  325. /* Finally, we've "done" the instruction, so move past it. */
  326. cpu->regs->eip += insnlen;
  327. /* Success! */
  328. return 1;
  329. }
  330. /*H:050 Once we've re-enabled interrupts, we look at why the Guest exited. */
  331. void lguest_arch_handle_trap(struct lg_cpu *cpu)
  332. {
  333. switch (cpu->regs->trapnum) {
  334. case 13: /* We've intercepted a General Protection Fault. */
  335. /*
  336. * Check if this was one of those annoying IN or OUT
  337. * instructions which we need to emulate. If so, we just go
  338. * back into the Guest after we've done it.
  339. */
  340. if (cpu->regs->errcode == 0) {
  341. if (emulate_insn(cpu))
  342. return;
  343. }
  344. break;
  345. case 14: /* We've intercepted a Page Fault. */
  346. /*
  347. * The Guest accessed a virtual address that wasn't mapped.
  348. * This happens a lot: we don't actually set up most of the page
  349. * tables for the Guest at all when we start: as it runs it asks
  350. * for more and more, and we set them up as required. In this
  351. * case, we don't even tell the Guest that the fault happened.
  352. *
  353. * The errcode tells whether this was a read or a write, and
  354. * whether kernel or userspace code.
  355. */
  356. if (demand_page(cpu, cpu->arch.last_pagefault,
  357. cpu->regs->errcode))
  358. return;
  359. /*
  360. * OK, it's really not there (or not OK): the Guest needs to
  361. * know. We write out the cr2 value so it knows where the
  362. * fault occurred.
  363. *
  364. * Note that if the Guest were really messed up, this could
  365. * happen before it's done the LHCALL_LGUEST_INIT hypercall, so
  366. * lg->lguest_data could be NULL
  367. */
  368. if (cpu->lg->lguest_data &&
  369. put_user(cpu->arch.last_pagefault,
  370. &cpu->lg->lguest_data->cr2))
  371. kill_guest(cpu, "Writing cr2");
  372. break;
  373. case 7: /* We've intercepted a Device Not Available fault. */
  374. /*
  375. * If the Guest doesn't want to know, we already restored the
  376. * Floating Point Unit, so we just continue without telling it.
  377. */
  378. if (!cpu->ts)
  379. return;
  380. break;
  381. case 32 ... 255:
  382. /*
  383. * These values mean a real interrupt occurred, in which case
  384. * the Host handler has already been run. We just do a
  385. * friendly check if another process should now be run, then
  386. * return to run the Guest again.
  387. */
  388. cond_resched();
  389. return;
  390. case LGUEST_TRAP_ENTRY:
  391. /*
  392. * Our 'struct hcall_args' maps directly over our regs: we set
  393. * up the pointer now to indicate a hypercall is pending.
  394. */
  395. cpu->hcall = (struct hcall_args *)cpu->regs;
  396. return;
  397. }
  398. /* We didn't handle the trap, so it needs to go to the Guest. */
  399. if (!deliver_trap(cpu, cpu->regs->trapnum))
  400. /*
  401. * If the Guest doesn't have a handler (either it hasn't
  402. * registered any yet, or it's one of the faults we don't let
  403. * it handle), it dies with this cryptic error message.
  404. */
  405. kill_guest(cpu, "unhandled trap %li at %#lx (%#lx)",
  406. cpu->regs->trapnum, cpu->regs->eip,
  407. cpu->regs->trapnum == 14 ? cpu->arch.last_pagefault
  408. : cpu->regs->errcode);
  409. }
  410. /*
  411. * Now we can look at each of the routines this calls, in increasing order of
  412. * complexity: do_hypercalls(), emulate_insn(), maybe_do_interrupt(),
  413. * deliver_trap() and demand_page(). After all those, we'll be ready to
  414. * examine the Switcher, and our philosophical understanding of the Host/Guest
  415. * duality will be complete.
  416. :*/
  417. static void adjust_pge(void *on)
  418. {
  419. if (on)
  420. write_cr4(read_cr4() | X86_CR4_PGE);
  421. else
  422. write_cr4(read_cr4() & ~X86_CR4_PGE);
  423. }
  424. /*H:020
  425. * Now the Switcher is mapped and every thing else is ready, we need to do
  426. * some more i386-specific initialization.
  427. */
  428. void __init lguest_arch_host_init(void)
  429. {
  430. int i;
  431. /*
  432. * Most of the x86/switcher_32.S doesn't care that it's been moved; on
  433. * Intel, jumps are relative, and it doesn't access any references to
  434. * external code or data.
  435. *
  436. * The only exception is the interrupt handlers in switcher.S: their
  437. * addresses are placed in a table (default_idt_entries), so we need to
  438. * update the table with the new addresses. switcher_offset() is a
  439. * convenience function which returns the distance between the
  440. * compiled-in switcher code and the high-mapped copy we just made.
  441. */
  442. for (i = 0; i < IDT_ENTRIES; i++)
  443. default_idt_entries[i] += switcher_offset();
  444. /*
  445. * Set up the Switcher's per-cpu areas.
  446. *
  447. * Each CPU gets two pages of its own within the high-mapped region
  448. * (aka. "struct lguest_pages"). Much of this can be initialized now,
  449. * but some depends on what Guest we are running (which is set up in
  450. * copy_in_guest_info()).
  451. */
  452. for_each_possible_cpu(i) {
  453. /* lguest_pages() returns this CPU's two pages. */
  454. struct lguest_pages *pages = lguest_pages(i);
  455. /* This is a convenience pointer to make the code neater. */
  456. struct lguest_ro_state *state = &pages->state;
  457. /*
  458. * The Global Descriptor Table: the Host has a different one
  459. * for each CPU. We keep a descriptor for the GDT which says
  460. * where it is and how big it is (the size is actually the last
  461. * byte, not the size, hence the "-1").
  462. */
  463. state->host_gdt_desc.size = GDT_SIZE-1;
  464. state->host_gdt_desc.address = (long)get_cpu_gdt_table(i);
  465. /*
  466. * All CPUs on the Host use the same Interrupt Descriptor
  467. * Table, so we just use store_idt(), which gets this CPU's IDT
  468. * descriptor.
  469. */
  470. store_idt(&state->host_idt_desc);
  471. /*
  472. * The descriptors for the Guest's GDT and IDT can be filled
  473. * out now, too. We copy the GDT & IDT into ->guest_gdt and
  474. * ->guest_idt before actually running the Guest.
  475. */
  476. state->guest_idt_desc.size = sizeof(state->guest_idt)-1;
  477. state->guest_idt_desc.address = (long)&state->guest_idt;
  478. state->guest_gdt_desc.size = sizeof(state->guest_gdt)-1;
  479. state->guest_gdt_desc.address = (long)&state->guest_gdt;
  480. /*
  481. * We know where we want the stack to be when the Guest enters
  482. * the Switcher: in pages->regs. The stack grows upwards, so
  483. * we start it at the end of that structure.
  484. */
  485. state->guest_tss.sp0 = (long)(&pages->regs + 1);
  486. /*
  487. * And this is the GDT entry to use for the stack: we keep a
  488. * couple of special LGUEST entries.
  489. */
  490. state->guest_tss.ss0 = LGUEST_DS;
  491. /*
  492. * x86 can have a finegrained bitmap which indicates what I/O
  493. * ports the process can use. We set it to the end of our
  494. * structure, meaning "none".
  495. */
  496. state->guest_tss.io_bitmap_base = sizeof(state->guest_tss);
  497. /*
  498. * Some GDT entries are the same across all Guests, so we can
  499. * set them up now.
  500. */
  501. setup_default_gdt_entries(state);
  502. /* Most IDT entries are the same for all Guests, too.*/
  503. setup_default_idt_entries(state, default_idt_entries);
  504. /*
  505. * The Host needs to be able to use the LGUEST segments on this
  506. * CPU, too, so put them in the Host GDT.
  507. */
  508. get_cpu_gdt_table(i)[GDT_ENTRY_LGUEST_CS] = FULL_EXEC_SEGMENT;
  509. get_cpu_gdt_table(i)[GDT_ENTRY_LGUEST_DS] = FULL_SEGMENT;
  510. }
  511. /*
  512. * In the Switcher, we want the %cs segment register to use the
  513. * LGUEST_CS GDT entry: we've put that in the Host and Guest GDTs, so
  514. * it will be undisturbed when we switch. To change %cs and jump we
  515. * need this structure to feed to Intel's "lcall" instruction.
  516. */
  517. lguest_entry.offset = (long)switch_to_guest + switcher_offset();
  518. lguest_entry.segment = LGUEST_CS;
  519. /*
  520. * Finally, we need to turn off "Page Global Enable". PGE is an
  521. * optimization where page table entries are specially marked to show
  522. * they never change. The Host kernel marks all the kernel pages this
  523. * way because it's always present, even when userspace is running.
  524. *
  525. * Lguest breaks this: unbeknownst to the rest of the Host kernel, we
  526. * switch to the Guest kernel. If you don't disable this on all CPUs,
  527. * you'll get really weird bugs that you'll chase for two days.
  528. *
  529. * I used to turn PGE off every time we switched to the Guest and back
  530. * on when we return, but that slowed the Switcher down noticibly.
  531. */
  532. /*
  533. * We don't need the complexity of CPUs coming and going while we're
  534. * doing this.
  535. */
  536. get_online_cpus();
  537. if (cpu_has_pge) { /* We have a broader idea of "global". */
  538. /* Remember that this was originally set (for cleanup). */
  539. cpu_had_pge = 1;
  540. /*
  541. * adjust_pge is a helper function which sets or unsets the PGE
  542. * bit on its CPU, depending on the argument (0 == unset).
  543. */
  544. on_each_cpu(adjust_pge, (void *)0, 1);
  545. /* Turn off the feature in the global feature set. */
  546. clear_cpu_cap(&boot_cpu_data, X86_FEATURE_PGE);
  547. }
  548. put_online_cpus();
  549. }
  550. /*:*/
  551. void __exit lguest_arch_host_fini(void)
  552. {
  553. /* If we had PGE before we started, turn it back on now. */
  554. get_online_cpus();
  555. if (cpu_had_pge) {
  556. set_cpu_cap(&boot_cpu_data, X86_FEATURE_PGE);
  557. /* adjust_pge's argument "1" means set PGE. */
  558. on_each_cpu(adjust_pge, (void *)1, 1);
  559. }
  560. put_online_cpus();
  561. }
  562. /*H:122 The i386-specific hypercalls simply farm out to the right functions. */
  563. int lguest_arch_do_hcall(struct lg_cpu *cpu, struct hcall_args *args)
  564. {
  565. switch (args->arg0) {
  566. case LHCALL_LOAD_GDT_ENTRY:
  567. load_guest_gdt_entry(cpu, args->arg1, args->arg2, args->arg3);
  568. break;
  569. case LHCALL_LOAD_IDT_ENTRY:
  570. load_guest_idt_entry(cpu, args->arg1, args->arg2, args->arg3);
  571. break;
  572. case LHCALL_LOAD_TLS:
  573. guest_load_tls(cpu, args->arg1);
  574. break;
  575. default:
  576. /* Bad Guest. Bad! */
  577. return -EIO;
  578. }
  579. return 0;
  580. }
  581. /*H:126 i386-specific hypercall initialization: */
  582. int lguest_arch_init_hypercalls(struct lg_cpu *cpu)
  583. {
  584. u32 tsc_speed;
  585. /*
  586. * The pointer to the Guest's "struct lguest_data" is the only argument.
  587. * We check that address now.
  588. */
  589. if (!lguest_address_ok(cpu->lg, cpu->hcall->arg1,
  590. sizeof(*cpu->lg->lguest_data)))
  591. return -EFAULT;
  592. /*
  593. * Having checked it, we simply set lg->lguest_data to point straight
  594. * into the Launcher's memory at the right place and then use
  595. * copy_to_user/from_user from now on, instead of lgread/write. I put
  596. * this in to show that I'm not immune to writing stupid
  597. * optimizations.
  598. */
  599. cpu->lg->lguest_data = cpu->lg->mem_base + cpu->hcall->arg1;
  600. /*
  601. * We insist that the Time Stamp Counter exist and doesn't change with
  602. * cpu frequency. Some devious chip manufacturers decided that TSC
  603. * changes could be handled in software. I decided that time going
  604. * backwards might be good for benchmarks, but it's bad for users.
  605. *
  606. * We also insist that the TSC be stable: the kernel detects unreliable
  607. * TSCs for its own purposes, and we use that here.
  608. */
  609. if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC) && !check_tsc_unstable())
  610. tsc_speed = tsc_khz;
  611. else
  612. tsc_speed = 0;
  613. if (put_user(tsc_speed, &cpu->lg->lguest_data->tsc_khz))
  614. return -EFAULT;
  615. /* The interrupt code might not like the system call vector. */
  616. if (!check_syscall_vector(cpu->lg))
  617. kill_guest(cpu, "bad syscall vector");
  618. return 0;
  619. }
  620. /*:*/
  621. /*L:030
  622. * Most of the Guest's registers are left alone: we used get_zeroed_page() to
  623. * allocate the structure, so they will be 0.
  624. */
  625. void lguest_arch_setup_regs(struct lg_cpu *cpu, unsigned long start)
  626. {
  627. struct lguest_regs *regs = cpu->regs;
  628. /*
  629. * There are four "segment" registers which the Guest needs to boot:
  630. * The "code segment" register (cs) refers to the kernel code segment
  631. * __KERNEL_CS, and the "data", "extra" and "stack" segment registers
  632. * refer to the kernel data segment __KERNEL_DS.
  633. *
  634. * The privilege level is packed into the lower bits. The Guest runs
  635. * at privilege level 1 (GUEST_PL).
  636. */
  637. regs->ds = regs->es = regs->ss = __KERNEL_DS|GUEST_PL;
  638. regs->cs = __KERNEL_CS|GUEST_PL;
  639. /*
  640. * The "eflags" register contains miscellaneous flags. Bit 1 (0x002)
  641. * is supposed to always be "1". Bit 9 (0x200) controls whether
  642. * interrupts are enabled. We always leave interrupts enabled while
  643. * running the Guest.
  644. */
  645. regs->eflags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
  646. /*
  647. * The "Extended Instruction Pointer" register says where the Guest is
  648. * running.
  649. */
  650. regs->eip = start;
  651. /*
  652. * %esi points to our boot information, at physical address 0, so don't
  653. * touch it.
  654. */
  655. /* There are a couple of GDT entries the Guest expects at boot. */
  656. setup_guest_gdt(cpu);
  657. }