lguest: move process freezing before pending signals check
[~shefty/rdma-dev.git] / drivers / lguest / lguest_device.c
1 /*P:050
2  * Lguest guests use a very simple method to describe devices.  It's a
3  * series of device descriptors contained just above the top of normal Guest
4  * memory.
5  *
6  * We use the standard "virtio" device infrastructure, which provides us with a
7  * console, a network and a block driver.  Each one expects some configuration
8  * information and a "virtqueue" or two to send and receive data.
9 :*/
10 #include <linux/init.h>
11 #include <linux/bootmem.h>
12 #include <linux/lguest_launcher.h>
13 #include <linux/virtio.h>
14 #include <linux/virtio_config.h>
15 #include <linux/interrupt.h>
16 #include <linux/virtio_ring.h>
17 #include <linux/err.h>
18 #include <linux/slab.h>
19 #include <asm/io.h>
20 #include <asm/paravirt.h>
21 #include <asm/lguest_hcall.h>
22
23 /* The pointer to our (page) of device descriptions. */
24 static void *lguest_devices;
25
26 /*
27  * For Guests, device memory can be used as normal memory, so we cast away the
28  * __iomem to quieten sparse.
29  */
30 static inline void *lguest_map(unsigned long phys_addr, unsigned long pages)
31 {
32         return (__force void *)ioremap_cache(phys_addr, PAGE_SIZE*pages);
33 }
34
35 static inline void lguest_unmap(void *addr)
36 {
37         iounmap((__force void __iomem *)addr);
38 }
39
40 /*D:100
41  * Each lguest device is just a virtio device plus a pointer to its entry
42  * in the lguest_devices page.
43  */
44 struct lguest_device {
45         struct virtio_device vdev;
46
47         /* The entry in the lguest_devices page for this device. */
48         struct lguest_device_desc *desc;
49 };
50
51 /*
52  * Since the virtio infrastructure hands us a pointer to the virtio_device all
53  * the time, it helps to have a curt macro to get a pointer to the struct
54  * lguest_device it's enclosed in.
55  */
56 #define to_lgdev(vd) container_of(vd, struct lguest_device, vdev)
57
58 /*D:130
59  * Device configurations
60  *
61  * The configuration information for a device consists of one or more
62  * virtqueues, a feature bitmap, and some configuration bytes.  The
63  * configuration bytes don't really matter to us: the Launcher sets them up, and
64  * the driver will look at them during setup.
65  *
66  * A convenient routine to return the device's virtqueue config array:
67  * immediately after the descriptor.
68  */
69 static struct lguest_vqconfig *lg_vq(const struct lguest_device_desc *desc)
70 {
71         return (void *)(desc + 1);
72 }
73
74 /* The features come immediately after the virtqueues. */
75 static u8 *lg_features(const struct lguest_device_desc *desc)
76 {
77         return (void *)(lg_vq(desc) + desc->num_vq);
78 }
79
80 /* The config space comes after the two feature bitmasks. */
81 static u8 *lg_config(const struct lguest_device_desc *desc)
82 {
83         return lg_features(desc) + desc->feature_len * 2;
84 }
85
86 /* The total size of the config page used by this device (incl. desc) */
87 static unsigned desc_size(const struct lguest_device_desc *desc)
88 {
89         return sizeof(*desc)
90                 + desc->num_vq * sizeof(struct lguest_vqconfig)
91                 + desc->feature_len * 2
92                 + desc->config_len;
93 }
94
95 /* This gets the device's feature bits. */
96 static u32 lg_get_features(struct virtio_device *vdev)
97 {
98         unsigned int i;
99         u32 features = 0;
100         struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
101         u8 *in_features = lg_features(desc);
102
103         /* We do this the slow but generic way. */
104         for (i = 0; i < min(desc->feature_len * 8, 32); i++)
105                 if (in_features[i / 8] & (1 << (i % 8)))
106                         features |= (1 << i);
107
108         return features;
109 }
110
111 /*
112  * To notify on reset or feature finalization, we (ab)use the NOTIFY
113  * hypercall, with the descriptor address of the device.
114  */
115 static void status_notify(struct virtio_device *vdev)
116 {
117         unsigned long offset = (void *)to_lgdev(vdev)->desc - lguest_devices;
118
119         hcall(LHCALL_NOTIFY, (max_pfn << PAGE_SHIFT) + offset, 0, 0, 0);
120 }
121
122 /*
123  * The virtio core takes the features the Host offers, and copies the ones
124  * supported by the driver into the vdev->features array.  Once that's all
125  * sorted out, this routine is called so we can tell the Host which features we
126  * understand and accept.
127  */
128 static void lg_finalize_features(struct virtio_device *vdev)
129 {
130         unsigned int i, bits;
131         struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
132         /* Second half of bitmap is features we accept. */
133         u8 *out_features = lg_features(desc) + desc->feature_len;
134
135         /* Give virtio_ring a chance to accept features. */
136         vring_transport_features(vdev);
137
138         /*
139          * The vdev->feature array is a Linux bitmask: this isn't the same as a
140          * the simple array of bits used by lguest devices for features.  So we
141          * do this slow, manual conversion which is completely general.
142          */
143         memset(out_features, 0, desc->feature_len);
144         bits = min_t(unsigned, desc->feature_len, sizeof(vdev->features)) * 8;
145         for (i = 0; i < bits; i++) {
146                 if (test_bit(i, vdev->features))
147                         out_features[i / 8] |= (1 << (i % 8));
148         }
149
150         /* Tell Host we've finished with this device's feature negotiation */
151         status_notify(vdev);
152 }
153
154 /* Once they've found a field, getting a copy of it is easy. */
155 static void lg_get(struct virtio_device *vdev, unsigned int offset,
156                    void *buf, unsigned len)
157 {
158         struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
159
160         /* Check they didn't ask for more than the length of the config! */
161         BUG_ON(offset + len > desc->config_len);
162         memcpy(buf, lg_config(desc) + offset, len);
163 }
164
165 /* Setting the contents is also trivial. */
166 static void lg_set(struct virtio_device *vdev, unsigned int offset,
167                    const void *buf, unsigned len)
168 {
169         struct lguest_device_desc *desc = to_lgdev(vdev)->desc;
170
171         /* Check they didn't ask for more than the length of the config! */
172         BUG_ON(offset + len > desc->config_len);
173         memcpy(lg_config(desc) + offset, buf, len);
174 }
175
176 /*
177  * The operations to get and set the status word just access the status field
178  * of the device descriptor.
179  */
180 static u8 lg_get_status(struct virtio_device *vdev)
181 {
182         return to_lgdev(vdev)->desc->status;
183 }
184
185 static void lg_set_status(struct virtio_device *vdev, u8 status)
186 {
187         BUG_ON(!status);
188         to_lgdev(vdev)->desc->status = status;
189
190         /* Tell Host immediately if we failed. */
191         if (status & VIRTIO_CONFIG_S_FAILED)
192                 status_notify(vdev);
193 }
194
195 static void lg_reset(struct virtio_device *vdev)
196 {
197         /* 0 status means "reset" */
198         to_lgdev(vdev)->desc->status = 0;
199         status_notify(vdev);
200 }
201
202 /*
203  * Virtqueues
204  *
205  * The other piece of infrastructure virtio needs is a "virtqueue": a way of
206  * the Guest device registering buffers for the other side to read from or
207  * write into (ie. send and receive buffers).  Each device can have multiple
208  * virtqueues: for example the console driver uses one queue for sending and
209  * another for receiving.
210  *
211  * Fortunately for us, a very fast shared-memory-plus-descriptors virtqueue
212  * already exists in virtio_ring.c.  We just need to connect it up.
213  *
214  * We start with the information we need to keep about each virtqueue.
215  */
216
217 /*D:140 This is the information we remember about each virtqueue. */
218 struct lguest_vq_info {
219         /* A copy of the information contained in the device config. */
220         struct lguest_vqconfig config;
221
222         /* The address where we mapped the virtio ring, so we can unmap it. */
223         void *pages;
224 };
225
226 /*
227  * When the virtio_ring code wants to prod the Host, it calls us here and we
228  * make a hypercall.  We hand the physical address of the virtqueue so the Host
229  * knows which virtqueue we're talking about.
230  */
231 static void lg_notify(struct virtqueue *vq)
232 {
233         /*
234          * We store our virtqueue information in the "priv" pointer of the
235          * virtqueue structure.
236          */
237         struct lguest_vq_info *lvq = vq->priv;
238
239         hcall(LHCALL_NOTIFY, lvq->config.pfn << PAGE_SHIFT, 0, 0, 0);
240 }
241
242 /* An extern declaration inside a C file is bad form.  Don't do it. */
243 extern void lguest_setup_irq(unsigned int irq);
244
245 /*
246  * This routine finds the Nth virtqueue described in the configuration of
247  * this device and sets it up.
248  *
249  * This is kind of an ugly duckling.  It'd be nicer to have a standard
250  * representation of a virtqueue in the configuration space, but it seems that
251  * everyone wants to do it differently.  The KVM coders want the Guest to
252  * allocate its own pages and tell the Host where they are, but for lguest it's
253  * simpler for the Host to simply tell us where the pages are.
254  */
255 static struct virtqueue *lg_find_vq(struct virtio_device *vdev,
256                                     unsigned index,
257                                     void (*callback)(struct virtqueue *vq),
258                                     const char *name)
259 {
260         struct lguest_device *ldev = to_lgdev(vdev);
261         struct lguest_vq_info *lvq;
262         struct virtqueue *vq;
263         int err;
264
265         /* We must have this many virtqueues. */
266         if (index >= ldev->desc->num_vq)
267                 return ERR_PTR(-ENOENT);
268
269         lvq = kmalloc(sizeof(*lvq), GFP_KERNEL);
270         if (!lvq)
271                 return ERR_PTR(-ENOMEM);
272
273         /*
274          * Make a copy of the "struct lguest_vqconfig" entry, which sits after
275          * the descriptor.  We need a copy because the config space might not
276          * be aligned correctly.
277          */
278         memcpy(&lvq->config, lg_vq(ldev->desc)+index, sizeof(lvq->config));
279
280         printk("Mapping virtqueue %i addr %lx\n", index,
281                (unsigned long)lvq->config.pfn << PAGE_SHIFT);
282         /* Figure out how many pages the ring will take, and map that memory */
283         lvq->pages = lguest_map((unsigned long)lvq->config.pfn << PAGE_SHIFT,
284                                 DIV_ROUND_UP(vring_size(lvq->config.num,
285                                                         LGUEST_VRING_ALIGN),
286                                              PAGE_SIZE));
287         if (!lvq->pages) {
288                 err = -ENOMEM;
289                 goto free_lvq;
290         }
291
292         /*
293          * OK, tell virtio_ring.c to set up a virtqueue now we know its size
294          * and we've got a pointer to its pages.
295          */
296         vq = vring_new_virtqueue(lvq->config.num, LGUEST_VRING_ALIGN,
297                                  vdev, lvq->pages, lg_notify, callback, name);
298         if (!vq) {
299                 err = -ENOMEM;
300                 goto unmap;
301         }
302
303         /* Make sure the interrupt is allocated. */
304         lguest_setup_irq(lvq->config.irq);
305
306         /*
307          * Tell the interrupt for this virtqueue to go to the virtio_ring
308          * interrupt handler.
309          *
310          * FIXME: We used to have a flag for the Host to tell us we could use
311          * the interrupt as a source of randomness: it'd be nice to have that
312          * back.
313          */
314         err = request_irq(lvq->config.irq, vring_interrupt, IRQF_SHARED,
315                           dev_name(&vdev->dev), vq);
316         if (err)
317                 goto destroy_vring;
318
319         /*
320          * Last of all we hook up our 'struct lguest_vq_info" to the
321          * virtqueue's priv pointer.
322          */
323         vq->priv = lvq;
324         return vq;
325
326 destroy_vring:
327         vring_del_virtqueue(vq);
328 unmap:
329         lguest_unmap(lvq->pages);
330 free_lvq:
331         kfree(lvq);
332         return ERR_PTR(err);
333 }
334 /*:*/
335
336 /* Cleaning up a virtqueue is easy */
337 static void lg_del_vq(struct virtqueue *vq)
338 {
339         struct lguest_vq_info *lvq = vq->priv;
340
341         /* Release the interrupt */
342         free_irq(lvq->config.irq, vq);
343         /* Tell virtio_ring.c to free the virtqueue. */
344         vring_del_virtqueue(vq);
345         /* Unmap the pages containing the ring. */
346         lguest_unmap(lvq->pages);
347         /* Free our own queue information. */
348         kfree(lvq);
349 }
350
351 static void lg_del_vqs(struct virtio_device *vdev)
352 {
353         struct virtqueue *vq, *n;
354
355         list_for_each_entry_safe(vq, n, &vdev->vqs, list)
356                 lg_del_vq(vq);
357 }
358
359 static int lg_find_vqs(struct virtio_device *vdev, unsigned nvqs,
360                        struct virtqueue *vqs[],
361                        vq_callback_t *callbacks[],
362                        const char *names[])
363 {
364         struct lguest_device *ldev = to_lgdev(vdev);
365         int i;
366
367         /* We must have this many virtqueues. */
368         if (nvqs > ldev->desc->num_vq)
369                 return -ENOENT;
370
371         for (i = 0; i < nvqs; ++i) {
372                 vqs[i] = lg_find_vq(vdev, i, callbacks[i], names[i]);
373                 if (IS_ERR(vqs[i]))
374                         goto error;
375         }
376         return 0;
377
378 error:
379         lg_del_vqs(vdev);
380         return PTR_ERR(vqs[i]);
381 }
382
383 /* The ops structure which hooks everything together. */
384 static struct virtio_config_ops lguest_config_ops = {
385         .get_features = lg_get_features,
386         .finalize_features = lg_finalize_features,
387         .get = lg_get,
388         .set = lg_set,
389         .get_status = lg_get_status,
390         .set_status = lg_set_status,
391         .reset = lg_reset,
392         .find_vqs = lg_find_vqs,
393         .del_vqs = lg_del_vqs,
394 };
395
396 /*
397  * The root device for the lguest virtio devices.  This makes them appear as
398  * /sys/devices/lguest/0,1,2 not /sys/devices/0,1,2.
399  */
400 static struct device *lguest_root;
401
402 /*D:120
403  * This is the core of the lguest bus: actually adding a new device.
404  * It's a separate function because it's neater that way, and because an
405  * earlier version of the code supported hotplug and unplug.  They were removed
406  * early on because they were never used.
407  *
408  * As Andrew Tridgell says, "Untested code is buggy code".
409  *
410  * It's worth reading this carefully: we start with a pointer to the new device
411  * descriptor in the "lguest_devices" page, and the offset into the device
412  * descriptor page so we can uniquely identify it if things go badly wrong.
413  */
414 static void add_lguest_device(struct lguest_device_desc *d,
415                               unsigned int offset)
416 {
417         struct lguest_device *ldev;
418
419         /* Start with zeroed memory; Linux's device layer counts on it. */
420         ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
421         if (!ldev) {
422                 printk(KERN_EMERG "Cannot allocate lguest dev %u type %u\n",
423                        offset, d->type);
424                 return;
425         }
426
427         /* This devices' parent is the lguest/ dir. */
428         ldev->vdev.dev.parent = lguest_root;
429         /*
430          * The device type comes straight from the descriptor.  There's also a
431          * device vendor field in the virtio_device struct, which we leave as
432          * 0.
433          */
434         ldev->vdev.id.device = d->type;
435         /*
436          * We have a simple set of routines for querying the device's
437          * configuration information and setting its status.
438          */
439         ldev->vdev.config = &lguest_config_ops;
440         /* And we remember the device's descriptor for lguest_config_ops. */
441         ldev->desc = d;
442
443         /*
444          * register_virtio_device() sets up the generic fields for the struct
445          * virtio_device and calls device_register().  This makes the bus
446          * infrastructure look for a matching driver.
447          */
448         if (register_virtio_device(&ldev->vdev) != 0) {
449                 printk(KERN_ERR "Failed to register lguest dev %u type %u\n",
450                        offset, d->type);
451                 kfree(ldev);
452         }
453 }
454
455 /*D:110
456  * scan_devices() simply iterates through the device page.  The type 0 is
457  * reserved to mean "end of devices".
458  */
459 static void scan_devices(void)
460 {
461         unsigned int i;
462         struct lguest_device_desc *d;
463
464         /* We start at the page beginning, and skip over each entry. */
465         for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
466                 d = lguest_devices + i;
467
468                 /* Once we hit a zero, stop. */
469                 if (d->type == 0)
470                         break;
471
472                 printk("Device at %i has size %u\n", i, desc_size(d));
473                 add_lguest_device(d, i);
474         }
475 }
476
477 /*D:105
478  * Fairly early in boot, lguest_devices_init() is called to set up the
479  * lguest device infrastructure.  We check that we are a Guest by checking
480  * pv_info.name: there are other ways of checking, but this seems most
481  * obvious to me.
482  *
483  * So we can access the "struct lguest_device_desc"s easily, we map that memory
484  * and store the pointer in the global "lguest_devices".  Then we register a
485  * root device from which all our devices will hang (this seems to be the
486  * correct sysfs incantation).
487  *
488  * Finally we call scan_devices() which adds all the devices found in the
489  * lguest_devices page.
490  */
491 static int __init lguest_devices_init(void)
492 {
493         if (strcmp(pv_info.name, "lguest") != 0)
494                 return 0;
495
496         lguest_root = root_device_register("lguest");
497         if (IS_ERR(lguest_root))
498                 panic("Could not register lguest root");
499
500         /* Devices are in a single page above top of "normal" mem */
501         lguest_devices = lguest_map(max_pfn<<PAGE_SHIFT, 1);
502
503         scan_devices();
504         return 0;
505 }
506 /* We do this after core stuff, but before the drivers. */
507 postcore_initcall(lguest_devices_init);
508
509 /*D:150
510  * At this point in the journey we used to now wade through the lguest
511  * devices themselves: net, block and console.  Since they're all now virtio
512  * devices rather than lguest-specific, I've decided to ignore them.  Mostly,
513  * they're kind of boring.  But this does mean you'll never experience the
514  * thrill of reading the forbidden love scene buried deep in the block driver.
515  *
516  * "make Launcher" beckons, where we answer questions like "Where do Guests
517  * come from?", and "What do you do when someone asks for optimization?".
518  */