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

13 files changed, 100 insertions, 66 deletions

diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index cab100acf983..fad3df2c1276 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -1,6 +1,8 @@
+menu "Xen driver support"
+        depends on XEN
+
 config XEN_BALLOON
         bool "Xen memory balloon driver"
-        depends on XEN
         default y
         help
           The balloon driver allows the Xen domain to request more memory from
@@ -20,7 +22,6 @@ config XEN_SCRUB_PAGES
 
 config XEN_DEV_EVTCHN
         tristate "Xen /dev/xen/evtchn device"
-        depends on XEN
         default y
         help
           The evtchn driver allows a userspace process to triger event
@@ -30,7 +31,6 @@ config XEN_DEV_EVTCHN
 
 config XENFS
         tristate "Xen filesystem"
-        depends on XEN
         default y
         help
           The xen filesystem provides a way for domains to share
@@ -53,11 +53,13 @@ config XEN_COMPAT_XENFS
 
 config XEN_SYS_HYPERVISOR
        bool "Create xen entries under /sys/hypervisor"
-       depends on XEN && SYSFS
+       depends on SYSFS
        select SYS_HYPERVISOR
        default y
        help
          Create entries under /sys/hypervisor describing the Xen
          hypervisor environment.  When running native or in another
          virtual environment, /sys/hypervisor will still be present,
-         but will have no xen contents.
\ No newline at end of file
+         but will have no xen contents.
+
+endmenu
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index d31505b6f7a4..1a0d8c2a0354 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -43,6 +43,7 @@
 #include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/sysdev.h>
+#include <linux/gfp.h>
 
 #include <asm/page.h>
 #include <asm/pgalloc.h>
@@ -52,6 +53,8 @@
 
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
+
+#include <xen/xen.h>
 #include <xen/interface/xen.h>
 #include <xen/interface/memory.h>
 #include <xen/xenbus.h>
@@ -66,8 +69,6 @@ struct balloon_stats {
         /* We aim for 'current allocation' == 'target allocation'. */
         unsigned long current_pages;
         unsigned long target_pages;
-        /* We may hit the hard limit in Xen. If we do then we remember it. */
-        unsigned long hard_limit;
         /*
          * Drivers may alter the memory reservation independently, but they
          * must inform the balloon driver so we avoid hitting the hard limit.
@@ -136,6 +137,8 @@ static void balloon_append(struct page *page)
                 list_add(&page->lru, &ballooned_pages);
                 balloon_stats.balloon_low++;
         }
+
+        totalram_pages--;
 }
 
 /* balloon_retrieve: rescue a page from the balloon, if it is not empty. */
@@ -156,6 +159,8 @@ static struct page *balloon_retrieve(void)
         else
                 balloon_stats.balloon_low--;
 
+        totalram_pages++;
+
         return page;
 }
 
@@ -181,7 +186,7 @@ static void balloon_alarm(unsigned long unused)
 
 static unsigned long current_target(void)
 {
-        unsigned long target = min(balloon_stats.target_pages, balloon_stats.hard_limit);
+        unsigned long target = balloon_stats.target_pages;
 
         target = min(target,
                      balloon_stats.current_pages +
@@ -217,23 +222,10 @@ static int increase_reservation(unsigned long nr_pages)
         set_xen_guest_handle(reservation.extent_start, frame_list);
         reservation.nr_extents = nr_pages;
         rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation);
-        if (rc < nr_pages) {
-                if (rc > 0) {
-                        int ret;
-
-                        /* We hit the Xen hard limit: reprobe. */
-                        reservation.nr_extents = rc;
-                        ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
-                                                   &reservation);
-                        BUG_ON(ret != rc);
-                }
-                if (rc >= 0)
-                        balloon_stats.hard_limit = (balloon_stats.current_pages + rc -
-                                                    balloon_stats.driver_pages);
+        if (rc < 0)
                 goto out;
-        }
 
-        for (i = 0; i < nr_pages; i++) {
+        for (i = 0; i < rc; i++) {
                 page = balloon_retrieve();
                 BUG_ON(page == NULL);
 
@@ -259,13 +251,12 @@ static int increase_reservation(unsigned long nr_pages)
                 __free_page(page);
         }
 
-        balloon_stats.current_pages += nr_pages;
-        totalram_pages = balloon_stats.current_pages;
+        balloon_stats.current_pages += rc;
 
  out:
         spin_unlock_irqrestore(&balloon_lock, flags);
 
-        return 0;
+        return rc < 0 ? rc : rc != nr_pages;
 }
 
 static int decrease_reservation(unsigned long nr_pages)
@@ -323,7 +314,6 @@ static int decrease_reservation(unsigned long nr_pages)
         BUG_ON(ret != nr_pages);
 
         balloon_stats.current_pages -= nr_pages;
-        totalram_pages = balloon_stats.current_pages;
 
         spin_unlock_irqrestore(&balloon_lock, flags);
 
