Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 1 | #include <linux/linkage.h> |
| 2 | #include <linux/lguest.h> |
Rusty Russell | 47436aa | 2007-10-22 11:03:36 +1000 | [diff] [blame] | 3 | #include <asm/lguest_hcall.h> |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 4 | #include <asm/asm-offsets.h> |
| 5 | #include <asm/thread_info.h> |
Rusty Russell | 876be9d | 2007-07-20 22:12:56 +1000 | [diff] [blame] | 6 | #include <asm/processor-flags.h> |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 7 | |
Rusty Russell | 814a0e5 | 2007-10-22 11:29:44 +1000 | [diff] [blame] | 8 | /*G:020 This is where we begin: head.S notes that the boot header's platform |
Rusty Russell | e1e7296 | 2007-10-25 15:02:50 +1000 | [diff] [blame] | 9 | * type field is "1" (lguest), so calls us here. |
Rusty Russell | 47436aa | 2007-10-22 11:03:36 +1000 | [diff] [blame] | 10 | * |
| 11 | * WARNING: be very careful here! We're running at addresses equal to physical |
| 12 | * addesses (around 0), not above PAGE_OFFSET as most code expectes |
| 13 | * (eg. 0xC0000000). Jumps are relative, so they're OK, but we can't touch any |
| 14 | * data. |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 15 | * |
Rusty Russell | b2b47c2 | 2007-07-26 10:41:02 -0700 | [diff] [blame] | 16 | * The .section line puts this code in .init.text so it will be discarded after |
| 17 | * boot. */ |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 18 | .section .init.text, "ax", @progbits |
Rusty Russell | 814a0e5 | 2007-10-22 11:29:44 +1000 | [diff] [blame] | 19 | ENTRY(lguest_entry) |
Rusty Russell | e1e7296 | 2007-10-25 15:02:50 +1000 | [diff] [blame] | 20 | /* We make the "initialization" hypercall now to tell the Host about |
| 21 | * us, and also find out where it put our page tables. */ |
Rusty Russell | 47436aa | 2007-10-22 11:03:36 +1000 | [diff] [blame] | 22 | movl $LHCALL_LGUEST_INIT, %eax |
| 23 | movl $lguest_data - __PAGE_OFFSET, %edx |
| 24 | int $LGUEST_TRAP_ENTRY |
| 25 | |
Rusty Russell | 47436aa | 2007-10-22 11:03:36 +1000 | [diff] [blame] | 26 | /* The Host put the toplevel pagetable in lguest_data.pgdir. The movsl |
Rusty Russell | e1e7296 | 2007-10-25 15:02:50 +1000 | [diff] [blame] | 27 | * instruction uses %esi implicitly as the source for the copy we' |
| 28 | * about to do. */ |
Rusty Russell | 47436aa | 2007-10-22 11:03:36 +1000 | [diff] [blame] | 29 | movl lguest_data - __PAGE_OFFSET + LGUEST_DATA_pgdir, %esi |
| 30 | |
| 31 | /* Copy first 32 entries of page directory to __PAGE_OFFSET entries. |
| 32 | * This means the first 128M of kernel memory will be mapped at |
| 33 | * PAGE_OFFSET where the kernel expects to run. This will get it far |
| 34 | * enough through boot to switch to its own pagetables. */ |
| 35 | movl $32, %ecx |
| 36 | movl %esi, %edi |
| 37 | addl $((__PAGE_OFFSET >> 22) * 4), %edi |
| 38 | rep |
| 39 | movsl |
| 40 | |
| 41 | /* Set up the initial stack so we can run C code. */ |
| 42 | movl $(init_thread_union+THREAD_SIZE),%esp |
| 43 | |
Rusty Russell | 47436aa | 2007-10-22 11:03:36 +1000 | [diff] [blame] | 44 | /* Jumps are relative, and we're running __PAGE_OFFSET too low at the |
| 45 | * moment. */ |
| 46 | jmp lguest_init+__PAGE_OFFSET |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 47 | |
Rusty Russell | b2b47c2 | 2007-07-26 10:41:02 -0700 | [diff] [blame] | 48 | /*G:055 We create a macro which puts the assembler code between lgstart_ and |
Rusty Russell | bbbd2bf | 2007-09-24 21:24:44 -0700 | [diff] [blame] | 49 | * lgend_ markers. These templates are put in the .text section: they can't be |
| 50 | * discarded after boot as we may need to patch modules, too. */ |
| 51 | .text |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 52 | #define LGUEST_PATCH(name, insns...) \ |
| 53 | lgstart_##name: insns; lgend_##name:; \ |
| 54 | .globl lgstart_##name; .globl lgend_##name |
| 55 | |
| 56 | LGUEST_PATCH(cli, movl $0, lguest_data+LGUEST_DATA_irq_enabled) |
| 57 | LGUEST_PATCH(sti, movl $X86_EFLAGS_IF, lguest_data+LGUEST_DATA_irq_enabled) |
| 58 | LGUEST_PATCH(popf, movl %eax, lguest_data+LGUEST_DATA_irq_enabled) |
| 59 | LGUEST_PATCH(pushf, movl lguest_data+LGUEST_DATA_irq_enabled, %eax) |
Rusty Russell | b2b47c2 | 2007-07-26 10:41:02 -0700 | [diff] [blame] | 60 | /*:*/ |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 61 | |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 62 | /* These demark the EIP range where host should never deliver interrupts. */ |
| 63 | .global lguest_noirq_start |
| 64 | .global lguest_noirq_end |
| 65 | |
Rusty Russell | f56a384 | 2007-07-26 10:41:05 -0700 | [diff] [blame] | 66 | /*M:004 When the Host reflects a trap or injects an interrupt into the Guest, |
| 67 | * it sets the eflags interrupt bit on the stack based on |
| 68 | * lguest_data.irq_enabled, so the Guest iret logic does the right thing when |
| 69 | * restoring it. However, when the Host sets the Guest up for direct traps, |
| 70 | * such as system calls, the processor is the one to push eflags onto the |
| 71 | * stack, and the interrupt bit will be 1 (in reality, interrupts are always |
| 72 | * enabled in the Guest). |
| 73 | * |
| 74 | * This turns out to be harmless: the only trap which should happen under Linux |
| 75 | * with interrupts disabled is Page Fault (due to our lazy mapping of vmalloc |
| 76 | * regions), which has to be reflected through the Host anyway. If another |
| 77 | * trap *does* go off when interrupts are disabled, the Guest will panic, and |
| 78 | * we'll never get to this iret! :*/ |
| 79 | |
Rusty Russell | b2b47c2 | 2007-07-26 10:41:02 -0700 | [diff] [blame] | 80 | /*G:045 There is one final paravirt_op that the Guest implements, and glancing |
| 81 | * at it you can see why I left it to last. It's *cool*! It's in *assembler*! |
| 82 | * |
| 83 | * The "iret" instruction is used to return from an interrupt or trap. The |
| 84 | * stack looks like this: |
| 85 | * old address |
| 86 | * old code segment & privilege level |
| 87 | * old processor flags ("eflags") |
| 88 | * |
| 89 | * The "iret" instruction pops those values off the stack and restores them all |
| 90 | * at once. The only problem is that eflags includes the Interrupt Flag which |
| 91 | * the Guest can't change: the CPU will simply ignore it when we do an "iret". |
| 92 | * So we have to copy eflags from the stack to lguest_data.irq_enabled before |
| 93 | * we do the "iret". |
| 94 | * |
| 95 | * There are two problems with this: firstly, we need to use a register to do |
| 96 | * the copy and secondly, the whole thing needs to be atomic. The first |
| 97 | * problem is easy to solve: push %eax on the stack so we can use it, and then |
| 98 | * restore it at the end just before the real "iret". |
| 99 | * |
| 100 | * The second is harder: copying eflags to lguest_data.irq_enabled will turn |
| 101 | * interrupts on before we're finished, so we could be interrupted before we |
| 102 | * return to userspace or wherever. Our solution to this is to surround the |
| 103 | * code with lguest_noirq_start: and lguest_noirq_end: labels. We tell the |
| 104 | * Host that it is *never* to interrupt us there, even if interrupts seem to be |
| 105 | * enabled. */ |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 106 | ENTRY(lguest_iret) |
| 107 | pushl %eax |
| 108 | movl 12(%esp), %eax |
| 109 | lguest_noirq_start: |
Rusty Russell | b2b47c2 | 2007-07-26 10:41:02 -0700 | [diff] [blame] | 110 | /* Note the %ss: segment prefix here. Normal data accesses use the |
| 111 | * "ds" segment, but that will have already been restored for whatever |
| 112 | * we're returning to (such as userspace): we can't trust it. The %ss: |
| 113 | * prefix makes sure we use the stack segment, which is still valid. */ |
Rusty Russell | 07ad157 | 2007-07-19 01:49:22 -0700 | [diff] [blame] | 114 | movl %eax,%ss:lguest_data+LGUEST_DATA_irq_enabled |
| 115 | popl %eax |
| 116 | iret |
| 117 | lguest_noirq_end: |