1
2
3
4
5
6#include <linux/module.h>
7#include <linux/stringify.h>
8#include <linux/stddef.h>
9#include <linux/io.h>
10#include <linux/mm.h>
11#include <linux/vmalloc.h>
12#include <linux/cpu.h>
13#include <linux/freezer.h>
14#include <linux/highmem.h>
15#include <linux/slab.h>
16#include <asm/paravirt.h>
17#include <asm/pgtable.h>
18#include <asm/uaccess.h>
19#include <asm/poll.h>
20#include <asm/asm-offsets.h>
21#include "lg.h"
22
23
24static struct vm_struct *switcher_vma;
25static struct page **switcher_page;
26
27
28DEFINE_MUTEX(lguest_lock);
29
30
31
32
33
34
35
36
37
38
39
40
41
42static __init int map_switcher(void)
43{
44 int i, err;
45 struct page **pagep;
46
47
48
49
50
51
52
53
54
55
56
57
58
59 switcher_page = kmalloc(sizeof(switcher_page[0])*TOTAL_SWITCHER_PAGES,
60 GFP_KERNEL);
61 if (!switcher_page) {
62 err = -ENOMEM;
63 goto out;
64 }
65
66
67
68
69
70 for (i = 0; i < TOTAL_SWITCHER_PAGES; i++) {
71 switcher_page[i] = alloc_page(GFP_KERNEL|__GFP_ZERO);
72 if (!switcher_page[i]) {
73 err = -ENOMEM;
74 goto free_some_pages;
75 }
76 }
77
78
79
80
81
82
83 if (SWITCHER_ADDR + (TOTAL_SWITCHER_PAGES+1)*PAGE_SIZE > FIXADDR_START){
84 err = -ENOMEM;
85 printk("lguest: mapping switcher would thwack fixmap\n");
86 goto free_pages;
87 }
88
89
90
91
92
93
94
95 switcher_vma = __get_vm_area(TOTAL_SWITCHER_PAGES * PAGE_SIZE,
96 VM_ALLOC, SWITCHER_ADDR, SWITCHER_ADDR
97 + (TOTAL_SWITCHER_PAGES+1) * PAGE_SIZE);
98 if (!switcher_vma) {
99 err = -ENOMEM;
100 printk("lguest: could not map switcher pages high\n");
101 goto free_pages;
102 }
103
104
105
106
107
108
109
110
111 pagep = switcher_page;
112 err = map_vm_area(switcher_vma, PAGE_KERNEL_EXEC, &pagep);
113 if (err) {
114 printk("lguest: map_vm_area failed: %i\n", err);
115 goto free_vma;
116 }
117
118
119
120
121
122 memcpy(switcher_vma->addr, start_switcher_text,
123 end_switcher_text - start_switcher_text);
124
125 printk(KERN_INFO "lguest: mapped switcher at %p\n",
126 switcher_vma->addr);
127
128 return 0;
129
130free_vma:
131 vunmap(switcher_vma->addr);
132free_pages:
133 i = TOTAL_SWITCHER_PAGES;
134free_some_pages:
135 for (--i; i >= 0; i--)
136 __free_pages(switcher_page[i], 0);
137 kfree(switcher_page);
138out:
139 return err;
140}
141
142
143
144static void unmap_switcher(void)
145{
146 unsigned int i;
147
148
149 vunmap(switcher_vma->addr);
150
151 for (i = 0; i < TOTAL_SWITCHER_PAGES; i++)
152 __free_pages(switcher_page[i], 0);
153 kfree(switcher_page);
154}
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171bool lguest_address_ok(const struct lguest *lg,
172 unsigned long addr, unsigned long len)
173{
174 return (addr+len) / PAGE_SIZE < lg->pfn_limit && (addr+len >= addr);
175}
176
177
178
179
180
181
182void __lgread(struct lg_cpu *cpu, void *b, unsigned long addr, unsigned bytes)
183{
184 if (!lguest_address_ok(cpu->lg, addr, bytes)
185 || copy_from_user(b, cpu->lg->mem_base + addr, bytes) != 0) {
186
187 memset(b, 0, bytes);
188 kill_guest(cpu, "bad read address %#lx len %u", addr, bytes);
189 }
190}
191
192
193void __lgwrite(struct lg_cpu *cpu, unsigned long addr, const void *b,
194 unsigned bytes)
195{
196 if (!lguest_address_ok(cpu->lg, addr, bytes)
197 || copy_to_user(cpu->lg->mem_base + addr, b, bytes) != 0)
198 kill_guest(cpu, "bad write address %#lx len %u", addr, bytes);
199}
200
201
202
203
204
205
206
207int run_guest(struct lg_cpu *cpu, unsigned long __user *user)
208{
209
210 while (!cpu->lg->dead) {
211 unsigned int irq;
212 bool more;
213
214
215 if (cpu->hcall)
216 do_hypercalls(cpu);
217
218
219
220
221
222 if (cpu->pending_notify) {
223
224
225
226
227 if (!send_notify_to_eventfd(cpu)) {
228
229 if (put_user(cpu->pending_notify, user))
230 return -EFAULT;
231 return sizeof(cpu->pending_notify);
232 }
233 }
234
235
236 if (signal_pending(current))
237 return -ERESTARTSYS;
238
239
240
241
242
243
244 irq = interrupt_pending(cpu, &more);
245 if (irq < LGUEST_IRQS)
246 try_deliver_interrupt(cpu, irq, more);
247
248
249
250
251
252
253 try_to_freeze();
254
255
256
257
258
259 if (cpu->lg->dead)
260 break;
261
262
263
264
265
266 if (cpu->halted) {
267 set_current_state(TASK_INTERRUPTIBLE);
268
269
270
271
272 if (interrupt_pending(cpu, &more) < LGUEST_IRQS)
273 set_current_state(TASK_RUNNING);
274 else
275 schedule();
276 continue;
277 }
278
279
280
281
282
283 local_irq_disable();
284
285
286 lguest_arch_run_guest(cpu);
287
288
289 local_irq_enable();
290
291
292 lguest_arch_handle_trap(cpu);
293 }
294
295
296 if (cpu->lg->dead == ERR_PTR(-ERESTART))
297 return -ERESTART;
298
299
300 return -ENOENT;
301}
302
303
304
305
306
307
308
309
310
311static int __init init(void)
312{
313 int err;
314
315
316 if (paravirt_enabled()) {
317 printk("lguest is afraid of being a guest\n");
318 return -EPERM;
319 }
320
321
322 err = map_switcher();
323 if (err)
324 goto out;
325
326
327 err = init_pagetables(switcher_page, SHARED_SWITCHER_PAGES);
328 if (err)
329 goto unmap;
330
331
332 err = init_interrupts();
333 if (err)
334 goto free_pgtables;
335
336
337 err = lguest_device_init();
338 if (err)
339 goto free_interrupts;
340
341
342 lguest_arch_host_init();
343
344
345 return 0;
346
347free_interrupts:
348 free_interrupts();
349free_pgtables:
350 free_pagetables();
351unmap:
352 unmap_switcher();
353out:
354 return err;
355}
356
357
358static void __exit fini(void)
359{
360 lguest_device_remove();
361 free_interrupts();
362 free_pagetables();
363 unmap_switcher();
364
365 lguest_arch_host_fini();
366}
367
368
369
370
371
372
373module_init(init);
374module_exit(fini);
375MODULE_LICENSE("GPL");
376MODULE_AUTHOR("Rusty Russell <rusty@rustcorp.com.au>");
377