um: Switch clocksource to hrtimers

UML is using an obsolete itimer call for
all timers and "polls" for kernel space timer firing
in its userspace portion resulting in a long list
of bugs and incorrect behaviour(s). It also uses
ITIMER_VIRTUAL for its timer which results in the
timer being dependent on it running and the cpu
load.

This patch fixes this by moving to posix high resolution
timers firing off CLOCK_MONOTONIC and relaying the timer
correctly to the UML userspace.

Fixes:
 - crashes when hosts suspends/resumes
 - broken userspace timers - effecive ~40Hz instead
   of what they should be. Note - this modifies skas behavior
   by no longer setting an itimer per clone(). Timer events
   are relayed instead.
 - kernel network packet scheduling disciplines
 - tcp behaviour especially under load
 - various timer related corner cases

Finally, overall responsiveness of userspace is better.

Signed-off-by: Thomas Meyer <thomas@m3y3r.de>
Signed-off-by: Anton Ivanov <aivanov@brocade.com>
[rw: massaged commit message]
Signed-off-by: Richard Weinberger <richard@nod.at>

1 files changed, 48 insertions, 25 deletions

diff --git a/arch/um/kernel/time.c b/arch/um/kernel/time.c
index 5af441efb377..25c23666d592 100644
--- a/arch/um/kernel/time.c
+++ b/arch/um/kernel/time.c
@@ -1,4 +1,7 @@
 /*
+ * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk})
+ * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
+ * Copyright (C) 2012-2014 Cisco Systems
  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
@@ -7,11 +10,15 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/jiffies.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
 #include <linux/threads.h>
 #include <asm/irq.h>
 #include <asm/param.h>
 #include <kern_util.h>
 #include <os.h>
+#include <timer-internal.h>
 
 void timer_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs)
 {
@@ -24,81 +31,97 @@ void timer_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs *regs)
 
 static int itimer_shutdown(struct clock_event_device *evt)
 {
-        disable_timer();
+        os_timer_disable();
         return 0;
 }
 
 static int itimer_set_periodic(struct clock_event_device *evt)
 {
-        set_interval();
+        os_timer_set_interval(NULL, NULL);
         return 0;
 }
 
 static int itimer_next_event(unsigned long delta,
                              struct clock_event_device *evt)
 {
-        return timer_one_shot(delta + 1);
+        return os_timer_one_shot(delta);
 }
 
-static struct clock_event_device itimer_clockevent = {
-        .name                   = "itimer",
+static int itimer_one_shot(struct clock_event_device *evt)
+{
+        os_timer_one_shot(1);
+        return 0;
+}
+
+static struct clock_event_device timer_clockevent = {
+        .name                   = "posix-timer",
         .rating                 = 250,
         .cpumask                = cpu_all_mask,
         .features               = CLOCK_EVT_FEAT_PERIODIC |
                                   CLOCK_EVT_FEAT_ONESHOT,
         .set_state_shutdown     = itimer_shutdown,
         .set_state_periodic     = itimer_set_periodic,
-        .set_state_oneshot      = itimer_shutdown,
+        .set_state_oneshot      = itimer_one_shot,
         .set_next_event         = itimer_next_event,
-        .shift                  = 32,
+        .shift                  = 0,
+        .max_delta_ns           = 0xffffffff,
+        .min_delta_ns           = TIMER_MIN_DELTA, //microsecond resolution should be enough for anyone, same as 640K RAM
         .irq                    = 0,
+        .mult                   = 1,
 };
 
 static irqreturn_t um_timer(int irq, void *dev)
 {
-        (*itimer_clockevent.event_handler)(&itimer_clockevent);
+        if (get_current()->mm != NULL)
+        {
+        /* userspace - relay signal, results in correct userspace timers */
+                os_alarm_process(get_current()->mm->context.id.u.pid);
+        }
+
+        (*timer_clockevent.event_handler)(&timer_clockevent);
 
         return IRQ_HANDLED;
 }
 
-static cycle_t itimer_read(struct clocksource *cs)
+static cycle_t timer_read(struct clocksource *cs)
 {
-        return os_nsecs() / 1000;
+        return os_nsecs() / TIMER_MULTIPLIER;
 }
 
-static struct clocksource itimer_clocksource = {
-        .name           = "itimer",
+static struct clocksource timer_clocksource = {
+        .name           = "timer",
         .rating         = 300,
-        .read           = itimer_read,
+        .read           = timer_read,
         .mask           = CLOCKSOURCE_MASK(64),
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
-static void __init setup_itimer(void)
+static void __init timer_setup(void)
 {
         int err;
 
-        err = request_irq(TIMER_IRQ, um_timer, 0, "timer", NULL);
+        err = request_irq(TIMER_IRQ, um_timer, IRQF_TIMER, "hr timer", NULL);
         if (err != 0)
                 printk(KERN_ERR "register_timer : request_irq failed - "
                        "errno = %d\n", -err);
 
-        itimer_clockevent.mult = div_sc(HZ, NSEC_PER_SEC, 32);
-        itimer_clockevent.max_delta_ns =
-                clockevent_delta2ns(60 * HZ, &itimer_clockevent);
-        itimer_clockevent.min_delta_ns =
-                clockevent_delta2ns(1, &itimer_clockevent);
-        err = clocksource_register_hz(&itimer_clocksource, USEC_PER_SEC);
+        err = os_timer_create(NULL);
+        if (err != 0) {
+                printk(KERN_ERR "creation of timer failed - errno = %d\n", -err);
+                return;
+        }
+
+        err = clocksource_register_hz(&timer_clocksource, NSEC_PER_SEC/TIMER_MULTIPLIER);
         if (err) {
                 printk(KERN_ERR "clocksource_register_hz returned %d\n", err);
                 return;
         }
-        clockevents_register_device(&itimer_clockevent);
+        clockevents_register_device(&timer_clockevent);
 }
 
 void read_persistent_clock(struct timespec *ts)
 {
-        long long nsecs = os_nsecs();
+        long long nsecs = os_persistent_clock_emulation();
 
         set_normalized_timespec(ts, nsecs / NSEC_PER_SEC,
                                 nsecs % NSEC_PER_SEC);
@@ -106,6 +129,6 @@ void read_persistent_clock(struct timespec *ts)
 
 void __init time_init(void)
 {
-        timer_init();
-        late_time_init = setup_itimer;
+        timer_set_signal_handler();
+        late_time_init = timer_setup;
 }