1 files changed, 21 insertions, 185 deletions

diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c
index 3159a37d966..ed2ba474a56 100644
--- a/drivers/xen/xenbus/xenbus_probe_frontend.c
+++ b/drivers/xen/xenbus/xenbus_probe_frontend.c
@@ -13,7 +13,6 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/io.h>
-#include <linux/module.h>
 
 #include <asm/page.h>
 #include <asm/pgtable.h>
@@ -21,7 +20,6 @@
 #include <xen/xenbus.h>
 #include <xen/events.h>
 #include <xen/page.h>
-#include <xen/xen.h>
 
 #include <xen/platform_pci.h>
 
@@ -54,12 +52,6 @@ static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type,
         char *nodename;
         int err;
 
-        /* ignore console/0 */
-        if (!strncmp(type, "console", 7) && !strncmp(name, "0", 1)) {
-                DPRINTK("Ignoring buggy device entry console/0");
-                return 0;
-        }
-
         nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name);
         if (!nodename)
                 return -ENOMEM;
@@ -136,7 +128,7 @@ static int read_backend_details(struct xenbus_device *xendev)
         return xenbus_read_otherend_details(xendev, "backend-id", "backend");
 }
 
-static int is_device_connecting(struct device *dev, void *data, bool ignore_nonessential)
+static int is_device_connecting(struct device *dev, void *data)
 {
         struct xenbus_device *xendev = to_xenbus_device(dev);
         struct device_driver *drv = data;
@@ -153,41 +145,16 @@ static int is_device_connecting(struct device *dev, void *data, bool ignore_none
         if (drv && (dev->driver != drv))
                 return 0;
 
-        if (ignore_nonessential) {
-                /* With older QEMU, for PVonHVM guests the guest config files
-                 * could contain: vfb = [ 'vnc=1, vnclisten=0.0.0.0']
-                 * which is nonsensical as there is no PV FB (there can be
-                 * a PVKB) running as HVM guest. */
-
-                if ((strncmp(xendev->nodename, "device/vkbd", 11) == 0))
-                        return 0;
-
-                if ((strncmp(xendev->nodename, "device/vfb", 10) == 0))
-                        return 0;
-        }
         xendrv = to_xenbus_driver(dev->driver);
         return (xendev->state < XenbusStateConnected ||
                 (xendev->state == XenbusStateConnected &&
                  xendrv->is_ready && !xendrv->is_ready(xendev)));
 }
-static int essential_device_connecting(struct device *dev, void *data)
-{
-        return is_device_connecting(dev, data, true /* ignore PV[KBB+FB] */);
-}
-static int non_essential_device_connecting(struct device *dev, void *data)
-{
-        return is_device_connecting(dev, data, false);
-}
 
-static int exists_essential_connecting_device(struct device_driver *drv)
+static int exists_connecting_device(struct device_driver *drv)
 {
         return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                                essential_device_connecting);
-}
-static int exists_non_essential_connecting_device(struct device_driver *drv)
-{
-        return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                                non_essential_device_connecting);
+                                is_device_connecting);
 }
 
 static int print_device_status(struct device *dev, void *data)
@@ -218,23 +185,6 @@ static int print_device_status(struct device *dev, void *data)
 /* We only wait for device setup after most initcalls have run. */
 static int ready_to_wait_for_devices;
 
-static bool wait_loop(unsigned long start, unsigned int max_delay,
-                     unsigned int *seconds_waited)
-{
-        if (time_after(jiffies, start + (*seconds_waited+5)*HZ)) {
-                if (!*seconds_waited)
-                        printk(KERN_WARNING "XENBUS: Waiting for "
-                               "devices to initialise: ");
-                *seconds_waited += 5;
-                printk("%us...", max_delay - *seconds_waited);
-                if (*seconds_waited == max_delay)
-                        return true;
-        }
-
-        schedule_timeout_interruptible(HZ/10);
-
-        return false;
-}
 /*
  * On a 5-minute timeout, wait for all devices currently configured.  We need
  * to do this to guarantee that the filesystems and / or network devices
@@ -258,14 +208,19 @@ static void wait_for_devices(struct xenbus_driver *xendrv)
         if (!ready_to_wait_for_devices || !xen_domain())
                 return;
 
-        while (exists_non_essential_connecting_device(drv))
-                if (wait_loop(start, 30, &seconds_waited))
-                        break;
-
-        /* Skips PVKB and PVFB check.*/
-        while (exists_essential_connecting_device(drv))
-                if (wait_loop(start, 270, &seconds_waited))
-                        break;
+        while (exists_connecting_device(drv)) {
+                if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
+                        if (!seconds_waited)
+                                printk(KERN_WARNING "XENBUS: Waiting for "
+                                       "devices to initialise: ");
+                        seconds_waited += 5;
+                        printk("%us...", 300 - seconds_waited);
+                        if (seconds_waited == 300)
+                                break;
+                }
+
+                schedule_timeout_interruptible(HZ/10);
+        }
 
         if (seconds_waited)
                 printk("\n");