@@ -367,7 +357,6 @@ static void balloon_process(struct work_struct *work)
 static void balloon_set_new_target(unsigned long target)
 {
         /* No need for lock. Not read-modify-write updates. */
-        balloon_stats.hard_limit   = ~0UL;
         balloon_stats.target_pages = target;
         schedule_work(&balloon_worker);
 }
@@ -422,12 +411,10 @@ static int __init balloon_init(void)
         pr_info("xen_balloon: Initialising balloon driver.\n");
 
         balloon_stats.current_pages = min(xen_start_info->nr_pages, max_pfn);
-        totalram_pages   = balloon_stats.current_pages;
         balloon_stats.target_pages  = balloon_stats.current_pages;
         balloon_stats.balloon_low   = 0;
         balloon_stats.balloon_high  = 0;
         balloon_stats.driver_pages  = 0UL;
-        balloon_stats.hard_limit    = ~0UL;
 
         init_timer(&balloon_timer);
         balloon_timer.data = 0;
@@ -472,9 +459,6 @@ module_exit(balloon_exit);
 BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages));
 BALLOON_SHOW(low_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_low));
 BALLOON_SHOW(high_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_high));
-BALLOON_SHOW(hard_limit_kb,
-             (balloon_stats.hard_limit!=~0UL) ? "%lu\n" : "???\n",
-             (balloon_stats.hard_limit!=~0UL) ? PAGES2KB(balloon_stats.hard_limit) : 0);
 BALLOON_SHOW(driver_kb, "%lu\n", PAGES2KB(balloon_stats.driver_pages));
 
 static ssize_t show_target_kb(struct sys_device *dev, struct sysdev_attribute *attr,
@@ -544,7 +528,6 @@ static struct attribute *balloon_info_attrs[] = {
         &attr_current_kb.attr,
         &attr_low_kb.attr,
         &attr_high_kb.attr,
-        &attr_hard_limit_kb.attr,
         &attr_driver_kb.attr,
         NULL
 };
diff --git a/drivers/xen/cpu_hotplug.c b/drivers/xen/cpu_hotplug.c
index bdfd584ad853..14e2d995e958 100644
--- a/drivers/xen/cpu_hotplug.c
+++ b/drivers/xen/cpu_hotplug.c
@@ -1,5 +1,6 @@
 #include <linux/notifier.h>
 
+#include <xen/xen.h>
 #include <xen/xenbus.h>
 
 #include <asm/xen/hypervisor.h>
@@ -86,7 +87,7 @@ static int setup_cpu_watcher(struct notifier_block *notifier,
         for_each_possible_cpu(cpu) {
                 if (vcpu_online(cpu) == 0) {
                         (void)cpu_down(cpu);
-                        cpu_clear(cpu, cpu_present_map);
+                        set_cpu_present(cpu, false);
                 }
         }
 
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 2f57276e87a2..db8f506817f0 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -27,6 +27,7 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/bootmem.h>
+#include <linux/slab.h>
 
 #include <asm/ptrace.h>
 #include <asm/irq.h>
@@ -474,6 +475,9 @@ static void unbind_from_irq(unsigned int irq)
                 bind_evtchn_to_cpu(evtchn, 0);
 
                 evtchn_to_irq[evtchn] = -1;
+        }
+
+        if (irq_info[irq].type != IRQT_UNBOUND) {
                 irq_info[irq] = mk_unbound_info();
 
                 dynamic_irq_cleanup(irq);
@@ -646,9 +650,13 @@ void xen_evtchn_do_upcall(struct pt_regs *regs)
                                 int bit_idx = __ffs(pending_bits);
                                 int port = (word_idx * BITS_PER_LONG) + bit_idx;
                                 int irq = evtchn_to_irq[port];
+                                struct irq_desc *desc;
 
-                                if (irq != -1)
-                                        handle_irq(irq, regs);
+                                if (irq != -1) {
+                                        desc = irq_to_desc(irq);
+                                        if (desc)
+                                                generic_handle_irq_desc(irq, desc);
+                                }
                         }
                 }
 
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index 79bedba44fee..66e185cfe92f 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -45,9 +45,10 @@
 #include <linux/poll.h>
 #include <linux/irq.h>
 #include <linux/init.h>
-#include <linux/gfp.h>
 #include <linux/mutex.h>
 #include <linux/cpu.h>
+
+#include <xen/xen.h>
 #include <xen/events.h>
 #include <xen/evtchn.h>
 #include <asm/xen/hypervisor.h>
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index 7d8f531fb8e8..f66db3b91d61 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -34,9 +34,11 @@
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/uaccess.h>
 
+#include <xen/xen.h>
 #include <xen/interface/xen.h>
 #include <xen/page.h>
 #include <xen/grant_table.h>
diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c
index 10d03d7931c4..2ac4440e7b08 100644
--- a/drivers/xen/manage.c
+++ b/drivers/xen/manage.c
@@ -3,6 +3,7 @@
  */
 #include <linux/kernel.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 #include <linux/reboot.h>
 #include <linux/sysrq.h>
 #include <linux/stop_machine.h>
