Merge git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6

[mv-sheeva.git] / arch / um / os-Linux / time.c

diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c
index 5de169b168f6d94c9fa360c7ab45ca90371f7c8c..e34e1effe0f59b53b7b12f0f733053643f7bee4f 100644 (file)
--- a/arch/um/os-Linux/time.c
+++ b/arch/um/os-Linux/time.c
@@ -1,101 +1,86 @@
 /*
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
+#include <stddef.h>
+#include <errno.h>
+#include <signal.h>
 #include <time.h>
 #include <sys/time.h>
-#include <signal.h>
-#include <errno.h>
-#include "kern_util.h"
-#include "user.h"
-#include "process.h"
 #include "kern_constants.h"
 #include "os.h"
-#include "uml-config.h"
+#include "user.h"
 
-int set_interval(int is_virtual)
+int set_interval(void)
 {
-       int usec = 1000000/hz();
-       int timer_type = is_virtual ? ITIMER_VIRTUAL : ITIMER_REAL;
+       int usec = UM_USEC_PER_SEC / UM_HZ;
        struct itimerval interval = ((struct itimerval) { { 0, usec },
                                                          { 0, usec } });
 
-       if(setitimer(timer_type, &interval, NULL) == -1)
+       if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1)
                return -errno;
 
        return 0;
 }
 
-#ifdef UML_CONFIG_MODE_TT
-void enable_timer(void)
+int timer_one_shot(int ticks)
 {
-       set_interval(1);
-}
-#endif
+       unsigned long usec = ticks * UM_USEC_PER_SEC / UM_HZ;
+       unsigned long sec = usec / UM_USEC_PER_SEC;
+       struct itimerval interval;
 
-void disable_timer(void)
-{
-       struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
-       if((setitimer(ITIMER_VIRTUAL, &disable, NULL) < 0) ||
-          (setitimer(ITIMER_REAL, &disable, NULL) < 0))
-               printk("disnable_timer - setitimer failed, errno = %d\n",
-                      errno);
-       /* If there are signals already queued, after unblocking ignore them */
-       signal(SIGALRM, SIG_IGN);
-       signal(SIGVTALRM, SIG_IGN);
+       usec %= UM_USEC_PER_SEC;
+       interval = ((struct itimerval) { { 0, 0 }, { sec, usec } });
+
+       if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1)
+               return -errno;
+
+       return 0;
 }
 
-void switch_timers(int to_real)
+/**
+ * timeval_to_ns - Convert timeval to nanoseconds
+ * @ts:                pointer to the timeval variable to be converted
+ *
+ * Returns the scalar nanosecond representation of the timeval
+ * parameter.
+ *
+ * Ripped from linux/time.h because it's a kernel header, and thus
+ * unusable from here.
+ */
+static inline long long timeval_to_ns(const struct timeval *tv)
 {
-       struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
-       struct itimerval enable = ((struct itimerval) { { 0, 1000000/hz() },
-                                                       { 0, 1000000/hz() }});
-       int old, new;
-
-       if(to_real){
-               old = ITIMER_VIRTUAL;
-               new = ITIMER_REAL;
-       }
-       else {
-               old = ITIMER_REAL;
-               new = ITIMER_VIRTUAL;
-       }
-
-       if((setitimer(old, &disable, NULL) < 0) ||
-          (setitimer(new, &enable, NULL)))
-               printk("switch_timers - setitimer failed, errno = %d\n",
-                      errno);
+       return ((long long) tv->tv_sec * UM_NSEC_PER_SEC) +
+               tv->tv_usec * UM_NSEC_PER_USEC;
 }
 
-#ifdef UML_CONFIG_MODE_TT
-void uml_idle_timer(void)
+long long disable_timer(void)
 {
-       if(signal(SIGVTALRM, SIG_IGN) == SIG_ERR)
-               panic("Couldn't unset SIGVTALRM handler");
+       struct itimerval time = ((struct itimerval) { { 0, 0 }, { 0, 0 } });
+
+       if(setitimer(ITIMER_VIRTUAL, &time, &time) < 0)
+               printk(UM_KERN_ERR "disable_timer - setitimer failed, "
+                      "errno = %d\n", errno);
 
-       set_handler(SIGALRM, (__sighandler_t) alarm_handler,
-                   SA_RESTART, SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
-       set_interval(0);
+       return timeval_to_ns(&time.it_value);
 }
-#endif
 
-unsigned long long os_nsecs(void)
+long long os_nsecs(void)
 {
        struct timeval tv;
 
        gettimeofday(&tv, NULL);
-       return((unsigned long long) tv.tv_sec * BILLION + tv.tv_usec * 1000);
+       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 / UM_NSEC_PER_SEC,
+                              .tv_nsec = nsecs % UM_NSEC_PER_SEC };
 
-       ts.tv_sec = secs;
-       ts.tv_nsec = 0;
-       nanosleep(&ts, NULL);
+       if (nanosleep(&ts, &ts) == 0)
+               alarm_handler(SIGVTALRM, NULL);
 }