1 #define DPRINTK(fmt, args...) \ 2 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \ 3 __func__, __LINE__, ##args) 4 5 #include <linux/kernel.h> 6 #include <linux/err.h> 7 #include <linux/string.h> 8 #include <linux/ctype.h> 9 #include <linux/fcntl.h> 10 #include <linux/mm.h> 11 #include <linux/proc_fs.h> 12 #include <linux/notifier.h> 13 #include <linux/kthread.h> 14 #include <linux/mutex.h> 15 #include <linux/io.h> 16 #include <linux/module.h> 17 18 #include <asm/page.h> 19 #include <asm/pgtable.h> 20 #include <asm/xen/hypervisor.h> 21 #include <xen/xenbus.h> 22 #include <xen/events.h> 23 #include <xen/page.h> 24 25 #include <xen/platform_pci.h> 26 27 #include "xenbus_comms.h" 28 #include "xenbus_probe.h" 29 30 31 /* device/<type>/<id> => <type>-<id> */ 32 static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename) 33 { 34 nodename = strchr(nodename, '/'); 35 if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) { 36 printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename); 37 return -EINVAL; 38 } 39 40 strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE); 41 if (!strchr(bus_id, '/')) { 42 printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id); 43 return -EINVAL; 44 } 45 *strchr(bus_id, '/') = '-'; 46 return 0; 47 } 48 49 /* device/<typename>/<name> */ 50 static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type, 51 const char *name) 52 { 53 char *nodename; 54 int err; 55 56 nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name); 57 if (!nodename) 58 return -ENOMEM; 59 60 DPRINTK("%s", nodename); 61 62 err = xenbus_probe_node(bus, type, nodename); 63 kfree(nodename); 64 return err; 65 } 66 67 static int xenbus_uevent_frontend(struct device *_dev, 68 struct kobj_uevent_env *env) 69 { 70 struct xenbus_device *dev = to_xenbus_device(_dev); 71 72 if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype)) 73 return -ENOMEM; 74 75 return 0; 76 } 77 78 79 static void backend_changed(struct xenbus_watch *watch, 80 const char **vec, unsigned int len) 81 { 82 xenbus_otherend_changed(watch, vec, len, 1); 83 } 84 85 static const struct dev_pm_ops xenbus_pm_ops = { 86 .suspend = xenbus_dev_suspend, 87 .resume = xenbus_dev_resume, 88 .freeze = xenbus_dev_suspend, 89 .thaw = xenbus_dev_cancel, 90 .restore = xenbus_dev_resume, 91 }; 92 93 static struct xen_bus_type xenbus_frontend = { 94 .root = "device", 95 .levels = 2, /* device/type/<id> */ 96 .get_bus_id = frontend_bus_id, 97 .probe = xenbus_probe_frontend, 98 .otherend_changed = backend_changed, 99 .bus = { 100 .name = "xen", 101 .match = xenbus_match, 102 .uevent = xenbus_uevent_frontend, 103 .probe = xenbus_dev_probe, 104 .remove = xenbus_dev_remove, 105 .shutdown = xenbus_dev_shutdown, 106 .dev_attrs = xenbus_dev_attrs, 107 108 .pm = &xenbus_pm_ops, 109 }, 110 }; 111 112 static void frontend_changed(struct xenbus_watch *watch, 113 const char **vec, unsigned int len) 114 { 115 DPRINTK(""); 116 117 xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend); 118 } 119 120 121 /* We watch for devices appearing and vanishing. */ 122 static struct xenbus_watch fe_watch = { 123 .node = "device", 124 .callback = frontend_changed, 125 }; 126 127 static int read_backend_details(struct xenbus_device *xendev) 128 { 129 return xenbus_read_otherend_details(xendev, "backend-id", "backend"); 130 } 131 132 static int is_device_connecting(struct device *dev, void *data) 133 { 134 struct xenbus_device *xendev = to_xenbus_device(dev); 135 struct device_driver *drv = data; 136 struct xenbus_driver *xendrv; 137 138 /* 139 * A device with no driver will never connect. We care only about 140 * devices which should currently be in the process of connecting. 141 */ 142 if (!dev->driver) 143 return 0; 144 145 /* Is this search limited to a particular driver? */ 146 if (drv && (dev->driver != drv)) 147 return 0; 148 149 xendrv = to_xenbus_driver(dev->driver); 150 return (xendev->state < XenbusStateConnected || 151 (xendev->state == XenbusStateConnected && 152 xendrv->is_ready && !xendrv->is_ready(xendev))); 153 } 154 155 static int exists_connecting_device(struct device_driver *drv) 156 { 157 return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv, 158 is_device_connecting); 159 } 160 161 static int print_device_status(struct device *dev, void *data) 162 { 163 struct xenbus_device *xendev = to_xenbus_device(dev); 164 struct device_driver *drv = data; 165 166 /* Is this operation limited to a particular driver? */ 167 if (drv && (dev->driver != drv)) 168 return 0; 169 170 if (!dev->driver) { 171 /* Information only: is this too noisy? */ 172 printk(KERN_INFO "XENBUS: Device with no driver: %s\n", 173 xendev->nodename); 174 } else if (xendev->state < XenbusStateConnected) { 175 enum xenbus_state rstate = XenbusStateUnknown; 176 if (xendev->otherend) 177 rstate = xenbus_read_driver_state(xendev->otherend); 178 printk(KERN_WARNING "XENBUS: Timeout connecting " 179 "to device: %s (local state %d, remote state %d)\n", 180 xendev->nodename, xendev->state, rstate); 181 } 182 183 return 0; 184 } 185 186 /* We only wait for device setup after most initcalls have run. */ 187 static int ready_to_wait_for_devices; 188 189 /* 190 * On a 5-minute timeout, wait for all devices currently configured. We need 191 * to do this to guarantee that the filesystems and / or network devices 192 * needed for boot are available, before we can allow the boot to proceed. 193 * 194 * This needs to be on a late_initcall, to happen after the frontend device 195 * drivers have been initialised, but before the root fs is mounted. 196 * 197 * A possible improvement here would be to have the tools add a per-device 198 * flag to the store entry, indicating whether it is needed at boot time. 199 * This would allow people who knew what they were doing to accelerate their 200 * boot slightly, but of course needs tools or manual intervention to set up 201 * those flags correctly. 202 */ 203 static void wait_for_devices(struct xenbus_driver *xendrv) 204 { 205 unsigned long start = jiffies; 206 struct device_driver *drv = xendrv ? &xendrv->driver : NULL; 207 unsigned int seconds_waited = 0; 208 209 if (!ready_to_wait_for_devices || !xen_domain()) 210 return; 211 212 while (exists_connecting_device(drv)) { 213 if (time_after(jiffies, start + (seconds_waited+5)*HZ)) { 214 if (!seconds_waited) 215 printk(KERN_WARNING "XENBUS: Waiting for " 216 "devices to initialise: "); 217 seconds_waited += 5; 218 printk("%us...", 300 - seconds_waited); 219 if (seconds_waited == 300) 220 break; 221 } 222 223 schedule_timeout_interruptible(HZ/10); 224 } 225 226 if (seconds_waited) 227 printk("\n"); 228 229 bus_for_each_dev(&xenbus_frontend.bus, NULL, drv, 230 print_device_status); 231 } 232 233 int __xenbus_register_frontend(struct xenbus_driver *drv, 234 struct module *owner, const char *mod_name) 235 { 236 int ret; 237 238 drv->read_otherend_details = read_backend_details; 239 240 ret = xenbus_register_driver_common(drv, &xenbus_frontend, 241 owner, mod_name); 242 if (ret) 243 return ret; 244 245 /* If this driver is loaded as a module wait for devices to attach. */ 246 wait_for_devices(drv); 247 248 return 0; 249 } 250 EXPORT_SYMBOL_GPL(__xenbus_register_frontend); 251 252 static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq); 253 static int backend_state; 254 255 static void xenbus_reset_backend_state_changed(struct xenbus_watch *w, 256 const char **v, unsigned int l) 257 { 258 xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &backend_state); 259 printk(KERN_DEBUG "XENBUS: backend %s %s\n", 260 v[XS_WATCH_PATH], xenbus_strstate(backend_state)); 261 wake_up(&backend_state_wq); 262 } 263 264 static void xenbus_reset_wait_for_backend(char *be, int expected) 265 { 266 long timeout; 267 timeout = wait_event_interruptible_timeout(backend_state_wq, 268 backend_state == expected, 5 * HZ); 269 if (timeout <= 0) 270 printk(KERN_INFO "XENBUS: backend %s timed out.\n", be); 271 } 272 273 /* 274 * Reset frontend if it is in Connected or Closed state. 275 * Wait for backend to catch up. 276 * State Connected happens during kdump, Closed after kexec. 277 */ 278 static void xenbus_reset_frontend(char *fe, char *be, int be_state) 279 { 280 struct xenbus_watch be_watch; 281 282 printk(KERN_DEBUG "XENBUS: backend %s %s\n", 283 be, xenbus_strstate(be_state)); 284 285 memset(&be_watch, 0, sizeof(be_watch)); 286 be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", be); 287 if (!be_watch.node) 288 return; 289 290 be_watch.callback = xenbus_reset_backend_state_changed; 291 backend_state = XenbusStateUnknown; 292 293 printk(KERN_INFO "XENBUS: triggering reconnect on %s\n", be); 294 register_xenbus_watch(&be_watch); 295 296 /* fall through to forward backend to state XenbusStateInitialising */ 297 switch (be_state) { 298 case XenbusStateConnected: 299 xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosing); 300 xenbus_reset_wait_for_backend(be, XenbusStateClosing); 301 302 case XenbusStateClosing: 303 xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosed); 304 xenbus_reset_wait_for_backend(be, XenbusStateClosed); 305 306 case XenbusStateClosed: 307 xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateInitialising); 308 xenbus_reset_wait_for_backend(be, XenbusStateInitWait); 309 } 310 311 unregister_xenbus_watch(&be_watch); 312 printk(KERN_INFO "XENBUS: reconnect done on %s\n", be); 313 kfree(be_watch.node); 314 } 315 316 static void xenbus_check_frontend(char *class, char *dev) 317 { 318 int be_state, fe_state, err; 319 char *backend, *frontend; 320 321 frontend = kasprintf(GFP_NOIO | __GFP_HIGH, "device/%s/%s", class, dev); 322 if (!frontend) 323 return; 324 325 err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &fe_state); 326 if (err != 1) 327 goto out; 328 329 switch (fe_state) { 330 case XenbusStateConnected: 331 case XenbusStateClosed: 332 printk(KERN_DEBUG "XENBUS: frontend %s %s\n", 333 frontend, xenbus_strstate(fe_state)); 334 backend = xenbus_read(XBT_NIL, frontend, "backend", NULL); 335 if (!backend || IS_ERR(backend)) 336 goto out; 337 err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &be_state); 338 if (err == 1) 339 xenbus_reset_frontend(frontend, backend, be_state); 340 kfree(backend); 341 break; 342 default: 343 break; 344 } 345 out: 346 kfree(frontend); 347 } 348 349 static void xenbus_reset_state(void) 350 { 351 char **devclass, **dev; 352 int devclass_n, dev_n; 353 int i, j; 354 355 devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n); 356 if (IS_ERR(devclass)) 357 return; 358 359 for (i = 0; i < devclass_n; i++) { 360 dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n); 361 if (IS_ERR(dev)) 362 continue; 363 for (j = 0; j < dev_n; j++) 364 xenbus_check_frontend(devclass[i], dev[j]); 365 kfree(dev); 366 } 367 kfree(devclass); 368 } 369 370 static int frontend_probe_and_watch(struct notifier_block *notifier, 371 unsigned long event, 372 void *data) 373 { 374 /* reset devices in Connected or Closed state */ 375 if (xen_hvm_domain()) 376 xenbus_reset_state(); 377 /* Enumerate devices in xenstore and watch for changes. */ 378 xenbus_probe_devices(&xenbus_frontend); 379 register_xenbus_watch(&fe_watch); 380 381 return NOTIFY_DONE; 382 } 383 384 385 static int __init xenbus_probe_frontend_init(void) 386 { 387 static struct notifier_block xenstore_notifier = { 388 .notifier_call = frontend_probe_and_watch 389 }; 390 int err; 391 392 DPRINTK(""); 393 394 /* Register ourselves with the kernel bus subsystem */ 395 err = bus_register(&xenbus_frontend.bus); 396 if (err) 397 return err; 398 399 register_xenstore_notifier(&xenstore_notifier); 400 401 return 0; 402 } 403 subsys_initcall(xenbus_probe_frontend_init); 404 405 #ifndef MODULE 406 static int __init boot_wait_for_devices(void) 407 { 408 if (xen_hvm_domain() && !xen_platform_pci_unplug) 409 return -ENODEV; 410 411 ready_to_wait_for_devices = 1; 412 wait_for_devices(NULL); 413 return 0; 414 } 415 416 late_initcall(boot_wait_for_devices); 417 #endif 418 419 MODULE_LICENSE("GPL"); 420