Rusty Russell | f938d2c | 2007-07-26 10:41:02 -0700 | [diff] [blame] | 1 | /*P:400 This contains run_guest() which actually calls into the Host<->Guest |
| 2 | * Switcher and analyzes the return, such as determining if the Guest wants the |
Rusty Russell | a6bd8e1 | 2008-03-28 11:05:53 -0500 | [diff] [blame] | 3 | * Host to do something. This file also contains useful helper routines. :*/ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 4 | #include <linux/module.h> |
| 5 | #include <linux/stringify.h> |
| 6 | #include <linux/stddef.h> |
| 7 | #include <linux/io.h> |
| 8 | #include <linux/mm.h> |
| 9 | #include <linux/vmalloc.h> |
| 10 | #include <linux/cpu.h> |
| 11 | #include <linux/freezer.h> |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 12 | #include <linux/highmem.h> |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 13 | #include <asm/paravirt.h> |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 14 | #include <asm/pgtable.h> |
| 15 | #include <asm/uaccess.h> |
| 16 | #include <asm/poll.h> |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 17 | #include <asm/asm-offsets.h> |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 18 | #include "lg.h" |
| 19 | |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 20 | |
| 21 | static struct vm_struct *switcher_vma; |
| 22 | static struct page **switcher_page; |
| 23 | |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 24 | /* This One Big lock protects all inter-guest data structures. */ |
| 25 | DEFINE_MUTEX(lguest_lock); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 26 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 27 | /*H:010 We need to set up the Switcher at a high virtual address. Remember the |
| 28 | * Switcher is a few hundred bytes of assembler code which actually changes the |
| 29 | * CPU to run the Guest, and then changes back to the Host when a trap or |
| 30 | * interrupt happens. |
| 31 | * |
| 32 | * The Switcher code must be at the same virtual address in the Guest as the |
| 33 | * Host since it will be running as the switchover occurs. |
| 34 | * |
| 35 | * Trying to map memory at a particular address is an unusual thing to do, so |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 36 | * it's not a simple one-liner. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 37 | static __init int map_switcher(void) |
| 38 | { |
| 39 | int i, err; |
| 40 | struct page **pagep; |
| 41 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 42 | /* |
| 43 | * Map the Switcher in to high memory. |
| 44 | * |
| 45 | * It turns out that if we choose the address 0xFFC00000 (4MB under the |
| 46 | * top virtual address), it makes setting up the page tables really |
| 47 | * easy. |
| 48 | */ |
| 49 | |
Rusty Russell | a6bd8e1 | 2008-03-28 11:05:53 -0500 | [diff] [blame] | 50 | /* We allocate an array of struct page pointers. map_vm_area() wants |
| 51 | * this, rather than just an array of pages. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 52 | switcher_page = kmalloc(sizeof(switcher_page[0])*TOTAL_SWITCHER_PAGES, |
| 53 | GFP_KERNEL); |
| 54 | if (!switcher_page) { |
| 55 | err = -ENOMEM; |
| 56 | goto out; |
| 57 | } |
| 58 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 59 | /* Now we actually allocate the pages. The Guest will see these pages, |
| 60 | * so we make sure they're zeroed. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 61 | for (i = 0; i < TOTAL_SWITCHER_PAGES; i++) { |
| 62 | unsigned long addr = get_zeroed_page(GFP_KERNEL); |
| 63 | if (!addr) { |
| 64 | err = -ENOMEM; |
| 65 | goto free_some_pages; |
| 66 | } |
| 67 | switcher_page[i] = virt_to_page(addr); |
| 68 | } |
| 69 | |
Rusty Russell | f14ae65 | 2008-03-11 09:35:56 -0500 | [diff] [blame] | 70 | /* First we check that the Switcher won't overlap the fixmap area at |
| 71 | * the top of memory. It's currently nowhere near, but it could have |
| 72 | * very strange effects if it ever happened. */ |
| 73 | if (SWITCHER_ADDR + (TOTAL_SWITCHER_PAGES+1)*PAGE_SIZE > FIXADDR_START){ |
| 74 | err = -ENOMEM; |
| 75 | printk("lguest: mapping switcher would thwack fixmap\n"); |
| 76 | goto free_pages; |
| 77 | } |
| 78 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 79 | /* Now we reserve the "virtual memory area" we want: 0xFFC00000 |
| 80 | * (SWITCHER_ADDR). We might not get it in theory, but in practice |
Rusty Russell | f14ae65 | 2008-03-11 09:35:56 -0500 | [diff] [blame] | 81 | * it's worked so far. The end address needs +1 because __get_vm_area |
| 82 | * allocates an extra guard page, so we need space for that. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 83 | switcher_vma = __get_vm_area(TOTAL_SWITCHER_PAGES * PAGE_SIZE, |
Rusty Russell | f14ae65 | 2008-03-11 09:35:56 -0500 | [diff] [blame] | 84 | VM_ALLOC, SWITCHER_ADDR, SWITCHER_ADDR |
| 85 | + (TOTAL_SWITCHER_PAGES+1) * PAGE_SIZE); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 86 | if (!switcher_vma) { |
| 87 | err = -ENOMEM; |
| 88 | printk("lguest: could not map switcher pages high\n"); |
| 89 | goto free_pages; |
| 90 | } |
| 91 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 92 | /* This code actually sets up the pages we've allocated to appear at |
| 93 | * SWITCHER_ADDR. map_vm_area() takes the vma we allocated above, the |
| 94 | * kind of pages we're mapping (kernel pages), and a pointer to our |
| 95 | * array of struct pages. It increments that pointer, but we don't |
| 96 | * care. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 97 | pagep = switcher_page; |
Matias Zabaljauregui | ed1dc77 | 2009-05-30 15:35:49 -0300 | [diff] [blame] | 98 | err = map_vm_area(switcher_vma, PAGE_KERNEL_EXEC, &pagep); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 99 | if (err) { |
| 100 | printk("lguest: map_vm_area failed: %i\n", err); |
| 101 | goto free_vma; |
| 102 | } |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 103 | |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 104 | /* Now the Switcher is mapped at the right address, we can't fail! |
| 105 | * Copy in the compiled-in Switcher code (from <arch>_switcher.S). */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 106 | memcpy(switcher_vma->addr, start_switcher_text, |
| 107 | end_switcher_text - start_switcher_text); |
| 108 | |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 109 | printk(KERN_INFO "lguest: mapped switcher at %p\n", |
| 110 | switcher_vma->addr); |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 111 | /* And we succeeded... */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 112 | return 0; |
| 113 | |
| 114 | free_vma: |
| 115 | vunmap(switcher_vma->addr); |
| 116 | free_pages: |
| 117 | i = TOTAL_SWITCHER_PAGES; |
| 118 | free_some_pages: |
| 119 | for (--i; i >= 0; i--) |
| 120 | __free_pages(switcher_page[i], 0); |
| 121 | kfree(switcher_page); |
| 122 | out: |
| 123 | return err; |
| 124 | } |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 125 | /*:*/ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 126 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 127 | /* Cleaning up the mapping when the module is unloaded is almost... |
| 128 | * too easy. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 129 | static void unmap_switcher(void) |
| 130 | { |
| 131 | unsigned int i; |
| 132 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 133 | /* vunmap() undoes *both* map_vm_area() and __get_vm_area(). */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 134 | vunmap(switcher_vma->addr); |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 135 | /* Now we just need to free the pages we copied the switcher into */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 136 | for (i = 0; i < TOTAL_SWITCHER_PAGES; i++) |
| 137 | __free_pages(switcher_page[i], 0); |
Johannes Weiner | 0a70721 | 2008-07-08 10:29:42 +0200 | [diff] [blame] | 138 | kfree(switcher_page); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Rusty Russell | e1e7296 | 2007-10-25 15:02:50 +1000 | [diff] [blame] | 141 | /*H:032 |
Rusty Russell | dde7978 | 2007-07-26 10:41:03 -0700 | [diff] [blame] | 142 | * Dealing With Guest Memory. |
| 143 | * |
Rusty Russell | e1e7296 | 2007-10-25 15:02:50 +1000 | [diff] [blame] | 144 | * Before we go too much further into the Host, we need to grok the routines |
| 145 | * we use to deal with Guest memory. |
| 146 | * |
Rusty Russell | dde7978 | 2007-07-26 10:41:03 -0700 | [diff] [blame] | 147 | * When the Guest gives us (what it thinks is) a physical address, we can use |
Rusty Russell | 3c6b5bf | 2007-10-22 11:03:26 +1000 | [diff] [blame] | 148 | * the normal copy_from_user() & copy_to_user() on the corresponding place in |
| 149 | * the memory region allocated by the Launcher. |
Rusty Russell | dde7978 | 2007-07-26 10:41:03 -0700 | [diff] [blame] | 150 | * |
| 151 | * But we can't trust the Guest: it might be trying to access the Launcher |
| 152 | * code. We have to check that the range is below the pfn_limit the Launcher |
| 153 | * gave us. We have to make sure that addr + len doesn't give us a false |
| 154 | * positive by overflowing, too. */ |
Matias Zabaljauregui | df1693a | 2009-03-18 13:38:35 -0300 | [diff] [blame] | 155 | bool lguest_address_ok(const struct lguest *lg, |
| 156 | unsigned long addr, unsigned long len) |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 157 | { |
| 158 | return (addr+len) / PAGE_SIZE < lg->pfn_limit && (addr+len >= addr); |
| 159 | } |
| 160 | |
Rusty Russell | 2d37f94 | 2007-10-22 11:24:24 +1000 | [diff] [blame] | 161 | /* This routine copies memory from the Guest. Here we can see how useful the |
| 162 | * kill_lguest() routine we met in the Launcher can be: we return a random |
| 163 | * value (all zeroes) instead of needing to return an error. */ |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 164 | void __lgread(struct lg_cpu *cpu, void *b, unsigned long addr, unsigned bytes) |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 165 | { |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 166 | if (!lguest_address_ok(cpu->lg, addr, bytes) |
| 167 | || copy_from_user(b, cpu->lg->mem_base + addr, bytes) != 0) { |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 168 | /* copy_from_user should do this, but as we rely on it... */ |
| 169 | memset(b, 0, bytes); |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 170 | kill_guest(cpu, "bad read address %#lx len %u", addr, bytes); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 171 | } |
| 172 | } |
| 173 | |
Rusty Russell | a6bd8e1 | 2008-03-28 11:05:53 -0500 | [diff] [blame] | 174 | /* This is the write (copy into Guest) version. */ |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 175 | void __lgwrite(struct lg_cpu *cpu, unsigned long addr, const void *b, |
Rusty Russell | 2d37f94 | 2007-10-22 11:24:24 +1000 | [diff] [blame] | 176 | unsigned bytes) |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 177 | { |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 178 | if (!lguest_address_ok(cpu->lg, addr, bytes) |
| 179 | || copy_to_user(cpu->lg->mem_base + addr, b, bytes) != 0) |
| 180 | kill_guest(cpu, "bad write address %#lx len %u", addr, bytes); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 181 | } |
Rusty Russell | 2d37f94 | 2007-10-22 11:24:24 +1000 | [diff] [blame] | 182 | /*:*/ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 183 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 184 | /*H:030 Let's jump straight to the the main loop which runs the Guest. |
| 185 | * Remember, this is called by the Launcher reading /dev/lguest, and we keep |
| 186 | * going around and around until something interesting happens. */ |
Glauber de Oliveira Costa | d0953d4 | 2008-01-07 11:05:25 -0200 | [diff] [blame] | 187 | int run_guest(struct lg_cpu *cpu, unsigned long __user *user) |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 188 | { |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 189 | /* We stop running once the Guest is dead. */ |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 190 | while (!cpu->lg->dead) { |
Rusty Russell | abd41f0 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 191 | unsigned int irq; |
Rusty Russell | a32a881 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 192 | bool more; |
Rusty Russell | abd41f0 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 193 | |
Rusty Russell | cc6d4fb | 2007-10-22 11:03:30 +1000 | [diff] [blame] | 194 | /* First we run any hypercalls the Guest wants done. */ |
Glauber de Oliveira Costa | 73044f0 | 2008-01-07 11:05:27 -0200 | [diff] [blame] | 195 | if (cpu->hcall) |
| 196 | do_hypercalls(cpu); |
Rusty Russell | cc6d4fb | 2007-10-22 11:03:30 +1000 | [diff] [blame] | 197 | |
Rusty Russell | 1504527 | 2007-10-22 11:24:10 +1000 | [diff] [blame] | 198 | /* It's possible the Guest did a NOTIFY hypercall to the |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 199 | * Launcher, in which case we return from the read() now. */ |
Glauber de Oliveira Costa | 5e232f4 | 2008-01-07 11:05:36 -0200 | [diff] [blame] | 200 | if (cpu->pending_notify) { |
Rusty Russell | df60aee | 2009-06-12 22:27:09 -0600 | [diff] [blame] | 201 | if (!send_notify_to_eventfd(cpu)) { |
| 202 | if (put_user(cpu->pending_notify, user)) |
| 203 | return -EFAULT; |
| 204 | return sizeof(cpu->pending_notify); |
| 205 | } |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 206 | } |
| 207 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 208 | /* Check for signals */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 209 | if (signal_pending(current)) |
| 210 | return -ERESTARTSYS; |
| 211 | |
Rusty Russell | a6bd8e1 | 2008-03-28 11:05:53 -0500 | [diff] [blame] | 212 | /* Check if there are any interrupts which can be delivered now: |
| 213 | * if so, this sets up the hander to be executed when we next |
| 214 | * run the Guest. */ |
Rusty Russell | a32a881 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 215 | irq = interrupt_pending(cpu, &more); |
Rusty Russell | abd41f0 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 216 | if (irq < LGUEST_IRQS) |
Rusty Russell | a32a881 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 217 | try_deliver_interrupt(cpu, irq, more); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 218 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 219 | /* All long-lived kernel loops need to check with this horrible |
| 220 | * thing called the freezer. If the Host is trying to suspend, |
| 221 | * it stops us. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 222 | try_to_freeze(); |
| 223 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 224 | /* Just make absolutely sure the Guest is still alive. One of |
| 225 | * those hypercalls could have been fatal, for example. */ |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 226 | if (cpu->lg->dead) |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 227 | break; |
| 228 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 229 | /* If the Guest asked to be stopped, we sleep. The Guest's |
Rusty Russell | 5dac051 | 2009-06-12 22:27:10 -0600 | [diff] [blame] | 230 | * clock timer will wake us. */ |
Glauber de Oliveira Costa | 66686c2 | 2008-01-07 11:05:34 -0200 | [diff] [blame] | 231 | if (cpu->halted) { |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 232 | set_current_state(TASK_INTERRUPTIBLE); |
Rusty Russell | 5dac051 | 2009-06-12 22:27:10 -0600 | [diff] [blame] | 233 | /* Just before we sleep, make sure no interrupt snuck in |
Rusty Russell | abd41f0 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 234 | * which we should be doing. */ |
Rusty Russell | 5dac051 | 2009-06-12 22:27:10 -0600 | [diff] [blame] | 235 | if (interrupt_pending(cpu, &more) < LGUEST_IRQS) |
Rusty Russell | abd41f0 | 2009-06-12 22:27:02 -0600 | [diff] [blame] | 236 | set_current_state(TASK_RUNNING); |
| 237 | else |
| 238 | schedule(); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 239 | continue; |
| 240 | } |
| 241 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 242 | /* OK, now we're ready to jump into the Guest. First we put up |
| 243 | * the "Do Not Disturb" sign: */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 244 | local_irq_disable(); |
| 245 | |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 246 | /* Actually run the Guest until something happens. */ |
Glauber de Oliveira Costa | d0953d4 | 2008-01-07 11:05:25 -0200 | [diff] [blame] | 247 | lguest_arch_run_guest(cpu); |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 248 | |
| 249 | /* Now we're ready to be interrupted or moved to other CPUs */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 250 | local_irq_enable(); |
| 251 | |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 252 | /* Now we deal with whatever happened to the Guest. */ |
Glauber de Oliveira Costa | 73044f0 | 2008-01-07 11:05:27 -0200 | [diff] [blame] | 253 | lguest_arch_handle_trap(cpu); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 254 | } |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 255 | |
Rusty Russell | a6bd8e1 | 2008-03-28 11:05:53 -0500 | [diff] [blame] | 256 | /* Special case: Guest is 'dead' but wants a reboot. */ |
Glauber de Oliveira Costa | 382ac6b | 2008-01-17 19:19:42 -0200 | [diff] [blame] | 257 | if (cpu->lg->dead == ERR_PTR(-ERESTART)) |
Balaji Rao | ec04b13 | 2007-12-28 14:26:24 +0530 | [diff] [blame] | 258 | return -ERESTART; |
Rusty Russell | a6bd8e1 | 2008-03-28 11:05:53 -0500 | [diff] [blame] | 259 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 260 | /* The Guest is dead => "No such file or directory" */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 261 | return -ENOENT; |
| 262 | } |
| 263 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 264 | /*H:000 |
| 265 | * Welcome to the Host! |
| 266 | * |
| 267 | * By this point your brain has been tickled by the Guest code and numbed by |
| 268 | * the Launcher code; prepare for it to be stretched by the Host code. This is |
| 269 | * the heart. Let's begin at the initialization routine for the Host's lg |
| 270 | * module. |
| 271 | */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 272 | static int __init init(void) |
| 273 | { |
| 274 | int err; |
| 275 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 276 | /* Lguest can't run under Xen, VMI or itself. It does Tricky Stuff. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 277 | if (paravirt_enabled()) { |
Glauber de Oliveira Costa | 5c55841 | 2008-01-17 22:32:50 -0200 | [diff] [blame] | 278 | printk("lguest is afraid of being a guest\n"); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 279 | return -EPERM; |
| 280 | } |
| 281 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 282 | /* First we put the Switcher up in very high virtual memory. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 283 | err = map_switcher(); |
| 284 | if (err) |
Rusty Russell | c18acd7 | 2007-10-22 11:03:35 +1000 | [diff] [blame] | 285 | goto out; |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 286 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 287 | /* Now we set up the pagetable implementation for the Guests. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 288 | err = init_pagetables(switcher_page, SHARED_SWITCHER_PAGES); |
Rusty Russell | c18acd7 | 2007-10-22 11:03:35 +1000 | [diff] [blame] | 289 | if (err) |
| 290 | goto unmap; |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 291 | |
Rusty Russell | c18acd7 | 2007-10-22 11:03:35 +1000 | [diff] [blame] | 292 | /* We might need to reserve an interrupt vector. */ |
| 293 | err = init_interrupts(); |
| 294 | if (err) |
| 295 | goto free_pgtables; |
| 296 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 297 | /* /dev/lguest needs to be registered. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 298 | err = lguest_device_init(); |
Rusty Russell | c18acd7 | 2007-10-22 11:03:35 +1000 | [diff] [blame] | 299 | if (err) |
| 300 | goto free_interrupts; |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 301 | |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 302 | /* Finally we do some architecture-specific setup. */ |
| 303 | lguest_arch_host_init(); |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 304 | |
| 305 | /* All good! */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 306 | return 0; |
Rusty Russell | c18acd7 | 2007-10-22 11:03:35 +1000 | [diff] [blame] | 307 | |
| 308 | free_interrupts: |
| 309 | free_interrupts(); |
| 310 | free_pgtables: |
| 311 | free_pagetables(); |
| 312 | unmap: |
| 313 | unmap_switcher(); |
| 314 | out: |
| 315 | return err; |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 318 | /* Cleaning up is just the same code, backwards. With a little French. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 319 | static void __exit fini(void) |
| 320 | { |
| 321 | lguest_device_remove(); |
Rusty Russell | c18acd7 | 2007-10-22 11:03:35 +1000 | [diff] [blame] | 322 | free_interrupts(); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 323 | free_pagetables(); |
| 324 | unmap_switcher(); |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 325 | |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 326 | lguest_arch_host_fini(); |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 327 | } |
Jes Sorensen | 625efab | 2007-10-22 11:03:28 +1000 | [diff] [blame] | 328 | /*:*/ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 329 | |
Rusty Russell | bff672e | 2007-07-26 10:41:04 -0700 | [diff] [blame] | 330 | /* The Host side of lguest can be a module. This is a nice way for people to |
| 331 | * play with it. */ |
Rusty Russell | d7e28ff | 2007-07-19 01:49:23 -0700 | [diff] [blame] | 332 | module_init(init); |
| 333 | module_exit(fini); |
| 334 | MODULE_LICENSE("GPL"); |
| 335 | MODULE_AUTHOR("Rusty Russell <rusty@rustcorp.com.au>"); |