timekeeping: Fix clock_gettime vsyscall time warp
[linux-2.6.git] / arch / s390 / kernel / time.c
index d649600..68e1ecf 100644 (file)
@@ -36,7 +36,6 @@
 #include <linux/notifier.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
-#include <linux/bootmem.h>
 #include <asm/uaccess.h>
 #include <asm/delay.h>
 #include <asm/s390_ext.h>
@@ -52,9 +51,6 @@
 #define USECS_PER_JIFFY     ((unsigned long) 1000000/HZ)
 #define CLK_TICKS_PER_JIFFY ((unsigned long) USECS_PER_JIFFY << 12)
 
-/* The value of the TOD clock for 1.1.1970. */
-#define TOD_UNIX_EPOCH 0x7d91048bca000000ULL
-
 /*
  * Create a small time difference between the timer interrupts
  * on the different cpus to avoid lock contention.
 
 #define TICK_SIZE tick
 
-static ext_int_info_t ext_int_info_cc;
-static ext_int_info_t ext_int_etr_cc;
-static u64 sched_clock_base_cc;
+u64 sched_clock_base_cc = -1;  /* Force to data section. */
+EXPORT_SYMBOL_GPL(sched_clock_base_cc);
 
 static DEFINE_PER_CPU(struct clock_event_device, comparators);
 
 /*
  * Scheduler clock - returns current time in nanosec units.
  */
-unsigned long long sched_clock(void)
+unsigned long long notrace sched_clock(void)
 {
-       return ((get_clock_xt() - sched_clock_base_cc) * 125) >> 9;
+       return (get_clock_monotonic() * 125) >> 9;
 }
 
 /*
@@ -96,12 +91,7 @@ void tod_to_timeval(__u64 todval, struct timespec *xtime)
        todval -= (sec * 1000000) << 12;
        xtime->tv_nsec = ((todval * 1000) >> 12);
 }
-
-#ifdef CONFIG_PROFILING
-#define s390_do_profile()      profile_tick(CPU_PROFILING)
-#else
-#define s390_do_profile()      do { ; } while(0)
-#endif /* CONFIG_PROFILING */
+EXPORT_SYMBOL(tod_to_timeval);
 
 void clock_comparator_work(void)
 {
@@ -111,7 +101,6 @@ void clock_comparator_work(void)
        set_clock_comparator(S390_lowcore.clock_comparator);
        cd = &__get_cpu_var(comparators);
        cd->event_handler(cd);
-       s390_do_profile();
 }
 
 /*
@@ -195,25 +184,17 @@ static void timing_alert_interrupt(__u16 code)
 static void etr_reset(void);
 static void stp_reset(void);
 
-/*
- * Get the TOD clock running.
- */
-static u64 __init reset_tod_clock(void)
+void read_persistent_clock(struct timespec *ts)
 {
-       u64 time;
-
-       etr_reset();
-       stp_reset();
-       if (store_clock(&time) == 0)
-               return time;
-       /* TOD clock not running. Set the clock to Unix Epoch. */
-       if (set_clock(TOD_UNIX_EPOCH) != 0 || store_clock(&time) != 0)
-               panic("TOD clock not operational.");
+       tod_to_timeval(get_clock() - TOD_UNIX_EPOCH, ts);
+}
 
-       return TOD_UNIX_EPOCH;
+void read_boot_clock(struct timespec *ts)
+{
+       tod_to_timeval(sched_clock_base_cc - TOD_UNIX_EPOCH, ts);
 }
 
-static cycle_t read_tod_clock(void)
+static cycle_t read_tod_clock(struct clocksource *cs)
 {
        return get_clock();
 }
