Merge remote-tracking branch 'linus/master' into testing

6 files changed, 153 insertions, 91 deletions

diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index a492be2635ac..193097ef3d7d 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -1557,7 +1557,7 @@ asmlinkage void __init xen_start_kernel(void)
 #ifdef CONFIG_X86_32
         /* set up basic CPUID stuff */
         cpu_detect(&new_cpu_data);
-        new_cpu_data.hard_math = 1;
+        set_cpu_cap(&new_cpu_data, X86_FEATURE_FPU);
         new_cpu_data.wp_works_ok = 1;
         new_cpu_data.x86_capability[0] = cpuid_edx(1);
 #endif
@@ -1681,8 +1681,8 @@ static void __init init_hvm_pv_info(void)
         xen_domain_type = XEN_HVM_DOMAIN;
 }
 
-static int __cpuinit xen_hvm_cpu_notify(struct notifier_block *self,
-                                    unsigned long action, void *hcpu)
+static int xen_hvm_cpu_notify(struct notifier_block *self, unsigned long action,
+                              void *hcpu)
 {
         int cpu = (long)hcpu;
         switch (action) {
@@ -1700,7 +1700,7 @@ static int __cpuinit xen_hvm_cpu_notify(struct notifier_block *self,
         return NOTIFY_OK;
 }
 
-static struct notifier_block xen_hvm_cpu_notifier __cpuinitdata = {
+static struct notifier_block xen_hvm_cpu_notifier = {
         .notifier_call  = xen_hvm_cpu_notify,
 };
 
diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index 94eac5c85cdc..056d11faef21 100644
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -475,7 +475,7 @@ static void __init fiddle_vdso(void)
 #endif
 }
 
-static int __cpuinit register_callback(unsigned type, const void *func)
+static int register_callback(unsigned type, const void *func)
 {
         struct callback_register callback = {
                 .type = type,
@@ -486,7 +486,7 @@ static int __cpuinit register_callback(unsigned type, const void *func)
         return HYPERVISOR_callback_op(CALLBACKOP_register, &callback);
 }
 
-void __cpuinit xen_enable_sysenter(void)
+void xen_enable_sysenter(void)
 {
         int ret;
         unsigned sysenter_feature;
@@ -505,7 +505,7 @@ void __cpuinit xen_enable_sysenter(void)
                 setup_clear_cpu_cap(sysenter_feature);
 }
 
-void __cpuinit xen_enable_syscall(void)
+void xen_enable_syscall(void)
 {
 #ifdef CONFIG_X86_64
         int ret;
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index d99cae8147d1..ca92754eb846 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -40,11 +40,15 @@
 
 cpumask_var_t xen_cpu_initialized_map;
 
-static DEFINE_PER_CPU(int, xen_resched_irq);
-static DEFINE_PER_CPU(int, xen_callfunc_irq);
-static DEFINE_PER_CPU(int, xen_callfuncsingle_irq);
-static DEFINE_PER_CPU(int, xen_irq_work);
-static DEFINE_PER_CPU(int, xen_debug_irq) = -1;
+struct xen_common_irq {
+        int irq;
+        char *name;
+};
+static DEFINE_PER_CPU(struct xen_common_irq, xen_resched_irq) = { .irq = -1 };
+static DEFINE_PER_CPU(struct xen_common_irq, xen_callfunc_irq) = { .irq = -1 };
+static DEFINE_PER_CPU(struct xen_common_irq, xen_callfuncsingle_irq) = { .irq = -1 };
+static DEFINE_PER_CPU(struct xen_common_irq, xen_irq_work) = { .irq = -1 };
+static DEFINE_PER_CPU(struct xen_common_irq, xen_debug_irq) = { .irq = -1 };
 
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
 static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
@@ -61,7 +65,7 @@ static irqreturn_t xen_reschedule_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static void __cpuinit cpu_bringup(void)
+static void cpu_bringup(void)
 {
         int cpu;
 
@@ -93,16 +97,53 @@ static void __cpuinit cpu_bringup(void)
         wmb();                  /* make sure everything is out */
 }
 
-static void __cpuinit cpu_bringup_and_idle(void)
+static void cpu_bringup_and_idle(void)
 {
         cpu_bringup();
         cpu_startup_entry(CPUHP_ONLINE);
 }
 
+static void xen_smp_intr_free(unsigned int cpu)
+{
+        if (per_cpu(xen_resched_irq, cpu).irq >= 0) {
+                unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu).irq, NULL);
+                per_cpu(xen_resched_irq, cpu).irq = -1;
+                kfree(per_cpu(xen_resched_irq, cpu).name);
+                per_cpu(xen_resched_irq, cpu).name = NULL;
+        }
+        if (per_cpu(xen_callfunc_irq, cpu).irq >= 0) {
+                unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu).irq, NULL);
+                per_cpu(xen_callfunc_irq, cpu).irq = -1;
+                kfree(per_cpu(xen_callfunc_irq, cpu).name);
+                per_cpu(xen_callfunc_irq, cpu).name = NULL;
+        }
+        if (per_cpu(xen_debug_irq, cpu).irq >= 0) {
+                unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu).irq, NULL);
+                per_cpu(xen_debug_irq, cpu).irq = -1;
+                kfree(per_cpu(xen_debug_irq, cpu).name);
+                per_cpu(xen_debug_irq, cpu).name = NULL;
+        }
+        if (per_cpu(xen_callfuncsingle_irq, cpu).irq >= 0) {
+                unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu).irq,
+                                       NULL);
+                per_cpu(xen_callfuncsingle_irq, cpu).irq = -1;
+                kfree(per_cpu(xen_callfuncsingle_irq, cpu).name);
+                per_cpu(xen_callfuncsingle_irq, cpu).name = NULL;
+        }
+        if (xen_hvm_domain())
+                return;
+
+        if (per_cpu(xen_irq_work, cpu).irq >= 0) {
+                unbind_from_irqhandler(per_cpu(xen_irq_work, cpu).irq, NULL);
+                per_cpu(xen_irq_work, cpu).irq = -1;
+                kfree(per_cpu(xen_irq_work, cpu).name);
+                per_cpu(xen_irq_work, cpu).name = NULL;
+        }
+};
 static int xen_smp_intr_init(unsigned int cpu)
 {
         int rc;
-        const char *resched_name, *callfunc_name, *debug_name;
+        char *resched_name, *callfunc_name, *debug_name;
 
         resched_name = kasprintf(GFP_KERNEL, "resched%d", cpu);
         rc = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR,
@@ -113,7 +154,8 @@ static int xen_smp_intr_init(unsigned int cpu)
                                     NULL);
         if (rc < 0)
                 goto fail;