@@ -43,7 +44,6 @@ static int xen_suspend(void *data)
         if (err) {
                 printk(KERN_ERR "xen_suspend: sysdev_suspend failed: %d\n",
                         err);
-                dpm_resume_noirq(PMSG_RESUME);
                 return err;
         }
 
@@ -69,7 +69,6 @@ static int xen_suspend(void *data)
         }
 
         sysdev_resume();
-        dpm_resume_noirq(PMSG_RESUME);
 
         return 0;
 }
@@ -81,6 +80,12 @@ static void do_suspend(void)
 
         shutting_down = SHUTDOWN_SUSPEND;
 
+        err = stop_machine_create();
+        if (err) {
+                printk(KERN_ERR "xen suspend: failed to setup stop_machine %d\n", err);
+                goto out;
+        }
+
 #ifdef CONFIG_PREEMPT
         /* If the kernel is preemptible, we need to freeze all the processes
            to prevent them from being in the middle of a pagetable update
@@ -88,14 +93,14 @@ static void do_suspend(void)
         err = freeze_processes();
         if (err) {
                 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
-                return;
+                goto out_destroy_sm;
         }
 #endif
 
         err = dpm_suspend_start(PMSG_SUSPEND);
         if (err) {
                 printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
-                goto out;
+                goto out_thaw;
         }
 
         printk(KERN_DEBUG "suspending xenstore...\n");
@@ -104,32 +109,39 @@ static void do_suspend(void)
         err = dpm_suspend_noirq(PMSG_SUSPEND);
         if (err) {
                 printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
-                goto resume_devices;
+                goto out_resume;
         }
 
         err = stop_machine(xen_suspend, &cancelled, cpumask_of(0));
+
+        dpm_resume_noirq(PMSG_RESUME);
+
         if (err) {
                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
-                goto out;
+                cancelled = 1;
         }
 
+out_resume:
         if (!cancelled) {
                 xen_arch_resume();
                 xs_resume();
         } else
                 xs_suspend_cancel();
 
-        dpm_resume_noirq(PMSG_RESUME);
-
-resume_devices:
         dpm_resume_end(PMSG_RESUME);
 
         /* Make sure timer events get retriggered on all CPUs */
         clock_was_set();
-out:
+
+out_thaw:
 #ifdef CONFIG_PREEMPT
         thaw_processes();
+
+out_destroy_sm:
 #endif
+        stop_machine_destroy();
+
+out:
         shutting_down = SHUTDOWN_INVALID;
 }
 #endif  /* CONFIG_PM_SLEEP */
diff --git a/drivers/xen/sys-hypervisor.c b/drivers/xen/sys-hypervisor.c
index 88a60e03ccf0..60f1827a32cb 100644
--- a/drivers/xen/sys-hypervisor.c
+++ b/drivers/xen/sys-hypervisor.c
@@ -7,6 +7,7 @@
  *  published by the Free Software Foundation.
  */
 
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/kobject.h>
@@ -14,6 +15,7 @@
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
 
+#include <xen/xen.h>
 #include <xen/xenbus.h>
 #include <xen/interface/xen.h>
 #include <xen/interface/version.h>
@@ -425,7 +427,7 @@ static ssize_t hyp_sysfs_store(struct kobject *kobj,
         return 0;
 }
 
-static struct sysfs_ops hyp_sysfs_ops = {
+static const struct sysfs_ops hyp_sysfs_ops = {
         .show = hyp_sysfs_show,
         .store = hyp_sysfs_store,
 };
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);
 }
diff --git a/drivers/xen/xencomm.c b/drivers/xen/xencomm.c
index a240b2c20b99..b91f8ff50d05 100644
--- a/drivers/xen/xencomm.c
+++ b/drivers/xen/xencomm.c
@@ -18,8 +18,8 @@
  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  */
 
-#include <linux/gfp.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <asm/page.h>
 #include <xen/xencomm.h>
 #include <xen/interface/xen.h>
diff --git a/drivers/xen/xenfs/super.c b/drivers/xen/xenfs/super.c
index 6559e0c752ce..8924d93136f1 100644
--- a/drivers/xen/xenfs/super.c
+++ b/drivers/xen/xenfs/super.c
@@ -13,6 +13,8 @@
 #include <linux/fs.h>
 #include <linux/magic.h>
 
+#include <xen/xen.h>
+
 #include "xenfs.h"
 
 #include <asm/xen/hypervisor.h>
diff --git a/drivers/xen/xenfs/xenbus.c b/drivers/xen/xenfs/xenbus.c
index 6c4269b836b7..f28ece397361 100644
--- a/drivers/xen/xenfs/xenbus.c
+++ b/drivers/xen/xenfs/xenbus.c
@@ -51,6 +51,7 @@
 #include <linux/init.h>
 #include <linux/namei.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 
 #include "xenfs.h"
 #include "../xenbus/xenbus_comms.h"