11 files changed, 151 insertions, 186 deletions

diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 3ca643cafccd..d5e753255153 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -1032,7 +1032,7 @@ static struct xenbus_driver blkfront = {
 
 static int __init xlblk_init(void)
 {
-        if (!is_running_on_xen())
+        if (!xen_domain())
                 return -ENODEV;
 
         if (register_blkdev(XENVBD_MAJOR, DEV_NAME)) {
diff --git a/drivers/char/hvc_xen.c b/drivers/char/hvc_xen.c
index 6b70aa66a587..538ceea5e7df 100644
--- a/drivers/char/hvc_xen.c
+++ b/drivers/char/hvc_xen.c
@@ -108,8 +108,8 @@ static int __init xen_init(void)
 {
         struct hvc_struct *hp;
 
-        if (!is_running_on_xen() ||
-            is_initial_xendomain() ||
+        if (!xen_pv_domain() ||
+            xen_initial_domain() ||
             !xen_start_info->console.domU.evtchn)
                 return -ENODEV;
 
@@ -142,7 +142,7 @@ static void __exit xen_fini(void)
 
 static int xen_cons_init(void)
 {
-        if (!is_running_on_xen())
+        if (!xen_pv_domain())
                 return 0;
 
         hvc_instantiate(HVC_COOKIE, 0, &hvc_ops);
diff --git a/drivers/input/xen-kbdfront.c b/drivers/input/xen-kbdfront.c
index 9ce3b3baf3a2..3ab6362f043c 100644
--- a/drivers/input/xen-kbdfront.c
+++ b/drivers/input/xen-kbdfront.c
@@ -335,11 +335,11 @@ static struct xenbus_driver xenkbd = {
 
 static int __init xenkbd_init(void)
 {
-        if (!is_running_on_xen())
+        if (!xen_domain())
                 return -ENODEV;
 
         /* Nothing to do if running in dom0. */
-        if (is_initial_xendomain())
+        if (xen_initial_domain())
                 return -ENODEV;
 
         return xenbus_register_frontend(&xenkbd);
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index c749bdba214c..3c3dd403f5dd 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -1794,10 +1794,10 @@ static struct xenbus_driver netfront = {
 
 static int __init netif_init(void)
 {
-        if (!is_running_on_xen())
+        if (!xen_domain())
                 return -ENODEV;
 
-        if (is_initial_xendomain())
+        if (xen_initial_domain())
                 return 0;
 
         printk(KERN_INFO "Initialising Xen virtual ethernet driver.\n");
@@ -1809,7 +1809,7 @@ module_init(netif_init);
 
 static void __exit netif_exit(void)
 {
-        if (is_initial_xendomain())
+        if (xen_initial_domain())
                 return;
 
         xenbus_unregister_driver(&netfront);
diff --git a/drivers/video/xen-fbfront.c b/drivers/video/xen-fbfront.c
index 47ed39b52f9c..a463b3dd837b 100644
--- a/drivers/video/xen-fbfront.c
+++ b/drivers/video/xen-fbfront.c
@@ -680,11 +680,11 @@ static struct xenbus_driver xenfb = {
 
 static int __init xenfb_init(void)
 {
-        if (!is_running_on_xen())
+        if (!xen_domain())
                 return -ENODEV;
 
         /* Nothing to do if running in dom0. */
-        if (is_initial_xendomain())
+        if (xen_initial_domain())
                 return -ENODEV;
 
         return xenbus_register_frontend(&xenfb);
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index 363286c54290..d2a8fdf0e191 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -1,4 +1,5 @@
 obj-y   += grant-table.o features.o events.o manage.o
 obj-y   += xenbus/
+obj-$(CONFIG_HOTPLUG_CPU)       += cpu_hotplug.o
 obj-$(CONFIG_XEN_XENCOMM)       += xencomm.o
 obj-$(CONFIG_XEN_BALLOON)       += balloon.o
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 2e15da5459cf..a51f3e17a5fd 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -226,9 +226,8 @@ 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);
+        reservation.nr_extents = nr_pages;
+        rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation);
         if (rc < nr_pages) {
                 if (rc > 0) {
                         int ret;
@@ -236,7 +235,7 @@ static int increase_reservation(unsigned long nr_pages)
                         /* We hit the Xen hard limit: reprobe. */
                         reservation.nr_extents = rc;
                         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
-                                        &reservation);
+                                                   &reservation);
                         BUG_ON(ret != rc);
                 }
                 if (rc >= 0)
@@ -420,7 +419,7 @@ static int __init balloon_init(void)
         unsigned long pfn;
         struct page *page;
 
-        if (!is_running_on_xen())
+        if (!xen_pv_domain())
                 return -ENODEV;
 
         pr_info("xen_balloon: Initialising balloon driver.\n");
@@ -464,136 +463,13 @@ static void balloon_exit(void)
 
 module_exit(balloon_exit);
 
-static void balloon_update_driver_allowance(long delta)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&balloon_lock, flags);
-        balloon_stats.driver_pages += delta;
-        spin_unlock_irqrestore(&balloon_lock, flags);
-}
-
-static int dealloc_pte_fn(
-        pte_t *pte, struct page *pmd_page, unsigned long addr, void *data)
-{
-        unsigned long mfn = pte_mfn(*pte);
-        int ret;
-        struct xen_memory_reservation reservation = {
-                .nr_extents   = 1,
-                .extent_order = 0,
-                .domid        = DOMID_SELF
-        };
-        set_xen_guest_handle(reservation.extent_start, &mfn);
-        set_pte_at(&init_mm, addr, pte, __pte_ma(0ull));
-        set_phys_to_machine(__pa(addr) >> PAGE_SHIFT, INVALID_P2M_ENTRY);
-        ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
-        BUG_ON(ret != 1);
-        return 0;
-}
-
-static struct page **alloc_empty_pages_and_pagevec(int nr_pages)
-{
-        unsigned long vaddr, flags;
-        struct page *page, **pagevec;
-        int i, ret;
-
-        pagevec = kmalloc(sizeof(page) * nr_pages, GFP_KERNEL);
-        if (pagevec == NULL)
-                return NULL;
-
-        for (i = 0; i < nr_pages; i++) {
-                page = pagevec[i] = alloc_page(GFP_KERNEL);
-                if (page == NULL)
-                        goto err;
-
-                vaddr = (unsigned long)page_address(page);
-
-                scrub_page(page);
-
-                spin_lock_irqsave(&balloon_lock, flags);
-
-                if (xen_feature(XENFEAT_auto_translated_physmap)) {
-                        unsigned long gmfn = page_to_pfn(page);
-                        struct xen_memory_reservation reservation = {
-                                .nr_extents   = 1,
-                                .extent_order = 0,
-                                .domid        = DOMID_SELF
-                        };
-                        set_xen_guest_handle(reservation.extent_start, &gmfn);
-                        ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
-                                                   &reservation);
-                        if (ret == 1)
-                                ret = 0; /* success */
-                } else {
-                        ret = apply_to_page_range(&init_mm, vaddr, PAGE_SIZE,
-                                                  dealloc_pte_fn, NULL);
-                }
-
-                if (ret != 0) {
-                        spin_unlock_irqrestore(&balloon_lock, flags);
-                        __free_page(page);
-                        goto err;
-                }
-
-                totalram_pages = --balloon_stats.current_pages;
-
-                spin_unlock_irqrestore(&balloon_lock, flags);
-        }
-
- out:
-        schedule_work(&balloon_worker);
-        flush_tlb_all();
-        return pagevec;
-
- err:
-        spin_lock_irqsave(&balloon_lock, flags);
-        while (--i >= 0)
-                balloon_append(pagevec[i]);
-        spin_unlock_irqrestore(&balloon_lock, flags);
-        kfree(pagevec);
-        pagevec = NULL;
-        goto out;
-}
-
-static void free_empty_pages_and_pagevec(struct page **pagevec, int nr_pages)
-{
-        unsigned long flags;
-        int i;
-
-        if (pagevec == NULL)
-                return;
-
-        spin_lock_irqsave(&balloon_lock, flags);
-        for (i = 0; i < nr_pages; i++) {
-                BUG_ON(page_count(pagevec[i]) != 1);
-                balloon_append(pagevec[i]);
-        }
-        spin_unlock_irqrestore(&balloon_lock, flags);
-
-        kfree(pagevec);
-
-        schedule_work(&balloon_worker);
-}
-
-static void balloon_release_driver_page(struct page *page)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&balloon_lock, flags);
-        balloon_append(page);
-        balloon_stats.driver_pages--;
-        spin_unlock_irqrestore(&balloon_lock, flags);
-
-        schedule_work(&balloon_worker);
-}
-
-
-#define BALLOON_SHOW(name, format, args...)                     \
-        static ssize_t show_##name(struct sys_device *dev,      \
-                                   char *buf)                   \
-        {                                                       \
-                return sprintf(buf, format, ##args);            \
-        }                                                       \
+#define BALLOON_SHOW(name, format, args...)                             \
+        static ssize_t show_##name(struct sys_device *dev,              \
+                                   struct sysdev_attribute *attr,       \
+                                   char *buf)                           \
+        {                                                               \
+                return sprintf(buf, format, ##args);                    \
+        }                                                               \
         static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL)
 
 BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages));
@@ -604,7 +480,8 @@ BALLOON_SHOW(hard_limit_kb,
              (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, char *buf)
+static ssize_t show_target_kb(struct sys_device *dev, struct sysdev_attribute *attr,
+                              char *buf)
 {
         return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages));
 }
@@ -614,19 +491,14 @@ static ssize_t store_target_kb(struct sys_device *dev,
                                const char *buf,
                                size_t count)
 {
-        char memstring[64], *endchar;
+        char *endchar;
         unsigned long long target_bytes;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (count <= 1)
-                return -EBADMSG; /* runt */
-        if (count > sizeof(memstring))
-                return -EFBIG;   /* too long */
-        strcpy(memstring, buf);
+        target_bytes = memparse(buf, &endchar);
 
-        target_bytes = memparse(memstring, &endchar);
         balloon_set_new_target(target_bytes >> PAGE_SHIFT);
 
         return count;
@@ -694,20 +566,4 @@ static int register_balloon(struct sys_device *sysdev)
         return error;
 }
 
-static void unregister_balloon(struct sys_device *sysdev)
-{
-        int i;
-
-        sysfs_remove_group(&sysdev->kobj, &balloon_info_group);
-        for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++)
-                sysdev_remove_file(sysdev, balloon_attrs[i]);
-        sysdev_unregister(sysdev);
-        sysdev_class_unregister(&balloon_sysdev_class);
-}
-
-static void balloon_sysfs_exit(void)
-{
-        unregister_balloon(&balloon_sysdev);
-}
-
 MODULE_LICENSE("GPL");