-        per_cpu(xen_resched_irq, cpu) = rc;
+        per_cpu(xen_resched_irq, cpu).irq = rc;
+        per_cpu(xen_resched_irq, cpu).name = resched_name;
 
         callfunc_name = kasprintf(GFP_KERNEL, "callfunc%d", cpu);
         rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_VECTOR,
@@ -124,7 +166,8 @@ static int xen_smp_intr_init(unsigned int cpu)
                                     NULL);
         if (rc < 0)
                 goto fail;
-        per_cpu(xen_callfunc_irq, cpu) = rc;
+        per_cpu(xen_callfunc_irq, cpu).irq = rc;
+        per_cpu(xen_callfunc_irq, cpu).name = callfunc_name;
 
         debug_name = kasprintf(GFP_KERNEL, "debug%d", cpu);
         rc = bind_virq_to_irqhandler(VIRQ_DEBUG, cpu, xen_debug_interrupt,
@@ -132,7 +175,8 @@ static int xen_smp_intr_init(unsigned int cpu)
                                      debug_name, NULL);
         if (rc < 0)
                 goto fail;
-        per_cpu(xen_debug_irq, cpu) = rc;
+        per_cpu(xen_debug_irq, cpu).irq = rc;
+        per_cpu(xen_debug_irq, cpu).name = debug_name;
 
         callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);
         rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_SINGLE_VECTOR,
