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