Merge branch 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull timer core updates from Thomas Gleixner:
 "The timer changes contain:

   - posix timer code consolidation and fixes for odd corner cases

   - sched_clock implementation moved from ARM to core code to avoid
     duplication by other architectures

   - alarm timer updates

   - clocksource and clockevents unregistration facilities

   - clocksource/events support for new hardware

   - precise nanoseconds RTC readout (Xen feature)

   - generic support for Xen suspend/resume oddities

   - the usual lot of fixes and cleanups all over the place

  The parts which touch other areas (ARM/XEN) have been coordinated with
  the relevant maintainers.  Though this results in an handful of
  trivial to solve merge conflicts, which we preferred over nasty cross
  tree merge dependencies.

  The patches which have been committed in the last few days are bug
  fixes plus the posix timer lot.  The latter was in akpms queue and
  next for quite some time; they just got forgotten and Frederic
  collected them last minute."

* 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (59 commits)
  hrtimer: Remove unused variable
  hrtimers: Move SMP function call to thread context
  clocksource: Reselect clocksource when watchdog validated high-res capability
  posix-cpu-timers: don't account cpu timer after stopped thread runtime accounting
  posix_timers: fix racy timer delta caching on task exit
  posix-timers: correctly get dying task time sample in posix_cpu_timer_schedule()
  selftests: add basic posix timers selftests
  posix_cpu_timers: consolidate expired timers check
  posix_cpu_timers: consolidate timer list cleanups
  posix_cpu_timer: consolidate expiry time type
  tick: Sanitize broadcast control logic
  tick: Prevent uncontrolled switch to oneshot mode
  tick: Make oneshot broadcast robust vs. CPU offlining
  x86: xen: Sync the CMOS RTC as well as the Xen wallclock
  x86: xen: Sync the wallclock when the system time is set
  timekeeping: Indicate that clock was set in the pvclock gtod notifier
  timekeeping: Pass flags instead of multiple bools to timekeeping_update()
  xen: Remove clock_was_set() call in the resume path
  hrtimers: Support resuming with two or more CPUs online (but stopped)
  timer: Fix jiffies wrap behavior of round_jiffies_common()
  ...

9 files changed, 75 insertions, 48 deletions

diff --git a/arch/x86/include/asm/mc146818rtc.h b/arch/x86/include/asm/mc146818rtc.h
index d354fb781c57..a55c7efcc4ed 100644
--- a/arch/x86/include/asm/mc146818rtc.h
+++ b/arch/x86/include/asm/mc146818rtc.h
@@ -95,8 +95,8 @@ static inline unsigned char current_lock_cmos_reg(void)
 unsigned char rtc_cmos_read(unsigned char addr);
 void rtc_cmos_write(unsigned char val, unsigned char addr);
 
-extern int mach_set_rtc_mmss(unsigned long nowtime);
-extern unsigned long mach_get_cmos_time(void);
+extern int mach_set_rtc_mmss(const struct timespec *now);
+extern void mach_get_cmos_time(struct timespec *now);
 
 #define RTC_IRQ 8
 
diff --git a/arch/x86/include/asm/mrst-vrtc.h b/arch/x86/include/asm/mrst-vrtc.h
index 73668abdbedf..1e69a75412a4 100644
--- a/arch/x86/include/asm/mrst-vrtc.h
+++ b/arch/x86/include/asm/mrst-vrtc.h
@@ -3,7 +3,7 @@
 
 extern unsigned char vrtc_cmos_read(unsigned char reg);
 extern void vrtc_cmos_write(unsigned char val, unsigned char reg);
-extern unsigned long vrtc_get_time(void);
-extern int vrtc_set_mmss(unsigned long nowtime);
+extern void vrtc_get_time(struct timespec *now);
+extern int vrtc_set_mmss(const struct timespec *now);
 
 #endif
diff --git a/arch/x86/include/asm/x86_init.h b/arch/x86/include/asm/x86_init.h
index d8d99222b36a..828a1565ba57 100644
--- a/arch/x86/include/asm/x86_init.h
+++ b/arch/x86/include/asm/x86_init.h
@@ -142,6 +142,8 @@ struct x86_cpuinit_ops {
         void (*fixup_cpu_id)(struct cpuinfo_x86 *c, int node);
 };
 
