1 /******************************************************************************
2 * Talks to Xen Store to figure out what devices we have.
4 * Copyright (C) 2005 Rusty Russell, IBM Corporation
5 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
6 * Copyright (C) 2005, 2006 XenSource Ltd
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:
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:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
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
33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
35 #define DPRINTK(fmt, args...) \
36 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \
37 __func__, __LINE__, ##args)
39 #include <linux/kernel.h>
40 #include <linux/err.h>
41 #include <linux/string.h>
42 #include <linux/ctype.h>
43 #include <linux/fcntl.h>
45 #include <linux/proc_fs.h>
46 #include <linux/notifier.h>
47 #include <linux/kthread.h>
48 #include <linux/mutex.h>
50 #include <linux/slab.h>
51 #include <linux/module.h>
54 #include <asm/pgtable.h>
55 #include <asm/xen/hypervisor.h>
58 #include <xen/xenbus.h>
59 #include <xen/events.h>
60 #include <xen/xen-ops.h>
69 EXPORT_SYMBOL_GPL(xen_store_evtchn
);
71 struct xenstore_domain_interface
*xen_store_interface
;
72 EXPORT_SYMBOL_GPL(xen_store_interface
);
74 enum xenstore_init xen_store_domain_type
;
75 EXPORT_SYMBOL_GPL(xen_store_domain_type
);
77 static unsigned long xen_store_gfn
;
79 static BLOCKING_NOTIFIER_HEAD(xenstore_chain
);
81 /* If something in array of ids matches this device, return it. */
82 static const struct xenbus_device_id
*
83 match_device(const struct xenbus_device_id
*arr
, struct xenbus_device
*dev
)
85 for (; *arr
->devicetype
!= '\0'; arr
++) {
86 if (!strcmp(arr
->devicetype
, dev
->devicetype
))
92 int xenbus_match(struct device
*_dev
, struct device_driver
*_drv
)
94 struct xenbus_driver
*drv
= to_xenbus_driver(_drv
);
99 return match_device(drv
->ids
, to_xenbus_device(_dev
)) != NULL
;
101 EXPORT_SYMBOL_GPL(xenbus_match
);
104 static void free_otherend_details(struct xenbus_device
*dev
)
106 kfree(dev
->otherend
);
107 dev
->otherend
= NULL
;
111 static void free_otherend_watch(struct xenbus_device
*dev
)
113 if (dev
->otherend_watch
.node
) {
114 unregister_xenbus_watch(&dev
->otherend_watch
);
115 kfree(dev
->otherend_watch
.node
);
116 dev
->otherend_watch
.node
= NULL
;
121 static int talk_to_otherend(struct xenbus_device
*dev
)
123 struct xenbus_driver
*drv
= to_xenbus_driver(dev
->dev
.driver
);
125 free_otherend_watch(dev
);
126 free_otherend_details(dev
);
128 return drv
->read_otherend_details(dev
);
133 static int watch_otherend(struct xenbus_device
*dev
)
135 struct xen_bus_type
*bus
=
136 container_of(dev
->dev
.bus
, struct xen_bus_type
, bus
);
138 return xenbus_watch_pathfmt(dev
, &dev
->otherend_watch
,
139 bus
->otherend_changed
,
140 "%s/%s", dev
->otherend
, "state");
144 int xenbus_read_otherend_details(struct xenbus_device
*xendev
,
145 char *id_node
, char *path_node
)
147 int err
= xenbus_gather(XBT_NIL
, xendev
->nodename
,
148 id_node
, "%i", &xendev
->otherend_id
,
149 path_node
, NULL
, &xendev
->otherend
,
152 xenbus_dev_fatal(xendev
, err
,
153 "reading other end details from %s",
157 if (strlen(xendev
->otherend
) == 0 ||
158 !xenbus_exists(XBT_NIL
, xendev
->otherend
, "")) {
159 xenbus_dev_fatal(xendev
, -ENOENT
,
160 "unable to read other end from %s. "
161 "missing or inaccessible.",
163 free_otherend_details(xendev
);
169 EXPORT_SYMBOL_GPL(xenbus_read_otherend_details
);
171 void xenbus_otherend_changed(struct xenbus_watch
*watch
,
172 const char *path
, const char *token
,
173 int ignore_on_shutdown
)
175 struct xenbus_device
*dev
=
176 container_of(watch
, struct xenbus_device
, otherend_watch
);
177 struct xenbus_driver
*drv
= to_xenbus_driver(dev
->dev
.driver
);
178 enum xenbus_state state
;
180 /* Protect us against watches firing on old details when the otherend
181 details change, say immediately after a resume. */
182 if (!dev
->otherend
||
183 strncmp(dev
->otherend
, path
, strlen(dev
->otherend
))) {
184 dev_dbg(&dev
->dev
, "Ignoring watch at %s\n", path
);
188 state
= xenbus_read_driver_state(dev
->otherend
);
190 dev_dbg(&dev
->dev
, "state is %d, (%s), %s, %s\n",
191 state
, xenbus_strstate(state
), dev
->otherend_watch
.node
, path
);
194 * Ignore xenbus transitions during shutdown. This prevents us doing
195 * work that can fail e.g., when the rootfs is gone.
197 if (system_state
> SYSTEM_RUNNING
) {
198 if (ignore_on_shutdown
&& (state
== XenbusStateClosing
))
199 xenbus_frontend_closed(dev
);
203 if (drv
->otherend_changed
)
204 drv
->otherend_changed(dev
, state
);
206 EXPORT_SYMBOL_GPL(xenbus_otherend_changed
);
208 int xenbus_dev_probe(struct device
*_dev
)
210 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
211 struct xenbus_driver
*drv
= to_xenbus_driver(_dev
->driver
);
212 const struct xenbus_device_id
*id
;
215 DPRINTK("%s", dev
->nodename
);
222 id
= match_device(drv
->ids
, dev
);
228 err
= talk_to_otherend(dev
);
230 dev_warn(&dev
->dev
, "talk_to_otherend on %s failed.\n",
235 err
= drv
->probe(dev
, id
);
239 err
= watch_otherend(dev
);
241 dev_warn(&dev
->dev
, "watch_otherend on %s failed.\n",
248 xenbus_dev_error(dev
, err
, "xenbus_dev_probe on %s", dev
->nodename
);
249 xenbus_switch_state(dev
, XenbusStateClosed
);
252 EXPORT_SYMBOL_GPL(xenbus_dev_probe
);
254 int xenbus_dev_remove(struct device
*_dev
)
256 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
257 struct xenbus_driver
*drv
= to_xenbus_driver(_dev
->driver
);
259 DPRINTK("%s", dev
->nodename
);
261 free_otherend_watch(dev
);
266 free_otherend_details(dev
);
268 xenbus_switch_state(dev
, XenbusStateClosed
);
271 EXPORT_SYMBOL_GPL(xenbus_dev_remove
);
273 void xenbus_dev_shutdown(struct device
*_dev
)
275 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
276 unsigned long timeout
= 5*HZ
;
278 DPRINTK("%s", dev
->nodename
);
280 get_device(&dev
->dev
);
281 if (dev
->state
!= XenbusStateConnected
) {
282 pr_info("%s: %s: %s != Connected, skipping\n",
283 __func__
, dev
->nodename
, xenbus_strstate(dev
->state
));
286 xenbus_switch_state(dev
, XenbusStateClosing
);
287 timeout
= wait_for_completion_timeout(&dev
->down
, timeout
);
289 pr_info("%s: %s timeout closing device\n",
290 __func__
, dev
->nodename
);
292 put_device(&dev
->dev
);
294 EXPORT_SYMBOL_GPL(xenbus_dev_shutdown
);
296 int xenbus_register_driver_common(struct xenbus_driver
*drv
,
297 struct xen_bus_type
*bus
,
298 struct module
*owner
, const char *mod_name
)
300 drv
->driver
.name
= drv
->name
? drv
->name
: drv
->ids
[0].devicetype
;
301 drv
->driver
.bus
= &bus
->bus
;
302 drv
->driver
.owner
= owner
;
303 drv
->driver
.mod_name
= mod_name
;
305 return driver_register(&drv
->driver
);
307 EXPORT_SYMBOL_GPL(xenbus_register_driver_common
);
309 void xenbus_unregister_driver(struct xenbus_driver
*drv
)
311 driver_unregister(&drv
->driver
);
313 EXPORT_SYMBOL_GPL(xenbus_unregister_driver
);
315 struct xb_find_info
{
316 struct xenbus_device
*dev
;
317 const char *nodename
;
320 static int cmp_dev(struct device
*dev
, void *data
)
322 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
323 struct xb_find_info
*info
= data
;
325 if (!strcmp(xendev
->nodename
, info
->nodename
)) {
333 static struct xenbus_device
*xenbus_device_find(const char *nodename
,
334 struct bus_type
*bus
)
336 struct xb_find_info info
= { .dev
= NULL
, .nodename
= nodename
};
338 bus_for_each_dev(bus
, NULL
, &info
, cmp_dev
);
342 static int cleanup_dev(struct device
*dev
, void *data
)
344 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
345 struct xb_find_info
*info
= data
;
346 int len
= strlen(info
->nodename
);
348 DPRINTK("%s", info
->nodename
);
350 /* Match the info->nodename path, or any subdirectory of that path. */
351 if (strncmp(xendev
->nodename
, info
->nodename
, len
))
354 /* If the node name is longer, ensure it really is a subdirectory. */
355 if ((strlen(xendev
->nodename
) > len
) && (xendev
->nodename
[len
] != '/'))
363 static void xenbus_cleanup_devices(const char *path
, struct bus_type
*bus
)
365 struct xb_find_info info
= { .nodename
= path
};
369 bus_for_each_dev(bus
, NULL
, &info
, cleanup_dev
);
371 device_unregister(&info
.dev
->dev
);
372 put_device(&info
.dev
->dev
);
377 static void xenbus_dev_release(struct device
*dev
)
380 kfree(to_xenbus_device(dev
));
383 static ssize_t
nodename_show(struct device
*dev
,
384 struct device_attribute
*attr
, char *buf
)
386 return sprintf(buf
, "%s\n", to_xenbus_device(dev
)->nodename
);
388 static DEVICE_ATTR_RO(nodename
);
390 static ssize_t
devtype_show(struct device
*dev
,
391 struct device_attribute
*attr
, char *buf
)
393 return sprintf(buf
, "%s\n", to_xenbus_device(dev
)->devicetype
);
395 static DEVICE_ATTR_RO(devtype
);
397 static ssize_t
modalias_show(struct device
*dev
,
398 struct device_attribute
*attr
, char *buf
)
400 return sprintf(buf
, "%s:%s\n", dev
->bus
->name
,
401 to_xenbus_device(dev
)->devicetype
);
403 static DEVICE_ATTR_RO(modalias
);
405 static struct attribute
*xenbus_dev_attrs
[] = {
406 &dev_attr_nodename
.attr
,
407 &dev_attr_devtype
.attr
,
408 &dev_attr_modalias
.attr
,
412 static const struct attribute_group xenbus_dev_group
= {
413 .attrs
= xenbus_dev_attrs
,
416 const struct attribute_group
*xenbus_dev_groups
[] = {
420 EXPORT_SYMBOL_GPL(xenbus_dev_groups
);
422 int xenbus_probe_node(struct xen_bus_type
*bus
,
424 const char *nodename
)
426 char devname
[XEN_BUS_ID_SIZE
];
428 struct xenbus_device
*xendev
;
432 enum xenbus_state state
= xenbus_read_driver_state(nodename
);
434 if (state
!= XenbusStateInitialising
) {
435 /* Device is not new, so ignore it. This can happen if a
436 device is going away after switching to Closed. */
440 stringlen
= strlen(nodename
) + 1 + strlen(type
) + 1;
441 xendev
= kzalloc(sizeof(*xendev
) + stringlen
, GFP_KERNEL
);
445 xendev
->state
= XenbusStateInitialising
;
447 /* Copy the strings into the extra space. */
449 tmpstring
= (char *)(xendev
+ 1);
450 strcpy(tmpstring
, nodename
);
451 xendev
->nodename
= tmpstring
;
453 tmpstring
+= strlen(tmpstring
) + 1;
454 strcpy(tmpstring
, type
);
455 xendev
->devicetype
= tmpstring
;
456 init_completion(&xendev
->down
);
458 xendev
->dev
.bus
= &bus
->bus
;
459 xendev
->dev
.release
= xenbus_dev_release
;
461 err
= bus
->get_bus_id(devname
, xendev
->nodename
);
465 dev_set_name(&xendev
->dev
, "%s", devname
);
467 /* Register with generic device framework. */
468 err
= device_register(&xendev
->dev
);
470 put_device(&xendev
->dev
);
480 EXPORT_SYMBOL_GPL(xenbus_probe_node
);
482 static int xenbus_probe_device_type(struct xen_bus_type
*bus
, const char *type
)
486 unsigned int dir_n
= 0;
489 dir
= xenbus_directory(XBT_NIL
, bus
->root
, type
, &dir_n
);
493 for (i
= 0; i
< dir_n
; i
++) {
494 err
= bus
->probe(bus
, type
, dir
[i
]);
503 int xenbus_probe_devices(struct xen_bus_type
*bus
)
507 unsigned int i
, dir_n
;
509 dir
= xenbus_directory(XBT_NIL
, bus
->root
, "", &dir_n
);
513 for (i
= 0; i
< dir_n
; i
++) {
514 err
= xenbus_probe_device_type(bus
, dir
[i
]);
522 EXPORT_SYMBOL_GPL(xenbus_probe_devices
);
524 static unsigned int char_count(const char *str
, char c
)
526 unsigned int i
, ret
= 0;
528 for (i
= 0; str
[i
]; i
++)
534 static int strsep_len(const char *str
, char c
, unsigned int len
)
538 for (i
= 0; str
[i
]; i
++)
544 return (len
== 0) ? i
: -ERANGE
;
547 void xenbus_dev_changed(const char *node
, struct xen_bus_type
*bus
)
550 struct xenbus_device
*dev
;
551 char type
[XEN_BUS_ID_SIZE
];
552 const char *p
, *root
;
554 if (char_count(node
, '/') < 2)
557 exists
= xenbus_exists(XBT_NIL
, node
, "");
559 xenbus_cleanup_devices(node
, &bus
->bus
);
563 /* backend/<type>/... or device/<type>/... */
564 p
= strchr(node
, '/') + 1;
565 snprintf(type
, XEN_BUS_ID_SIZE
, "%.*s", (int)strcspn(p
, "/"), p
);
566 type
[XEN_BUS_ID_SIZE
-1] = '\0';
568 rootlen
= strsep_len(node
, '/', bus
->levels
);
571 root
= kasprintf(GFP_KERNEL
, "%.*s", rootlen
, node
);
575 dev
= xenbus_device_find(root
, &bus
->bus
);
577 xenbus_probe_node(bus
, type
, root
);
579 put_device(&dev
->dev
);
583 EXPORT_SYMBOL_GPL(xenbus_dev_changed
);
585 int xenbus_dev_suspend(struct device
*dev
)
588 struct xenbus_driver
*drv
;
589 struct xenbus_device
*xdev
590 = container_of(dev
, struct xenbus_device
, dev
);
592 DPRINTK("%s", xdev
->nodename
);
594 if (dev
->driver
== NULL
)
596 drv
= to_xenbus_driver(dev
->driver
);
598 err
= drv
->suspend(xdev
);
600 pr_warn("suspend %s failed: %i\n", dev_name(dev
), err
);
603 EXPORT_SYMBOL_GPL(xenbus_dev_suspend
);
605 int xenbus_dev_resume(struct device
*dev
)
608 struct xenbus_driver
*drv
;
609 struct xenbus_device
*xdev
610 = container_of(dev
, struct xenbus_device
, dev
);
612 DPRINTK("%s", xdev
->nodename
);
614 if (dev
->driver
== NULL
)
616 drv
= to_xenbus_driver(dev
->driver
);
617 err
= talk_to_otherend(xdev
);
619 pr_warn("resume (talk_to_otherend) %s failed: %i\n",
624 xdev
->state
= XenbusStateInitialising
;
627 err
= drv
->resume(xdev
);
629 pr_warn("resume %s failed: %i\n", dev_name(dev
), err
);
634 err
= watch_otherend(xdev
);
636 pr_warn("resume (watch_otherend) %s failed: %d.\n",
643 EXPORT_SYMBOL_GPL(xenbus_dev_resume
);
645 int xenbus_dev_cancel(struct device
*dev
)
651 EXPORT_SYMBOL_GPL(xenbus_dev_cancel
);
653 /* A flag to determine if xenstored is 'ready' (i.e. has started) */
657 int register_xenstore_notifier(struct notifier_block
*nb
)
661 if (xenstored_ready
> 0)
662 ret
= nb
->notifier_call(nb
, 0, NULL
);
664 blocking_notifier_chain_register(&xenstore_chain
, nb
);
668 EXPORT_SYMBOL_GPL(register_xenstore_notifier
);
670 void unregister_xenstore_notifier(struct notifier_block
*nb
)
672 blocking_notifier_chain_unregister(&xenstore_chain
, nb
);
674 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier
);
676 void xenbus_probe(struct work_struct
*unused
)
680 /* Notify others that xenstore is up */
681 blocking_notifier_call_chain(&xenstore_chain
, 0, NULL
);
683 EXPORT_SYMBOL_GPL(xenbus_probe
);
685 static int __init
xenbus_probe_initcall(void)
690 if (xen_initial_domain() || xen_hvm_domain())
697 device_initcall(xenbus_probe_initcall
);
699 /* Set up event channel for xenstored which is run as a local process
700 * (this is normally used only in dom0)
702 static int __init
xenstored_local_init(void)
705 unsigned long page
= 0;
706 struct evtchn_alloc_unbound alloc_unbound
;
708 /* Allocate Xenstore page */
709 page
= get_zeroed_page(GFP_KERNEL
);
713 xen_store_gfn
= virt_to_gfn((void *)page
);
715 /* Next allocate a local port which xenstored can bind to */
716 alloc_unbound
.dom
= DOMID_SELF
;
717 alloc_unbound
.remote_dom
= DOMID_SELF
;
719 err
= HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound
,
725 xen_store_evtchn
= alloc_unbound
.port
;
735 static int xenbus_resume_cb(struct notifier_block
*nb
,
736 unsigned long action
, void *data
)
740 if (xen_hvm_domain()) {
743 err
= hvm_get_parameter(HVM_PARAM_STORE_EVTCHN
, &v
);
745 xen_store_evtchn
= v
;
747 pr_warn("Cannot update xenstore event channel: %d\n",
750 xen_store_evtchn
= xen_start_info
->store_evtchn
;
755 static struct notifier_block xenbus_resume_nb
= {
756 .notifier_call
= xenbus_resume_cb
,
759 static int __init
xenbus_init(void)
763 xen_store_domain_type
= XS_UNKNOWN
;
768 xenbus_ring_ops_init();
771 xen_store_domain_type
= XS_PV
;
772 if (xen_hvm_domain())
773 xen_store_domain_type
= XS_HVM
;
774 if (xen_hvm_domain() && xen_initial_domain())
775 xen_store_domain_type
= XS_LOCAL
;
776 if (xen_pv_domain() && !xen_start_info
->store_evtchn
)
777 xen_store_domain_type
= XS_LOCAL
;
778 if (xen_pv_domain() && xen_start_info
->store_evtchn
)
781 switch (xen_store_domain_type
) {
783 err
= xenstored_local_init();
786 xen_store_interface
= gfn_to_virt(xen_store_gfn
);
789 xen_store_evtchn
= xen_start_info
->store_evtchn
;
790 xen_store_gfn
= xen_start_info
->store_mfn
;
791 xen_store_interface
= gfn_to_virt(xen_store_gfn
);
794 err
= hvm_get_parameter(HVM_PARAM_STORE_EVTCHN
, &v
);
797 xen_store_evtchn
= (int)v
;
798 err
= hvm_get_parameter(HVM_PARAM_STORE_PFN
, &v
);
801 xen_store_gfn
= (unsigned long)v
;
802 xen_store_interface
=
803 xen_remap(xen_store_gfn
<< XEN_PAGE_SHIFT
,
807 pr_warn("Xenstore state unknown\n");
811 /* Initialize the interface to xenstore. */
814 pr_warn("Error initializing xenstore comms: %i\n", err
);
818 if ((xen_store_domain_type
!= XS_LOCAL
) &&
819 (xen_store_domain_type
!= XS_UNKNOWN
))
820 xen_resume_notifier_register(&xenbus_resume_nb
);
822 #ifdef CONFIG_XEN_COMPAT_XENFS
824 * Create xenfs mountpoint in /proc for compatibility with
825 * utilities that expect to find "xenbus" under "/proc/xen".
827 proc_create_mount_point("xen");
834 postcore_initcall(xenbus_init
);
836 MODULE_LICENSE("GPL");