Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

2 files changed, 36 insertions, 16 deletions

diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index 92a1ef80a288..7b3e973a1aee 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -30,6 +30,7 @@
  * IN THE SOFTWARE.
  */
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/vmalloc.h>
 #include <asm/xen/hypervisor.h>
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index d42e25d5968d..3479332113e9 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -45,10 +45,13 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/xen/hypervisor.h>
+
+#include <xen/xen.h>
 #include <xen/xenbus.h>
 #include <xen/events.h>
 #include <xen/page.h>
@@ -454,21 +457,21 @@ static ssize_t xendev_show_nodename(struct device *dev,
 {
         return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);
 }
-DEVICE_ATTR(nodename, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_nodename, NULL);
+static DEVICE_ATTR(nodename, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_nodename, NULL);
 
 static ssize_t xendev_show_devtype(struct device *dev,
                                    struct device_attribute *attr, char *buf)
 {
         return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);
 }
-DEVICE_ATTR(devtype, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_devtype, NULL);
+static DEVICE_ATTR(devtype, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_devtype, NULL);
 
 static ssize_t xendev_show_modalias(struct device *dev,
                                     struct device_attribute *attr, char *buf)
 {
         return sprintf(buf, "xen:%s\n", to_xenbus_device(dev)->devicetype);
 }
-DEVICE_ATTR(modalias, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_modalias, NULL);
+static DEVICE_ATTR(modalias, S_IRUSR | S_IRGRP | S_IROTH, xendev_show_modalias, NULL);
 
 int xenbus_probe_node(struct xen_bus_type *bus,
                       const char *type,
@@ -843,7 +846,7 @@ postcore_initcall(xenbus_probe_init);
 
 MODULE_LICENSE("GPL");
 
-static int is_disconnected_device(struct device *dev, void *data)
+static int is_device_connecting(struct device *dev, void *data)
 {
         struct xenbus_device *xendev = to_xenbus_device(dev);
         struct device_driver *drv = data;
@@ -861,14 +864,15 @@ static int is_disconnected_device(struct device *dev, void *data)
                 return 0;
 
         xendrv = to_xenbus_driver(dev->driver);
-        return (xendev->state != XenbusStateConnected ||
-                (xendrv->is_ready && !xendrv->is_ready(xendev)));
+        return (xendev->state < XenbusStateConnected ||
+                (xendev->state == XenbusStateConnected &&
+                 xendrv->is_ready && !xendrv->is_ready(xendev)));
 }
 
-static int exists_disconnected_device(struct device_driver *drv)
+static int exists_connecting_device(struct device_driver *drv)
 {
         return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                                is_disconnected_device);
+                                is_device_connecting);
 }
 
 static int print_device_status(struct device *dev, void *data)
@@ -884,10 +888,13 @@ static int print_device_status(struct device *dev, void *data)
                 /* Information only: is this too noisy? */
                 printk(KERN_INFO "XENBUS: Device with no driver: %s\n",
                        xendev->nodename);
-        } else if (xendev->state != XenbusStateConnected) {
+        } else if (xendev->state < XenbusStateConnected) {
+                enum xenbus_state rstate = XenbusStateUnknown;
+                if (xendev->otherend)
+                        rstate = xenbus_read_driver_state(xendev->otherend);
                 printk(KERN_WARNING "XENBUS: Timeout connecting "
-                       "to device: %s (state %d)\n",
-                       xendev->nodename, xendev->state);
+                       "to device: %s (local state %d, remote state %d)\n",
+                       xendev->nodename, xendev->state, rstate);
         }
 
         return 0;
@@ -897,7 +904,7 @@ static int print_device_status(struct device *dev, void *data)
 static int ready_to_wait_for_devices;
 
 /*
- * On a 10 second timeout, wait for all devices currently configured.  We need
+ * 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
  * needed for boot are available, before we can allow the boot to proceed.
  *
@@ -912,18 +919,30 @@ static int ready_to_wait_for_devices;
  */
 static void wait_for_devices(struct xenbus_driver *xendrv)
 {
-        unsigned long timeout = jiffies + 10*HZ;
+        unsigned long start = jiffies;
         struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
+        unsigned int seconds_waited = 0;
 
         if (!ready_to_wait_for_devices || !xen_domain())
                 return;
 
-        while (exists_disconnected_device(drv)) {
-                if (time_after(jiffies, timeout))
-                        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");
+
         bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
                          print_device_status);
 }