+struct timespec;
+
 /**
  * struct x86_platform_ops - platform specific runtime functions
  * @calibrate_tsc:              calibrate TSC
@@ -156,8 +158,8 @@ struct x86_cpuinit_ops {
  */
 struct x86_platform_ops {
         unsigned long (*calibrate_tsc)(void);
-        unsigned long (*get_wallclock)(void);
-        int (*set_wallclock)(unsigned long nowtime);
+        void (*get_wallclock)(struct timespec *ts);
+        int (*set_wallclock)(const struct timespec *ts);
         void (*iommu_shutdown)(void);
         bool (*is_untracked_pat_range)(u64 start, u64 end);
         void (*nmi_init)(void);
diff --git a/arch/x86/kernel/kvmclock.c b/arch/x86/kernel/kvmclock.c
index 3dd37ebd591b..1f354f4b602b 100644
--- a/arch/x86/kernel/kvmclock.c
+++ b/arch/x86/kernel/kvmclock.c
@@ -48,10 +48,9 @@ static struct pvclock_wall_clock wall_clock;
  * have elapsed since the hypervisor wrote the data. So we try to account for
  * that with system time
  */
-static unsigned long kvm_get_wallclock(void)
+static void kvm_get_wallclock(struct timespec *now)
 {
         struct pvclock_vcpu_time_info *vcpu_time;
-        struct timespec ts;
         int low, high;
         int cpu;
 
@@ -64,14 +63,12 @@ static unsigned long kvm_get_wallclock(void)
         cpu = smp_processor_id();
 
         vcpu_time = &hv_clock[cpu].pvti;
-        pvclock_read_wallclock(&wall_clock, vcpu_time, &ts);
+        pvclock_read_wallclock(&wall_clock, vcpu_time, now);
 
         preempt_enable();
-
-        return ts.tv_sec;
 }
 
-static int kvm_set_wallclock(unsigned long now)
+static int kvm_set_wallclock(const struct timespec *now)
 {
         return -1;
 }
diff --git a/arch/x86/kernel/rtc.c b/arch/x86/kernel/rtc.c
index 198eb201ed3b..0aa29394ed6f 100644
--- a/arch/x86/kernel/rtc.c
+++ b/arch/x86/kernel/rtc.c
@@ -38,8 +38,9 @@ EXPORT_SYMBOL(rtc_lock);
  * jump to the next second precisely 500 ms later. Check the Motorola
  * MC146818A or Dallas DS12887 data sheet for details.
  */
-int mach_set_rtc_mmss(unsigned long nowtime)
+int mach_set_rtc_mmss(const struct timespec *now)
 {
+        unsigned long nowtime = now->tv_sec;
         struct rtc_time tm;
         int retval = 0;
 
@@ -58,7 +59,7 @@ int mach_set_rtc_mmss(unsigned long nowtime)
         return retval;
 }
 
-unsigned long mach_get_cmos_time(void)
+void mach_get_cmos_time(struct timespec *now)
 {
         unsigned int status, year, mon, day, hour, min, sec, century = 0;
         unsigned long flags;
@@ -107,7 +108,8 @@ unsigned long mach_get_cmos_time(void)
         } else
                 year += CMOS_YEARS_OFFS;
 
-        return mktime(year, mon, day, hour, min, sec);
+        now->tv_sec = mktime(year, mon, day, hour, min, sec);
+        now->tv_nsec = 0;
 }
 
 /* Routines for accessing the CMOS RAM/RTC. */
