blob: 7f24a98a446f53e0a7fd2bd0ec518494ca7e72cd [file] [log] [blame]
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -07001/******************************************************************************
2 * Talks to Xen Store to figure out what devices we have.
3 *
4 * Copyright (C) 2005 Rusty Russell, IBM Corporation
5 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
6 * Copyright (C) 2005, 2006 XenSource Ltd
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version 2
10 * as published by the Free Software Foundation; or, when distributed
11 * separately from the Linux kernel or incorporated into other
12 * software packages, subject to the following license:
13 *
14 * Permission is hereby granted, free of charge, to any person obtaining a copy
15 * of this source file (the "Software"), to deal in the Software without
16 * restriction, including without limitation the rights to use, copy, modify,
17 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
18 * and to permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
30 * IN THE SOFTWARE.
31 */
32
33#define DPRINTK(fmt, args...) \
34 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \
35 __func__, __LINE__, ##args)
36
37#include <linux/kernel.h>
38#include <linux/err.h>
39#include <linux/string.h>
40#include <linux/ctype.h>
41#include <linux/fcntl.h>
42#include <linux/mm.h>
43#include <linux/notifier.h>
44#include <linux/kthread.h>
45#include <linux/mutex.h>
46#include <linux/io.h>
47
48#include <asm/page.h>
49#include <asm/pgtable.h>
50#include <asm/xen/hypervisor.h>
51#include <xen/xenbus.h>
52#include <xen/events.h>
53#include <xen/page.h>
54
55#include "xenbus_comms.h"
56#include "xenbus_probe.h"
57
58int xen_store_evtchn;
59struct xenstore_domain_interface *xen_store_interface;
60static unsigned long xen_store_mfn;
61
62static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
63
64static void wait_for_devices(struct xenbus_driver *xendrv);
65
66static int xenbus_probe_frontend(const char *type, const char *name);
67
68static void xenbus_dev_shutdown(struct device *_dev);
69
70/* If something in array of ids matches this device, return it. */
71static const struct xenbus_device_id *
72match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev)
73{
74 for (; *arr->devicetype != '\0'; arr++) {
75 if (!strcmp(arr->devicetype, dev->devicetype))
76 return arr;
77 }
78 return NULL;
79}
80
81int xenbus_match(struct device *_dev, struct device_driver *_drv)
82{
83 struct xenbus_driver *drv = to_xenbus_driver(_drv);
84
85 if (!drv->ids)
86 return 0;
87
88 return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
89}
90
Mark McLoughlind2f0c522008-04-02 10:54:05 -070091static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)
92{
93 struct xenbus_device *dev = to_xenbus_device(_dev);
94
95 if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
96 return -ENOMEM;
97
98 return 0;
99}
100
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700101/* device/<type>/<id> => <type>-<id> */
102static int frontend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename)
103{
104 nodename = strchr(nodename, '/');
105 if (!nodename || strlen(nodename + 1) >= BUS_ID_SIZE) {
106 printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename);
107 return -EINVAL;
108 }
109
110 strlcpy(bus_id, nodename + 1, BUS_ID_SIZE);
111 if (!strchr(bus_id, '/')) {
112 printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id);
113 return -EINVAL;
114 }
115 *strchr(bus_id, '/') = '-';
116 return 0;
117}
118
119
120static void free_otherend_details(struct xenbus_device *dev)
121{
122 kfree(dev->otherend);
123 dev->otherend = NULL;
124}
125
126
127static void free_otherend_watch(struct xenbus_device *dev)
128{
129 if (dev->otherend_watch.node) {
130 unregister_xenbus_watch(&dev->otherend_watch);
131 kfree(dev->otherend_watch.node);
132 dev->otherend_watch.node = NULL;
133 }
134}
135
136
137int read_otherend_details(struct xenbus_device *xendev,
138 char *id_node, char *path_node)
139{
140 int err = xenbus_gather(XBT_NIL, xendev->nodename,
141 id_node, "%i", &xendev->otherend_id,
142 path_node, NULL, &xendev->otherend,
143 NULL);
144 if (err) {
145 xenbus_dev_fatal(xendev, err,
146 "reading other end details from %s",
147 xendev->nodename);
148 return err;
149 }
150 if (strlen(xendev->otherend) == 0 ||
151 !xenbus_exists(XBT_NIL, xendev->otherend, "")) {
152 xenbus_dev_fatal(xendev, -ENOENT,
153 "unable to read other end from %s. "
154 "missing or inaccessible.",
155 xendev->nodename);
156 free_otherend_details(xendev);
157 return -ENOENT;
158 }
159
160 return 0;
161}
162
163
164static int read_backend_details(struct xenbus_device *xendev)
165{
166 return read_otherend_details(xendev, "backend-id", "backend");
167}
168
169
170/* Bus type for frontend drivers. */
171static struct xen_bus_type xenbus_frontend = {
172 .root = "device",
173 .levels = 2, /* device/type/<id> */
174 .get_bus_id = frontend_bus_id,
175 .probe = xenbus_probe_frontend,
176 .bus = {
177 .name = "xen",
178 .match = xenbus_match,
Mark McLoughlind2f0c522008-04-02 10:54:05 -0700179 .uevent = xenbus_uevent,
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700180 .probe = xenbus_dev_probe,
181 .remove = xenbus_dev_remove,
182 .shutdown = xenbus_dev_shutdown,
183 },
184};
185
186static void otherend_changed(struct xenbus_watch *watch,
187 const char **vec, unsigned int len)
188{
189 struct xenbus_device *dev =
190 container_of(watch, struct xenbus_device, otherend_watch);
191 struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
192 enum xenbus_state state;
193
194 /* Protect us against watches firing on old details when the otherend
195 details change, say immediately after a resume. */
196 if (!dev->otherend ||
197 strncmp(dev->otherend, vec[XS_WATCH_PATH],
198 strlen(dev->otherend))) {
Joe Perches898eb712007-10-18 03:06:30 -0700199 dev_dbg(&dev->dev, "Ignoring watch at %s\n",
200 vec[XS_WATCH_PATH]);
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700201 return;
202 }
203
204 state = xenbus_read_driver_state(dev->otherend);
205
Joe Perches898eb712007-10-18 03:06:30 -0700206 dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700207 state, xenbus_strstate(state), dev->otherend_watch.node,
208 vec[XS_WATCH_PATH]);
209
210 /*
211 * Ignore xenbus transitions during shutdown. This prevents us doing
212 * work that can fail e.g., when the rootfs is gone.
213 */
214 if (system_state > SYSTEM_RUNNING) {
215 struct xen_bus_type *bus = bus;
216 bus = container_of(dev->dev.bus, struct xen_bus_type, bus);
217 /* If we're frontend, drive the state machine to Closed. */
218 /* This should cause the backend to release our resources. */
219 if ((bus == &xenbus_frontend) && (state == XenbusStateClosing))
220 xenbus_frontend_closed(dev);
221 return;
222 }
223
224 if (drv->otherend_changed)
225 drv->otherend_changed(dev, state);
226}
227
228
229static int talk_to_otherend(struct xenbus_device *dev)
230{
231 struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
232
233 free_otherend_watch(dev);
234 free_otherend_details(dev);
235
236 return drv->read_otherend_details(dev);
237}
238
239
240static int watch_otherend(struct xenbus_device *dev)
241{
242 return xenbus_watch_pathfmt(dev, &dev->otherend_watch, otherend_changed,
243 "%s/%s", dev->otherend, "state");
244}
245
246
247int xenbus_dev_probe(struct device *_dev)
248{
249 struct xenbus_device *dev = to_xenbus_device(_dev);
250 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
251 const struct xenbus_device_id *id;
252 int err;
253
254 DPRINTK("%s", dev->nodename);
255
256 if (!drv->probe) {
257 err = -ENODEV;
258 goto fail;
259 }
260
261 id = match_device(drv->ids, dev);
262 if (!id) {
263 err = -ENODEV;
264 goto fail;
265 }
266
267 err = talk_to_otherend(dev);
268 if (err) {
269 dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n",
270 dev->nodename);
271 return err;
272 }
273
274 err = drv->probe(dev, id);
275 if (err)
276 goto fail;
277
278 err = watch_otherend(dev);
279 if (err) {
280 dev_warn(&dev->dev, "watch_otherend on %s failed.\n",
281 dev->nodename);
282 return err;
283 }
284
285 return 0;
286fail:
287 xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);
288 xenbus_switch_state(dev, XenbusStateClosed);
289 return -ENODEV;
290}
291
292int xenbus_dev_remove(struct device *_dev)
293{
294 struct xenbus_device *dev = to_xenbus_device(_dev);
295 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver);
296
297 DPRINTK("%s", dev->nodename);
298
299 free_otherend_watch(dev);
300 free_otherend_details(dev);
301
302 if (drv->remove)
303 drv->remove(dev);
304
305 xenbus_switch_state(dev, XenbusStateClosed);
306 return 0;
307}
308
309static void xenbus_dev_shutdown(struct device *_dev)
310{
311 struct xenbus_device *dev = to_xenbus_device(_dev);
312 unsigned long timeout = 5*HZ;
313
314 DPRINTK("%s", dev->nodename);
315
316 get_device(&dev->dev);
317 if (dev->state != XenbusStateConnected) {
318 printk(KERN_INFO "%s: %s: %s != Connected, skipping\n", __func__,
319 dev->nodename, xenbus_strstate(dev->state));
320 goto out;
321 }
322 xenbus_switch_state(dev, XenbusStateClosing);
323 timeout = wait_for_completion_timeout(&dev->down, timeout);
324 if (!timeout)
325 printk(KERN_INFO "%s: %s timeout closing device\n",
326 __func__, dev->nodename);
327 out:
328 put_device(&dev->dev);
329}
330
331int xenbus_register_driver_common(struct xenbus_driver *drv,
332 struct xen_bus_type *bus,
333 struct module *owner,
334 const char *mod_name)
335{
336 drv->driver.name = drv->name;
337 drv->driver.bus = &bus->bus;
338 drv->driver.owner = owner;
339 drv->driver.mod_name = mod_name;
340
341 return driver_register(&drv->driver);
342}
343
344int __xenbus_register_frontend(struct xenbus_driver *drv,
345 struct module *owner, const char *mod_name)
346{
347 int ret;
348
349 drv->read_otherend_details = read_backend_details;
350
351 ret = xenbus_register_driver_common(drv, &xenbus_frontend,
352 owner, mod_name);
353 if (ret)
354 return ret;
355
356 /* If this driver is loaded as a module wait for devices to attach. */
357 wait_for_devices(drv);
358
359 return 0;
360}
361EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
362
363void xenbus_unregister_driver(struct xenbus_driver *drv)
364{
365 driver_unregister(&drv->driver);
366}
367EXPORT_SYMBOL_GPL(xenbus_unregister_driver);
368
369struct xb_find_info
370{
371 struct xenbus_device *dev;
372 const char *nodename;
373};
374
375static int cmp_dev(struct device *dev, void *data)
376{
377 struct xenbus_device *xendev = to_xenbus_device(dev);
378 struct xb_find_info *info = data;
379
380 if (!strcmp(xendev->nodename, info->nodename)) {
381 info->dev = xendev;
382 get_device(dev);
383 return 1;
384 }
385 return 0;
386}
387
388struct xenbus_device *xenbus_device_find(const char *nodename,
389 struct bus_type *bus)
390{
391 struct xb_find_info info = { .dev = NULL, .nodename = nodename };
392
393 bus_for_each_dev(bus, NULL, &info, cmp_dev);
394 return info.dev;
395}
396
397static int cleanup_dev(struct device *dev, void *data)
398{
399 struct xenbus_device *xendev = to_xenbus_device(dev);
400 struct xb_find_info *info = data;
401 int len = strlen(info->nodename);
402
403 DPRINTK("%s", info->nodename);
404
405 /* Match the info->nodename path, or any subdirectory of that path. */
406 if (strncmp(xendev->nodename, info->nodename, len))
407 return 0;
408
409 /* If the node name is longer, ensure it really is a subdirectory. */
410 if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/'))
411 return 0;
412
413 info->dev = xendev;
414 get_device(dev);
415 return 1;
416}
417
418static void xenbus_cleanup_devices(const char *path, struct bus_type *bus)
419{
420 struct xb_find_info info = { .nodename = path };
421
422 do {
423 info.dev = NULL;
424 bus_for_each_dev(bus, NULL, &info, cleanup_dev);
425 if (info.dev) {
426 device_unregister(&info.dev->dev);
427 put_device(&info.dev->dev);
428 }
429 } while (info.dev);
430}
431
432static void xenbus_dev_release(struct device *dev)
433{
434 if (dev)
435 kfree(to_xenbus_device(dev));
436}
437
438static ssize_t xendev_show_nodename(struct device *dev,
439 struct device_attribute *attr, char *buf)
440{
441 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
442}
443DEVICE_ATTR(nodename, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_nodename, NULL);
444
445static ssize_t xendev_show_devtype(struct device *dev,
446 struct device_attribute *attr, char *buf)
447{
448 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
449}
450DEVICE_ATTR(devtype, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_devtype, NULL);
451
Mark McLoughlind2f0c522008-04-02 10:54:05 -0700452static ssize_t xendev_show_modalias(struct device *dev,
453 struct device_attribute *attr, char *buf)
454{
455 return sprintf(buf, "xen:%s\n", to_xenbus_device(dev)->devicetype);
456}
457DEVICE_ATTR(modalias, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_modalias, NULL);
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700458
459int xenbus_probe_node(struct xen_bus_type *bus,
460 const char *type,
461 const char *nodename)
462{
463 int err;
464 struct xenbus_device *xendev;
465 size_t stringlen;
466 char *tmpstring;
467
468 enum xenbus_state state = xenbus_read_driver_state(nodename);
469
470 if (state != XenbusStateInitialising) {
471 /* Device is not new, so ignore it. This can happen if a
472 device is going away after switching to Closed. */
473 return 0;
474 }
475
476 stringlen = strlen(nodename) + 1 + strlen(type) + 1;
477 xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL);
478 if (!xendev)
479 return -ENOMEM;
480
481 xendev->state = XenbusStateInitialising;
482
483 /* Copy the strings into the extra space. */
484
485 tmpstring = (char *)(xendev + 1);
486 strcpy(tmpstring, nodename);
487 xendev->nodename = tmpstring;
488
489 tmpstring += strlen(tmpstring) + 1;
490 strcpy(tmpstring, type);
491 xendev->devicetype = tmpstring;
492 init_completion(&xendev->down);
493
494 xendev->dev.bus = &bus->bus;
495 xendev->dev.release = xenbus_dev_release;
496
497 err = bus->get_bus_id(xendev->dev.bus_id, xendev->nodename);
498 if (err)
499 goto fail;
500
501 /* Register with generic device framework. */
502 err = device_register(&xendev->dev);
503 if (err)
504 goto fail;
505
506 err = device_create_file(&xendev->dev, &dev_attr_nodename);
507 if (err)
508 goto fail_unregister;
509
510 err = device_create_file(&xendev->dev, &dev_attr_devtype);
511 if (err)
Mark McLoughlind2f0c522008-04-02 10:54:05 -0700512 goto fail_remove_nodename;
513
514 err = device_create_file(&xendev->dev, &dev_attr_modalias);
515 if (err)
516 goto fail_remove_devtype;
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700517
518 return 0;
Mark McLoughlind2f0c522008-04-02 10:54:05 -0700519fail_remove_devtype:
520 device_remove_file(&xendev->dev, &dev_attr_devtype);
521fail_remove_nodename:
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700522 device_remove_file(&xendev->dev, &dev_attr_nodename);
523fail_unregister:
524 device_unregister(&xendev->dev);
525fail:
526 kfree(xendev);
527 return err;
528}
529
530/* device/<typename>/<name> */
531static int xenbus_probe_frontend(const char *type, const char *name)
532{
533 char *nodename;
534 int err;
535
536 nodename = kasprintf(GFP_KERNEL, "%s/%s/%s",
537 xenbus_frontend.root, type, name);
538 if (!nodename)
539 return -ENOMEM;
540
541 DPRINTK("%s", nodename);
542
543 err = xenbus_probe_node(&xenbus_frontend, type, nodename);
544 kfree(nodename);
545 return err;
546}
547
548static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
549{
550 int err = 0;
551 char **dir;
552 unsigned int dir_n = 0;
553 int i;
554
555 dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n);
556 if (IS_ERR(dir))
557 return PTR_ERR(dir);
558
559 for (i = 0; i < dir_n; i++) {
560 err = bus->probe(type, dir[i]);
561 if (err)
562 break;
563 }
564 kfree(dir);
565 return err;
566}
567
568int xenbus_probe_devices(struct xen_bus_type *bus)
569{
570 int err = 0;
571 char **dir;
572 unsigned int i, dir_n;
573
574 dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n);
575 if (IS_ERR(dir))
576 return PTR_ERR(dir);
577
578 for (i = 0; i < dir_n; i++) {
579 err = xenbus_probe_device_type(bus, dir[i]);
580 if (err)
581 break;
582 }
583 kfree(dir);
584 return err;
585}
586
587static unsigned int char_count(const char *str, char c)
588{
589 unsigned int i, ret = 0;
590
591 for (i = 0; str[i]; i++)
592 if (str[i] == c)
593 ret++;
594 return ret;
595}
596
597static int strsep_len(const char *str, char c, unsigned int len)
598{
599 unsigned int i;
600
601 for (i = 0; str[i]; i++)
602 if (str[i] == c) {
603 if (len == 0)
604 return i;
605 len--;
606 }
607 return (len == 0) ? i : -ERANGE;
608}
609
610void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
611{
612 int exists, rootlen;
613 struct xenbus_device *dev;
614 char type[BUS_ID_SIZE];
615 const char *p, *root;
616
617 if (char_count(node, '/') < 2)
618 return;
619
620 exists = xenbus_exists(XBT_NIL, node, "");
621 if (!exists) {
622 xenbus_cleanup_devices(node, &bus->bus);
623 return;
624 }
625
626 /* backend/<type>/... or device/<type>/... */
627 p = strchr(node, '/') + 1;
628 snprintf(type, BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);
629 type[BUS_ID_SIZE-1] = '\0';
630
631 rootlen = strsep_len(node, '/', bus->levels);
632 if (rootlen < 0)
633 return;
634 root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node);
635 if (!root)
636 return;
637
638 dev = xenbus_device_find(root, &bus->bus);
639 if (!dev)
640 xenbus_probe_node(bus, type, root);
641 else
642 put_device(&dev->dev);
643
644 kfree(root);
645}
646
647static void frontend_changed(struct xenbus_watch *watch,
648 const char **vec, unsigned int len)
649{
650 DPRINTK("");
651
652 xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
653}
654
655/* We watch for devices appearing and vanishing. */
656static struct xenbus_watch fe_watch = {
657 .node = "device",
658 .callback = frontend_changed,
659};
660
661static int suspend_dev(struct device *dev, void *data)
662{
663 int err = 0;
664 struct xenbus_driver *drv;
665 struct xenbus_device *xdev;
666
667 DPRINTK("");
668
669 if (dev->driver == NULL)
670 return 0;
671 drv = to_xenbus_driver(dev->driver);
672 xdev = container_of(dev, struct xenbus_device, dev);
673 if (drv->suspend)
674 err = drv->suspend(xdev);
675 if (err)
676 printk(KERN_WARNING
677 "xenbus: suspend %s failed: %i\n", dev->bus_id, err);
678 return 0;
679}
680
681static int suspend_cancel_dev(struct device *dev, void *data)
682{
683 int err = 0;
684 struct xenbus_driver *drv;
685 struct xenbus_device *xdev;
686
687 DPRINTK("");
688
689 if (dev->driver == NULL)
690 return 0;
691 drv = to_xenbus_driver(dev->driver);
692 xdev = container_of(dev, struct xenbus_device, dev);
693 if (drv->suspend_cancel)
694 err = drv->suspend_cancel(xdev);
695 if (err)
696 printk(KERN_WARNING
697 "xenbus: suspend_cancel %s failed: %i\n",
698 dev->bus_id, err);
699 return 0;
700}
701
702static int resume_dev(struct device *dev, void *data)
703{
704 int err;
705 struct xenbus_driver *drv;
706 struct xenbus_device *xdev;
707
708 DPRINTK("");
709
710 if (dev->driver == NULL)
711 return 0;
712
713 drv = to_xenbus_driver(dev->driver);
714 xdev = container_of(dev, struct xenbus_device, dev);
715
716 err = talk_to_otherend(xdev);
717 if (err) {
718 printk(KERN_WARNING
719 "xenbus: resume (talk_to_otherend) %s failed: %i\n",
720 dev->bus_id, err);
721 return err;
722 }
723
724 xdev->state = XenbusStateInitialising;
725
726 if (drv->resume) {
727 err = drv->resume(xdev);
728 if (err) {
729 printk(KERN_WARNING
730 "xenbus: resume %s failed: %i\n",
731 dev->bus_id, err);
732 return err;
733 }
734 }
735
736 err = watch_otherend(xdev);
737 if (err) {
738 printk(KERN_WARNING
739 "xenbus_probe: resume (watch_otherend) %s failed: "
740 "%d.\n", dev->bus_id, err);
741 return err;
742 }
743
744 return 0;
745}
746
747void xenbus_suspend(void)
748{
749 DPRINTK("");
750
751 bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, suspend_dev);
752 xenbus_backend_suspend(suspend_dev);
753 xs_suspend();
754}
755EXPORT_SYMBOL_GPL(xenbus_suspend);
756
757void xenbus_resume(void)
758{
759 xb_init_comms();
760 xs_resume();
761 bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, resume_dev);
762 xenbus_backend_resume(resume_dev);
763}
764EXPORT_SYMBOL_GPL(xenbus_resume);
765
766void xenbus_suspend_cancel(void)
767{
768 xs_suspend_cancel();
769 bus_for_each_dev(&xenbus_frontend.bus, NULL, NULL, suspend_cancel_dev);
770 xenbus_backend_resume(suspend_cancel_dev);
771}
772EXPORT_SYMBOL_GPL(xenbus_suspend_cancel);
773
774/* A flag to determine if xenstored is 'ready' (i.e. has started) */
775int xenstored_ready = 0;
776
777
778int register_xenstore_notifier(struct notifier_block *nb)
779{
780 int ret = 0;
781
782 if (xenstored_ready > 0)
783 ret = nb->notifier_call(nb, 0, NULL);
784 else
785 blocking_notifier_chain_register(&xenstore_chain, nb);
786
787 return ret;
788}
789EXPORT_SYMBOL_GPL(register_xenstore_notifier);
790
791void unregister_xenstore_notifier(struct notifier_block *nb)
792{
793 blocking_notifier_chain_unregister(&xenstore_chain, nb);
794}
795EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);
796
797void xenbus_probe(struct work_struct *unused)
798{
799 BUG_ON((xenstored_ready <= 0));
800
801 /* Enumerate devices in xenstore and watch for changes. */
802 xenbus_probe_devices(&xenbus_frontend);
803 register_xenbus_watch(&fe_watch);
804 xenbus_backend_probe_and_watch();
805
806 /* Notify others that xenstore is up */
807 blocking_notifier_call_chain(&xenstore_chain, 0, NULL);
808}
809
810static int __init xenbus_probe_init(void)
811{
812 int err = 0;
813
814 DPRINTK("");
815
816 err = -ENODEV;
Jeremy Fitzhardinge6e833582008-08-19 13:16:17 -0700817 if (!xen_domain())
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700818 goto out_error;
819
820 /* Register ourselves with the kernel bus subsystem */
821 err = bus_register(&xenbus_frontend.bus);
822 if (err)
823 goto out_error;
824
825 err = xenbus_backend_bus_register();
826 if (err)
827 goto out_unreg_front;
828
829 /*
830 * Domain0 doesn't have a store_evtchn or store_mfn yet.
831 */
Jeremy Fitzhardinge6e833582008-08-19 13:16:17 -0700832 if (xen_initial_domain()) {
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700833 /* dom0 not yet supported */
834 } else {
835 xenstored_ready = 1;
836 xen_store_evtchn = xen_start_info->store_evtchn;
837 xen_store_mfn = xen_start_info->store_mfn;
838 }
839 xen_store_interface = mfn_to_virt(xen_store_mfn);
840
841 /* Initialize the interface to xenstore. */
842 err = xs_init();
843 if (err) {
844 printk(KERN_WARNING
845 "XENBUS: Error initializing xenstore comms: %i\n", err);
846 goto out_unreg_back;
847 }
848
Jeremy Fitzhardinge6e833582008-08-19 13:16:17 -0700849 if (!xen_initial_domain())
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700850 xenbus_probe(NULL);
851
852 return 0;
853
854 out_unreg_back:
855 xenbus_backend_bus_unregister();
856
857 out_unreg_front:
858 bus_unregister(&xenbus_frontend.bus);
859
860 out_error:
861 return err;
862}
863
864postcore_initcall(xenbus_probe_init);
865
866MODULE_LICENSE("GPL");
867
868static int is_disconnected_device(struct device *dev, void *data)
869{
870 struct xenbus_device *xendev = to_xenbus_device(dev);
871 struct device_driver *drv = data;
Christian Limpach1d78d702008-04-02 10:54:04 -0700872 struct xenbus_driver *xendrv;
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700873
874 /*
875 * A device with no driver will never connect. We care only about
876 * devices which should currently be in the process of connecting.
877 */
878 if (!dev->driver)
879 return 0;
880
881 /* Is this search limited to a particular driver? */
882 if (drv && (dev->driver != drv))
883 return 0;
884
Christian Limpach1d78d702008-04-02 10:54:04 -0700885 xendrv = to_xenbus_driver(dev->driver);
886 return (xendev->state != XenbusStateConnected ||
887 (xendrv->is_ready && !xendrv->is_ready(xendev)));
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700888}
889
890static int exists_disconnected_device(struct device_driver *drv)
891{
892 return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
893 is_disconnected_device);
894}
895
896static int print_device_status(struct device *dev, void *data)
897{
898 struct xenbus_device *xendev = to_xenbus_device(dev);
899 struct device_driver *drv = data;
900
901 /* Is this operation limited to a particular driver? */
902 if (drv && (dev->driver != drv))
903 return 0;
904
905 if (!dev->driver) {
906 /* Information only: is this too noisy? */
907 printk(KERN_INFO "XENBUS: Device with no driver: %s\n",
908 xendev->nodename);
909 } else if (xendev->state != XenbusStateConnected) {
910 printk(KERN_WARNING "XENBUS: Timeout connecting "
911 "to device: %s (state %d)\n",
912 xendev->nodename, xendev->state);
913 }
914
915 return 0;
916}
917
918/* We only wait for device setup after most initcalls have run. */
919static int ready_to_wait_for_devices;
920
921/*
922 * On a 10 second timeout, wait for all devices currently configured. We need
923 * to do this to guarantee that the filesystems and / or network devices
924 * needed for boot are available, before we can allow the boot to proceed.
925 *
926 * This needs to be on a late_initcall, to happen after the frontend device
927 * drivers have been initialised, but before the root fs is mounted.
928 *
929 * A possible improvement here would be to have the tools add a per-device
930 * flag to the store entry, indicating whether it is needed at boot time.
931 * This would allow people who knew what they were doing to accelerate their
932 * boot slightly, but of course needs tools or manual intervention to set up
933 * those flags correctly.
934 */
935static void wait_for_devices(struct xenbus_driver *xendrv)
936{
937 unsigned long timeout = jiffies + 10*HZ;
938 struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
939
Jeremy Fitzhardinge6e833582008-08-19 13:16:17 -0700940 if (!ready_to_wait_for_devices || !xen_domain())
Jeremy Fitzhardinge4bac07c2007-07-17 18:37:06 -0700941 return;
942
943 while (exists_disconnected_device(drv)) {
944 if (time_after(jiffies, timeout))
945 break;
946 schedule_timeout_interruptible(HZ/10);
947 }
948
949 bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
950 print_device_status);
951}
952
953#ifndef MODULE
954static int __init boot_wait_for_devices(void)
955{
956 ready_to_wait_for_devices = 1;
957 wait_for_devices(NULL);
958 return 0;
959}
960
961late_initcall(boot_wait_for_devices);
962#endif