9f9a2953b3830dd42b9f1eb1f06649ed9870e5e3
[linux-2.6.git] / drivers / lguest / lguest_user.c
1 /*P:200 This contains all the /dev/lguest code, whereby the userspace launcher
2  * controls and communicates with the Guest.  For example, the first write will
3  * tell us the Guest's memory layout, pagetable, entry point and kernel address
4  * offset.  A read will run the Guest until something happens, such as a signal
5  * or the Guest doing a NOTIFY out to the Launcher. :*/
6 #include <linux/uaccess.h>
7 #include <linux/miscdevice.h>
8 #include <linux/fs.h>
9 #include <linux/sched.h>
10 #include <linux/eventfd.h>
11 #include <linux/file.h>
12 #include "lg.h"
13
14 bool send_notify_to_eventfd(struct lg_cpu *cpu)
15 {
16         unsigned int i;
17         struct lg_eventfd_map *map;
18
19         /* lg->eventfds is RCU-protected */
20         rcu_read_lock();
21         map = rcu_dereference(cpu->lg->eventfds);
22         for (i = 0; i < map->num; i++) {
23                 if (map->map[i].addr == cpu->pending_notify) {
24                         eventfd_signal(map->map[i].event, 1);
25                         cpu->pending_notify = 0;
26                         break;
27                 }
28         }
29         rcu_read_unlock();
30         return cpu->pending_notify == 0;
31 }
32
33 static int add_eventfd(struct lguest *lg, unsigned long addr, int fd)
34 {
35         struct lg_eventfd_map *new, *old = lg->eventfds;
36
37         if (!addr)
38                 return -EINVAL;
39
40         /* Replace the old array with the new one, carefully: others can
41          * be accessing it at the same time */
42         new = kmalloc(sizeof(*new) + sizeof(new->map[0]) * (old->num + 1),
43                       GFP_KERNEL);
44         if (!new)
45                 return -ENOMEM;
46
47         /* First make identical copy. */
48         memcpy(new->map, old->map, sizeof(old->map[0]) * old->num);
49         new->num = old->num;
50
51         /* Now append new entry. */
52         new->map[new->num].addr = addr;
53         new->map[new->num].event = eventfd_ctx_fdget(fd);
54         if (IS_ERR(new->map[new->num].event)) {
55                 kfree(new);
56                 return PTR_ERR(new->map[new->num].event);
57         }
58         new->num++;
59
60         /* Now put new one in place. */
61         rcu_assign_pointer(lg->eventfds, new);
62
63         /* We're not in a big hurry.  Wait until noone's looking at old
64          * version, then delete it. */
65         synchronize_rcu();
66         kfree(old);
67
68         return 0;
69 }
70
71 static int attach_eventfd(struct lguest *lg, const unsigned long __user *input)
72 {
73         unsigned long addr, fd;
74         int err;
75
76         if (get_user(addr, input) != 0)
77                 return -EFAULT;
78         input++;
79         if (get_user(fd, input) != 0)
80                 return -EFAULT;
81
82         mutex_lock(&lguest_lock);
83         err = add_eventfd(lg, addr, fd);
84         mutex_unlock(&lguest_lock);
85
86         return 0;
87 }
88
89 /*L:050 Sending an interrupt is done by writing LHREQ_IRQ and an interrupt
90  * number to /dev/lguest. */
91 static int user_send_irq(struct lg_cpu *cpu, const unsigned long __user *input)
92 {
93         unsigned long irq;
94
95         if (get_user(irq, input) != 0)
96                 return -EFAULT;
97         if (irq >= LGUEST_IRQS)
98                 return -EINVAL;
99
100         set_interrupt(cpu, irq);
101         return 0;
102 }
103
104 /*L:040 Once our Guest is initialized, the Launcher makes it run by reading
105  * from /dev/lguest. */
106 static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o)
107 {
108         struct lguest *lg = file->private_data;
109         struct lg_cpu *cpu;
110         unsigned int cpu_id = *o;
111
112         /* You must write LHREQ_INITIALIZE first! */
113         if (!lg)
114                 return -EINVAL;
115
116         /* Watch out for arbitrary vcpu indexes! */
117         if (cpu_id >= lg->nr_cpus)
118                 return -EINVAL;
119
120         cpu = &lg->cpus[cpu_id];
121
122         /* If you're not the task which owns the Guest, go away. */
123         if (current != cpu->tsk)
124                 return -EPERM;
125
126         /* If the Guest is already dead, we indicate why */
127         if (lg->dead) {
128                 size_t len;
129
130                 /* lg->dead either contains an error code, or a string. */
131                 if (IS_ERR(lg->dead))
132                         return PTR_ERR(lg->dead);
133
134                 /* We can only return as much as the buffer they read with. */
135                 len = min(size, strlen(lg->dead)+1);
136                 if (copy_to_user(user, lg->dead, len) != 0)
137                         return -EFAULT;
138                 return len;
139         }
140
141         /* If we returned from read() last time because the Guest sent I/O,
142          * clear the flag. */
143         if (cpu->pending_notify)
144                 cpu->pending_notify = 0;
145
146         /* Run the Guest until something interesting happens. */
147         return run_guest(cpu, (unsigned long __user *)user);
148 }
149
150 /*L:025 This actually initializes a CPU.  For the moment, a Guest is only
151  * uniprocessor, so "id" is always 0. */
152 static int lg_cpu_start(struct lg_cpu *cpu, unsigned id, unsigned long start_ip)
153 {
154         /* We have a limited number the number of CPUs in the lguest struct. */
155         if (id >= ARRAY_SIZE(cpu->lg->cpus))
156                 return -EINVAL;
157
158         /* Set up this CPU's id, and pointer back to the lguest struct. */
159         cpu->id = id;
160         cpu->lg = container_of((cpu - id), struct lguest, cpus[0]);
161         cpu->lg->nr_cpus++;
162
163         /* Each CPU has a timer it can set. */
164         init_clockdev(cpu);
165
166         /* We need a complete page for the Guest registers: they are accessible
167          * to the Guest and we can only grant it access to whole pages. */
168         cpu->regs_page = get_zeroed_page(GFP_KERNEL);
169         if (!cpu->regs_page)
170                 return -ENOMEM;
171
172         /* We actually put the registers at the bottom of the page. */
173         cpu->regs = (void *)cpu->regs_page + PAGE_SIZE - sizeof(*cpu->regs);
174
175         /* Now we initialize the Guest's registers, handing it the start
176          * address. */
177         lguest_arch_setup_regs(cpu, start_ip);
178
179         /* We keep a pointer to the Launcher task (ie. current task) for when
180          * other Guests want to wake this one (eg. console input). */
181         cpu->tsk = current;
182
183         /* We need to keep a pointer to the Launcher's memory map, because if
184          * the Launcher dies we need to clean it up.  If we don't keep a
185          * reference, it is destroyed before close() is called. */
186         cpu->mm = get_task_mm(cpu->tsk);
187
188         /* We remember which CPU's pages this Guest used last, for optimization
189          * when the same Guest runs on the same CPU twice. */
190         cpu->last_pages = NULL;
191
192         /* No error == success. */
193         return 0;
194 }
195
196 /*L:020 The initialization write supplies 3 pointer sized (32 or 64 bit)
197  * values (in addition to the LHREQ_INITIALIZE value).  These are:
198  *
199  * base: The start of the Guest-physical memory inside the Launcher memory.
200  *
201  * pfnlimit: The highest (Guest-physical) page number the Guest should be
202  * allowed to access.  The Guest memory lives inside the Launcher, so it sets
203  * this to ensure the Guest can only reach its own memory.
204  *
205  * start: The first instruction to execute ("eip" in x86-speak).
206  */
207 static int initialize(struct file *file, const unsigned long __user *input)
208 {
209         /* "struct lguest" contains everything we (the Host) know about a
210          * Guest. */
211         struct lguest *lg;
212         int err;
213         unsigned long args[3];
214
215         /* We grab the Big Lguest lock, which protects against multiple
216          * simultaneous initializations. */
217         mutex_lock(&lguest_lock);
218         /* You can't initialize twice!  Close the device and start again... */
219         if (file->private_data) {
220                 err = -EBUSY;
221                 goto unlock;
222         }
223
224         if (copy_from_user(args, input, sizeof(args)) != 0) {
225                 err = -EFAULT;
226                 goto unlock;
227         }
228
229         lg = kzalloc(sizeof(*lg), GFP_KERNEL);
230         if (!lg) {
231                 err = -ENOMEM;
232                 goto unlock;
233         }
234
235         lg->eventfds = kmalloc(sizeof(*lg->eventfds), GFP_KERNEL);
236         if (!lg->eventfds) {
237                 err = -ENOMEM;
238                 goto free_lg;
239         }
240         lg->eventfds->num = 0;
241
242         /* Populate the easy fields of our "struct lguest" */
243         lg->mem_base = (void __user *)args[0];
244         lg->pfn_limit = args[1];
245
246         /* This is the first cpu (cpu 0) and it will start booting at args[2] */
247         err = lg_cpu_start(&lg->cpus[0], 0, args[2]);
248         if (err)
249                 goto free_eventfds;
250
251         /* Initialize the Guest's shadow page tables, using the toplevel
252          * address the Launcher gave us.  This allocates memory, so can fail. */
253         err = init_guest_pagetable(lg);
254         if (err)
255                 goto free_regs;
256
257         /* We keep our "struct lguest" in the file's private_data. */
258         file->private_data = lg;
259
260         mutex_unlock(&lguest_lock);
261
262         /* And because this is a write() call, we return the length used. */
263         return sizeof(args);
264
265 free_regs:
266         /* FIXME: This should be in free_vcpu */
267         free_page(lg->cpus[0].regs_page);
268 free_eventfds:
269         kfree(lg->eventfds);
270 free_lg:
271         kfree(lg);
272 unlock:
273         mutex_unlock(&lguest_lock);
274         return err;
275 }
276
277 /*L:010 The first operation the Launcher does must be a write.  All writes
278  * start with an unsigned long number: for the first write this must be
279  * LHREQ_INITIALIZE to set up the Guest.  After that the Launcher can use
280  * writes of other values to send interrupts.
281  *
282  * Note that we overload the "offset" in the /dev/lguest file to indicate what
283  * CPU number we're dealing with.  Currently this is always 0, since we only
284  * support uniprocessor Guests, but you can see the beginnings of SMP support
285  * here. */
286 static ssize_t write(struct file *file, const char __user *in,
287                      size_t size, loff_t *off)
288 {
289         /* Once the Guest is initialized, we hold the "struct lguest" in the
290          * file private data. */
291         struct lguest *lg = file->private_data;
292         const unsigned long __user *input = (const unsigned long __user *)in;
293         unsigned long req;
294         struct lg_cpu *uninitialized_var(cpu);
295         unsigned int cpu_id = *off;
296
297         /* The first value tells us what this request is. */
298         if (get_user(req, input) != 0)
299                 return -EFAULT;
300         input++;
301
302         /* If you haven't initialized, you must do that first. */
303         if (req != LHREQ_INITIALIZE) {
304                 if (!lg || (cpu_id >= lg->nr_cpus))
305                         return -EINVAL;
306                 cpu = &lg->cpus[cpu_id];
307
308                 /* Once the Guest is dead, you can only read() why it died. */
309                 if (lg->dead)
310                         return -ENOENT;
311         }
312
313         switch (req) {
314         case LHREQ_INITIALIZE:
315                 return initialize(file, input);
316         case LHREQ_IRQ:
317                 return user_send_irq(cpu, input);
318         case LHREQ_EVENTFD:
319                 return attach_eventfd(lg, input);
320         default:
321                 return -EINVAL;
322         }
323 }
324
325 /*L:060 The final piece of interface code is the close() routine.  It reverses
326  * everything done in initialize().  This is usually called because the
327  * Launcher exited.
328  *
329  * Note that the close routine returns 0 or a negative error number: it can't
330  * really fail, but it can whine.  I blame Sun for this wart, and K&R C for
331  * letting them do it. :*/
332 static int close(struct inode *inode, struct file *file)
333 {
334         struct lguest *lg = file->private_data;
335         unsigned int i;
336
337         /* If we never successfully initialized, there's nothing to clean up */
338         if (!lg)
339                 return 0;
340
341         /* We need the big lock, to protect from inter-guest I/O and other
342          * Launchers initializing guests. */
343         mutex_lock(&lguest_lock);
344
345         /* Free up the shadow page tables for the Guest. */
346         free_guest_pagetable(lg);
347
348         for (i = 0; i < lg->nr_cpus; i++) {
349                 /* Cancels the hrtimer set via LHCALL_SET_CLOCKEVENT. */
350                 hrtimer_cancel(&lg->cpus[i].hrt);
351                 /* We can free up the register page we allocated. */
352                 free_page(lg->cpus[i].regs_page);
353                 /* Now all the memory cleanups are done, it's safe to release
354                  * the Launcher's memory management structure. */
355                 mmput(lg->cpus[i].mm);
356         }
357
358         /* Release any eventfds they registered. */
359         for (i = 0; i < lg->eventfds->num; i++)
360                 eventfd_ctx_put(lg->eventfds->map[i].event);
361         kfree(lg->eventfds);
362
363         /* If lg->dead doesn't contain an error code it will be NULL or a
364          * kmalloc()ed string, either of which is ok to hand to kfree(). */
365         if (!IS_ERR(lg->dead))
366                 kfree(lg->dead);
367         /* Free the memory allocated to the lguest_struct */
368         kfree(lg);
369         /* Release lock and exit. */
370         mutex_unlock(&lguest_lock);
371
372         return 0;
373 }
374
375 /*L:000
376  * Welcome to our journey through the Launcher!
377  *
378  * The Launcher is the Host userspace program which sets up, runs and services
379  * the Guest.  In fact, many comments in the Drivers which refer to "the Host"
380  * doing things are inaccurate: the Launcher does all the device handling for
381  * the Guest, but the Guest can't know that.
382  *
383  * Just to confuse you: to the Host kernel, the Launcher *is* the Guest and we
384  * shall see more of that later.
385  *
386  * We begin our understanding with the Host kernel interface which the Launcher
387  * uses: reading and writing a character device called /dev/lguest.  All the
388  * work happens in the read(), write() and close() routines: */
389 static struct file_operations lguest_fops = {
390         .owner   = THIS_MODULE,
391         .release = close,
392         .write   = write,
393         .read    = read,
394 };
395
396 /* This is a textbook example of a "misc" character device.  Populate a "struct
397  * miscdevice" and register it with misc_register(). */
398 static struct miscdevice lguest_dev = {
399         .minor  = MISC_DYNAMIC_MINOR,
400         .name   = "lguest",
401         .fops   = &lguest_fops,
402 };
403
404 int __init lguest_device_init(void)
405 {
406         return misc_register(&lguest_dev);
407 }
408
409 void __exit lguest_device_remove(void)
410 {
411         misc_deregister(&lguest_dev);
412 }