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