diff --git a/drivers/xen/cpu_hotplug.c b/drivers/xen/cpu_hotplug.c
new file mode 100644
index 000000000000..565280ec1c6a
--- /dev/null
+++ b/drivers/xen/cpu_hotplug.c
@@ -0,0 +1,90 @@
+#include <linux/notifier.h>
+
+#include <xen/xenbus.h>
+
+#include <asm-x86/xen/hypervisor.h>
+#include <asm/cpu.h>
+
+static void enable_hotplug_cpu(int cpu)
+{
+        if (!cpu_present(cpu))
+                arch_register_cpu(cpu);
+
+        cpu_set(cpu, cpu_present_map);
+}
+
+static void disable_hotplug_cpu(int cpu)
+{
+        if (cpu_present(cpu))
+                arch_unregister_cpu(cpu);
+
+        cpu_clear(cpu, cpu_present_map);
+}
+
+static void vcpu_hotplug(unsigned int cpu)
+{
+        int err;
+        char dir[32], state[32];
+
+        if (!cpu_possible(cpu))
+                return;
+
+        sprintf(dir, "cpu/%u", cpu);
+        err = xenbus_scanf(XBT_NIL, dir, "availability", "%s", state);
+        if (err != 1) {
+                printk(KERN_ERR "XENBUS: Unable to read cpu state\n");
+                return;
+        }
+
+        if (strcmp(state, "online") == 0) {
+                enable_hotplug_cpu(cpu);
+        } else if (strcmp(state, "offline") == 0) {
+                (void)cpu_down(cpu);
+                disable_hotplug_cpu(cpu);
+        } else {
+                printk(KERN_ERR "XENBUS: unknown state(%s) on CPU%d\n",
+                       state, cpu);
+        }
+}
+
+static void handle_vcpu_hotplug_event(struct xenbus_watch *watch,
+                                        const char **vec, unsigned int len)
+{
+        unsigned int cpu;
+        char *cpustr;
+        const char *node = vec[XS_WATCH_PATH];
+
+        cpustr = strstr(node, "cpu/");
+        if (cpustr != NULL) {
+                sscanf(cpustr, "cpu/%u", &cpu);
+                vcpu_hotplug(cpu);
+        }
+}
+
+static int setup_cpu_watcher(struct notifier_block *notifier,
+                              unsigned long event, void *data)
+{
+        static struct xenbus_watch cpu_watch = {
+                .node = "cpu",
+                .callback = handle_vcpu_hotplug_event};
+
+        (void)register_xenbus_watch(&cpu_watch);
+
+        return NOTIFY_DONE;
+}
+
+static int __init setup_vcpu_hotplug_event(void)
+{
+        static struct notifier_block xsn_cpu = {
+                .notifier_call = setup_cpu_watcher };
+
+        if (!xen_pv_domain())
+                return -ENODEV;
+
+        register_xenstore_notifier(&xsn_cpu);
+
+        return 0;
+}
+
+arch_initcall(setup_vcpu_hotplug_event);
+
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 0e0c28574af8..c3290bc186a0 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -84,17 +84,6 @@ static int irq_bindcount[NR_IRQS];
 /* Xen will never allocate port zero for any purpose. */
 #define VALID_EVTCHN(chn)       ((chn) != 0)
 
