/* * Callback received when the frontend's state changes. */ static void frontend_changed(struct xenbus_device *dev, enum xenbus_state frontend_state) { struct backend_info *be = dev_get_drvdata(&dev->dev); int err; DPRINTK("%s", xenbus_strstate(frontend_state)); switch (frontend_state) { case XenbusStateInitialising: if (dev->state == XenbusStateClosed) { pr_info(DRV_PFX "%s: prepare for reconnect\n", dev->nodename); xenbus_switch_state(dev, XenbusStateInitWait); } break; case XenbusStateInitialised: case XenbusStateConnected: /* * Ensure we connect even when two watches fire in * close succession and we miss the intermediate value * of frontend_state. */ if (dev->state == XenbusStateConnected) break; /* * Enforce precondition before potential leak point. * xen_blkif_disconnect() is idempotent. */ xen_blkif_disconnect(be->blkif); err = connect_ring(be); if (err) break; xen_update_blkif_status(be->blkif); break; case XenbusStateClosing: xenbus_switch_state(dev, XenbusStateClosing); break; case XenbusStateClosed: xen_blkif_disconnect(be->blkif); xenbus_switch_state(dev, XenbusStateClosed); if (xenbus_dev_is_online(dev)) break; /* fall through if not online */ case XenbusStateUnknown: /* implies xen_blkif_disconnect() via xen_blkbk_remove() */ device_unregister(&dev->dev); break; default: xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend", frontend_state); break; } }
/* * Callback received when the hotplug scripts have placed the physical-device * node. Read it and the mode node, and create a vbd. If the frontend is * ready, connect. */ static void backend_changed(struct xenbus_watch *watch, const char **vec, unsigned int len) { int err; unsigned major; unsigned minor; struct backend_info *be = container_of(watch, struct backend_info, backend_watch); struct xenbus_device *dev = be->dev; int cdrom = 0; unsigned long handle; char *device_type; DPRINTK(""); err = xenbus_scanf(XBT_NIL, dev->nodename, "physical-device", "%x:%x", &major, &minor); if (XENBUS_EXIST_ERR(err)) { /* * Since this watch will fire once immediately after it is * registered, we expect this. Ignore it, and wait for the * hotplug scripts. */ return; } if (err != 2) { xenbus_dev_fatal(dev, err, "reading physical-device"); return; } if (be->major | be->minor) { if (be->major != major || be->minor != minor) pr_warn(DRV_PFX "changing physical device (from %x:%x to %x:%x) not supported.\n", be->major, be->minor, major, minor); return; } be->mode = xenbus_read(XBT_NIL, dev->nodename, "mode", NULL); if (IS_ERR(be->mode)) { err = PTR_ERR(be->mode); be->mode = NULL; xenbus_dev_fatal(dev, err, "reading mode"); return; } device_type = xenbus_read(XBT_NIL, dev->otherend, "device-type", NULL); if (!IS_ERR(device_type)) { cdrom = strcmp(device_type, "cdrom") == 0; kfree(device_type); } /* Front end dir is a number, which is used as the handle. */ err = strict_strtoul(strrchr(dev->otherend, '/') + 1, 0, &handle); if (err) return; be->major = major; be->minor = minor; err = xen_vbd_create(be->blkif, handle, major, minor, !strchr(be->mode, 'w'), cdrom); if (err) xenbus_dev_fatal(dev, err, "creating vbd structure"); else { err = xenvbd_sysfs_addif(dev); if (err) { xen_vbd_free(&be->blkif->vbd); xenbus_dev_fatal(dev, err, "creating sysfs entries"); } } if (err) { kfree(be->mode); be->mode = NULL; be->major = 0; be->minor = 0; } else { /* We're potentially connected now */ xen_update_blkif_status(be->blkif); } }