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 busses 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/xen/xen-os.h>
71 #include <machine/stdarg.h>
72
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 /*
260 * Device tree has been removed from Xenbus.
261 * Tear down the device.
262 */
263 xenbusb_delete_child(dev, child);
264 }
265 }
266
267 /**
268 * \brief Enumerate the devices on a XenBus bus and register them with
269 * the NewBus device tree.
270 *
271 * xenbusb_enumerate_bus() will create entries (in state DS_NOTPRESENT)
272 * for nodes that appear in the XenStore, but will not invoke probe/attach
273 * operations on drivers. Probe/Attach processing must be separately
274 * performed via an invocation of xenbusb_probe_children(). This is usually
275 * done via the xbs_probe_children task.
276 *
277 * \param xbs XenBus Bus device softc of the owner of the bus to enumerate.
278 *
279 * \return On success, 0. Otherwise an errno value indicating the
280 * type of failure.
281 */
282 static int
283 xenbusb_enumerate_bus(struct xenbusb_softc *xbs)
284 {
285 const char **types;
286 u_int type_idx;
287 u_int type_count;
288 int error;
289
290 error = xs_directory(XST_NIL, xbs->xbs_node, "", &type_count, &types);
291 if (error)
292 return (error);
293
294 for (type_idx = 0; type_idx < type_count; type_idx++)
295 XENBUSB_ENUMERATE_TYPE(xbs->xbs_dev, types[type_idx]);
296
297 free(types, M_XENSTORE);
298
299 return (0);
300 }
301
302 /**
303 * Handler for all generic XenBus device systcl nodes.
304 */
305 static int
306 xenbusb_device_sysctl_handler(SYSCTL_HANDLER_ARGS)
307 {
308 device_t dev;
309 const char *value;
310
311 dev = (device_t)arg1;
312 switch (arg2) {
313 case XENBUS_IVAR_NODE:
314 value = xenbus_get_node(dev);
315 break;
316 case XENBUS_IVAR_TYPE:
317 value = xenbus_get_type(dev);
318 break;
319 case XENBUS_IVAR_STATE:
320 value = xenbus_strstate(xenbus_get_state(dev));
321 break;
322 case XENBUS_IVAR_OTHEREND_ID:
323 return (sysctl_handle_int(oidp, NULL,
324 xenbus_get_otherend_id(dev),
325 req));
326 /* NOTREACHED */
327 case XENBUS_IVAR_OTHEREND_PATH:
328 value = xenbus_get_otherend_path(dev);
329 break;
330 default:
331 return (EINVAL);
332 }
333 return (SYSCTL_OUT(req, value, strlen(value)));
334 }
335
336 /**
337 * Create read-only systcl nodes for xenbusb device ivar data.
338 *
339 * \param dev The XenBus device instance to register with sysctl.
340 */
341 static void
342 xenbusb_device_sysctl_init(device_t dev)
343 {
344 struct sysctl_ctx_list *ctx;
345 struct sysctl_oid *tree;
346
347 ctx = device_get_sysctl_ctx(dev);
348 tree = device_get_sysctl_tree(dev);
349
350 SYSCTL_ADD_PROC(ctx,
351 SYSCTL_CHILDREN(tree),
352 OID_AUTO,
353 "xenstore_path",
354 CTLTYPE_STRING | CTLFLAG_RD,
355 dev,
356 XENBUS_IVAR_NODE,
357 xenbusb_device_sysctl_handler,
358 "A",
359 "XenStore path to device");
360
361 SYSCTL_ADD_PROC(ctx,
362 SYSCTL_CHILDREN(tree),
363 OID_AUTO,
364 "xenbus_dev_type",
365 CTLTYPE_STRING | CTLFLAG_RD,
366 dev,
367 XENBUS_IVAR_TYPE,
368 xenbusb_device_sysctl_handler,
369 "A",
370 "XenBus device type");
371
372 SYSCTL_ADD_PROC(ctx,
373 SYSCTL_CHILDREN(tree),
374 OID_AUTO,
375 "xenbus_connection_state",
376 CTLTYPE_STRING | CTLFLAG_RD,
377 dev,
378 XENBUS_IVAR_STATE,
379 xenbusb_device_sysctl_handler,
380 "A",
381 "XenBus state of peer connection");
382
383 SYSCTL_ADD_PROC(ctx,
384 SYSCTL_CHILDREN(tree),
385 OID_AUTO,
386 "xenbus_peer_domid",
387 CTLTYPE_INT | CTLFLAG_RD,
388 dev,
389 XENBUS_IVAR_OTHEREND_ID,
390 xenbusb_device_sysctl_handler,
391 "I",
392 "Xen domain ID of peer");
393
394 SYSCTL_ADD_PROC(ctx,
395 SYSCTL_CHILDREN(tree),
396 OID_AUTO,
397 "xenstore_peer_path",
398 CTLTYPE_STRING | CTLFLAG_RD,
399 dev,
400 XENBUS_IVAR_OTHEREND_PATH,
401 xenbusb_device_sysctl_handler,
402 "A",
403 "XenStore path to peer device");
404 }
405
406 /**
407 * \brief Decrement the number of XenBus child devices in the
408 * connecting state by one and release the xbs_attch_ch
409 * interrupt configuration hook if the connecting count
410 * drops to zero.
411 *
412 * \param xbs XenBus Bus device softc of the owner of the bus to enumerate.
413 */
414 static void
415 xenbusb_release_confighook(struct xenbusb_softc *xbs)
416 {
417 mtx_lock(&xbs->xbs_lock);
418 KASSERT(xbs->xbs_connecting_children > 0,
419 ("Connecting device count error\n"));
420 xbs->xbs_connecting_children--;
421 if (xbs->xbs_connecting_children == 0
422 && (xbs->xbs_flags & XBS_ATTACH_CH_ACTIVE) != 0) {
423 xbs->xbs_flags &= ~XBS_ATTACH_CH_ACTIVE;
424 mtx_unlock(&xbs->xbs_lock);
425 config_intrhook_disestablish(&xbs->xbs_attach_ch);
426 } else {
427 mtx_unlock(&xbs->xbs_lock);
428 }
429 }
430
431 /**
432 * \brief Verify the existance of attached device instances and perform
433 * probe/attach processing for newly arrived devices.
434 *
435 * \param dev The NewBus device representing this XenBus bus.
436 *
437 * \return On success, 0. Otherwise an errno value indicating the
438 * type of failure.
439 */
440 static int
441 xenbusb_probe_children(device_t dev)
442 {
443 device_t *kids;
444 struct xenbus_device_ivars *ivars;
445 int i, count, error;
446
447 if (device_get_children(dev, &kids, &count) == 0) {
448 for (i = 0; i < count; i++) {
449 if (device_get_state(kids[i]) != DS_NOTPRESENT) {
450 /*
451 * We already know about this one.
452 * Make sure it's still here.
453 */
454 xenbusb_verify_device(dev, kids[i]);
455 continue;
456 }
457
458 error = device_probe_and_attach(kids[i]);
459 if (error == ENXIO) {
460 struct xenbusb_softc *xbs;
461
462 /*
463 * We don't have a PV driver for this device.
464 * However, an emulated device we do support
465 * may share this backend. Hide the node from
466 * XenBus until the next rescan, but leave it's
467 * state unchanged so we don't inadvertently
468 * prevent attachment of any emulated device.
469 */
470 xenbusb_delete_child(dev, kids[i]);
471
472 /*
473 * Since the XenStore state of this device
474 * still indicates a pending attach, manually
475 * release it's hold on the boot process.
476 */
477 xbs = device_get_softc(dev);
478 xenbusb_release_confighook(xbs);
479
480 continue;
481 } else if (error) {
482 /*
483 * Transition device to the closed state
484 * so the world knows that attachment will
485 * not occur.
486 */
487 xenbus_set_state(kids[i], XenbusStateClosed);
488
489 /*
490 * Remove our record of this device.
491 * So long as it remains in the closed
492 * state in the XenStore, we will not find
493 * it again. The state will only change
494 * if the control domain actively reconfigures
495 * this device.
496 */
497 xenbusb_delete_child(dev, kids[i]);
498
499 continue;
500 }
501 /*
502 * Augment default newbus provided dynamic sysctl
503 * variables with the standard ivar contents of
504 * XenBus devices.
505 */
506 xenbusb_device_sysctl_init(kids[i]);
507
508 /*
509 * Now that we have a driver managing this device
510 * that can receive otherend state change events,
511 * hook up a watch for them.
512 */
513 ivars = device_get_ivars(kids[i]);
514 xs_register_watch(&ivars->xd_otherend_watch);
515 xs_register_watch(&ivars->xd_local_watch);
516 }
517 free(kids, M_TEMP);
518 }
519
520 return (0);
521 }
522
523 /**
524 * \brief Task callback function to perform XenBus probe operations
525 * from a known safe context.
526 *
527 * \param arg The NewBus device_t representing the bus instance to
528 * on which to perform probe processing.
529 * \param pending The number of times this task was queued before it could
530 * be run.
531 */
532 static void
533 xenbusb_probe_children_cb(void *arg, int pending __unused)
534 {
535 device_t dev = (device_t)arg;
536
537 /*
538 * Hold Giant until the Giant free newbus changes are committed.
539 */
540 mtx_lock(&Giant);
541 xenbusb_probe_children(dev);
542 mtx_unlock(&Giant);
543 }
544
545 /**
546 * \brief XenStore watch callback for the root node of the XenStore
547 * subtree representing a XenBus.
548 *
549 * This callback performs, or delegates to the xbs_probe_children task,
550 * all processing necessary to handle dynmaic device arrival and departure
551 * events from a XenBus.
552 *
553 * \param watch The XenStore watch object associated with this callback.
554 * \param vec The XenStore watch event data.
555 * \param len The number of fields in the event data stream.
556 */
557 static void
558 xenbusb_devices_changed(struct xs_watch *watch, const char **vec,
559 unsigned int len)
560 {
561 struct xenbusb_softc *xbs;
562 device_t dev;
563 char *node;
564 char *bus;
565 char *type;
566 char *id;
567 char *p;
568 u_int component;
569
570 xbs = (struct xenbusb_softc *)watch->callback_data;
571 dev = xbs->xbs_dev;
572
573 if (len <= XS_WATCH_PATH) {
574 device_printf(dev, "xenbusb_devices_changed: "
575 "Short Event Data.\n");
576 return;
577 }
578
579 node = strdup(vec[XS_WATCH_PATH], M_XENBUS);
580 p = strchr(node, '/');
581 if (p == NULL)
582 goto out;
583 bus = node;
584 *p = 0;
585 type = p + 1;
586
587 p = strchr(type, '/');
588 if (p == NULL)
589 goto out;
590 *p++ = 0;
591
592 /*
593 * Extract the device ID. A device ID has one or more path
594 * components separated by the '/' character.
595 *
596 * e.g. "<frontend vm id>/<frontend dev id>" for backend devices.
597 */
598 id = p;
599 for (component = 0; component < xbs->xbs_id_components; component++) {
600 p = strchr(p, '/');
601 if (p == NULL)
602 break;
603 p++;
604 }
605 if (p != NULL)
606 *p = 0;
607
608 if (*id != 0 && component >= xbs->xbs_id_components - 1) {
609 xenbusb_add_device(xbs->xbs_dev, type, id);
610 taskqueue_enqueue(taskqueue_thread, &xbs->xbs_probe_children);
611 }
612 out:
613 free(node, M_XENBUS);
614 }
615
616 /**
617 * \brief Interrupt configuration hook callback associated with xbs_attch_ch.
618 *
619 * Since interrupts are always functional at the time of XenBus configuration,
620 * there is nothing to be done when the callback occurs. This hook is only
621 * registered to hold up boot processing while XenBus devices come online.
622 *
623 * \param arg Unused configuration hook callback argument.
624 */
625 static void
626 xenbusb_nop_confighook_cb(void *arg __unused)
627 {
628 }
629
630 /*--------------------------- Public Functions -------------------------------*/
631 /*--------- API comments for these methods can be found in xenbusb.h ---------*/
632 void
633 xenbusb_identify(driver_t *driver __unused, device_t parent)
634 {
635 /*
636 * A single instance of each bus type for which we have a driver
637 * is always present in a system operating under Xen.
638 */
639 BUS_ADD_CHILD(parent, 0, driver->name, 0);
640 }
641
642 int
643 xenbusb_add_device(device_t dev, const char *type, const char *id)
644 {
645 struct xenbusb_softc *xbs;
646 struct sbuf *devpath_sbuf;
647 char *devpath;
648 struct xenbus_device_ivars *ivars;
649 int error;
650
651 xbs = device_get_softc(dev);
652 devpath_sbuf = sbuf_new_auto();
653 sbuf_printf(devpath_sbuf, "%s/%s/%s", xbs->xbs_node, type, id);
654 sbuf_finish(devpath_sbuf);
655 devpath = sbuf_data(devpath_sbuf);
656
657 ivars = malloc(sizeof(*ivars), M_XENBUS, M_ZERO|M_WAITOK);
658 error = ENXIO;
659
660 if (xs_exists(XST_NIL, devpath, "") != 0) {
661 device_t child;
662 enum xenbus_state state;
663 char *statepath;
664
665 child = xenbusb_device_exists(dev, devpath);
666 if (child != NULL) {
667 /*
668 * We are already tracking this node
669 */
670 error = 0;
671 goto out;
672 }
673
674 state = xenbus_read_driver_state(devpath);
675 if (state != XenbusStateInitialising) {
676 /*
677 * Device is not new, so ignore it. This can
678 * happen if a device is going away after
679 * switching to Closed.
680 */
681 printf("xenbusb_add_device: Device %s ignored. "
682 "State %d\n", devpath, state);
683 error = 0;
684 goto out;
685 }
686
687 sx_init(&ivars->xd_lock, "xdlock");
688 ivars->xd_flags = XDF_CONNECTING;
689 ivars->xd_node = strdup(devpath, M_XENBUS);
690 ivars->xd_node_len = strlen(devpath);
691 ivars->xd_type = strdup(type, M_XENBUS);
692 ivars->xd_state = XenbusStateInitialising;
693
694 error = XENBUSB_GET_OTHEREND_NODE(dev, ivars);
695 if (error) {
696 printf("xenbus_update_device: %s no otherend id\n",
697 devpath);
698 goto out;
699 }
700
701 statepath = malloc(ivars->xd_otherend_path_len
702 + strlen("/state") + 1, M_XENBUS, M_WAITOK);
703 sprintf(statepath, "%s/state", ivars->xd_otherend_path);
704 ivars->xd_otherend_watch.node = statepath;
705 ivars->xd_otherend_watch.callback = xenbusb_otherend_watch_cb;
706 ivars->xd_otherend_watch.callback_data = (uintptr_t)ivars;
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 mtx_lock(&xbs->xbs_lock);
713 xbs->xbs_connecting_children++;
714 mtx_unlock(&xbs->xbs_lock);
715
716 child = device_add_child(dev, NULL, -1);
717 ivars->xd_dev = child;
718 device_set_ivars(child, ivars);
719 }
720
721 out:
722 sbuf_delete(devpath_sbuf);
723 if (error != 0)
724 xenbusb_free_child_ivars(ivars);
725
726 return (error);
727 }
728
729 int
730 xenbusb_attach(device_t dev, char *bus_node, u_int id_components)
731 {
732 struct xenbusb_softc *xbs;
733
734 xbs = device_get_softc(dev);
735 mtx_init(&xbs->xbs_lock, "xenbusb softc lock", NULL, MTX_DEF);
736 xbs->xbs_node = bus_node;
737 xbs->xbs_id_components = id_components;
738 xbs->xbs_dev = dev;
739
740 /*
741 * Since XenBus busses are attached to the XenStore, and
742 * the XenStore does not probe children until after interrupt
743 * services are available, this config hook is used solely
744 * to ensure that the remainder of the boot process (e.g.
745 * mount root) is deferred until child devices are adequately
746 * probed. We unblock the boot process as soon as the
747 * connecting child count in our softc goes to 0.
748 */
749 xbs->xbs_attach_ch.ich_func = xenbusb_nop_confighook_cb;
750 xbs->xbs_attach_ch.ich_arg = dev;
751 config_intrhook_establish(&xbs->xbs_attach_ch);
752 xbs->xbs_flags |= XBS_ATTACH_CH_ACTIVE;
753 xbs->xbs_connecting_children = 1;
754
755 /*
756 * The subtree for this bus type may not yet exist
757 * causing initial enumeration to fail. We still
758 * want to return success from our attach though
759 * so that we are ready to handle devices for this
760 * bus when they are dynamically attached to us
761 * by a Xen management action.
762 */
763 (void)xenbusb_enumerate_bus(xbs);
764 xenbusb_probe_children(dev);
765
766 xbs->xbs_device_watch.node = bus_node;
767 xbs->xbs_device_watch.callback = xenbusb_devices_changed;
768 xbs->xbs_device_watch.callback_data = (uintptr_t)xbs;
769
770 TASK_INIT(&xbs->xbs_probe_children, 0, xenbusb_probe_children_cb, dev);
771
772 xs_register_watch(&xbs->xbs_device_watch);
773
774 xenbusb_release_confighook(xbs);
775
776 return (0);
777 }
778
779 int
780 xenbusb_resume(device_t dev)
781 {
782 device_t *kids;
783 struct xenbus_device_ivars *ivars;
784 int i, count, error;
785 char *statepath;
786
787 /*
788 * We must re-examine each device and find the new path for
789 * its backend.
790 */
791 if (device_get_children(dev, &kids, &count) == 0) {
792 for (i = 0; i < count; i++) {
793 if (device_get_state(kids[i]) == DS_NOTPRESENT)
794 continue;
795
796 ivars = device_get_ivars(kids[i]);
797
798 xs_unregister_watch(&ivars->xd_otherend_watch);
799 xenbus_set_state(kids[i], XenbusStateInitialising);
800
801 /*
802 * Find the new backend details and
803 * re-register our watch.
804 */
805 error = XENBUSB_GET_OTHEREND_NODE(dev, ivars);
806 if (error)
807 return (error);
808
809 statepath = malloc(ivars->xd_otherend_path_len
810 + strlen("/state") + 1, M_XENBUS, M_WAITOK);
811 sprintf(statepath, "%s/state", ivars->xd_otherend_path);
812
813 free(ivars->xd_otherend_watch.node, M_XENBUS);
814 ivars->xd_otherend_watch.node = statepath;
815
816 DEVICE_RESUME(kids[i]);
817
818 xs_register_watch(&ivars->xd_otherend_watch);
819 #if 0
820 /*
821 * Can't do this yet since we are running in
822 * the xenwatch thread and if we sleep here,
823 * we will stop delivering watch notifications
824 * and the device will never come back online.
825 */
826 sx_xlock(&ivars->xd_lock);
827 while (ivars->xd_state != XenbusStateClosed
828 && ivars->xd_state != XenbusStateConnected)
829 sx_sleep(&ivars->xd_state, &ivars->xd_lock,
830 0, "xdresume", 0);
831 sx_xunlock(&ivars->xd_lock);
832 #endif
833 }
834 free(kids, M_TEMP);
835 }
836
837 return (0);
838 }
839
840 int
841 xenbusb_print_child(device_t dev, device_t child)
842 {
843 struct xenbus_device_ivars *ivars = device_get_ivars(child);
844 int retval = 0;
845
846 retval += bus_print_child_header(dev, child);
847 retval += printf(" at %s", ivars->xd_node);
848 retval += bus_print_child_footer(dev, child);
849
850 return (retval);
851 }
852
853 int
854 xenbusb_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
855 {
856 struct xenbus_device_ivars *ivars = device_get_ivars(child);
857
858 switch (index) {
859 case XENBUS_IVAR_NODE:
860 *result = (uintptr_t) ivars->xd_node;
861 return (0);
862
863 case XENBUS_IVAR_TYPE:
864 *result = (uintptr_t) ivars->xd_type;
865 return (0);
866
867 case XENBUS_IVAR_STATE:
868 *result = (uintptr_t) ivars->xd_state;
869 return (0);
870
871 case XENBUS_IVAR_OTHEREND_ID:
872 *result = (uintptr_t) ivars->xd_otherend_id;
873 return (0);
874
875 case XENBUS_IVAR_OTHEREND_PATH:
876 *result = (uintptr_t) ivars->xd_otherend_path;
877 return (0);
878 }
879
880 return (ENOENT);
881 }
882
883 int
884 xenbusb_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
885 {
886 struct xenbus_device_ivars *ivars = device_get_ivars(child);
887 enum xenbus_state newstate;
888 int currstate;
889
890 switch (index) {
891 case XENBUS_IVAR_STATE:
892 {
893 int error;
894
895 newstate = (enum xenbus_state)value;
896 sx_xlock(&ivars->xd_lock);
897 if (ivars->xd_state == newstate) {
898 error = 0;
899 goto out;
900 }
901
902 error = xs_scanf(XST_NIL, ivars->xd_node, "state",
903 NULL, "%d", &currstate);
904 if (error)
905 goto out;
906
907 do {
908 error = xs_printf(XST_NIL, ivars->xd_node, "state",
909 "%d", newstate);
910 } while (error == EAGAIN);
911 if (error) {
912 /*
913 * Avoid looping through xenbus_dev_fatal()
914 * which calls xenbus_write_ivar to set the
915 * state to closing.
916 */
917 if (newstate != XenbusStateClosing)
918 xenbus_dev_fatal(dev, error,
919 "writing new state");
920 goto out;
921 }
922 ivars->xd_state = newstate;
923
924 if ((ivars->xd_flags & XDF_CONNECTING) != 0
925 && (newstate == XenbusStateClosed
926 || newstate == XenbusStateConnected)) {
927 struct xenbusb_softc *xbs;
928
929 ivars->xd_flags &= ~XDF_CONNECTING;
930 xbs = device_get_softc(dev);
931 xenbusb_release_confighook(xbs);
932 }
933
934 wakeup(&ivars->xd_state);
935 out:
936 sx_xunlock(&ivars->xd_lock);
937 return (error);
938 }
939
940 case XENBUS_IVAR_NODE:
941 case XENBUS_IVAR_TYPE:
942 case XENBUS_IVAR_OTHEREND_ID:
943 case XENBUS_IVAR_OTHEREND_PATH:
944 /*
945 * These variables are read-only.
946 */
947 return (EINVAL);
948 }
949
950 return (ENOENT);
951 }
952
953 void
954 xenbusb_otherend_changed(device_t bus, device_t child, enum xenbus_state state)
955 {
956 XENBUS_OTHEREND_CHANGED(child, state);
957 }
958
959 void
960 xenbusb_localend_changed(device_t bus, device_t child, const char *path)
961 {
962
963 if (strcmp(path, "/state") != 0) {
964 struct xenbus_device_ivars *ivars;
965
966 ivars = device_get_ivars(child);
967 sx_xlock(&ivars->xd_lock);
968 ivars->xd_state = xenbus_read_driver_state(ivars->xd_node);
969 sx_xunlock(&ivars->xd_lock);
970 }
971 XENBUS_LOCALEND_CHANGED(child, path);
972 }
Cache object: a21730aceefb55bb7bb35c5659bbd2fd
|