1
2#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
3
4#define DPRINTK(fmt, ...) \
5 pr_debug("(%s:%d) " fmt "\n", \
6 __func__, __LINE__, ##__VA_ARGS__)
7
8#include <linux/kernel.h>
9#include <linux/err.h>
10#include <linux/string.h>
11#include <linux/ctype.h>
12#include <linux/fcntl.h>
13#include <linux/mm.h>
14#include <linux/proc_fs.h>
15#include <linux/notifier.h>
16#include <linux/kthread.h>
17#include <linux/mutex.h>
18#include <linux/io.h>
19#include <linux/module.h>
20
21#include <asm/page.h>
22#include <asm/xen/hypervisor.h>
23#include <xen/xenbus.h>
24#include <xen/events.h>
25#include <xen/page.h>
26#include <xen/xen.h>
27
28#include <xen/platform_pci.h>
29
30#include "xenbus.h"
31
32
33
34
35static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
36{
37 nodename = strchr(nodename, '/');
38 if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
39 pr_warn("bad frontend %s\n", nodename);
40 return -EINVAL;
41 }
42
43 strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
44 if (!strchr(bus_id, '/')) {
45 pr_warn("bus_id %s no slash\n", bus_id);
46 return -EINVAL;
47 }
48 *strchr(bus_id, '/') = '-';
49 return 0;
50}
51
52
53static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type,
54 const char *name)
55{
56 char *nodename;
57 int err;
58
59
60 if (!strncmp(type, "console", 7) && !strncmp(name, "0", 1)) {
61 DPRINTK("Ignoring buggy device entry console/0");
62 return 0;
63 }
64
65 nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name);
66 if (!nodename)
67 return -ENOMEM;
68
69 DPRINTK("%s", nodename);
70
71 err = xenbus_probe_node(bus, type, nodename);
72 kfree(nodename);
73 return err;
74}
75
76static int xenbus_uevent_frontend(struct device *_dev,
77 struct kobj_uevent_env *env)
78{
79 struct xenbus_device *dev = to_xenbus_device(_dev);
80
81 if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
82 return -ENOMEM;
83
84 return 0;
85}
86
87
88static void backend_changed(struct xenbus_watch *watch,
89 const char *path, const char *token)
90{
91 xenbus_otherend_changed(watch, path, token, 1);
92}
93
94static void xenbus_frontend_delayed_resume(struct work_struct *w)
95{
96 struct xenbus_device *xdev = container_of(w, struct xenbus_device, work);
97
98 xenbus_dev_resume(&xdev->dev);
99}
100
101static int xenbus_frontend_dev_resume(struct device *dev)
102{
103
104
105
106
107 if (xen_store_domain_type == XS_LOCAL) {
108 struct xenbus_device *xdev = to_xenbus_device(dev);
109
110 schedule_work(&xdev->work);
111
112 return 0;
113 }
114
115 return xenbus_dev_resume(dev);
116}
117
118static int xenbus_frontend_dev_probe(struct device *dev)
119{
120 if (xen_store_domain_type == XS_LOCAL) {
121 struct xenbus_device *xdev = to_xenbus_device(dev);
122 INIT_WORK(&xdev->work, xenbus_frontend_delayed_resume);
123 }
124
125 return xenbus_dev_probe(dev);
126}
127
128static void xenbus_frontend_dev_shutdown(struct device *_dev)
129{
130 struct xenbus_device *dev = to_xenbus_device(_dev);
131 unsigned long timeout = 5*HZ;
132
133 DPRINTK("%s", dev->nodename);
134
135 get_device(&dev->dev);
136 if (dev->state != XenbusStateConnected) {
137 pr_info("%s: %s: %s != Connected, skipping\n",
138 __func__, dev->nodename, xenbus_strstate(dev->state));
139 goto out;
140 }
141 xenbus_switch_state(dev, XenbusStateClosing);
142 timeout = wait_for_completion_timeout(&dev->down, timeout);
143 if (!timeout)
144 pr_info("%s: %s timeout closing device\n",
145 __func__, dev->nodename);
146 out:
147 put_device(&dev->dev);
148}
149
150static const struct dev_pm_ops xenbus_pm_ops = {
151 .suspend = xenbus_dev_suspend,
152 .resume = xenbus_frontend_dev_resume,
153 .freeze = xenbus_dev_suspend,
154 .thaw = xenbus_dev_cancel,
155 .restore = xenbus_dev_resume,
156};
157
158static struct xen_bus_type xenbus_frontend = {
159 .root = "device",
160 .levels = 2,
161 .get_bus_id = frontend_bus_id,
162 .probe = xenbus_probe_frontend,
163 .otherend_changed = backend_changed,
164 .bus = {
165 .name = "xen",
166 .match = xenbus_match,
167 .uevent = xenbus_uevent_frontend,
168 .probe = xenbus_frontend_dev_probe,
169 .remove = xenbus_dev_remove,
170 .shutdown = xenbus_frontend_dev_shutdown,
171 .dev_groups = xenbus_dev_groups,
172
173 .pm = &xenbus_pm_ops,
174 },
175};
176
177static void frontend_changed(struct xenbus_watch *watch,
178 const char *path, const char *token)
179{
180 DPRINTK("");
181
182 xenbus_dev_changed(path, &xenbus_frontend);
183}
184
185
186
187static struct xenbus_watch fe_watch = {
188 .node = "device",
189 .callback = frontend_changed,
190};
191
192static int read_backend_details(struct xenbus_device *xendev)
193{
194 return xenbus_read_otherend_details(xendev, "backend-id", "backend");
195}
196
197static int is_device_connecting(struct device *dev, void *data, bool ignore_nonessential)
198{
199 struct xenbus_device *xendev = to_xenbus_device(dev);
200 struct device_driver *drv = data;
201 struct xenbus_driver *xendrv;
202
203
204
205
206
207 if (!dev->driver)
208 return 0;
209
210
211 if (drv && (dev->driver != drv))
212 return 0;
213
214 if (ignore_nonessential) {
215
216
217
218
219
220 if ((strncmp(xendev->nodename, "device/vkbd", 11) == 0))
221 return 0;
222
223 if ((strncmp(xendev->nodename, "device/vfb", 10) == 0))
224 return 0;
225 }
226 xendrv = to_xenbus_driver(dev->driver);
227 return (xendev->state < XenbusStateConnected ||
228 (xendev->state == XenbusStateConnected &&
229 xendrv->is_ready && !xendrv->is_ready(xendev)));
230}
231static int essential_device_connecting(struct device *dev, void *data)
232{
233 return is_device_connecting(dev, data, true );
234}
235static int non_essential_device_connecting(struct device *dev, void *data)
236{
237 return is_device_connecting(dev, data, false);
238}
239
240static int exists_essential_connecting_device(struct device_driver *drv)
241{
242 return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
243 essential_device_connecting);
244}
245static int exists_non_essential_connecting_device(struct device_driver *drv)
246{
247 return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
248 non_essential_device_connecting);
249}
250
251static int print_device_status(struct device *dev, void *data)
252{
253 struct xenbus_device *xendev = to_xenbus_device(dev);
254 struct device_driver *drv = data;
255
256
257 if (drv && (dev->driver != drv))
258 return 0;
259
260 if (!dev->driver) {
261
262 pr_info("Device with no driver: %s\n", xendev->nodename);
263 } else if (xendev->state < XenbusStateConnected) {
264 enum xenbus_state rstate = XenbusStateUnknown;
265 if (xendev->otherend)
266 rstate = xenbus_read_driver_state(xendev->otherend);
267 pr_warn("Timeout connecting to device: %s (local state %d, remote state %d)\n",
268 xendev->nodename, xendev->state, rstate);
269 }
270
271 return 0;
272}
273
274
275static int ready_to_wait_for_devices;
276
277static bool wait_loop(unsigned long start, unsigned int max_delay,
278 unsigned int *seconds_waited)
279{
280 if (time_after(jiffies, start + (*seconds_waited+5)*HZ)) {
281 if (!*seconds_waited)
282 pr_warn("Waiting for devices to initialise: ");
283 *seconds_waited += 5;
284 pr_cont("%us...", max_delay - *seconds_waited);
285 if (*seconds_waited == max_delay) {
286 pr_cont("\n");
287 return true;
288 }
289 }
290
291 schedule_timeout_interruptible(HZ/10);
292
293 return false;
294}
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309static void wait_for_devices(struct xenbus_driver *xendrv)
310{
311 unsigned long start = jiffies;
312 struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
313 unsigned int seconds_waited = 0;
314
315 if (!ready_to_wait_for_devices || !xen_domain())
316 return;
317
318 while (exists_non_essential_connecting_device(drv))
319 if (wait_loop(start, 30, &seconds_waited))
320 break;
321
322
323 while (exists_essential_connecting_device(drv))
324 if (wait_loop(start, 270, &seconds_waited))
325 break;
326
327 if (seconds_waited)
328 printk("\n");
329
330 bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
331 print_device_status);
332}
333
334int __xenbus_register_frontend(struct xenbus_driver *drv, struct module *owner,
335 const char *mod_name)
336{
337 int ret;
338
339 drv->read_otherend_details = read_backend_details;
340
341 ret = xenbus_register_driver_common(drv, &xenbus_frontend,
342 owner, mod_name);
343 if (ret)
344 return ret;
345
346
347 wait_for_devices(drv);
348
349 return 0;
350}
351EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
352
353static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq);
354static int backend_state;
355
356static void xenbus_reset_backend_state_changed(struct xenbus_watch *w,
357 const char *path, const char *token)
358{
359 if (xenbus_scanf(XBT_NIL, path, "", "%i",
360 &backend_state) != 1)
361 backend_state = XenbusStateUnknown;
362 printk(KERN_DEBUG "XENBUS: backend %s %s\n",
363 path, xenbus_strstate(backend_state));
364 wake_up(&backend_state_wq);
365}
366
367static void xenbus_reset_wait_for_backend(char *be, int expected)
368{
369 long timeout;
370 timeout = wait_event_interruptible_timeout(backend_state_wq,
371 backend_state == expected, 5 * HZ);
372 if (timeout <= 0)
373 pr_info("backend %s timed out\n", be);
374}
375
376
377
378
379
380
381static void xenbus_reset_frontend(char *fe, char *be, int be_state)
382{
383 struct xenbus_watch be_watch;
384
385 printk(KERN_DEBUG "XENBUS: backend %s %s\n",
386 be, xenbus_strstate(be_state));
387
388 memset(&be_watch, 0, sizeof(be_watch));
389 be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", be);
390 if (!be_watch.node)
391 return;
392
393 be_watch.callback = xenbus_reset_backend_state_changed;
394 backend_state = XenbusStateUnknown;
395
396 pr_info("triggering reconnect on %s\n", be);
397 register_xenbus_watch(&be_watch);
398
399
400 switch (be_state) {
401 case XenbusStateConnected:
402 xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosing);
403 xenbus_reset_wait_for_backend(be, XenbusStateClosing);
404 fallthrough;
405
406 case XenbusStateClosing:
407 xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosed);
408 xenbus_reset_wait_for_backend(be, XenbusStateClosed);
409 fallthrough;
410
411 case XenbusStateClosed:
412 xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateInitialising);
413 xenbus_reset_wait_for_backend(be, XenbusStateInitWait);
414 }
415
416 unregister_xenbus_watch(&be_watch);
417 pr_info("reconnect done on %s\n", be);
418 kfree(be_watch.node);
419}
420
421static void xenbus_check_frontend(char *class, char *dev)
422{
423 int be_state, fe_state, err;
424 char *backend, *frontend;
425
426 frontend = kasprintf(GFP_NOIO | __GFP_HIGH, "device/%s/%s", class, dev);
427 if (!frontend)
428 return;
429
430 err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &fe_state);
431 if (err != 1)
432 goto out;
433
434 switch (fe_state) {
435 case XenbusStateConnected:
436 case XenbusStateClosed:
437 printk(KERN_DEBUG "XENBUS: frontend %s %s\n",
438 frontend, xenbus_strstate(fe_state));
439 backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
440 if (!backend || IS_ERR(backend))
441 goto out;
442 err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &be_state);
443 if (err == 1)
444 xenbus_reset_frontend(frontend, backend, be_state);
445 kfree(backend);
446 break;
447 default:
448 break;
449 }
450out:
451 kfree(frontend);
452}
453
454static void xenbus_reset_state(void)
455{
456 char **devclass, **dev;
457 int devclass_n, dev_n;
458 int i, j;
459
460 devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
461 if (IS_ERR(devclass))
462 return;
463
464 for (i = 0; i < devclass_n; i++) {
465 dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
466 if (IS_ERR(dev))
467 continue;
468 for (j = 0; j < dev_n; j++)
469 xenbus_check_frontend(devclass[i], dev[j]);
470 kfree(dev);
471 }
472 kfree(devclass);
473}
474
475static int frontend_probe_and_watch(struct notifier_block *notifier,
476 unsigned long event,
477 void *data)
478{
479
480 if (xen_hvm_domain())
481 xenbus_reset_state();
482
483 xenbus_probe_devices(&xenbus_frontend);
484 register_xenbus_watch(&fe_watch);
485
486 return NOTIFY_DONE;
487}
488
489
490static int __init xenbus_probe_frontend_init(void)
491{
492 static struct notifier_block xenstore_notifier = {
493 .notifier_call = frontend_probe_and_watch
494 };
495 int err;
496
497 DPRINTK("");
498
499
500 err = bus_register(&xenbus_frontend.bus);
501 if (err)
502 return err;
503
504 register_xenstore_notifier(&xenstore_notifier);
505
506 return 0;
507}
508subsys_initcall(xenbus_probe_frontend_init);
509
510#ifndef MODULE
511static int __init boot_wait_for_devices(void)
512{
513 if (!xen_has_pv_devices())
514 return -ENODEV;
515
516 ready_to_wait_for_devices = 1;
517 wait_for_devices(NULL);
518 return 0;
519}
520
521late_initcall(boot_wait_for_devices);
522#endif
523
524MODULE_LICENSE("GPL");
525