@@ -143,7 +187,8 @@ static int xen_smp_intr_init(unsigned int cpu)
                                     NULL);
         if (rc < 0)
                 goto fail;
-        per_cpu(xen_callfuncsingle_irq, cpu) = rc;
+        per_cpu(xen_callfuncsingle_irq, cpu).irq = rc;
+        per_cpu(xen_callfuncsingle_irq, cpu).name = callfunc_name;
 
         /*
          * The IRQ worker on PVHVM goes through the native path and uses the
@@ -161,26 +206,13 @@ static int xen_smp_intr_init(unsigned int cpu)
                                     NULL);
         if (rc < 0)
                 goto fail;
-        per_cpu(xen_irq_work, cpu) = rc;
+        per_cpu(xen_irq_work, cpu).irq = rc;
+        per_cpu(xen_irq_work, cpu).name = callfunc_name;
 
         return 0;
 
  fail:
-        if (per_cpu(xen_resched_irq, cpu) >= 0)
-                unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu), NULL);
-        if (per_cpu(xen_callfunc_irq, cpu) >= 0)
-                unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu), NULL);
-        if (per_cpu(xen_debug_irq, cpu) >= 0)
-                unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu), NULL);
-        if (per_cpu(xen_callfuncsingle_irq, cpu) >= 0)
-                unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu),
-                                       NULL);
-        if (xen_hvm_domain())
-                return rc;
-
-        if (per_cpu(xen_irq_work, cpu) >= 0)
-                unbind_from_irqhandler(per_cpu(xen_irq_work, cpu), NULL);
-
+        xen_smp_intr_free(cpu);
         return rc;
 }
 
@@ -294,7 +326,7 @@ static void __init xen_smp_prepare_cpus(unsigned int max_cpus)
                 set_cpu_present(cpu, true);
 }
 
-static int __cpuinit
+static int
 cpu_initialize_context(unsigned int cpu, struct task_struct *idle)
 {
         struct vcpu_guest_context *ctxt;
@@ -365,7 +397,7 @@ cpu_initialize_context(unsigned int cpu, struct task_struct *idle)
         return 0;
 }
 
-static int __cpuinit xen_cpu_up(unsigned int cpu, struct task_struct *idle)
+static int xen_cpu_up(unsigned int cpu, struct task_struct *idle)
 {
         int rc;
 
@@ -433,17 +465,12 @@ static void xen_cpu_die(unsigned int cpu)
                 current->state = TASK_UNINTERRUPTIBLE;
                 schedule_timeout(HZ/10);
         }
-        unbind_from_irqhandler(per_cpu(xen_resched_irq, cpu), NULL);
-        unbind_from_irqhandler(per_cpu(xen_callfunc_irq, cpu), NULL);
-        unbind_from_irqhandler(per_cpu(xen_debug_irq, cpu), NULL);
-        unbind_from_irqhandler(per_cpu(xen_callfuncsingle_irq, cpu), NULL);
-        if (!xen_hvm_domain())
-                unbind_from_irqhandler(per_cpu(xen_irq_work, cpu), NULL);
+        xen_smp_intr_free(cpu);
         xen_uninit_lock_cpu(cpu);
         xen_teardown_timer(cpu);
 }
 
-static void __cpuinit xen_play_dead(void) /* used only with HOTPLUG_CPU */
+static void xen_play_dead(void) /* used only with HOTPLUG_CPU */
 {
         play_dead_common();
         HYPERVISOR_vcpu_op(VCPUOP_down, smp_processor_id(), NULL);
@@ -664,7 +691,7 @@ static void __init xen_hvm_smp_prepare_cpus(unsigned int max_cpus)
         xen_init_lock_cpu(0);
 }
 
