netdev-tunnel: use sockaddr_storage

[sliver-openvswitch.git] / lib / timeval.c

diff --git a/lib/timeval.c b/lib/timeval.c
index 64ae845..691cf74 100644 (file)
--- a/lib/timeval.c
+++ b/lib/timeval.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,6 +33,7 @@
 #include "hmap.h"
 #include "ovs-thread.h"
 #include "signals.h"
+#include "seq.h"
 #include "unixctl.h"
 #include "util.h"
 #include "vlog.h"
@@ -57,6 +58,14 @@ static struct clock wall_clock;      /* CLOCK_REALTIME. */
 /* The monotonic time at which the time module was initialized. */
 static long long int boot_time;
 
+/* True only when timeval_dummy_register() is called. */
+static bool timewarp_enabled;
+/* Reference to the seq struct.  Threads other than main thread can
+ * wait on timewarp_seq and be waken up when time is warped. */
+static struct seq *timewarp_seq;
+/* Last value of 'timewarp_seq'. */
+DEFINE_STATIC_PER_THREAD_DATA(uint64_t, last_seq, 0);
+
 /* Monotonic time in milliseconds at which to die with SIGALRM (if not
  * LLONG_MAX). */
 static long long int deadline = LLONG_MAX;
@@ -79,6 +88,7 @@ init_clock(struct clock *c, clockid_t id)
     ovs_mutex_init(&c->mutex);
     atomic_init(&c->slow_path, false);
     xclock_gettime(c->id, &c->cache);
+    timewarp_seq = seq_create();
 }
 
 static void
@@ -222,19 +232,19 @@ time_alarm(unsigned int secs)
  *
  * Stores the number of milliseconds elapsed during poll in '*elapsed'. */
 int
-time_poll(struct pollfd *pollfds, int n_pollfds, long long int timeout_when,
-          int *elapsed)
+time_poll(struct pollfd *pollfds, int n_pollfds, HANDLE *handles OVS_UNUSED,
+          long long int timeout_when, int *elapsed)
 {
     long long int *last_wakeup = last_wakeup_get();
     long long int start;
-    int retval;
+    int retval = 0;
 
     time_init();
+    coverage_clear();
+    coverage_run();
     if (*last_wakeup) {
         log_poll_interval(*last_wakeup);
     }
-    coverage_clear();
-    coverage_run();
     start = time_msec();
 
     timeout_when = MIN(timeout_when, deadline);
@@ -251,10 +261,25 @@ time_poll(struct pollfd *pollfds, int n_pollfds, long long int timeout_when,
             time_left = timeout_when - now;
         }
 
+#ifndef _WIN32
         retval = poll(pollfds, n_pollfds, time_left);
         if (retval < 0) {
             retval = -errno;
         }
+#else
+        if (n_pollfds > MAXIMUM_WAIT_OBJECTS) {
+            VLOG_ERR("Cannot handle more than maximum wait objects\n");
+        } else if (n_pollfds != 0) {
+            retval = WaitForMultipleObjects(n_pollfds, handles, FALSE,
+                                            time_left);
+        }
+        if (retval < 0) {
+            /* XXX This will be replace by a win error to errno
+               conversion function */
+            retval = -WSAGetLastError();
+            retval = -EINVAL;
+        }
+#endif
 
         if (deadline <= time_msec()) {
             fatal_signal_handler(SIGALRM);
@@ -313,6 +338,19 @@ xclock_gettime(clock_t id, struct timespec *ts)
     }
 }
 
+/* Makes threads wait on timewarp_seq and be waken up when time is warped.
+ * This function will be no-op unless timeval_dummy_register() is called. */
+void
+timewarp_wait(void)
+{
+    if (timewarp_enabled) {
+        uint64_t *last_seq = last_seq_get();
+
+        *last_seq = seq_read(timewarp_seq);
+        seq_wait(timewarp_seq, *last_seq);
+    }
+}
+
 static long long int
 timeval_diff_msec(const struct timeval *a, const struct timeval *b)
 {
@@ -511,13 +549,15 @@ timeval_warp_cb(struct unixctl_conn *conn,
     atomic_store(&monotonic_clock.slow_path, true);
     timespec_add(&monotonic_clock.warp, &monotonic_clock.warp, &ts);
     ovs_mutex_unlock(&monotonic_clock.mutex);
-
+    seq_change(timewarp_seq);
+    poll(NULL, 0, 10); /* give threads (eg. monitor) some chances to run */
     unixctl_command_reply(conn, "warped");
 }
 
 void
 timeval_dummy_register(void)
 {
+    timewarp_enabled = true;
     unixctl_command_register("time/stop", "", 0, 0, timeval_stop_cb, NULL);
     unixctl_command_register("time/warp", "MSECS", 1, 1,
                              timeval_warp_cb, NULL);