@@ -274,13 +229,15 @@ static void wait_for_devices(struct xenbus_driver *xendrv)
                          print_device_status);
 }
 
-int xenbus_register_frontend(struct xenbus_driver *drv)
+int __xenbus_register_frontend(struct xenbus_driver *drv,
+                               struct module *owner, const char *mod_name)
 {
         int ret;
 
         drv->read_otherend_details = read_backend_details;
 
-        ret = xenbus_register_driver_common(drv, &xenbus_frontend);
+        ret = xenbus_register_driver_common(drv, &xenbus_frontend,
+                                            owner, mod_name);
         if (ret)
                 return ret;
 
@@ -289,133 +246,12 @@ int xenbus_register_frontend(struct xenbus_driver *drv)
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(xenbus_register_frontend);
-
-static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq);
-static int backend_state;
-
-static void xenbus_reset_backend_state_changed(struct xenbus_watch *w,
-                                        const char **v, unsigned int l)
-{
-        xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &backend_state);
-        printk(KERN_DEBUG "XENBUS: backend %s %s\n",
-                        v[XS_WATCH_PATH], xenbus_strstate(backend_state));
-        wake_up(&backend_state_wq);
-}
-
-static void xenbus_reset_wait_for_backend(char *be, int expected)
-{
-        long timeout;
-        timeout = wait_event_interruptible_timeout(backend_state_wq,
-                        backend_state == expected, 5 * HZ);
-        if (timeout <= 0)
-                printk(KERN_INFO "XENBUS: backend %s timed out.\n", be);
-}
-
-/*
- * Reset frontend if it is in Connected or Closed state.
- * Wait for backend to catch up.
- * State Connected happens during kdump, Closed after kexec.
- */
-static void xenbus_reset_frontend(char *fe, char *be, int be_state)
-{
-        struct xenbus_watch be_watch;
-
-        printk(KERN_DEBUG "XENBUS: backend %s %s\n",
-                        be, xenbus_strstate(be_state));
-
-        memset(&be_watch, 0, sizeof(be_watch));
-        be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", be);
-        if (!be_watch.node)
-                return;
-
-        be_watch.callback = xenbus_reset_backend_state_changed;
-        backend_state = XenbusStateUnknown;
-
-        printk(KERN_INFO "XENBUS: triggering reconnect on %s\n", be);
-        register_xenbus_watch(&be_watch);
-
-        /* fall through to forward backend to state XenbusStateInitialising */
-        switch (be_state) {
-        case XenbusStateConnected:
-                xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosing);
-                xenbus_reset_wait_for_backend(be, XenbusStateClosing);
-
-        case XenbusStateClosing:
-                xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosed);
-                xenbus_reset_wait_for_backend(be, XenbusStateClosed);
-
-        case XenbusStateClosed:
-                xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateInitialising);
-                xenbus_reset_wait_for_backend(be, XenbusStateInitWait);
-        }
-
-        unregister_xenbus_watch(&be_watch);
-        printk(KERN_INFO "XENBUS: reconnect done on %s\n", be);
-        kfree(be_watch.node);
-}
-
-static void xenbus_check_frontend(char *class, char *dev)
-{
-        int be_state, fe_state, err;
-        char *backend, *frontend;
-
-        frontend = kasprintf(GFP_NOIO | __GFP_HIGH, "device/%s/%s", class, dev);
-        if (!frontend)
-                return;
-
-        err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &fe_state);
-        if (err != 1)
-                goto out;
-
-        switch (fe_state) {
-        case XenbusStateConnected:
-        case XenbusStateClosed:
-                printk(KERN_DEBUG "XENBUS: frontend %s %s\n",
-                                frontend, xenbus_strstate(fe_state));
-                backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
-                if (!backend || IS_ERR(backend))
-                        goto out;
-                err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &be_state);
-                if (err == 1)
-                        xenbus_reset_frontend(frontend, backend, be_state);
-                kfree(backend);
-                break;
-        default:
-                break;
-        }
-out:
-        kfree(frontend);
-}
-
-static void xenbus_reset_state(void)
-{
-        char **devclass, **dev;
-        int devclass_n, dev_n;
-        int i, j;
-
-        devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
-        if (IS_ERR(devclass))
-                return;
-
-        for (i = 0; i < devclass_n; i++) {
-                dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
-                if (IS_ERR(dev))
-                        continue;
-                for (j = 0; j < dev_n; j++)
-                        xenbus_check_frontend(devclass[i], dev[j]);
-                kfree(dev);
-        }
-        kfree(devclass);
-}
+EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
 
 static int frontend_probe_and_watch(struct notifier_block *notifier,
                                    unsigned long event,
                                    void *data)
 {
-        /* reset devices in Connected or Closed state */
-        if (xen_hvm_domain())
-                xenbus_reset_state();
         /* Enumerate devices in xenstore and watch for changes. */
         xenbus_probe_devices(&xenbus_frontend);
         register_xenbus_watch(&fe_watch);