uml: eliminate interrupts in the idle loop

Now, the idle loop now longer needs SIGALRM firing - it can just sleep for the
requisite amount of time and fake a timer interrupt when it finishes.

Any use of ITIMER_REAL now goes away.  disable_timer only turns off
ITIMER_VIRTUAL.  switch_timers is no longer needed, so it, and all calls, goes
away.

disable_timer now returns the amount of time remaining on the timer.
default_idle uses this to tell idle_sleep how long to sleep.  idle_sleep will
call alarm_handler if nanosleep returns 0, which is the case if it didn't
return early due to an interrupt.  Otherwise, it just returns.

Signed-off-by: Jeff Dike <jdike@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 11 insertions, 43 deletions

diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c
index 9ffc61ac8ed6..d2cb161ae2b3 100644
--- a/arch/um/os-Linux/time.c
+++ b/arch/um/os-Linux/time.c
@@ -12,8 +12,6 @@
 #include "os.h"
 #include "user.h"
 
-static int is_real_timer = 0;
-
 int set_interval(void)
 {
         int usec = 1000000/UM_HZ;
@@ -41,47 +39,15 @@ int timer_one_shot(int ticks)
         return 0;
 }
 
-void disable_timer(void)
+unsigned long long disable_timer(void)
 {
-        struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
+        struct itimerval time = ((struct itimerval) { { 0, 0 }, { 0, 0 } });
 
-        if ((setitimer(ITIMER_VIRTUAL, &disable, NULL) < 0) ||
-            (setitimer(ITIMER_REAL, &disable, NULL) < 0))
+        if(setitimer(ITIMER_VIRTUAL, &time, &time) < 0)
                 printk(UM_KERN_ERR "disable_timer - setitimer failed, "
                        "errno = %d\n", errno);
-}
-
-int switch_timers(int to_real)
-{
-        struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
-        struct itimerval enable;
-        int old, new, old_type = is_real_timer;
-
-        if(to_real == old_type)
-                return to_real;
-
-        if (to_real) {
-                old = ITIMER_VIRTUAL;
-                new = ITIMER_REAL;
-        }
-        else {
-                old = ITIMER_REAL;
-                new = ITIMER_VIRTUAL;
-        }
-
-        if (setitimer(old, &disable, &enable) < 0)
-                printk(UM_KERN_ERR "switch_timers - setitimer disable failed, "
-                       "errno = %d\n", errno);
 
-        if((enable.it_value.tv_sec == 0) && (enable.it_value.tv_usec == 0))
-                enable.it_value = enable.it_interval;
-
-        if (setitimer(new, &enable, NULL))
-                printk(UM_KERN_ERR "switch_timers - setitimer enable failed, "
-                       "errno = %d\n", errno);
-
-        is_real_timer = to_real;
-        return old_type;
+        return tv_to_nsec(&time.it_value);
 }
 
 unsigned long long os_nsecs(void)
@@ -92,11 +58,13 @@ unsigned long long os_nsecs(void)
         return timeval_to_ns(&tv);
 }
 
-void idle_sleep(int secs)
+extern void alarm_handler(int sig, struct sigcontext *sc);
+
+void idle_sleep(unsigned long long nsecs)
 {
-        struct timespec ts;
+        struct timespec ts = { .tv_sec  = nsecs / BILLION,
+                               .tv_nsec = nsecs % BILLION };
 
-        ts.tv_sec = secs;
-        ts.tv_nsec = 0;
-        nanosleep(&ts, NULL);
+        if (nanosleep(&ts, &ts) == 0)
+                alarm_handler(SIGVTALRM, NULL);
 }