@@ -228,8 +209,13 @@ static struct clocksource clocksource_tod = {
        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
+struct clocksource * __init clocksource_default_clock(void)
+{
+       return &clocksource_tod;
+}
 
-void update_vsyscall(struct timespec *wall_time, struct clocksource *clock)
+void update_vsyscall(struct timespec *wall_time, struct clocksource *clock,
+                    u32 mult)
 {
        if (clock != &clocksource_tod)
                return;
@@ -265,30 +251,24 @@ void update_vsyscall_tz(void)
  */
 void __init time_init(void)
 {
-       sched_clock_base_cc = reset_tod_clock();
-
-       /* set xtime */
-       tod_to_timeval(sched_clock_base_cc - TOD_UNIX_EPOCH, &xtime);
-        set_normalized_timespec(&wall_to_monotonic,
-                                -xtime.tv_sec, -xtime.tv_nsec);
+       /* Reset time synchronization interfaces. */
+       etr_reset();
+       stp_reset();
 
        /* request the clock comparator external interrupt */
-       if (register_early_external_interrupt(0x1004,
-                                             clock_comparator_interrupt,
-                                             &ext_int_info_cc) != 0)
+       if (register_external_interrupt(0x1004, clock_comparator_interrupt))
                 panic("Couldn't request external interrupt 0x1004");
 
-       if (clocksource_register(&clocksource_tod) != 0)
-               panic("Could not register TOD clock source");
-
        /* request the timing alert external interrupt */
-       if (register_early_external_interrupt(0x1406,
-                                             timing_alert_interrupt,
-                                             &ext_int_etr_cc) != 0)
+       if (register_external_interrupt(0x1406, timing_alert_interrupt))
                panic("Couldn't request external interrupt 0x1406");
 
+       if (clocksource_register(&clocksource_tod) != 0)
+               panic("Could not register TOD clock source");
+
        /* Enable TOD clock interrupts on the boot cpu. */
        init_cpu_timer();
+
        /* Enable cpu timer interrupts on the boot cpu. */
        vtime_init();
 }
@@ -331,6 +311,7 @@ static unsigned long long adjust_time(unsigned long long old,
 }
 
 static DEFINE_PER_CPU(atomic_t, clock_sync_word);
+static DEFINE_MUTEX(clock_sync_mutex);
 static unsigned long clock_sync_flags;
 
 #define CLOCK_SYNC_HAS_ETR     0
@@ -394,13 +375,29 @@ static void enable_sync_clock(void)
        atomic_set_mask(0x80000000, sw_ptr);
 }
 
+/*
+ * Function to check if the clock is in sync.
+ */
+static inline int check_sync_clock(void)
+{
+       atomic_t *sw_ptr;
+       int rc;
+
+       sw_ptr = &get_cpu_var(clock_sync_word);
+       rc = (atomic_read(sw_ptr) & 0x80000000U) != 0;
+       put_cpu_var(clock_sync_sync);
+       return rc;
+}
+
 /* Single threaded workqueue used for etr and stp sync events */
 static struct workqueue_struct *time_sync_wq;
 
 static void __init time_init_wq(void)
 {
-       if (!time_sync_wq)
-               time_sync_wq = create_singlethread_workqueue("timesync");
+       if (time_sync_wq)
+               return;
+       time_sync_wq = create_singlethread_workqueue("timesync");
+       stop_machine_create();
 }
 
 /*
@@ -483,6 +480,8 @@ static void etr_reset(void)
        if (etr_setr(&etr_eacr) == 0) {
                etr_tolec = get_clock();
                set_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags);
+               if (etr_port0_online && etr_port1_online)
+                       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        } else if (etr_port0_online || etr_port1_online) {
                pr_warning("The real or virtual hardware system does "
                           "not provide an ETR interface\n");
@@ -531,8 +530,7 @@ void etr_switch_to_local(void)
 {
        if (!etr_eacr.sl)
                return;
-       if (test_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               disable_sync_clock(NULL);
+       disable_sync_clock(NULL);
        set_bit(ETR_EVENT_SWITCH_LOCAL, &etr_events);
        queue_work(time_sync_wq, &etr_work);
 }
@@ -547,8 +545,7 @@ void etr_sync_check(void)
 {
        if (!etr_eacr.es)
                return;
-       if (test_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               disable_sync_clock(NULL);
+       disable_sync_clock(NULL);
        set_bit(ETR_EVENT_SYNC_CHECK, &etr_events);
        queue_work(time_sync_wq, &etr_work);
 }
@@ -912,7 +909,7 @@ static struct etr_eacr etr_handle_update(struct etr_aib *aib,
         * Do not try to get the alternate port aib if the clock
         * is not in sync yet.
         */
-       if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags) && !eacr.es)
+       if (!check_sync_clock())
                return eacr;
 
        /*
@@ -995,7 +992,6 @@ static void etr_work_fn(struct work_struct *work)
                on_each_cpu(disable_sync_clock, NULL, 1);
                del_timer_sync(&etr_timer);
                etr_update_eacr(eacr);
-               clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                goto out_unlock;
        }
 
@@ -1069,18 +1065,13 @@ static void etr_work_fn(struct work_struct *work)
                /* Both ports not usable. */
                eacr.es = eacr.sl = 0;
                sync_port = -1;
-               clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        }
 