-static int __cpuinit xen_hvm_cpu_up(unsigned int cpu, struct task_struct *tidle)
+static int xen_hvm_cpu_up(unsigned int cpu, struct task_struct *tidle)
 {
         int rc;
         rc = native_cpu_up(cpu, tidle);
diff --git a/arch/x86/xen/spinlock.c b/arch/x86/xen/spinlock.c
index 3002ec1bb71a..cf3caee356b3 100644
--- a/arch/x86/xen/spinlock.c
+++ b/arch/x86/xen/spinlock.c
@@ -7,6 +7,7 @@
 #include <linux/debugfs.h>
 #include <linux/log2.h>
 #include <linux/gfp.h>
+#include <linux/slab.h>
 
 #include <asm/paravirt.h>
 
@@ -165,6 +166,7 @@ static int xen_spin_trylock(struct arch_spinlock *lock)
         return old == 0;
 }
 
+static DEFINE_PER_CPU(char *, irq_name);
 static DEFINE_PER_CPU(int, lock_kicker_irq) = -1;
 static DEFINE_PER_CPU(struct xen_spinlock *, lock_spinners);
 
@@ -359,10 +361,10 @@ static irqreturn_t dummy_handler(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-void __cpuinit xen_init_lock_cpu(int cpu)
+void xen_init_lock_cpu(int cpu)
 {
         int irq;
-        const char *name;
+        char *name;
 
         WARN(per_cpu(lock_kicker_irq, cpu) >= 0, "spinlock on CPU%d exists on IRQ%d!\n",
              cpu, per_cpu(lock_kicker_irq, cpu));
@@ -385,6 +387,7 @@ void __cpuinit xen_init_lock_cpu(int cpu)
         if (irq >= 0) {
                 disable_irq(irq); /* make sure it's never delivered */
                 per_cpu(lock_kicker_irq, cpu) = irq;
+                per_cpu(irq_name, cpu) = name;
         }
 
         printk("cpu %d spinlock event irq %d\n", cpu, irq);
@@ -401,6 +404,8 @@ void xen_uninit_lock_cpu(int cpu)
 
         unbind_from_irqhandler(per_cpu(lock_kicker_irq, cpu), NULL);
         per_cpu(lock_kicker_irq, cpu) = -1;
+        kfree(per_cpu(irq_name, cpu));
+        per_cpu(irq_name, cpu) = NULL;
 }
 
 void __init xen_init_spinlocks(void)
diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index 3d88bfdf9e1c..ee365895b06b 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -14,6 +14,8 @@
 #include <linux/kernel_stat.h>
 #include <linux/math64.h>
 #include <linux/gfp.h>
+#include <linux/slab.h>
+#include <linux/pvclock_gtod.h>
 
 #include <asm/pvclock.h>
 #include <asm/xen/hypervisor.h>
@@ -36,9 +38,8 @@ static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate);
 /* snapshots of runstate info */
 static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot);
 
-/* unused ns of stolen and blocked time */
+/* unused ns of stolen time */
 static DEFINE_PER_CPU(u64, xen_residual_stolen);
-static DEFINE_PER_CPU(u64, xen_residual_blocked);
 
 /* return an consistent snapshot of 64-bit time/counter value */
 static u64 get64(const u64 *p)
