lguest: documentation III: Drivers
[linux-2.6.git] / drivers / lguest / lguest_bus.c
1 /*P:050 Lguest guests use a very simple bus for devices.  It's a simple array
2  * of device descriptors contained just above the top of normal memory.  The
3  * lguest bus is 80% tedious boilerplate code. :*/
4 #include <linux/init.h>
5 #include <linux/bootmem.h>
6 #include <linux/lguest_bus.h>
7 #include <asm/io.h>
8
9 static ssize_t type_show(struct device *_dev,
10                          struct device_attribute *attr, char *buf)
11 {
12         struct lguest_device *dev = container_of(_dev,struct lguest_device,dev);
13         return sprintf(buf, "%hu", lguest_devices[dev->index].type);
14 }
15 static ssize_t features_show(struct device *_dev,
16                              struct device_attribute *attr, char *buf)
17 {
18         struct lguest_device *dev = container_of(_dev,struct lguest_device,dev);
19         return sprintf(buf, "%hx", lguest_devices[dev->index].features);
20 }
21 static ssize_t pfn_show(struct device *_dev,
22                          struct device_attribute *attr, char *buf)
23 {
24         struct lguest_device *dev = container_of(_dev,struct lguest_device,dev);
25         return sprintf(buf, "%u", lguest_devices[dev->index].pfn);
26 }
27 static ssize_t status_show(struct device *_dev,
28                            struct device_attribute *attr, char *buf)
29 {
30         struct lguest_device *dev = container_of(_dev,struct lguest_device,dev);
31         return sprintf(buf, "%hx", lguest_devices[dev->index].status);
32 }
33 static ssize_t status_store(struct device *_dev, struct device_attribute *attr,
34                             const char *buf, size_t count)
35 {
36         struct lguest_device *dev = container_of(_dev,struct lguest_device,dev);
37         if (sscanf(buf, "%hi", &lguest_devices[dev->index].status) != 1)
38                 return -EINVAL;
39         return count;
40 }
41 static struct device_attribute lguest_dev_attrs[] = {
42         __ATTR_RO(type),
43         __ATTR_RO(features),
44         __ATTR_RO(pfn),
45         __ATTR(status, 0644, status_show, status_store),
46         __ATTR_NULL
47 };
48
49 /*D:130 The generic bus infrastructure requires a function which says whether a
50  * device matches a driver.  For us, it is simple: "struct lguest_driver"
51  * contains a "device_type" field which indicates what type of device it can
52  * handle, so we just cast the args and compare: */
53 static int lguest_dev_match(struct device *_dev, struct device_driver *_drv)
54 {
55         struct lguest_device *dev = container_of(_dev,struct lguest_device,dev);
56         struct lguest_driver *drv = container_of(_drv,struct lguest_driver,drv);
57
58         return (drv->device_type == lguest_devices[dev->index].type);
59 }
60 /*:*/
61
62 struct lguest_bus {
63         struct bus_type bus;
64         struct device dev;
65 };
66
67 static struct lguest_bus lguest_bus = {
68         .bus = {
69                 .name  = "lguest",
70                 .match = lguest_dev_match,
71                 .dev_attrs = lguest_dev_attrs,
72         },
73         .dev = {
74                 .parent = NULL,
75                 .bus_id = "lguest",
76         }
77 };
78
79 /*D:140 This is the callback which occurs once the bus infrastructure matches
80  * up a device and driver, ie. in response to add_lguest_device() calling
81  * device_register(), or register_lguest_driver() calling driver_register().
82  *
83  * At the moment it's always the latter: the devices are added first, since
84  * scan_devices() is called from a "core_initcall", and the drivers themselves
85  * called later as a normal "initcall".  But it would work the other way too.
86  *
87  * So now we have the happy couple, we add the status bit to indicate that we
88  * found a driver.  If the driver truly loves the device, it will return
89  * happiness from its probe function (ok, perhaps this wasn't my greatest
90  * analogy), and we set the final "driver ok" bit so the Host sees it's all
91  * green. */
92 static int lguest_dev_probe(struct device *_dev)
93 {
94         int ret;
95         struct lguest_device*dev = container_of(_dev,struct lguest_device,dev);
96         struct lguest_driver*drv = container_of(dev->dev.driver,
97                                                 struct lguest_driver, drv);
98
99         lguest_devices[dev->index].status |= LGUEST_DEVICE_S_DRIVER;
100         ret = drv->probe(dev);
101         if (ret == 0)
102                 lguest_devices[dev->index].status |= LGUEST_DEVICE_S_DRIVER_OK;
103         return ret;
104 }
105
106 /* The last part of the bus infrastructure is the function lguest drivers use
107  * to register themselves.  Firstly, we do nothing if there's no lguest bus
108  * (ie. this is not a Guest), otherwise we fill in the embedded generic "struct
109  * driver" fields and call the generic driver_register(). */
110 int register_lguest_driver(struct lguest_driver *drv)
111 {
112         if (!lguest_devices)
113                 return 0;
114
115         drv->drv.bus = &lguest_bus.bus;
116         drv->drv.name = drv->name;
117         drv->drv.owner = drv->owner;
118         drv->drv.probe = lguest_dev_probe;
119
120         return driver_register(&drv->drv);
121 }
122
123 /* At the moment we build all the drivers into the kernel because they're so
124  * simple: 8144 bytes for all three of them as I type this.  And as the console
125  * really needs to be built in, it's actually only 3527 bytes for the network
126  * and block drivers.
127  *
128  * If they get complex it will make sense for them to be modularized, so we
129  * need to explicitly export the symbol.
130  *
131  * I don't think non-GPL modules make sense, so it's a GPL-only export.
132  */
133 EXPORT_SYMBOL_GPL(register_lguest_driver);
134
135 /*D:120 This is the core of the lguest bus: actually adding a new device.
136  * It's a separate function because it's neater that way, and because an
137  * earlier version of the code supported hotplug and unplug.  They were removed
138  * early on because they were never used.
139  *
140  * As Andrew Tridgell says, "Untested code is buggy code".
141  *
142  * It's worth reading this carefully: we start with an index into the array of
143  * "struct lguest_device_desc"s indicating the device which is new: */
144 static void add_lguest_device(unsigned int index)
145 {
146         struct lguest_device *new;
147
148         /* Each "struct lguest_device_desc" has a "status" field, which the
149          * Guest updates as the device is probed.  In the worst case, the Host
150          * can look at these bits to tell what part of device setup failed,
151          * even if the console isn't available. */
152         lguest_devices[index].status |= LGUEST_DEVICE_S_ACKNOWLEDGE;
153         new = kmalloc(sizeof(struct lguest_device), GFP_KERNEL);
154         if (!new) {
155                 printk(KERN_EMERG "Cannot allocate lguest device %u\n", index);
156                 lguest_devices[index].status |= LGUEST_DEVICE_S_FAILED;
157                 return;
158         }
159
160         /* The "struct lguest_device" setup is pretty straight-forward example
161          * code. */
162         new->index = index;
163         new->private = NULL;
164         memset(&new->dev, 0, sizeof(new->dev));
165         new->dev.parent = &lguest_bus.dev;
166         new->dev.bus = &lguest_bus.bus;
167         sprintf(new->dev.bus_id, "%u", index);
168
169         /* device_register() causes the bus infrastructure to look for a
170          * matching driver. */
171         if (device_register(&new->dev) != 0) {
172                 printk(KERN_EMERG "Cannot register lguest device %u\n", index);
173                 lguest_devices[index].status |= LGUEST_DEVICE_S_FAILED;
174                 kfree(new);
175         }
176 }
177
178 /*D:110 scan_devices() simply iterates through the device array.  The type 0
179  * is reserved to mean "no device", and anything else means we have found a
180  * device: add it. */
181 static void scan_devices(void)
182 {
183         unsigned int i;
184
185         for (i = 0; i < LGUEST_MAX_DEVICES; i++)
186                 if (lguest_devices[i].type)
187                         add_lguest_device(i);
188 }
189
190 /*D:100 Fairly early in boot, lguest_bus_init() is called to set up the lguest
191  * bus.  We check that we are a Guest by checking paravirt_ops.name: there are
192  * other ways of checking, but this seems most obvious to me.
193  *
194  * So we can access the array of "struct lguest_device_desc"s easily, we map
195  * that memory and store the pointer in the global "lguest_devices".  Then we
196  * register the bus with the core.  Doing two registrations seems clunky to me,
197  * but it seems to be the correct sysfs incantation.
198  *
199  * Finally we call scan_devices() which adds all the devices found in the
200  * "struct lguest_device_desc" array. */
201 static int __init lguest_bus_init(void)
202 {
203         if (strcmp(paravirt_ops.name, "lguest") != 0)
204                 return 0;
205
206         /* Devices are in a single page above top of "normal" mem */
207         lguest_devices = lguest_map(max_pfn<<PAGE_SHIFT, 1);
208
209         if (bus_register(&lguest_bus.bus) != 0
210             || device_register(&lguest_bus.dev) != 0)
211                 panic("lguest bus registration failed");
212
213         scan_devices();
214         return 0;
215 }
216 /* Do this after core stuff, before devices. */
217 postcore_initcall(lguest_bus_init);