xref: /freebsd/sys/xen/xenbus/xenbusb.c (revision e9e8876a4d6afc1ad5315faaa191b25121a813d7)
1 /******************************************************************************
2  * Copyright (C) 2010 Spectra Logic Corporation
3  * Copyright (C) 2008 Doug Rabson
4  * Copyright (C) 2005 Rusty Russell, IBM Corporation
5  * Copyright (C) 2005 Mike Wray, Hewlett-Packard
6  * Copyright (C) 2005 XenSource Ltd
7  *
8  * This file may be distributed separately from the Linux kernel, or
9  * incorporated into other software packages, subject to the following license:
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a copy
12  * of this source file (the "Software"), to deal in the Software without
13  * restriction, including without limitation the rights to use, copy, modify,
14  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
15  * and to permit persons to whom the Software is furnished to do so, subject to
16  * the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be included in
19  * all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
27  * IN THE SOFTWARE.
28  */
29 
30 /**
31  * \file xenbusb.c
32  *
33  * \brief Shared support functions for managing the NewBus buses that contain
34  *        Xen front and back end device instances.
35  *
36  * The NewBus implementation of XenBus attaches a xenbusb_front and xenbusb_back
37  * child bus to the xenstore device.  This strategy allows the small differences
38  * in the handling of XenBus operations for front and back devices to be handled
39  * as overrides in xenbusb_front/back.c.  Front and back specific device
40  * classes are also provided so device drivers can register for the devices they
41  * can handle without the need to filter within their probe routines.  The
42  * net result is a device hierarchy that might look like this:
43  *
44  * xenstore0/
45  *           xenbusb_front0/
46  *                         xn0
47  *                         xbd0
48  *                         xbd1
49  *           xenbusb_back0/
50  *                        xbbd0
51  *                        xnb0
52  *                        xnb1
53  */
54 #include <sys/cdefs.h>
55 __FBSDID("$FreeBSD$");
56 
57 #include <sys/param.h>
58 #include <sys/bus.h>
59 #include <sys/kernel.h>
60 #include <sys/lock.h>
61 #include <sys/malloc.h>
62 #include <sys/module.h>
63 #include <sys/sbuf.h>
64 #include <sys/sysctl.h>
65 #include <sys/syslog.h>
66 #include <sys/systm.h>
67 #include <sys/sx.h>
68 #include <sys/taskqueue.h>
69 
70 #include <machine/stdarg.h>
71 
72 #include <xen/xen-os.h>
73 #include <xen/gnttab.h>
74 #include <xen/xenstore/xenstorevar.h>
75 #include <xen/xenbus/xenbusb.h>
76 #include <xen/xenbus/xenbusvar.h>
77 
78 /*------------------------- Private Functions --------------------------------*/
79 /**
80  * \brief Deallocate XenBus device instance variables.
81  *
82  * \param ivars  The instance variable block to free.
83  */
84 static void
85 xenbusb_free_child_ivars(struct xenbus_device_ivars *ivars)
86 {
87 	if (ivars->xd_otherend_watch.node != NULL) {
88 		xs_unregister_watch(&ivars->xd_otherend_watch);
89 		free(ivars->xd_otherend_watch.node, M_XENBUS);
90 		ivars->xd_otherend_watch.node = NULL;
91 	}
92 
93 	if (ivars->xd_local_watch.node != NULL) {
94 		xs_unregister_watch(&ivars->xd_local_watch);
95 		ivars->xd_local_watch.node = NULL;
96 	}
97 
98 	if (ivars->xd_node != NULL) {
99 		free(ivars->xd_node, M_XENBUS);
100 		ivars->xd_node = NULL;
101 	}
102 	ivars->xd_node_len = 0;
103 
104 	if (ivars->xd_type != NULL) {
105 		free(ivars->xd_type, M_XENBUS);
106 		ivars->xd_type = NULL;
107 	}
108 
109 	if (ivars->xd_otherend_path != NULL) {
110 		free(ivars->xd_otherend_path, M_XENBUS);
111 		ivars->xd_otherend_path = NULL;
112 	}
113 	ivars->xd_otherend_path_len = 0;
114 
115 	free(ivars, M_XENBUS);
116 }
117 
118 /**
119  * XenBus watch callback registered against the "state" XenStore
120  * node of the other-end of a split device connection.
121  *
122  * This callback is invoked whenever the state of a device instance's
123  * peer changes.
124  *
125  * \param watch      The xs_watch object used to register this callback
126  *                   function.
127  * \param vec        An array of pointers to NUL terminated strings containing
128  *                   watch event data.  The vector should be indexed via the
129  *                   xs_watch_type enum in xs_wire.h.
130  * \param vec_size   The number of elements in vec.
131  */
132 static void
133 xenbusb_otherend_watch_cb(struct xs_watch *watch, const char **vec,
134     unsigned int vec_size __unused)
135 {
136 	struct xenbus_device_ivars *ivars;
137 	device_t child;
138 	device_t bus;
139 	const char *path;
140 	enum xenbus_state newstate;
141 
142 	ivars = (struct xenbus_device_ivars *)watch->callback_data;
143 	child = ivars->xd_dev;
144 	bus = device_get_parent(child);
145 
146 	path = vec[XS_WATCH_PATH];
147 	if (ivars->xd_otherend_path == NULL
148 	 || strncmp(ivars->xd_otherend_path, path, ivars->xd_otherend_path_len))
149 		return;
150 
151 	newstate = xenbus_read_driver_state(ivars->xd_otherend_path);
152 	XENBUSB_OTHEREND_CHANGED(bus, child, newstate);
153 }
154 
155 /**
156  * XenBus watch callback registered against the XenStore sub-tree
157  * represnting the local half of a split device connection.
158  *
159  * This callback is invoked whenever any XenStore data in the subtree
160  * is modified, either by us or another privledged domain.
161  *
162  * \param watch      The xs_watch object used to register this callback
163  *                   function.
164  * \param vec        An array of pointers to NUL terminated strings containing
165  *                   watch event data.  The vector should be indexed via the
166  *                   xs_watch_type enum in xs_wire.h.
167  * \param vec_size   The number of elements in vec.
168  *
169  */
170 static void
171 xenbusb_local_watch_cb(struct xs_watch *watch, const char **vec,
172     unsigned int vec_size __unused)
173 {
174 	struct xenbus_device_ivars *ivars;
175 	device_t child;
176 	device_t bus;
177 	const char *path;
178 
179 	ivars = (struct xenbus_device_ivars *)watch->callback_data;
180 	child = ivars->xd_dev;
181 	bus = device_get_parent(child);
182 
183 	path = vec[XS_WATCH_PATH];
184 	if (ivars->xd_node == NULL
185 	 || strncmp(ivars->xd_node, path, ivars->xd_node_len))
186 		return;
187 
188 	XENBUSB_LOCALEND_CHANGED(bus, child, &path[ivars->xd_node_len]);
189 }
190 
191 /**
192  * Search our internal record of configured devices (not the XenStore)
193  * to determine if the XenBus device indicated by \a node is known to
194  * the system.
195  *
196  * \param dev   The XenBus bus instance to search for device children.
197  * \param node  The XenStore node path for the device to find.
198  *
199  * \return  The device_t of the found device if any, or NULL.
200  *
201  * \note device_t is a pointer type, so it can be compared against
202  *       NULL for validity.
203  */
204 static device_t
205 xenbusb_device_exists(device_t dev, const char *node)
206 {
207 	device_t *kids;
208 	device_t result;
209 	struct xenbus_device_ivars *ivars;
210 	int i, count;
211 
212 	if (device_get_children(dev, &kids, &count))
213 		return (FALSE);
214 
215 	result = NULL;
216 	for (i = 0; i < count; i++) {
217 		ivars = device_get_ivars(kids[i]);
218 		if (!strcmp(ivars->xd_node, node)) {
219 			result = kids[i];
220 			break;
221 		}
222 	}
223 	free(kids, M_TEMP);
224 
225 	return (result);
226 }
227 
228 static void
229 xenbusb_delete_child(device_t dev, device_t child)
230 {
231 	struct xenbus_device_ivars *ivars;
232 
233 	ivars = device_get_ivars(child);
234 
235 	/*
236 	 * We no longer care about the otherend of the
237 	 * connection.  Cancel the watches now so that we
238 	 * don't try to handle an event for a partially
239 	 * detached child.
240 	 */
241 	if (ivars->xd_otherend_watch.node != NULL)
242 		xs_unregister_watch(&ivars->xd_otherend_watch);
243 	if (ivars->xd_local_watch.node != NULL)
244 		xs_unregister_watch(&ivars->xd_local_watch);
245 
246 	device_delete_child(dev, child);
247 	xenbusb_free_child_ivars(ivars);
248 }
249 
250 /**
251  * \param dev    The NewBus device representing this XenBus bus.
252  * \param child	 The NewBus device representing a child of dev%'s XenBus bus.
253  */
254 static void
255 xenbusb_verify_device(device_t dev, device_t child)
256 {
257 	if (xs_exists(XST_NIL, xenbus_get_node(child), "") == 0) {
258 		/*
259 		 * Device tree has been removed from Xenbus.
260 		 * Tear down the device.
261 		 */
262 		xenbusb_delete_child(dev, child);
263 	}
264 }
265 
266 /**
267  * \brief Enumerate the devices on a XenBus bus and register them with
268  *        the NewBus device tree.
269  *
270  * xenbusb_enumerate_bus() will create entries (in state DS_NOTPRESENT)
271  * for nodes that appear in the XenStore, but will not invoke probe/attach
272  * operations on drivers.  Probe/Attach processing must be separately
273  * performed via an invocation of xenbusb_probe_children().  This is usually
274  * done via the xbs_probe_children task.
275  *
276  * \param xbs  XenBus Bus device softc of the owner of the bus to enumerate.
277  *
278  * \return  On success, 0. Otherwise an errno value indicating the
279  *          type of failure.
280  */
281 static int
282 xenbusb_enumerate_bus(struct xenbusb_softc *xbs)
283 {
284 	const char **types;
285 	u_int type_idx;
286 	u_int type_count;
287 	int error;
288 
289 	error = xs_directory(XST_NIL, xbs->xbs_node, "", &type_count, &types);
290 	if (error)
291 		return (error);
292 
293 	for (type_idx = 0; type_idx < type_count; type_idx++)
294 		XENBUSB_ENUMERATE_TYPE(xbs->xbs_dev, types[type_idx]);
295 
296 	free(types, M_XENSTORE);
297 
298 	return (0);
299 }
300 
301 /**
302  * Handler for all generic XenBus device systcl nodes.
303  */
304 static int
305 xenbusb_device_sysctl_handler(SYSCTL_HANDLER_ARGS)
306 {
307 	device_t dev;
308         const char *value;
309 
310 	dev = (device_t)arg1;
311         switch (arg2) {
312 	case XENBUS_IVAR_NODE:
313 		value = xenbus_get_node(dev);
314 		break;
315 	case XENBUS_IVAR_TYPE:
316 		value = xenbus_get_type(dev);
317 		break;
318 	case XENBUS_IVAR_STATE:
319 		value = xenbus_strstate(xenbus_get_state(dev));
320 		break;
321 	case XENBUS_IVAR_OTHEREND_ID:
322 		return (sysctl_handle_int(oidp, NULL,
323 					  xenbus_get_otherend_id(dev),
324 					  req));
325 		/* NOTREACHED */
326 	case XENBUS_IVAR_OTHEREND_PATH:
327 		value = xenbus_get_otherend_path(dev);
328                 break;
329 	default:
330 		return (EINVAL);
331 	}
332 	return (SYSCTL_OUT_STR(req, value));
333 }
334 
335 /**
336  * Create read-only systcl nodes for xenbusb device ivar data.
337  *
338  * \param dev  The XenBus device instance to register with sysctl.
339  */
340 static void
341 xenbusb_device_sysctl_init(device_t dev)
342 {
343 	struct sysctl_ctx_list *ctx;
344 	struct sysctl_oid      *tree;
345 
346 	ctx  = device_get_sysctl_ctx(dev);
347 	tree = device_get_sysctl_tree(dev);
348 
349         SYSCTL_ADD_PROC(ctx,
350 			SYSCTL_CHILDREN(tree),
351 			OID_AUTO,
352 			"xenstore_path",
353 			CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
354 			dev,
355 			XENBUS_IVAR_NODE,
356 			xenbusb_device_sysctl_handler,
357 			"A",
358 			"XenStore path to device");
359 
360         SYSCTL_ADD_PROC(ctx,
361 			SYSCTL_CHILDREN(tree),
362 			OID_AUTO,
363 			"xenbus_dev_type",
364 			CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
365 			dev,
366 			XENBUS_IVAR_TYPE,
367 			xenbusb_device_sysctl_handler,
368 			"A",
369 			"XenBus device type");
370 
371         SYSCTL_ADD_PROC(ctx,
372 			SYSCTL_CHILDREN(tree),
373 			OID_AUTO,
374 			"xenbus_connection_state",
375 			CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
376 			dev,
377 			XENBUS_IVAR_STATE,
378 			xenbusb_device_sysctl_handler,
379 			"A",
380 			"XenBus state of peer connection");
381 
382         SYSCTL_ADD_PROC(ctx,
383 			SYSCTL_CHILDREN(tree),
384 			OID_AUTO,
385 			"xenbus_peer_domid",
386 			CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
387 			dev,
388 			XENBUS_IVAR_OTHEREND_ID,
389 			xenbusb_device_sysctl_handler,
390 			"I",
391 			"Xen domain ID of peer");
392 
393         SYSCTL_ADD_PROC(ctx,
394 			SYSCTL_CHILDREN(tree),
395 			OID_AUTO,
396 			"xenstore_peer_path",
397 			CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
398 			dev,
399 			XENBUS_IVAR_OTHEREND_PATH,
400 			xenbusb_device_sysctl_handler,
401 			"A",
402 			"XenStore path to peer device");
403 }
404 
405 /**
406  * \brief Decrement the number of XenBus child devices in the
407  *        connecting state by one and release the xbs_attch_ch
408  *        interrupt configuration hook if the connecting count
409  *        drops to zero.
410  *
411  * \param xbs  XenBus Bus device softc of the owner of the bus to enumerate.
412  */
413 static void
414 xenbusb_release_confighook(struct xenbusb_softc *xbs)
415 {
416 	mtx_lock(&xbs->xbs_lock);
417 	KASSERT(xbs->xbs_connecting_children > 0,
418 		("Connecting device count error\n"));
419 	xbs->xbs_connecting_children--;
420 	if (xbs->xbs_connecting_children == 0
421 	 && (xbs->xbs_flags & XBS_ATTACH_CH_ACTIVE) != 0) {
422 		xbs->xbs_flags &= ~XBS_ATTACH_CH_ACTIVE;
423 		mtx_unlock(&xbs->xbs_lock);
424 		config_intrhook_disestablish(&xbs->xbs_attach_ch);
425 	} else {
426 		mtx_unlock(&xbs->xbs_lock);
427 	}
428 }
429 
430 /**
431  * \brief Verify the existance of attached device instances and perform
432  *        probe/attach processing for newly arrived devices.
433  *
434  * \param dev  The NewBus device representing this XenBus bus.
435  *
436  * \return  On success, 0. Otherwise an errno value indicating the
437  *          type of failure.
438  */
439 static int
440 xenbusb_probe_children(device_t dev)
441 {
442 	device_t *kids;
443 	struct xenbus_device_ivars *ivars;
444 	int i, count, error;
445 
446 	if (device_get_children(dev, &kids, &count) == 0) {
447 		for (i = 0; i < count; i++) {
448 			if (device_get_state(kids[i]) != DS_NOTPRESENT) {
449 				/*
450 				 * We already know about this one.
451 				 * Make sure it's still here.
452 				 */
453 				xenbusb_verify_device(dev, kids[i]);
454 				continue;
455 			}
456 
457 			error = device_probe_and_attach(kids[i]);
458 			if (error == ENXIO) {
459 				struct xenbusb_softc *xbs;
460 
461 				/*
462 				 * We don't have a PV driver for this device.
463 				 * However, an emulated device we do support
464 				 * may share this backend.  Hide the node from
465 				 * XenBus until the next rescan, but leave it's
466 				 * state unchanged so we don't inadvertently
467 				 * prevent attachment of any emulated device.
468 				 */
469 				xenbusb_delete_child(dev, kids[i]);
470 
471 				/*
472 				 * Since the XenStore state of this device
473 				 * still indicates a pending attach, manually
474 				 * release it's hold on the boot process.
475 				 */
476 				xbs = device_get_softc(dev);
477 				xenbusb_release_confighook(xbs);
478 
479 				continue;
480 			} else if (error) {
481 				/*
482 				 * Transition device to the closed state
483 				 * so the world knows that attachment will
484 				 * not occur.
485 				 */
486 				xenbus_set_state(kids[i], XenbusStateClosed);
487 
488 				/*
489 				 * Remove our record of this device.
490 				 * So long as it remains in the closed
491 				 * state in the XenStore, we will not find
492 				 * it again.  The state will only change
493 				 * if the control domain actively reconfigures
494 				 * this device.
495 				 */
496 				xenbusb_delete_child(dev, kids[i]);
497 
498 				continue;
499 			}
500 			/*
501 			 * Augment default newbus provided dynamic sysctl
502 			 * variables with the standard ivar contents of
503 			 * XenBus devices.
504 			 */
505 			xenbusb_device_sysctl_init(kids[i]);
506 
507 			/*
508 			 * Now that we have a driver managing this device
509 			 * that can receive otherend state change events,
510 			 * hook up a watch for them.
511 			 */
512 			ivars = device_get_ivars(kids[i]);
513 			xs_register_watch(&ivars->xd_otherend_watch);
514 			xs_register_watch(&ivars->xd_local_watch);
515 		}
516 		free(kids, M_TEMP);
517 	}
518 
519 	return (0);
520 }
521 
522 /**
523  * \brief Task callback function to perform XenBus probe operations
524  *        from a known safe context.
525  *
526  * \param arg      The NewBus device_t representing the bus instance to
527  *                 on which to perform probe processing.
528  * \param pending  The number of times this task was queued before it could
529  *                 be run.
530  */
531 static void
532 xenbusb_probe_children_cb(void *arg, int pending __unused)
533 {
534 	device_t dev = (device_t)arg;
535 
536 	bus_topo_lock();
537 	xenbusb_probe_children(dev);
538 	bus_topo_unlock();
539 }
540 
541 /**
542  * \brief XenStore watch callback for the root node of the XenStore
543  *        subtree representing a XenBus.
544  *
545  * This callback performs, or delegates to the xbs_probe_children task,
546  * all processing necessary to handle dynmaic device arrival and departure
547  * events from a XenBus.
548  *
549  * \param watch  The XenStore watch object associated with this callback.
550  * \param vec    The XenStore watch event data.
551  * \param len	 The number of fields in the event data stream.
552  */
553 static void
554 xenbusb_devices_changed(struct xs_watch *watch, const char **vec,
555 			unsigned int len)
556 {
557 	struct xenbusb_softc *xbs;
558 	device_t dev;
559 	char *node;
560 	char *type;
561 	char *id;
562 	char *p;
563 	u_int component;
564 
565 	xbs = (struct xenbusb_softc *)watch->callback_data;
566 	dev = xbs->xbs_dev;
567 
568 	if (len <= XS_WATCH_PATH) {
569 		device_printf(dev, "xenbusb_devices_changed: "
570 			      "Short Event Data.\n");
571 		return;
572 	}
573 
574 	node = strdup(vec[XS_WATCH_PATH], M_XENBUS);
575 	p = strchr(node, '/');
576 	if (p == NULL)
577 		goto out;
578 	*p = 0;
579 	type = p + 1;
580 
581 	p = strchr(type, '/');
582 	if (p == NULL)
583 		goto out;
584 	*p++ = 0;
585 
586 	/*
587 	 * Extract the device ID.  A device ID has one or more path
588 	 * components separated by the '/' character.
589 	 *
590 	 * e.g. "<frontend vm id>/<frontend dev id>" for backend devices.
591 	 */
592 	id = p;
593 	for (component = 0; component < xbs->xbs_id_components; component++) {
594 		p = strchr(p, '/');
595 		if (p == NULL)
596 			break;
597 		p++;
598 	}
599 	if (p != NULL)
600 		*p = 0;
601 
602 	if (*id != 0 && component >= xbs->xbs_id_components - 1) {
603 		xenbusb_add_device(xbs->xbs_dev, type, id);
604 		taskqueue_enqueue(taskqueue_thread, &xbs->xbs_probe_children);
605 	}
606 out:
607 	free(node, M_XENBUS);
608 }
609 
610 /**
611  * \brief Interrupt configuration hook callback associated with xbs_attch_ch.
612  *
613  * Since interrupts are always functional at the time of XenBus configuration,
614  * there is nothing to be done when the callback occurs.  This hook is only
615  * registered to hold up boot processing while XenBus devices come online.
616  *
617  * \param arg  Unused configuration hook callback argument.
618  */
619 static void
620 xenbusb_nop_confighook_cb(void *arg __unused)
621 {
622 }
623 
624 /*--------------------------- Public Functions -------------------------------*/
625 /*--------- API comments for these methods can be found in xenbusb.h ---------*/
626 void
627 xenbusb_identify(driver_t *driver __unused, device_t parent)
628 {
629 	/*
630 	 * A single instance of each bus type for which we have a driver
631 	 * is always present in a system operating under Xen.
632 	 */
633 	BUS_ADD_CHILD(parent, 0, driver->name, 0);
634 }
635 
636 int
637 xenbusb_add_device(device_t dev, const char *type, const char *id)
638 {
639 	struct xenbusb_softc *xbs;
640 	struct sbuf *devpath_sbuf;
641 	char *devpath;
642 	struct xenbus_device_ivars *ivars;
643 	int error;
644 
645 	xbs = device_get_softc(dev);
646 	devpath_sbuf = sbuf_new_auto();
647 	sbuf_printf(devpath_sbuf, "%s/%s/%s", xbs->xbs_node, type, id);
648 	sbuf_finish(devpath_sbuf);
649 	devpath = sbuf_data(devpath_sbuf);
650 
651 	ivars = malloc(sizeof(*ivars), M_XENBUS, M_ZERO|M_WAITOK);
652 	error = ENXIO;
653 
654 	if (xs_exists(XST_NIL, devpath, "") != 0) {
655 		device_t child;
656 		enum xenbus_state state;
657 		char *statepath;
658 
659 		child = xenbusb_device_exists(dev, devpath);
660 		if (child != NULL) {
661 			/*
662 			 * We are already tracking this node
663 			 */
664 			error = 0;
665 			goto out;
666 		}
667 
668 		state = xenbus_read_driver_state(devpath);
669 		if (state != XenbusStateInitialising) {
670 			/*
671 			 * Device is not new, so ignore it. This can
672 			 * happen if a device is going away after
673 			 * switching to Closed.
674 			 */
675 			printf("xenbusb_add_device: Device %s ignored. "
676 			       "State %d\n", devpath, state);
677 			error = 0;
678 			goto out;
679 		}
680 
681 		sx_init(&ivars->xd_lock, "xdlock");
682 		ivars->xd_flags = XDF_CONNECTING;
683 		ivars->xd_node = strdup(devpath, M_XENBUS);
684 		ivars->xd_node_len = strlen(devpath);
685 		ivars->xd_type  = strdup(type, M_XENBUS);
686 		ivars->xd_state = XenbusStateInitialising;
687 
688 		error = XENBUSB_GET_OTHEREND_NODE(dev, ivars);
689 		if (error) {
690 			printf("xenbus_update_device: %s no otherend id\n",
691 			    devpath);
692 			goto out;
693 		}
694 
695 		statepath = malloc(ivars->xd_otherend_path_len
696 		    + strlen("/state") + 1, M_XENBUS, M_WAITOK);
697 		sprintf(statepath, "%s/state", ivars->xd_otherend_path);
698 		ivars->xd_otherend_watch.node = statepath;
699 		ivars->xd_otherend_watch.callback = xenbusb_otherend_watch_cb;
700 		ivars->xd_otherend_watch.callback_data = (uintptr_t)ivars;
701 		/*
702 		 * Other end state node watch, limit to one pending event
703 		 * to prevent frontends from queuing too many events that
704 		 * could cause resource starvation.
705 		 */
706 		ivars->xd_otherend_watch.max_pending = 1;
707 
708 		ivars->xd_local_watch.node = ivars->xd_node;
709 		ivars->xd_local_watch.callback = xenbusb_local_watch_cb;
710 		ivars->xd_local_watch.callback_data = (uintptr_t)ivars;
711 		/*
712 		 * Watch our local path, only writable by us or a privileged
713 		 * domain, no need to limit.
714 		 */
715 		ivars->xd_local_watch.max_pending = 0;
716 
717 		mtx_lock(&xbs->xbs_lock);
718 		xbs->xbs_connecting_children++;
719 		mtx_unlock(&xbs->xbs_lock);
720 
721 		child = device_add_child(dev, NULL, -1);
722 		ivars->xd_dev = child;
723 		device_set_ivars(child, ivars);
724 	}
725 
726 out:
727 	sbuf_delete(devpath_sbuf);
728 	if (error != 0)
729 		xenbusb_free_child_ivars(ivars);
730 
731 	return (error);
732 }
733 
734 int
735 xenbusb_attach(device_t dev, char *bus_node, u_int id_components)
736 {
737 	struct xenbusb_softc *xbs;
738 
739 	xbs = device_get_softc(dev);
740 	mtx_init(&xbs->xbs_lock, "xenbusb softc lock", NULL, MTX_DEF);
741 	xbs->xbs_node = bus_node;
742 	xbs->xbs_id_components = id_components;
743 	xbs->xbs_dev = dev;
744 
745 	/*
746 	 * Since XenBus buses are attached to the XenStore, and
747 	 * the XenStore does not probe children until after interrupt
748 	 * services are available, this config hook is used solely
749 	 * to ensure that the remainder of the boot process (e.g.
750 	 * mount root) is deferred until child devices are adequately
751 	 * probed.  We unblock the boot process as soon as the
752 	 * connecting child count in our softc goes to 0.
753 	 */
754 	xbs->xbs_attach_ch.ich_func = xenbusb_nop_confighook_cb;
755 	xbs->xbs_attach_ch.ich_arg = dev;
756 	config_intrhook_establish(&xbs->xbs_attach_ch);
757 	xbs->xbs_flags |= XBS_ATTACH_CH_ACTIVE;
758 	xbs->xbs_connecting_children = 1;
759 
760 	/*
761 	 * The subtree for this bus type may not yet exist
762 	 * causing initial enumeration to fail.  We still
763 	 * want to return success from our attach though
764 	 * so that we are ready to handle devices for this
765 	 * bus when they are dynamically attached to us
766 	 * by a Xen management action.
767 	 */
768 	(void)xenbusb_enumerate_bus(xbs);
769 	xenbusb_probe_children(dev);
770 
771 	xbs->xbs_device_watch.node = bus_node;
772 	xbs->xbs_device_watch.callback = xenbusb_devices_changed;
773 	xbs->xbs_device_watch.callback_data = (uintptr_t)xbs;
774 	/*
775 	 * Allow for unlimited pending watches, as those are local paths
776 	 * either controlled by the guest or only writable by privileged
777 	 * domains.
778 	 */
779 	xbs->xbs_device_watch.max_pending = 0;
780 
781 	TASK_INIT(&xbs->xbs_probe_children, 0, xenbusb_probe_children_cb, dev);
782 
783 	xs_register_watch(&xbs->xbs_device_watch);
784 
785 	xenbusb_release_confighook(xbs);
786 
787 	return (0);
788 }
789 
790 int
791 xenbusb_resume(device_t dev)
792 {
793 	device_t *kids;
794 	struct xenbus_device_ivars *ivars;
795 	int i, count, error;
796 	char *statepath;
797 
798 	/*
799 	 * We must re-examine each device and find the new path for
800 	 * its backend.
801 	 */
802 	if (device_get_children(dev, &kids, &count) == 0) {
803 		for (i = 0; i < count; i++) {
804 			if (device_get_state(kids[i]) == DS_NOTPRESENT)
805 				continue;
806 
807 			if (xen_suspend_cancelled) {
808 				DEVICE_RESUME(kids[i]);
809 				continue;
810 			}
811 
812 			ivars = device_get_ivars(kids[i]);
813 
814 			xs_unregister_watch(&ivars->xd_otherend_watch);
815 			xenbus_set_state(kids[i], XenbusStateInitialising);
816 
817 			/*
818 			 * Find the new backend details and
819 			 * re-register our watch.
820 			 */
821 			error = XENBUSB_GET_OTHEREND_NODE(dev, ivars);
822 			if (error)
823 				return (error);
824 
825 			statepath = malloc(ivars->xd_otherend_path_len
826 			    + strlen("/state") + 1, M_XENBUS, M_WAITOK);
827 			sprintf(statepath, "%s/state", ivars->xd_otherend_path);
828 
829 			free(ivars->xd_otherend_watch.node, M_XENBUS);
830 			ivars->xd_otherend_watch.node = statepath;
831 
832 			DEVICE_RESUME(kids[i]);
833 
834 			xs_register_watch(&ivars->xd_otherend_watch);
835 #if 0
836 			/*
837 			 * Can't do this yet since we are running in
838 			 * the xenwatch thread and if we sleep here,
839 			 * we will stop delivering watch notifications
840 			 * and the device will never come back online.
841 			 */
842 			sx_xlock(&ivars->xd_lock);
843 			while (ivars->xd_state != XenbusStateClosed
844 			    && ivars->xd_state != XenbusStateConnected)
845 				sx_sleep(&ivars->xd_state, &ivars->xd_lock,
846 				    0, "xdresume", 0);
847 			sx_xunlock(&ivars->xd_lock);
848 #endif
849 		}
850 		free(kids, M_TEMP);
851 	}
852 
853 	return (0);
854 }
855 
856 int
857 xenbusb_print_child(device_t dev, device_t child)
858 {
859 	struct xenbus_device_ivars *ivars = device_get_ivars(child);
860 	int	retval = 0;
861 
862 	retval += bus_print_child_header(dev, child);
863 	retval += printf(" at %s", ivars->xd_node);
864 	retval += bus_print_child_footer(dev, child);
865 
866 	return (retval);
867 }
868 
869 int
870 xenbusb_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
871 {
872 	struct xenbus_device_ivars *ivars = device_get_ivars(child);
873 
874 	switch (index) {
875 	case XENBUS_IVAR_NODE:
876 		*result = (uintptr_t) ivars->xd_node;
877 		return (0);
878 
879 	case XENBUS_IVAR_TYPE:
880 		*result = (uintptr_t) ivars->xd_type;
881 		return (0);
882 
883 	case XENBUS_IVAR_STATE:
884 		*result = (uintptr_t) ivars->xd_state;
885 		return (0);
886 
887 	case XENBUS_IVAR_OTHEREND_ID:
888 		*result = (uintptr_t) ivars->xd_otherend_id;
889 		return (0);
890 
891 	case XENBUS_IVAR_OTHEREND_PATH:
892 		*result = (uintptr_t) ivars->xd_otherend_path;
893 		return (0);
894 	}
895 
896 	return (ENOENT);
897 }
898 
899 int
900 xenbusb_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
901 {
902 	struct xenbus_device_ivars *ivars = device_get_ivars(child);
903 	enum xenbus_state newstate;
904 	int currstate;
905 
906 	switch (index) {
907 	case XENBUS_IVAR_STATE:
908 	{
909 		int error;
910 
911 		newstate = (enum xenbus_state)value;
912 		sx_xlock(&ivars->xd_lock);
913 		if (ivars->xd_state == newstate) {
914 			error = 0;
915 			goto out;
916 		}
917 
918 		error = xs_scanf(XST_NIL, ivars->xd_node, "state",
919 		    NULL, "%d", &currstate);
920 		if (error)
921 			goto out;
922 
923 		do {
924 			error = xs_printf(XST_NIL, ivars->xd_node, "state",
925 			    "%d", newstate);
926 		} while (error == EAGAIN);
927 		if (error) {
928 			/*
929 			 * Avoid looping through xenbus_dev_fatal()
930 			 * which calls xenbus_write_ivar to set the
931 			 * state to closing.
932 			 */
933 			if (newstate != XenbusStateClosing)
934 				xenbus_dev_fatal(dev, error,
935 						 "writing new state");
936 			goto out;
937 		}
938 		ivars->xd_state = newstate;
939 
940 		if ((ivars->xd_flags & XDF_CONNECTING) != 0
941 		 && (newstate == XenbusStateClosed
942 		  || newstate == XenbusStateConnected)) {
943 			struct xenbusb_softc *xbs;
944 
945 			ivars->xd_flags &= ~XDF_CONNECTING;
946 			xbs = device_get_softc(dev);
947 			xenbusb_release_confighook(xbs);
948 		}
949 
950 		wakeup(&ivars->xd_state);
951 	out:
952 		sx_xunlock(&ivars->xd_lock);
953 		return (error);
954 	}
955 
956 	case XENBUS_IVAR_NODE:
957 	case XENBUS_IVAR_TYPE:
958 	case XENBUS_IVAR_OTHEREND_ID:
959 	case XENBUS_IVAR_OTHEREND_PATH:
960 		/*
961 		 * These variables are read-only.
962 		 */
963 		return (EINVAL);
964 	}
965 
966 	return (ENOENT);
967 }
968 
969 void
970 xenbusb_otherend_changed(device_t bus, device_t child, enum xenbus_state state)
971 {
972 	XENBUS_OTHEREND_CHANGED(child, state);
973 }
974 
975 void
976 xenbusb_localend_changed(device_t bus, device_t child, const char *path)
977 {
978 
979 	if (strcmp(path, "/state") != 0) {
980 		struct xenbus_device_ivars *ivars;
981 
982 		ivars = device_get_ivars(child);
983 		sx_xlock(&ivars->xd_lock);
984 		ivars->xd_state = xenbus_read_driver_state(ivars->xd_node);
985 		sx_xunlock(&ivars->xd_lock);
986 	}
987 	XENBUS_LOCALEND_CHANGED(child, path);
988 }
989