-       if (!test_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               eacr.es = 0;
-
        /*
         * If the clock is in sync just update the eacr and return.
         * If there is no valid sync port wait for a port update.
         */
-       if (test_bit(CLOCK_SYNC_STP, &clock_sync_flags) ||
-           eacr.es || sync_port < 0) {
+       if (check_sync_clock() || sync_port < 0) {
                etr_update_eacr(eacr);
                etr_set_tolec_timeout(now);
                goto out_unlock;
@@ -1101,13 +1092,11 @@ static void etr_work_fn(struct work_struct *work)
         * and set up a timer to try again after 0.5 seconds
         */
        etr_update_eacr(eacr);
-       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
        if (now < etr_tolec + (1600000 << 12) ||
            etr_sync_clock_stop(&aib, sync_port) != 0) {
                /* Sync failed. Try again in 1/2 second. */
                eacr.es = 0;
                etr_update_eacr(eacr);
-               clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                etr_set_sync_timeout();
        } else
                etr_set_tolec_timeout(now);
@@ -1189,19 +1178,30 @@ static ssize_t etr_online_store(struct sys_device *dev,
                return -EINVAL;
        if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
                return -EOPNOTSUPP;
+       mutex_lock(&clock_sync_mutex);
        if (dev == &etr_port0_dev) {
                if (etr_port0_online == value)
-                       return count;   /* Nothing to do. */
+                       goto out;       /* Nothing to do. */
                etr_port0_online = value;
+               if (etr_port0_online && etr_port1_online)
+                       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
+               else
+                       clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
                queue_work(time_sync_wq, &etr_work);
        } else {
                if (etr_port1_online == value)
-                       return count;   /* Nothing to do. */
+                       goto out;       /* Nothing to do. */
                etr_port1_online = value;
+               if (etr_port0_online && etr_port1_online)
+                       set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
+               else
+                       clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
                set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
                queue_work(time_sync_wq, &etr_work);
        }
+out:
+       mutex_unlock(&clock_sync_mutex);
        return count;
 }
 
@@ -1403,6 +1403,7 @@ static void *stp_page;
 static void stp_work_fn(struct work_struct *work);
 static DEFINE_MUTEX(stp_work_mutex);
 static DECLARE_WORK(stp_work, stp_work_fn);
+static struct timer_list stp_timer;
 
 static int __init early_parse_stp(char *p)
 {
@@ -1421,23 +1422,29 @@ static void __init stp_reset(void)
 {
        int rc;
 
-       stp_page = alloc_bootmem_pages(PAGE_SIZE);
+       stp_page = (void *) get_zeroed_page(GFP_ATOMIC);
        rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
        if (rc == 0)
                set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
        else if (stp_online) {
                pr_warning("The real or virtual hardware system does "
                           "not provide an STP interface\n");
-               free_bootmem((unsigned long) stp_page, PAGE_SIZE);
+               free_page((unsigned long) stp_page);
                stp_page = NULL;
                stp_online = 0;
        }
 }
 
+static void stp_timeout(unsigned long dummy)
+{
+       queue_work(time_sync_wq, &stp_work);
+}
+
 static int __init stp_init(void)
 {
        if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
                return 0;
+       setup_timer(&stp_timer, stp_timeout, 0UL);
        time_init_wq();
        if (!stp_online)
                return 0;
@@ -1469,8 +1476,6 @@ static void stp_timing_alert(struct stp_irq_parm *intparm)
  */
 void stp_sync_check(void)
 {
-       if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
-               return;
        disable_sync_clock(NULL);
        queue_work(time_sync_wq, &stp_work);
 }
@@ -1483,8 +1488,6 @@ void stp_sync_check(void)
  */
 void stp_island_check(void)
 {
-       if (!test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
-               return;
        disable_sync_clock(NULL);
        queue_work(time_sync_wq, &stp_work);
 }
@@ -1511,10 +1514,6 @@ static int stp_sync_clock(void *data)
 
        enable_sync_clock();
 
-       set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
-       if (test_and_clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags))
-               queue_work(time_sync_wq, &etr_work);
-
        rc = 0;
        if (stp_info.todoff[0] || stp_info.todoff[1] ||
            stp_info.todoff[2] || stp_info.todoff[3] ||
@@ -1533,9 +1532,6 @@ static int stp_sync_clock(void *data)
        if (rc) {
                disable_sync_clock(NULL);
                stp_sync->in_sync = -EAGAIN;
-               clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
-               if (etr_port0_online || etr_port1_online)
-                       queue_work(time_sync_wq, &etr_work);
        } else
                stp_sync->in_sync = 1;
        xchg(&first, 0);
@@ -1556,6 +1552,7 @@ static void stp_work_fn(struct work_struct *work)
 
        if (!stp_online) {
                chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
+               del_timer_sync(&stp_timer);
                goto out_unlock;
        }
 
@@ -1567,12 +1564,23 @@ static void stp_work_fn(struct work_struct *work)
        if (rc || stp_info.c == 0)
                goto out_unlock;
 
+       /* Skip synchronization if the clock is already in sync. */
+       if (check_sync_clock())
+               goto out_unlock;
+
        memset(&stp_sync, 0, sizeof(stp_sync));
        get_online_cpus();
        atomic_set(&stp_sync.cpus, num_online_cpus() - 1);
        stop_machine(stp_sync_clock, &stp_sync, &cpu_online_map);
        put_online_cpus();
 
+       if (!check_sync_clock())
+               /*
+                * There is a usable clock but the synchonization failed.
+                * Retry after a second.
+                */
+               mod_timer(&stp_timer, jiffies + HZ);
+
 out_unlock:
        mutex_unlock(&stp_work_mutex);
 }
@@ -1682,8 +1690,14 @@ static ssize_t stp_online_store(struct sysdev_class *class,
                return -EINVAL;
        if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
                return -EOPNOTSUPP;
+       mutex_lock(&clock_sync_mutex);
        stp_online = value;
+       if (stp_online)
+               set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
+       else
+               clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
        queue_work(time_sync_wq, &stp_work);
+       mutex_unlock(&clock_sync_mutex);
        return count;
 }