@@ -135,18 +137,13 @@ EXPORT_SYMBOL(rtc_cmos_write);
 
 int update_persistent_clock(struct timespec now)
 {
-        return x86_platform.set_wallclock(now.tv_sec);
+        return x86_platform.set_wallclock(&now);
 }
 
 /* not static: needed by APM */
 void read_persistent_clock(struct timespec *ts)
 {
-        unsigned long retval;
-
-        retval = x86_platform.get_wallclock();
-
-        ts->tv_sec = retval;
-        ts->tv_nsec = 0;
+        x86_platform.get_wallclock(ts);
 }
 
 
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c
index d482bcaf61c1..6a22c19da663 100644
--- a/arch/x86/lguest/boot.c
+++ b/arch/x86/lguest/boot.c
@@ -882,9 +882,9 @@ int lguest_setup_irq(unsigned int irq)
  * It would be far better for everyone if the Guest had its own clock, but
  * until then the Host gives us the time on every interrupt.
  */
-static unsigned long lguest_get_wallclock(void)
+static void lguest_get_wallclock(struct timespec *now)
 {
-        return lguest_data.time.tv_sec;
+        *now = lguest_data.time;
 }
 
 /*
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index b410b71bdcf7..c8d5577044bb 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -274,8 +274,9 @@ static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
         return status;
 }
 
-int efi_set_rtc_mmss(unsigned long nowtime)
+int efi_set_rtc_mmss(const struct timespec *now)
 {
+        unsigned long nowtime = now->tv_sec;
         efi_status_t    status;
         efi_time_t      eft;
         efi_time_cap_t  cap;
@@ -310,7 +311,7 @@ int efi_set_rtc_mmss(unsigned long nowtime)
         return 0;
 }
 
-unsigned long efi_get_time(void)
+void efi_get_time(struct timespec *now)
 {
         efi_status_t status;
         efi_time_t eft;
@@ -320,8 +321,9 @@ unsigned long efi_get_time(void)
         if (status != EFI_SUCCESS)
                 pr_err("Oops: efitime: can't read time!\n");
 
-        return mktime(eft.year, eft.month, eft.day, eft.hour,
-                      eft.minute, eft.second);
+        now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour,
+                             eft.minute, eft.second);
+        now->tv_nsec = 0;
 }
 
 /*
diff --git a/arch/x86/platform/mrst/vrtc.c b/arch/x86/platform/mrst/vrtc.c
index d62b0a3b5c14..5e355b134ba4 100644
--- a/arch/x86/platform/mrst/vrtc.c
+++ b/arch/x86/platform/mrst/vrtc.c
@@ -56,7 +56,7 @@ void vrtc_cmos_write(unsigned char val, unsigned char reg)
 }
 EXPORT_SYMBOL_GPL(vrtc_cmos_write);
 
-unsigned long vrtc_get_time(void)
+void vrtc_get_time(struct timespec *now)
 {
         u8 sec, min, hour, mday, mon;
         unsigned long flags;
@@ -82,17 +82,18 @@ unsigned long vrtc_get_time(void)
         printk(KERN_INFO "vRTC: sec: %d min: %d hour: %d day: %d "
                 "mon: %d year: %d\n", sec, min, hour, mday, mon, year);
 
-        return mktime(year, mon, mday, hour, min, sec);
+        now->tv_sec = mktime(year, mon, mday, hour, min, sec);
+        now->tv_nsec = 0;
 }
 
-int vrtc_set_mmss(unsigned long nowtime)
+int vrtc_set_mmss(const struct timespec *now)
 {
         unsigned long flags;
         struct rtc_time tm;
         int year;
         int retval = 0;
 
-        rtc_time_to_tm(nowtime, &tm);
+        rtc_time_to_tm(now->tv_sec, &tm);
         if (!rtc_valid_tm(&tm) && tm.tm_year >= 72) {
                 /*
                  * tm.year is the number of years since 1900, and the
@@ -110,7 +111,7 @@ int vrtc_set_mmss(unsigned long nowtime)
         } else {
                 printk(KERN_ERR
                        "%s: Invalid vRTC value: write of %lx to vRTC failed\n",
-                        __FUNCTION__, nowtime);
+                        __FUNCTION__, now->tv_sec);
                 retval = -EINVAL;
         }
         return retval;
diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index a690868be837..ee365895b06b 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -15,6 +15,7 @@
 #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>
@@ -179,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);
 
-        return rc;
+        /*
+         * 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 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,
@@ -482,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)
@@ -494,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