-/*
- * Force a proper event-channel callback from Xen after clearing the
- * callback mask. We do this in a very simple manner, by making a call
- * down into Xen. The pending flag will be checked by Xen on return.
- */
-void force_evtchn_callback(void)
-{
-        (void)HYPERVISOR_xen_version(0, NULL);
-}
-EXPORT_SYMBOL_GPL(force_evtchn_callback);
-
 static struct irq_chip xen_dynamic_chip;
 
 /* Constructor for packed IRQ information. */
@@ -175,6 +164,12 @@ static inline void set_evtchn(int port)
         sync_set_bit(port, &s->evtchn_pending[0]);
 }
 
+static inline int test_evtchn(int port)
+{
+        struct shared_info *s = HYPERVISOR_shared_info;
+        return sync_test_bit(port, &s->evtchn_pending[0]);
+}
+
 
 /**
  * notify_remote_via_irq - send event to remote end of event channel via irq
@@ -365,6 +360,10 @@ static void unbind_from_irq(unsigned int irq)
                         per_cpu(virq_to_irq, cpu_from_evtchn(evtchn))
                                 [index_from_irq(irq)] = -1;
                         break;
+                case IRQT_IPI:
+                        per_cpu(ipi_to_irq, cpu_from_evtchn(evtchn))
+                                [index_from_irq(irq)] = -1;
+                        break;
                 default:
                         break;
                 }
@@ -743,6 +742,25 @@ void xen_clear_irq_pending(int irq)
                 clear_evtchn(evtchn);
 }
 
+void xen_set_irq_pending(int irq)
+{
+        int evtchn = evtchn_from_irq(irq);
+
+        if (VALID_EVTCHN(evtchn))
+                set_evtchn(evtchn);
+}
+
+bool xen_test_irq_pending(int irq)
+{
+        int evtchn = evtchn_from_irq(irq);
+        bool ret = false;
+
+        if (VALID_EVTCHN(evtchn))
+                ret = test_evtchn(evtchn);
+
+        return ret;
+}
+
 /* Poll waiting for an irq to become pending.  In the usual case, the
    irq will be disabled so it won't deliver an interrupt. */
 void xen_poll_irq(int irq)
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index e9e11168616a..06592b9da83c 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -508,7 +508,7 @@ static int __devinit gnttab_init(void)
         unsigned int max_nr_glist_frames, nr_glist_frames;
         unsigned int nr_init_grefs;
 
