1 #define DPRINTK(fmt, args...) \
2 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \
3 __func__, __LINE__, ##args)
5 #include <linux/kernel.h>
7 #include <linux/string.h>
8 #include <linux/ctype.h>
9 #include <linux/fcntl.h>
11 #include <linux/proc_fs.h>
12 #include <linux/notifier.h>
13 #include <linux/kthread.h>
14 #include <linux/mutex.h>
18 #include <asm/pgtable.h>
19 #include <asm/xen/hypervisor.h>
20 #include <xen/xenbus.h>
21 #include <xen/events.h>
24 #include <xen/platform_pci.h>
26 #include "xenbus_comms.h"
27 #include "xenbus_probe.h"
30 /* device/<type>/<id> => <type>-<id> */
31 static int frontend_bus_id(char bus_id
[XEN_BUS_ID_SIZE
], const char *nodename
)
33 nodename
= strchr(nodename
, '/');
34 if (!nodename
|| strlen(nodename
+ 1) >= XEN_BUS_ID_SIZE
) {
35 printk(KERN_WARNING
"XENBUS: bad frontend %s\n", nodename
);
39 strlcpy(bus_id
, nodename
+ 1, XEN_BUS_ID_SIZE
);
40 if (!strchr(bus_id
, '/')) {
41 printk(KERN_WARNING
"XENBUS: bus_id %s no slash\n", bus_id
);
44 *strchr(bus_id
, '/') = '-';
48 /* device/<typename>/<name> */
49 static int xenbus_probe_frontend(struct xen_bus_type
*bus
, const char *type
,
55 nodename
= kasprintf(GFP_KERNEL
, "%s/%s/%s", bus
->root
, type
, name
);
59 DPRINTK("%s", nodename
);
61 err
= xenbus_probe_node(bus
, type
, nodename
);
66 static int xenbus_uevent_frontend(struct device
*_dev
,
67 struct kobj_uevent_env
*env
)
69 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
71 if (add_uevent_var(env
, "MODALIAS=xen:%s", dev
->devicetype
))
78 static void backend_changed(struct xenbus_watch
*watch
,
79 const char **vec
, unsigned int len
)
81 xenbus_otherend_changed(watch
, vec
, len
, 1);
84 static const struct dev_pm_ops xenbus_pm_ops
= {
85 .suspend
= xenbus_dev_suspend
,
86 .resume
= xenbus_dev_resume
,
87 .freeze
= xenbus_dev_suspend
,
88 .thaw
= xenbus_dev_cancel
,
89 .restore
= xenbus_dev_resume
,
92 static struct xen_bus_type xenbus_frontend
= {
94 .levels
= 2, /* device/type/<id> */
95 .get_bus_id
= frontend_bus_id
,
96 .probe
= xenbus_probe_frontend
,
97 .otherend_changed
= backend_changed
,
100 .match
= xenbus_match
,
101 .uevent
= xenbus_uevent_frontend
,
102 .probe
= xenbus_dev_probe
,
103 .remove
= xenbus_dev_remove
,
104 .shutdown
= xenbus_dev_shutdown
,
105 .dev_attrs
= xenbus_dev_attrs
,
107 .pm
= &xenbus_pm_ops
,
111 static void frontend_changed(struct xenbus_watch
*watch
,
112 const char **vec
, unsigned int len
)
116 xenbus_dev_changed(vec
[XS_WATCH_PATH
], &xenbus_frontend
);
120 /* We watch for devices appearing and vanishing. */
121 static struct xenbus_watch fe_watch
= {
123 .callback
= frontend_changed
,
126 static int read_backend_details(struct xenbus_device
*xendev
)
128 return xenbus_read_otherend_details(xendev
, "backend-id", "backend");
131 static int is_device_connecting(struct device
*dev
, void *data
)
133 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
134 struct device_driver
*drv
= data
;
135 struct xenbus_driver
*xendrv
;
138 * A device with no driver will never connect. We care only about
139 * devices which should currently be in the process of connecting.
144 /* Is this search limited to a particular driver? */
145 if (drv
&& (dev
->driver
!= drv
))
148 xendrv
= to_xenbus_driver(dev
->driver
);
149 return (xendev
->state
< XenbusStateConnected
||
150 (xendev
->state
== XenbusStateConnected
&&
151 xendrv
->is_ready
&& !xendrv
->is_ready(xendev
)));
154 static int exists_connecting_device(struct device_driver
*drv
)
156 return bus_for_each_dev(&xenbus_frontend
.bus
, NULL
, drv
,
157 is_device_connecting
);
160 static int print_device_status(struct device
*dev
, void *data
)
162 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
163 struct device_driver
*drv
= data
;
165 /* Is this operation limited to a particular driver? */
166 if (drv
&& (dev
->driver
!= drv
))
170 /* Information only: is this too noisy? */
171 printk(KERN_INFO
"XENBUS: Device with no driver: %s\n",
173 } else if (xendev
->state
< XenbusStateConnected
) {
174 enum xenbus_state rstate
= XenbusStateUnknown
;
175 if (xendev
->otherend
)
176 rstate
= xenbus_read_driver_state(xendev
->otherend
);
177 printk(KERN_WARNING
"XENBUS: Timeout connecting "
178 "to device: %s (local state %d, remote state %d)\n",
179 xendev
->nodename
, xendev
->state
, rstate
);
185 /* We only wait for device setup after most initcalls have run. */
186 static int ready_to_wait_for_devices
;
189 * On a 5-minute timeout, wait for all devices currently configured. We need
190 * to do this to guarantee that the filesystems and / or network devices
191 * needed for boot are available, before we can allow the boot to proceed.
193 * This needs to be on a late_initcall, to happen after the frontend device
194 * drivers have been initialised, but before the root fs is mounted.
196 * A possible improvement here would be to have the tools add a per-device
197 * flag to the store entry, indicating whether it is needed at boot time.
198 * This would allow people who knew what they were doing to accelerate their
199 * boot slightly, but of course needs tools or manual intervention to set up
200 * those flags correctly.
202 static void wait_for_devices(struct xenbus_driver
*xendrv
)
204 unsigned long start
= jiffies
;
205 struct device_driver
*drv
= xendrv
? &xendrv
->driver
: NULL
;
206 unsigned int seconds_waited
= 0;
208 if (!ready_to_wait_for_devices
|| !xen_domain())
211 while (exists_connecting_device(drv
)) {
212 if (time_after(jiffies
, start
+ (seconds_waited
+5)*HZ
)) {
214 printk(KERN_WARNING
"XENBUS: Waiting for "
215 "devices to initialise: ");
217 printk("%us...", 300 - seconds_waited
);
218 if (seconds_waited
== 300)
222 schedule_timeout_interruptible(HZ
/10);
228 bus_for_each_dev(&xenbus_frontend
.bus
, NULL
, drv
,
229 print_device_status
);
232 int __xenbus_register_frontend(struct xenbus_driver
*drv
,
233 struct module
*owner
, const char *mod_name
)
237 drv
->read_otherend_details
= read_backend_details
;
239 ret
= xenbus_register_driver_common(drv
, &xenbus_frontend
,
244 /* If this driver is loaded as a module wait for devices to attach. */
245 wait_for_devices(drv
);
249 EXPORT_SYMBOL_GPL(__xenbus_register_frontend
);
251 static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq
);
252 static int backend_state
;
254 static void xenbus_reset_backend_state_changed(struct xenbus_watch
*w
,
255 const char **v
, unsigned int l
)
257 xenbus_scanf(XBT_NIL
, v
[XS_WATCH_PATH
], "", "%i", &backend_state
);
258 printk(KERN_DEBUG
"XENBUS: backend %s %s\n",
259 v
[XS_WATCH_PATH
], xenbus_strstate(backend_state
));
260 wake_up(&backend_state_wq
);
263 static void xenbus_reset_wait_for_backend(char *be
, int expected
)
266 timeout
= wait_event_interruptible_timeout(backend_state_wq
,
267 backend_state
== expected
, 5 * HZ
);
269 printk(KERN_INFO
"XENBUS: backend %s timed out.\n", be
);
273 * Reset frontend if it is in Connected or Closed state.
274 * Wait for backend to catch up.
275 * State Connected happens during kdump, Closed after kexec.
277 static void xenbus_reset_frontend(char *fe
, char *be
, int be_state
)
279 struct xenbus_watch be_watch
;
281 printk(KERN_DEBUG
"XENBUS: backend %s %s\n",
282 be
, xenbus_strstate(be_state
));
284 memset(&be_watch
, 0, sizeof(be_watch
));
285 be_watch
.node
= kasprintf(GFP_NOIO
| __GFP_HIGH
, "%s/state", be
);
289 be_watch
.callback
= xenbus_reset_backend_state_changed
;
290 backend_state
= XenbusStateUnknown
;
292 printk(KERN_INFO
"XENBUS: triggering reconnect on %s\n", be
);
293 register_xenbus_watch(&be_watch
);
295 /* fall through to forward backend to state XenbusStateInitialising */
297 case XenbusStateConnected
:
298 xenbus_printf(XBT_NIL
, fe
, "state", "%d", XenbusStateClosing
);
299 xenbus_reset_wait_for_backend(be
, XenbusStateClosing
);
301 case XenbusStateClosing
:
302 xenbus_printf(XBT_NIL
, fe
, "state", "%d", XenbusStateClosed
);
303 xenbus_reset_wait_for_backend(be
, XenbusStateClosed
);
305 case XenbusStateClosed
:
306 xenbus_printf(XBT_NIL
, fe
, "state", "%d", XenbusStateInitialising
);
307 xenbus_reset_wait_for_backend(be
, XenbusStateInitWait
);
310 unregister_xenbus_watch(&be_watch
);
311 printk(KERN_INFO
"XENBUS: reconnect done on %s\n", be
);
312 kfree(be_watch
.node
);
315 static void xenbus_check_frontend(char *class, char *dev
)
317 int be_state
, fe_state
, err
;
318 char *backend
, *frontend
;
320 frontend
= kasprintf(GFP_NOIO
| __GFP_HIGH
, "device/%s/%s", class, dev
);
324 err
= xenbus_scanf(XBT_NIL
, frontend
, "state", "%i", &fe_state
);
329 case XenbusStateConnected
:
330 case XenbusStateClosed
:
331 printk(KERN_DEBUG
"XENBUS: frontend %s %s\n",
332 frontend
, xenbus_strstate(fe_state
));
333 backend
= xenbus_read(XBT_NIL
, frontend
, "backend", NULL
);
334 if (!backend
|| IS_ERR(backend
))
336 err
= xenbus_scanf(XBT_NIL
, backend
, "state", "%i", &be_state
);
338 xenbus_reset_frontend(frontend
, backend
, be_state
);
348 static void xenbus_reset_state(void)
350 char **devclass
, **dev
;
351 int devclass_n
, dev_n
;
354 devclass
= xenbus_directory(XBT_NIL
, "device", "", &devclass_n
);
355 if (IS_ERR(devclass
))
358 for (i
= 0; i
< devclass_n
; i
++) {
359 dev
= xenbus_directory(XBT_NIL
, "device", devclass
[i
], &dev_n
);
362 for (j
= 0; j
< dev_n
; j
++)
363 xenbus_check_frontend(devclass
[i
], dev
[j
]);
369 static int frontend_probe_and_watch(struct notifier_block
*notifier
,
373 /* reset devices in Connected or Closed state */
374 if (xen_hvm_domain())
375 xenbus_reset_state();
376 /* Enumerate devices in xenstore and watch for changes. */
377 xenbus_probe_devices(&xenbus_frontend
);
378 register_xenbus_watch(&fe_watch
);
384 static int __init
xenbus_probe_frontend_init(void)
386 static struct notifier_block xenstore_notifier
= {
387 .notifier_call
= frontend_probe_and_watch
393 /* Register ourselves with the kernel bus subsystem */
394 err
= bus_register(&xenbus_frontend
.bus
);
398 register_xenstore_notifier(&xenstore_notifier
);
402 subsys_initcall(xenbus_probe_frontend_init
);
405 static int __init
boot_wait_for_devices(void)
407 if (xen_hvm_domain() && !xen_platform_pci_unplug
)
410 ready_to_wait_for_devices
= 1;
411 wait_for_devices(NULL
);
415 late_initcall(boot_wait_for_devices
);
418 MODULE_LICENSE("GPL");