X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Ftimeval.c;h=099730e8f921a30e5bc48bbeacb748febd0750f3;hb=1b807595c4e6b4348444852bda8814e92412ad41;hp=314b3f4303653ee3f51ed757f5f24c6d406b53c3;hpb=3f355f47f8e7343e909ccfa854454d667baf3c38;p=sliver-openvswitch.git

diff --git a/lib/timeval.c b/lib/timeval.c
index 314b3f430..099730e8f 100644
--- a/lib/timeval.c
+++ b/lib/timeval.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,71 +26,125 @@
 #include <unistd.h>
 #include "coverage.h"
 #include "fatal-signal.h"
+#include "signals.h"
 #include "util.h"
-
 #include "vlog.h"
-#define THIS_MODULE VLM_timeval
 
-/* Initialized? */
-static bool inited;
+VLOG_DEFINE_THIS_MODULE(timeval);
+
+/* The clock to use for measuring time intervals.  This is CLOCK_MONOTONIC by
+ * preference, but on systems that don't have a monotonic clock we fall back
+ * to CLOCK_REALTIME. */
+static clockid_t monotonic_clock;
 
-/* Has a timer tick occurred? */
-static volatile sig_atomic_t tick;
+/* Has a timer tick occurred?
+ *
+ * We initialize these to true to force time_init() to get called on the first
+ * call to time_msec() or another function that queries the current time. */
+static volatile sig_atomic_t wall_tick = true;
+static volatile sig_atomic_t monotonic_tick = true;
 
 /* The current time, as of the last refresh. */
-static struct timeval now;
+static struct timespec wall_time;
+static struct timespec monotonic_time;
 
 /* Time at which to die with SIGALRM (if not TIME_MIN). */
 static time_t deadline = TIME_MIN;
 
-static void setup_timer(void);
+static void set_up_timer(void);
+static void set_up_signal(int flags);
 static void sigalrm_handler(int);
-static void refresh_if_ticked(void);
+static void refresh_wall_if_ticked(void);
+static void refresh_monotonic_if_ticked(void);
 static time_t time_add(time_t, time_t);
 static void block_sigalrm(sigset_t *);
 static void unblock_sigalrm(const sigset_t *);
 static void log_poll_interval(long long int last_wakeup,
                               const struct rusage *last_rusage);
-static long long int timeval_to_msec(const struct timeval *);
 
-/* Initializes the timetracking module. */
-void
+/* Initializes the timetracking module.
+ *
+ * It is not necessary to call this function directly, because other time
+ * functions will call it automatically, but it doesn't hurt. */
+static void
 time_init(void)
 {
-    struct sigaction sa;
+    static bool inited;
     if (inited) {
         return;
     }
+    inited = true;
 
     coverage_init();
 
-    inited = true;
-    gettimeofday(&now, NULL);
-    tick = false;
+    if (!clock_gettime(CLOCK_MONOTONIC, &monotonic_time)) {
+        monotonic_clock = CLOCK_MONOTONIC;
+    } else {
+        monotonic_clock = CLOCK_REALTIME;
+        VLOG_DBG("monotonic timer not available");
+    }
+
+    set_up_signal(SA_RESTART);
+    set_up_timer();
+}
+
+static void
+set_up_signal(int flags)
+{
+    struct sigaction sa;
 
-    /* Set up signal handler. */
     memset(&sa, 0, sizeof sa);
     sa.sa_handler = sigalrm_handler;
     sigemptyset(&sa.sa_mask);
-    sa.sa_flags = SA_RESTART;
-    if (sigaction(SIGALRM, &sa, NULL)) {
-        ovs_fatal(errno, "sigaction(SIGALRM) failed");
-    }
+    sa.sa_flags = flags;
+    xsigaction(SIGALRM, &sa, NULL);
+}
+
+/* Remove SA_RESTART from the flags for SIGALRM, so that any system call that
+ * is interrupted by the periodic timer interrupt will return EINTR instead of
+ * continuing after the signal handler returns.
+ *
+ * time_disable_restart() and time_enable_restart() may be usefully wrapped
+ * around function calls that might otherwise block forever unless interrupted
+ * by a signal, e.g.:
+ *
+ *   time_disable_restart();
+ *   fcntl(fd, F_SETLKW, &lock);
+ *   time_enable_restart();
+ */
+void
+time_disable_restart(void)
+{
+    time_init();
+    set_up_signal(0);
+}
 
