1 /****************************************************************************** 2 * Talks to Xen Store to figure out what devices we have. 3 * 4 * Copyright (C) 2009, 2010 Spectra Logic Corporation 5 * Copyright (C) 2008 Doug Rabson 6 * Copyright (C) 2005 Rusty Russell, IBM Corporation 7 * Copyright (C) 2005 Mike Wray, Hewlett-Packard 8 * Copyright (C) 2005 XenSource Ltd 9 * 10 * This file may be distributed separately from the Linux kernel, or 11 * incorporated into other software packages, subject to the following license: 12 * 13 * Permission is hereby granted, free of charge, to any person obtaining a copy 14 * of this source file (the "Software"), to deal in the Software without 15 * restriction, including without limitation the rights to use, copy, modify, 16 * merge, publish, distribute, sublicense, and/or sell copies of the Software, 17 * and to permit persons to whom the Software is furnished to do so, subject to 18 * the following conditions: 19 * 20 * The above copyright notice and this permission notice shall be included in 21 * all copies or substantial portions of the Software. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 26 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 29 * IN THE SOFTWARE. 30 */ 31 32 /** 33 * \file xenbusb_back.c 34 * 35 * XenBus management of the NewBus bus containing the backend instances of 36 * Xen split devices. 37 */ 38 #include <sys/cdefs.h> 39 __FBSDID("$FreeBSD$"); 40 41 #include <sys/param.h> 42 #include <sys/bus.h> 43 #include <sys/kernel.h> 44 #include <sys/lock.h> 45 #include <sys/malloc.h> 46 #include <sys/module.h> 47 #include <sys/sbuf.h> 48 #include <sys/sysctl.h> 49 #include <sys/syslog.h> 50 #include <sys/systm.h> 51 #include <sys/sx.h> 52 #include <sys/taskqueue.h> 53 54 #include <machine/stdarg.h> 55 56 #include <xen/xen-os.h> 57 #include <xen/gnttab.h> 58 #include <xen/xenbus/xenbusvar.h> 59 #include <xen/xenbus/xenbusb.h> 60 61 /*------------------ Private Device Attachment Functions --------------------*/ 62 /** 63 * \brief Probe for the existance of the XenBus back bus. 64 * 65 * \param dev NewBus device_t for this XenBus back bus instance. 66 * 67 * \return Always returns 0 indicating success. 68 */ 69 static int 70 xenbusb_back_probe(device_t dev) 71 { 72 device_set_desc(dev, "Xen Backend Devices"); 73 74 return (0); 75 } 76 77 /** 78 * \brief Attach the XenBus back bus. 79 * 80 * \param dev NewBus device_t for this XenBus back bus instance. 81 * 82 * \return On success, 0. Otherwise an errno value indicating the 83 * type of failure. 84 */ 85 static int 86 xenbusb_back_attach(device_t dev) 87 { 88 struct xenbusb_softc *xbs; 89 int error; 90 91 xbs = device_get_softc(dev); 92 error = xenbusb_attach(dev, "backend", /*id_components*/2); 93 94 /* 95 * Backend devices operate to serve other domains, 96 * so there is no need to hold up boot processing 97 * while connections to foreign domains are made. 98 */ 99 mtx_lock(&xbs->xbs_lock); 100 if ((xbs->xbs_flags & XBS_ATTACH_CH_ACTIVE) != 0) { 101 xbs->xbs_flags &= ~XBS_ATTACH_CH_ACTIVE; 102 mtx_unlock(&xbs->xbs_lock); 103 config_intrhook_disestablish(&xbs->xbs_attach_ch); 104 } else { 105 mtx_unlock(&xbs->xbs_lock); 106 } 107 108 return (error); 109 } 110 111 /** 112 * \brief Enumerate all devices of the given type on this bus. 113 * 114 * \param dev NewBus device_t for this XenBus backend bus instance. 115 * \param type String indicating the device sub-tree (e.g. "vfb", "vif") 116 * to enumerate. 117 * 118 * \return On success, 0. Otherwise an errno value indicating the 119 * type of failure. 120 * 121 * Devices that are found are entered into the NewBus hierarchy via 122 * xenbusb_add_device(). xenbusb_add_device() ignores duplicate detects 123 * and ignores duplicate devices, so it can be called unconditionally 124 * for any device found in the XenStore. 125 * 126 * The backend XenStore hierarchy has the following format: 127 * 128 * backend/<device type>/<frontend vm id>/<device id> 129 * 130 */ 131 static int 132 xenbusb_back_enumerate_type(device_t dev, const char *type) 133 { 134 struct xenbusb_softc *xbs; 135 const char **vms; 136 u_int vm_idx; 137 u_int vm_count; 138 int error; 139 140 xbs = device_get_softc(dev); 141 error = xs_directory(XST_NIL, xbs->xbs_node, type, &vm_count, &vms); 142 if (error) 143 return (error); 144 for (vm_idx = 0; vm_idx < vm_count; vm_idx++) { 145 struct sbuf *vm_path; 146 const char *vm; 147 const char **devs; 148 u_int dev_idx; 149 u_int dev_count; 150 151 vm = vms[vm_idx]; 152 153 vm_path = xs_join(type, vm); 154 error = xs_directory(XST_NIL, xbs->xbs_node, sbuf_data(vm_path), 155 &dev_count, &devs); 156 sbuf_delete(vm_path); 157 if (error) 158 break; 159 160 for (dev_idx = 0; dev_idx < dev_count; dev_idx++) { 161 const char *dev_num; 162 struct sbuf *id; 163 164 dev_num = devs[dev_idx]; 165 id = xs_join(vm, dev_num); 166 xenbusb_add_device(dev, type, sbuf_data(id)); 167 sbuf_delete(id); 168 } 169 free(devs, M_XENSTORE); 170 } 171 172 free(vms, M_XENSTORE); 173 174 return (0); 175 } 176 177 /** 178 * \brief Determine and store the XenStore path for the other end of 179 * a split device whose local end is represented by ivars. 180 * 181 * \param dev NewBus device_t for this XenBus backend bus instance. 182 * \param ivars Instance variables from the XenBus child device for 183 * which to perform this function. 184 * 185 * \return On success, 0. Otherwise an errno value indicating the 186 * type of failure. 187 * 188 * If successful, the xd_otherend_path field of the child's instance 189 * variables will be updated. 190 * 191 */ 192 static int 193 xenbusb_back_get_otherend_node(device_t dev, struct xenbus_device_ivars *ivars) 194 { 195 char *otherend_path; 196 int error; 197 198 if (ivars->xd_otherend_path != NULL) { 199 free(ivars->xd_otherend_path, M_XENBUS); 200 ivars->xd_otherend_path = NULL; 201 } 202 203 error = xs_gather(XST_NIL, ivars->xd_node, 204 "frontend-id", "%i", &ivars->xd_otherend_id, 205 "frontend", NULL, &otherend_path, 206 NULL); 207 208 if (error == 0) { 209 ivars->xd_otherend_path = strdup(otherend_path, M_XENBUS); 210 ivars->xd_otherend_path_len = strlen(otherend_path); 211 free(otherend_path, M_XENSTORE); 212 } 213 return (error); 214 } 215 216 /** 217 * \brief Backend XenBus method implementing responses to peer state changes. 218 * 219 * \param bus The XenBus bus parent of child. 220 * \param child The XenBus child whose peer stat has changed. 221 * \param state The current state of the peer. 222 */ 223 static void 224 xenbusb_back_otherend_changed(device_t bus, device_t child, 225 enum xenbus_state peer_state) 226 { 227 /* Perform default processing of state. */ 228 xenbusb_otherend_changed(bus, child, peer_state); 229 230 /* 231 * "Online" devices are never fully detached in the 232 * newbus sense. Only the front<->back connection is 233 * torn down. If the front returns to the initialising 234 * state after closing a previous connection, signal 235 * our willingness to reconnect and that all necessary 236 * XenStore data for feature negotiation is present. 237 */ 238 if (peer_state == XenbusStateInitialising 239 && xenbus_dev_is_online(child) != 0 240 && xenbus_get_state(child) == XenbusStateClosed) 241 xenbus_set_state(child, XenbusStateInitWait); 242 } 243 244 /** 245 * \brief Backend XenBus method implementing responses to local 246 * XenStore changes. 247 * 248 * \param bus The XenBus bus parent of child. 249 * \param child The XenBus child whose peer stat has changed. 250 * \param_path The tree relative sub-path to the modified node. The empty 251 * string indicates the root of the tree was destroyed. 252 */ 253 static void 254 xenbusb_back_localend_changed(device_t bus, device_t child, const char *path) 255 { 256 257 xenbusb_localend_changed(bus, child, path); 258 259 if (strcmp(path, "/state") != 0 260 && strcmp(path, "/online") != 0) 261 return; 262 263 if (xenbus_get_state(child) != XenbusStateClosed 264 || xenbus_dev_is_online(child) != 0) 265 return; 266 267 /* 268 * Cleanup the hotplug entry in the XenStore if 269 * present. The control domain expects any userland 270 * component associated with this device to destroy 271 * this node in order to signify it is safe to 272 * teardown the device. However, not all backends 273 * rely on userland components, and those that 274 * do should either use a communication channel 275 * other than the XenStore, or ensure the hotplug 276 * data is already cleaned up. 277 * 278 * This removal ensures that no matter what path 279 * is taken to mark a back-end closed, the control 280 * domain will understand that it is closed. 281 */ 282 xs_rm(XST_NIL, xenbus_get_node(child), "hotplug-status"); 283 } 284 285 /*-------------------- Private Device Attachment Data -----------------------*/ 286 static device_method_t xenbusb_back_methods[] = { 287 /* Device interface */ 288 DEVMETHOD(device_identify, xenbusb_identify), 289 DEVMETHOD(device_probe, xenbusb_back_probe), 290 DEVMETHOD(device_attach, xenbusb_back_attach), 291 DEVMETHOD(device_detach, bus_generic_detach), 292 DEVMETHOD(device_shutdown, bus_generic_shutdown), 293 DEVMETHOD(device_suspend, bus_generic_suspend), 294 DEVMETHOD(device_resume, xenbusb_resume), 295 296 /* Bus Interface */ 297 DEVMETHOD(bus_print_child, xenbusb_print_child), 298 DEVMETHOD(bus_read_ivar, xenbusb_read_ivar), 299 DEVMETHOD(bus_write_ivar, xenbusb_write_ivar), 300 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource), 301 DEVMETHOD(bus_release_resource, bus_generic_release_resource), 302 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 303 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 304 305 /* XenBus Bus Interface */ 306 DEVMETHOD(xenbusb_enumerate_type, xenbusb_back_enumerate_type), 307 DEVMETHOD(xenbusb_get_otherend_node, xenbusb_back_get_otherend_node), 308 DEVMETHOD(xenbusb_otherend_changed, xenbusb_back_otherend_changed), 309 DEVMETHOD(xenbusb_localend_changed, xenbusb_back_localend_changed), 310 { 0, 0 } 311 }; 312 313 DEFINE_CLASS_0(xenbusb_back, xenbusb_back_driver, xenbusb_back_methods, 314 sizeof(struct xenbusb_softc)); 315 devclass_t xenbusb_back_devclass; 316 317 DRIVER_MODULE(xenbusb_back, xenstore, xenbusb_back_driver, 318 xenbusb_back_devclass, 0, 0); 319