@@ -115,7 +116,7 @@ static void do_stolen_accounting(void)
 {
         struct vcpu_runstate_info state;
         struct vcpu_runstate_info *snap;
-        s64 blocked, runnable, offline, stolen;
+        s64 runnable, offline, stolen;
         cputime_t ticks;
 
         get_runstate_snapshot(&state);
@@ -125,7 +126,6 @@ static void do_stolen_accounting(void)
         snap = &__get_cpu_var(xen_runstate_snapshot);
 
         /* work out how much time the VCPU has not been runn*ing*  */
-        blocked = state.time[RUNSTATE_blocked] - snap->time[RUNSTATE_blocked];
         runnable = state.time[RUNSTATE_runnable] - snap->time[RUNSTATE_runnable];
         offline = state.time[RUNSTATE_offline] - snap->time[RUNSTATE_offline];
 
@@ -141,17 +141,6 @@ static void do_stolen_accounting(void)
         ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen);
         __this_cpu_write(xen_residual_stolen, stolen);
         account_steal_ticks(ticks);
-
-        /* Add the appropriate number of ticks of blocked time,
-           including any left-overs from last time. */
-        blocked += __this_cpu_read(xen_residual_blocked);
-
-        if (blocked < 0)
-                blocked = 0;
-
-        ticks = iter_div_u64_rem(blocked, NS_PER_TICK, &blocked);
-        __this_cpu_write(xen_residual_blocked, blocked);
-        account_idle_ticks(ticks);
 }
 
 /* Get the TSC speed from Xen */
@@ -191,34 +180,56 @@ static void xen_read_wallclock(struct timespec *ts)
         put_cpu_var(xen_vcpu);
 }
 
-static unsigned long xen_get_wallclock(void)
+static void xen_get_wallclock(struct timespec *now)
 {
-        struct timespec ts;
+        xen_read_wallclock(now);
+}
 
-        xen_read_wallclock(&ts);
-        return ts.tv_sec;
+static int xen_set_wallclock(const struct timespec *now)
+{
+        return -1;
 }
 
-static int xen_set_wallclock(unsigned long now)
+static int xen_pvclock_gtod_notify(struct notifier_block *nb,
+                                   unsigned long was_set, void *priv)
 {
+        /* Protected by the calling core code serialization */
+        static struct timespec next_sync;
+
         struct xen_platform_op op;
-        int rc;
+        struct timespec now;
 
-        /* do nothing for domU */
-        if (!xen_initial_domain())
-                return -1;
+        now = __current_kernel_time();
+
+        /*
+         * We only take the expensive HV call when the clock was set
+         * or when the 11 minutes RTC synchronization time elapsed.
+         */
+        if (!was_set && timespec_compare(&now, &next_sync) < 0)
+                return NOTIFY_OK;
 
         op.cmd = XENPF_settime;
-        op.u.settime.secs = now;
-        op.u.settime.nsecs = 0;
+        op.u.settime.secs = now.tv_sec;
+        op.u.settime.nsecs = now.tv_nsec;
         op.u.settime.system_time = xen_clocksource_read();
 
-        rc = HYPERVISOR_dom0_op(&op);
-        WARN(rc != 0, "XENPF_settime failed: now=%ld\n", now);
+        (void)HYPERVISOR_dom0_op(&op);
+
+        /*
+         * Move the next drift compensation time 11 minutes
+         * ahead. That's emulating the sync_cmos_clock() update for
+         * the hardware RTC.
+         */
+        next_sync = now;
+        next_sync.tv_sec += 11 * 60;
 
-        return rc;
+        return NOTIFY_OK;
 }
 