-    /* Set up periodic signal. */
-    setup_timer();
+/* Add SA_RESTART to the flags for SIGALRM, so that any system call that
+ * is interrupted by the periodic timer interrupt will continue after the
+ * signal handler returns instead of returning EINTR. */
+void
+time_enable_restart(void)
+{
+    time_init();
+    set_up_signal(SA_RESTART);
 }
 
 static void
-setup_timer(void)
+set_up_timer(void)
 {
-    struct itimerval itimer;
+    static timer_t timer_id;    /* "static" to avoid apparent memory leak. */
+    struct itimerspec itimer;
+
+    if (timer_create(monotonic_clock, NULL, &timer_id)) {
+        VLOG_FATAL("timer_create failed (%s)", strerror(errno));
+    }
 
     itimer.it_interval.tv_sec = 0;
-    itimer.it_interval.tv_usec = TIME_UPDATE_INTERVAL * 1000;
+    itimer.it_interval.tv_nsec = TIME_UPDATE_INTERVAL * 1000 * 1000;
     itimer.it_value = itimer.it_interval;
-    if (setitimer(ITIMER_REAL, &itimer, NULL)) {
-        ovs_fatal(errno, "setitimer failed");
+
+    if (timer_settime(timer_id, 0, &itimer, NULL)) {
+        VLOG_FATAL("timer_settime failed (%s)", strerror(errno));
     }
 }
 
@@ -102,7 +156,31 @@ setup_timer(void)
 void
 time_postfork(void)
 {
-    setup_timer();
+    time_init();
+    set_up_timer();
+}
+
+static void
+refresh_wall(void)
+{
+    time_init();
+    clock_gettime(CLOCK_REALTIME, &wall_time);
+    wall_tick = false;
+}
+
+static void
+refresh_monotonic(void)
+{
+    time_init();
+
+    if (monotonic_clock == CLOCK_MONOTONIC) {
+        clock_gettime(monotonic_clock, &monotonic_time);
+    } else {
+        refresh_wall_if_ticked();
+        monotonic_time = wall_time;
+    }
+
+    monotonic_tick = false;
 }
 
 /* Forces a refresh of the current time from the kernel.  It is not usually
@@ -111,33 +189,68 @@ time_postfork(void)
 void
 time_refresh(void)
 {
-    gettimeofday(&now, NULL);
-    tick = false;
+    wall_tick = monotonic_tick = true;
 }
 
-/* Returns the current time, in seconds. */
+/* Returns a monotonic timer, in seconds. */
 time_t
 time_now(void)
 {
-    refresh_if_ticked();
-    return now.tv_sec;
+    refresh_monotonic_if_ticked();
+    return monotonic_time.tv_sec;
 }
 
-/* Returns the current time, in ms (within TIME_UPDATE_INTERVAL ms). */
+/* Same as time_now() except does not write to static variables, for use in
+ * signal handlers.  */
+static time_t
+time_now_sig(void)
+{
+    struct timespec cur_time;
+
+    clock_gettime(monotonic_clock, &cur_time);
+    return cur_time.tv_sec;
+}
+
+/* Returns the current time, in seconds. */
+time_t
+time_wall(void)
+{
+    refresh_wall_if_ticked();
+    return wall_time.tv_sec;
+}
+
+/* Returns a monotonic timer, in ms (within TIME_UPDATE_INTERVAL ms). */
 long long int
 time_msec(void)
 {
-    refresh_if_ticked();
-    return timeval_to_msec(&now);
+    refresh_monotonic_if_ticked();
+    return timespec_to_msec(&monotonic_time);
+}
+
+/* Returns the current time, in ms (within TIME_UPDATE_INTERVAL ms). */
+long long int
+time_wall_msec(void)
+{
+    refresh_wall_if_ticked();
+    return timespec_to_msec(&wall_time);
+}
+
+/* Stores a monotonic timer, accurate within TIME_UPDATE_INTERVAL ms, into
+ * '*ts'. */
+void
+time_timespec(struct timespec *ts)
+{
+    refresh_monotonic_if_ticked();
+    *ts = monotonic_time;
 }
 
 /* Stores the current time, accurate within TIME_UPDATE_INTERVAL ms, into
- * '*tv'. */
+ * '*ts'. */
 void
-time_timeval(struct timeval *tv)
+time_wall_timespec(struct timespec *ts)
 {
-    refresh_if_ticked();
-    *tv = now;
+    refresh_wall_if_ticked();
+    *ts = wall_time;
 }
 
 /* Configures the program to die with SIGALRM 'secs' seconds from now, if
@@ -221,18 +334,26 @@ time_add(time_t a, time_t b)
 static void
 sigalrm_handler(int sig_nr)
 {
-    tick = true;
-    if (deadline != TIME_MIN && time(0) > deadline) {
+    wall_tick = true;
+    monotonic_tick = true;
+    if (deadline != TIME_MIN && time_now_sig() > deadline) {
         fatal_signal_handler(sig_nr);
     }
 }
 
 static void
-refresh_if_ticked(void)
+refresh_wall_if_ticked(void)
 {
-    assert(inited);
-    if (tick) {
-        time_refresh();
+    if (wall_tick) {
+        refresh_wall();
+    }
+}
+
+static void
+refresh_monotonic_if_ticked(void)
+{
+    if (monotonic_tick) {
+        refresh_monotonic();
     }
 }
 
@@ -242,25 +363,35 @@ block_sigalrm(sigset_t *oldsigs)
     sigset_t sigalrm;
     sigemptyset(&sigalrm);
     sigaddset(&sigalrm, SIGALRM);
-    if (sigprocmask(SIG_BLOCK, &sigalrm, oldsigs)) {
-        ovs_fatal(errno, "sigprocmask");
-    }
+    xsigprocmask(SIG_BLOCK, &sigalrm, oldsigs);
 }
 
 static void
 unblock_sigalrm(const sigset_t *oldsigs)
 {
-    if (sigprocmask(SIG_SETMASK, oldsigs, NULL)) {
-        ovs_fatal(errno, "sigprocmask");
-    }
+    xsigprocmask(SIG_SETMASK, oldsigs, NULL);
 }
 
-static long long int
+long long int
+timespec_to_msec(const struct timespec *ts)
+{
+    return (long long int) ts->tv_sec * 1000 + ts->tv_nsec / (1000 * 1000);
+}
+
+long long int
 timeval_to_msec(const struct timeval *tv)
 {
     return (long long int) tv->tv_sec * 1000 + tv->tv_usec / 1000;
 }
 
+void
+xgettimeofday(struct timeval *tv)
+{
+    if (gettimeofday(tv, NULL) == -1) {
+        VLOG_FATAL("gettimeofday failed (%s)", strerror(errno));
+    }
+}
+
 static long long int
 timeval_diff_msec(const struct timeval *a, const struct timeval *b)
 {
@@ -281,15 +412,16 @@ log_poll_interval(long long int last_wakeup, const struct rusage *last_rusage)
     now = time_msec();
     interval = MIN(10000, now - last_wakeup) << 4;
 
-    /* Warn if we took too much time between polls. */
-    if (n_samples > 10 && interval > mean_interval * 8) {
+    /* Warn if we took too much time between polls: at least 50 ms and at least
+     * 8X the mean interval. */
+    if (n_samples > 10 && interval > mean_interval * 8 && interval > 50 * 16) {
         struct rusage rusage;
 
         getrusage(RUSAGE_SELF, &rusage);
-        VLOG_WARN("%u ms poll interval (%lld ms user, %lld ms system) "
+        VLOG_WARN("%lld ms poll interval (%lld ms user, %lld ms system) "
                   "is over %u times the weighted mean interval %u ms "
                   "(%u samples)",
-                  (interval + 8) / 16,
+                  now - last_wakeup,
                   timeval_diff_msec(&rusage.ru_utime, &last_rusage->ru_utime),
                   timeval_diff_msec(&rusage.ru_stime, &last_rusage->ru_stime),
                   interval / mean_interval,
@@ -313,9 +445,9 @@ log_poll_interval(long long int last_wakeup, const struct rusage *last_rusage)
                       rusage.ru_nivcsw - last_rusage->ru_nivcsw);
         }
 
-        /* Care should be taken in the value chosen for logging.  Depending 
-         * on the configuration, syslog can write changes synchronously, 
-         * which can cause the coverage messages to take longer to log 
+        /* Care should be taken in the value chosen for logging.  Depending
+         * on the configuration, syslog can write changes synchronously,
+         * which can cause the coverage messages to take longer to log
          * than the processing delay that triggered it. */
         coverage_log(VLL_INFO, true);
     }