-        if (!is_running_on_xen())
+        if (!xen_domain())
                 return -ENODEV;
 
         nr_grant_frames = 1;
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 57ceb5346b74..7f24a98a446f 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -814,7 +814,7 @@ static int __init xenbus_probe_init(void)
         DPRINTK("");
 
         err = -ENODEV;
-        if (!is_running_on_xen())
+        if (!xen_domain())
                 goto out_error;
 
         /* Register ourselves with the kernel bus subsystem */
@@ -829,7 +829,7 @@ static int __init xenbus_probe_init(void)
         /*
          * Domain0 doesn't have a store_evtchn or store_mfn yet.
          */
-        if (is_initial_xendomain()) {
+        if (xen_initial_domain()) {
                 /* dom0 not yet supported */
         } else {
                 xenstored_ready = 1;
@@ -846,7 +846,7 @@ static int __init xenbus_probe_init(void)
                 goto out_unreg_back;
         }
 
-        if (!is_initial_xendomain())
+        if (!xen_initial_domain())
                 xenbus_probe(NULL);
 
         return 0;
@@ -937,7 +937,7 @@ static void wait_for_devices(struct xenbus_driver *xendrv)
         unsigned long timeout = jiffies + 10*HZ;
         struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
 
-        if (!ready_to_wait_for_devices || !is_running_on_xen())
+        if (!ready_to_wait_for_devices || !xen_domain())
                 return;
 
         while (exists_disconnected_device(drv)) {