+static struct notifier_block xen_pvclock_gtod_notifier = {
+        .notifier_call = xen_pvclock_gtod_notify,
+};
+
 static struct clocksource xen_clocksource __read_mostly = {
         .name = "xen",
         .rating = 400,
@@ -377,11 +388,16 @@ static const struct clock_event_device xen_vcpuop_clockevent = {
 
 static const struct clock_event_device *xen_clockevent =
         &xen_timerop_clockevent;
-static DEFINE_PER_CPU(struct clock_event_device, xen_clock_events) = { .irq = -1 };
+
+struct xen_clock_event_device {
+        struct clock_event_device evt;
+        char *name;
+};
+static DEFINE_PER_CPU(struct xen_clock_event_device, xen_clock_events) = { .evt.irq = -1 };
 
 static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
 {
-        struct clock_event_device *evt = &__get_cpu_var(xen_clock_events);
+        struct clock_event_device *evt = &__get_cpu_var(xen_clock_events).evt;
         irqreturn_t ret;
 
         ret = IRQ_NONE;
@@ -395,14 +411,30 @@ static irqreturn_t xen_timer_interrupt(int irq, void *dev_id)
         return ret;
 }
 
+void xen_teardown_timer(int cpu)
+{
+        struct clock_event_device *evt;
+        BUG_ON(cpu == 0);
+        evt = &per_cpu(xen_clock_events, cpu).evt;
+
+        if (evt->irq >= 0) {
+                unbind_from_irqhandler(evt->irq, NULL);
+                evt->irq = -1;
+                kfree(per_cpu(xen_clock_events, cpu).name);
+                per_cpu(xen_clock_events, cpu).name = NULL;
+        }
+}
+
 void xen_setup_timer(int cpu)
 {
-        const char *name;
+        char *name;
         struct clock_event_device *evt;
         int irq;
 
-        evt = &per_cpu(xen_clock_events, cpu);
+        evt = &per_cpu(xen_clock_events, cpu).evt;
         WARN(evt->irq >= 0, "IRQ%d for CPU%d is already allocated\n", evt->irq, cpu);
+        if (evt->irq >= 0)
+                xen_teardown_timer(cpu);
 
         printk(KERN_INFO "installing Xen timer for CPU %d\n", cpu);
 
@@ -420,22 +452,15 @@ void xen_setup_timer(int cpu)
 
         evt->cpumask = cpumask_of(cpu);
         evt->irq = irq;
+        per_cpu(xen_clock_events, cpu).name = name;
 }
 
-void xen_teardown_timer(int cpu)
-{
-        struct clock_event_device *evt;
-        BUG_ON(cpu == 0);
-        evt = &per_cpu(xen_clock_events, cpu);
-        unbind_from_irqhandler(evt->irq, NULL);
-        evt->irq = -1;
-}
 
 void xen_setup_cpu_clockevents(void)
 {
         BUG_ON(preemptible());
 
-        clockevents_register_device(&__get_cpu_var(xen_clock_events));
+        clockevents_register_device(&__get_cpu_var(xen_clock_events).evt);
 }
 
 void xen_timer_resume(void)
@@ -480,6 +505,9 @@ static void __init xen_time_init(void)
         xen_setup_runstate_info(cpu);
         xen_setup_timer(cpu);
         xen_setup_cpu_clockevents();
+
+        if (xen_initial_domain())
+                pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier);
 }
 
 void __init xen_init_time_ops(void)
@@ -492,7 +520,9 @@ void __init xen_init_time_ops(void)
 
         x86_platform.calibrate_tsc = xen_tsc_khz;
         x86_platform.get_wallclock = xen_get_wallclock;
-        x86_platform.set_wallclock = xen_set_wallclock;
+        /* Dom0 uses the native method to set the hardware RTC. */
+        if (!xen_initial_domain())
+                x86_platform.set_wallclock = xen_set_wallclock;
 }
 
 #ifdef CONFIG_XEN_PVHVM
diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h
index a95b41744ad0..86782c5d7e2a 100644
--- a/arch/x86/xen/xen-ops.h
+++ b/arch/x86/xen/xen-ops.h
@@ -73,7 +73,7 @@ static inline void xen_hvm_smp_init(void) {}
 
 #ifdef CONFIG_PARAVIRT_SPINLOCKS
 void __init xen_init_spinlocks(void);
-void __cpuinit xen_init_lock_cpu(int cpu);
+void xen_init_lock_cpu(int cpu);
 void xen_uninit_lock_cpu(int cpu);
 #else
 static inline void xen_init_spinlocks(void)