1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
3 #define DPRINTK(fmt, ...) \
4 pr_debug("(%s:%d) " fmt "\n", \
5 __func__, __LINE__, ##__VA_ARGS__)
7 #include <linux/kernel.h>
9 #include <linux/string.h>
10 #include <linux/ctype.h>
11 #include <linux/fcntl.h>
13 #include <linux/proc_fs.h>
14 #include <linux/notifier.h>
15 #include <linux/kthread.h>
16 #include <linux/mutex.h>
18 #include <linux/module.h>
21 #include <asm/pgtable.h>
22 #include <asm/xen/hypervisor.h>
23 #include <xen/xenbus.h>
24 #include <xen/events.h>
28 #include <xen/platform_pci.h>
30 #include "xenbus_comms.h"
31 #include "xenbus_probe.h"
34 static struct workqueue_struct
*xenbus_frontend_wq
;
36 /* device/<type>/<id> => <type>-<id> */
37 static int frontend_bus_id(char bus_id
[XEN_BUS_ID_SIZE
], const char *nodename
)
39 nodename
= strchr(nodename
, '/');
40 if (!nodename
|| strlen(nodename
+ 1) >= XEN_BUS_ID_SIZE
) {
41 pr_warn("bad frontend %s\n", nodename
);
45 strlcpy(bus_id
, nodename
+ 1, XEN_BUS_ID_SIZE
);
46 if (!strchr(bus_id
, '/')) {
47 pr_warn("bus_id %s no slash\n", bus_id
);
50 *strchr(bus_id
, '/') = '-';
54 /* device/<typename>/<name> */
55 static int xenbus_probe_frontend(struct xen_bus_type
*bus
, const char *type
,
61 /* ignore console/0 */
62 if (!strncmp(type
, "console", 7) && !strncmp(name
, "0", 1)) {
63 DPRINTK("Ignoring buggy device entry console/0");
67 nodename
= kasprintf(GFP_KERNEL
, "%s/%s/%s", bus
->root
, type
, name
);
71 DPRINTK("%s", nodename
);
73 err
= xenbus_probe_node(bus
, type
, nodename
);
78 static int xenbus_uevent_frontend(struct device
*_dev
,
79 struct kobj_uevent_env
*env
)
81 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
83 if (add_uevent_var(env
, "MODALIAS=xen:%s", dev
->devicetype
))
90 static void backend_changed(struct xenbus_watch
*watch
,
91 const char **vec
, unsigned int len
)
93 xenbus_otherend_changed(watch
, vec
, len
, 1);
96 static void xenbus_frontend_delayed_resume(struct work_struct
*w
)
98 struct xenbus_device
*xdev
= container_of(w
, struct xenbus_device
, work
);
100 xenbus_dev_resume(&xdev
->dev
);
103 static int xenbus_frontend_dev_resume(struct device
*dev
)
106 * If xenstored is running in this domain, we cannot access the backend
107 * state at the moment, so we need to defer xenbus_dev_resume
109 if (xen_store_domain_type
== XS_LOCAL
) {
110 struct xenbus_device
*xdev
= to_xenbus_device(dev
);
112 if (!xenbus_frontend_wq
) {
113 pr_err("%s: no workqueue to process delayed resume\n",
118 INIT_WORK(&xdev
->work
, xenbus_frontend_delayed_resume
);
119 queue_work(xenbus_frontend_wq
, &xdev
->work
);
124 return xenbus_dev_resume(dev
);
127 static const struct dev_pm_ops xenbus_pm_ops
= {
128 .suspend
= xenbus_dev_suspend
,
129 .resume
= xenbus_frontend_dev_resume
,
130 .freeze
= xenbus_dev_suspend
,
131 .thaw
= xenbus_dev_cancel
,
132 .restore
= xenbus_dev_resume
,
135 static struct xen_bus_type xenbus_frontend
= {
137 .levels
= 2, /* device/type/<id> */
138 .get_bus_id
= frontend_bus_id
,
139 .probe
= xenbus_probe_frontend
,
140 .otherend_changed
= backend_changed
,
143 .match
= xenbus_match
,
144 .uevent
= xenbus_uevent_frontend
,
145 .probe
= xenbus_dev_probe
,
146 .remove
= xenbus_dev_remove
,
147 .shutdown
= xenbus_dev_shutdown
,
148 .dev_attrs
= xenbus_dev_attrs
,
150 .pm
= &xenbus_pm_ops
,
154 static void frontend_changed(struct xenbus_watch
*watch
,
155 const char **vec
, unsigned int len
)
159 xenbus_dev_changed(vec
[XS_WATCH_PATH
], &xenbus_frontend
);
163 /* We watch for devices appearing and vanishing. */
164 static struct xenbus_watch fe_watch
= {
166 .callback
= frontend_changed
,
169 static int read_backend_details(struct xenbus_device
*xendev
)
171 return xenbus_read_otherend_details(xendev
, "backend-id", "backend");
174 static int is_device_connecting(struct device
*dev
, void *data
, bool ignore_nonessential
)
176 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
177 struct device_driver
*drv
= data
;
178 struct xenbus_driver
*xendrv
;
181 * A device with no driver will never connect. We care only about
182 * devices which should currently be in the process of connecting.
187 /* Is this search limited to a particular driver? */
188 if (drv
&& (dev
->driver
!= drv
))
191 if (ignore_nonessential
) {
192 /* With older QEMU, for PVonHVM guests the guest config files
193 * could contain: vfb = [ 'vnc=1, vnclisten=0.0.0.0']
194 * which is nonsensical as there is no PV FB (there can be
195 * a PVKB) running as HVM guest. */
197 if ((strncmp(xendev
->nodename
, "device/vkbd", 11) == 0))
200 if ((strncmp(xendev
->nodename
, "device/vfb", 10) == 0))
203 xendrv
= to_xenbus_driver(dev
->driver
);
204 return (xendev
->state
< XenbusStateConnected
||
205 (xendev
->state
== XenbusStateConnected
&&
206 xendrv
->is_ready
&& !xendrv
->is_ready(xendev
)));
208 static int essential_device_connecting(struct device
*dev
, void *data
)
210 return is_device_connecting(dev
, data
, true /* ignore PV[KBB+FB] */);
212 static int non_essential_device_connecting(struct device
*dev
, void *data
)
214 return is_device_connecting(dev
, data
, false);
217 static int exists_essential_connecting_device(struct device_driver
*drv
)
219 return bus_for_each_dev(&xenbus_frontend
.bus
, NULL
, drv
,
220 essential_device_connecting
);
222 static int exists_non_essential_connecting_device(struct device_driver
*drv
)
224 return bus_for_each_dev(&xenbus_frontend
.bus
, NULL
, drv
,
225 non_essential_device_connecting
);
228 static int print_device_status(struct device
*dev
, void *data
)
230 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
231 struct device_driver
*drv
= data
;
233 /* Is this operation limited to a particular driver? */
234 if (drv
&& (dev
->driver
!= drv
))
238 /* Information only: is this too noisy? */
239 pr_info("Device with no driver: %s\n", xendev
->nodename
);
240 } else if (xendev
->state
< XenbusStateConnected
) {
241 enum xenbus_state rstate
= XenbusStateUnknown
;
242 if (xendev
->otherend
)
243 rstate
= xenbus_read_driver_state(xendev
->otherend
);
244 pr_warn("Timeout connecting to device: %s (local state %d, remote state %d)\n",
245 xendev
->nodename
, xendev
->state
, rstate
);
251 /* We only wait for device setup after most initcalls have run. */
252 static int ready_to_wait_for_devices
;
254 static bool wait_loop(unsigned long start
, unsigned int max_delay
,
255 unsigned int *seconds_waited
)
257 if (time_after(jiffies
, start
+ (*seconds_waited
+5)*HZ
)) {
258 if (!*seconds_waited
)
259 pr_warn("Waiting for devices to initialise: ");
260 *seconds_waited
+= 5;
261 pr_cont("%us...", max_delay
- *seconds_waited
);
262 if (*seconds_waited
== max_delay
) {
268 schedule_timeout_interruptible(HZ
/10);
273 * On a 5-minute timeout, wait for all devices currently configured. We need
274 * to do this to guarantee that the filesystems and / or network devices
275 * needed for boot are available, before we can allow the boot to proceed.
277 * This needs to be on a late_initcall, to happen after the frontend device
278 * drivers have been initialised, but before the root fs is mounted.
280 * A possible improvement here would be to have the tools add a per-device
281 * flag to the store entry, indicating whether it is needed at boot time.
282 * This would allow people who knew what they were doing to accelerate their
283 * boot slightly, but of course needs tools or manual intervention to set up
284 * those flags correctly.
286 static void wait_for_devices(struct xenbus_driver
*xendrv
)
288 unsigned long start
= jiffies
;
289 struct device_driver
*drv
= xendrv
? &xendrv
->driver
: NULL
;
290 unsigned int seconds_waited
= 0;
292 if (!ready_to_wait_for_devices
|| !xen_domain())
295 while (exists_non_essential_connecting_device(drv
))
296 if (wait_loop(start
, 30, &seconds_waited
))
299 /* Skips PVKB and PVFB check.*/
300 while (exists_essential_connecting_device(drv
))
301 if (wait_loop(start
, 270, &seconds_waited
))
307 bus_for_each_dev(&xenbus_frontend
.bus
, NULL
, drv
,
308 print_device_status
);
311 int xenbus_register_frontend(struct xenbus_driver
*drv
)
315 drv
->read_otherend_details
= read_backend_details
;
317 ret
= xenbus_register_driver_common(drv
, &xenbus_frontend
);
321 /* If this driver is loaded as a module wait for devices to attach. */
322 wait_for_devices(drv
);
326 EXPORT_SYMBOL_GPL(xenbus_register_frontend
);
328 static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq
);
329 static int backend_state
;
331 static void xenbus_reset_backend_state_changed(struct xenbus_watch
*w
,
332 const char **v
, unsigned int l
)
334 xenbus_scanf(XBT_NIL
, v
[XS_WATCH_PATH
], "", "%i", &backend_state
);
335 printk(KERN_DEBUG
"XENBUS: backend %s %s\n",
336 v
[XS_WATCH_PATH
], xenbus_strstate(backend_state
));
337 wake_up(&backend_state_wq
);
340 static void xenbus_reset_wait_for_backend(char *be
, int expected
)
343 timeout
= wait_event_interruptible_timeout(backend_state_wq
,
344 backend_state
== expected
, 5 * HZ
);
346 pr_info("backend %s timed out\n", be
);
350 * Reset frontend if it is in Connected or Closed state.
351 * Wait for backend to catch up.
352 * State Connected happens during kdump, Closed after kexec.
354 static void xenbus_reset_frontend(char *fe
, char *be
, int be_state
)
356 struct xenbus_watch be_watch
;
358 printk(KERN_DEBUG
"XENBUS: backend %s %s\n",
359 be
, xenbus_strstate(be_state
));
361 memset(&be_watch
, 0, sizeof(be_watch
));
362 be_watch
.node
= kasprintf(GFP_NOIO
| __GFP_HIGH
, "%s/state", be
);
366 be_watch
.callback
= xenbus_reset_backend_state_changed
;
367 backend_state
= XenbusStateUnknown
;
369 pr_info("triggering reconnect on %s\n", be
);
370 register_xenbus_watch(&be_watch
);
372 /* fall through to forward backend to state XenbusStateInitialising */
374 case XenbusStateConnected
:
375 xenbus_printf(XBT_NIL
, fe
, "state", "%d", XenbusStateClosing
);
376 xenbus_reset_wait_for_backend(be
, XenbusStateClosing
);
378 case XenbusStateClosing
:
379 xenbus_printf(XBT_NIL
, fe
, "state", "%d", XenbusStateClosed
);
380 xenbus_reset_wait_for_backend(be
, XenbusStateClosed
);
382 case XenbusStateClosed
:
383 xenbus_printf(XBT_NIL
, fe
, "state", "%d", XenbusStateInitialising
);
384 xenbus_reset_wait_for_backend(be
, XenbusStateInitWait
);
387 unregister_xenbus_watch(&be_watch
);
388 pr_info("reconnect done on %s\n", be
);
389 kfree(be_watch
.node
);
392 static void xenbus_check_frontend(char *class, char *dev
)
394 int be_state
, fe_state
, err
;
395 char *backend
, *frontend
;
397 frontend
= kasprintf(GFP_NOIO
| __GFP_HIGH
, "device/%s/%s", class, dev
);
401 err
= xenbus_scanf(XBT_NIL
, frontend
, "state", "%i", &fe_state
);
406 case XenbusStateConnected
:
407 case XenbusStateClosed
:
408 printk(KERN_DEBUG
"XENBUS: frontend %s %s\n",
409 frontend
, xenbus_strstate(fe_state
));
410 backend
= xenbus_read(XBT_NIL
, frontend
, "backend", NULL
);
411 if (!backend
|| IS_ERR(backend
))
413 err
= xenbus_scanf(XBT_NIL
, backend
, "state", "%i", &be_state
);
415 xenbus_reset_frontend(frontend
, backend
, be_state
);
425 static void xenbus_reset_state(void)
427 char **devclass
, **dev
;
428 int devclass_n
, dev_n
;
431 devclass
= xenbus_directory(XBT_NIL
, "device", "", &devclass_n
);
432 if (IS_ERR(devclass
))
435 for (i
= 0; i
< devclass_n
; i
++) {
436 dev
= xenbus_directory(XBT_NIL
, "device", devclass
[i
], &dev_n
);
439 for (j
= 0; j
< dev_n
; j
++)
440 xenbus_check_frontend(devclass
[i
], dev
[j
]);
446 static int frontend_probe_and_watch(struct notifier_block
*notifier
,
450 /* reset devices in Connected or Closed state */
451 if (xen_hvm_domain())
452 xenbus_reset_state();
453 /* Enumerate devices in xenstore and watch for changes. */
454 xenbus_probe_devices(&xenbus_frontend
);
455 register_xenbus_watch(&fe_watch
);
461 static int __init
xenbus_probe_frontend_init(void)
463 static struct notifier_block xenstore_notifier
= {
464 .notifier_call
= frontend_probe_and_watch
470 /* Register ourselves with the kernel bus subsystem */
471 err
= bus_register(&xenbus_frontend
.bus
);
475 register_xenstore_notifier(&xenstore_notifier
);
477 xenbus_frontend_wq
= create_workqueue("xenbus_frontend");
481 subsys_initcall(xenbus_probe_frontend_init
);
484 static int __init
boot_wait_for_devices(void)
486 if (xen_hvm_domain() && !xen_platform_pci_unplug
)
489 ready_to_wait_for_devices
= 1;
490 wait_for_devices(NULL
);
494 late_initcall(boot_wait_for_devices
);
497 MODULE_LICENSE("GPL");