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