libevent: fix race in the common case.

third_party/libevent/event.c

 /*
  * Copyright (c) 2000-2004 Niels Provos <provos@citi.umich.edu>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 89 matching lines @@
 #endif
 #ifdef WIN32
         &win32ops,
 #endif
         NULL
 };
 
 /* Global state */
 struct event_base *current_base = NULL;
 extern struct event_base *evsignal_base;
-static int use_monotonic;
+static int no_monotonic_clock = 0;

[jln (very slow on Chromium), 2014/04/09 20:13:09]

Isn't it more clear to keep this as "use_monotonic" and statically initialize it
to 1?

"no__monotonic_clock == 0" is harder to read, as a double negation.

[agl, 2014/04/09 20:25:20]

Yea, fair point. I was just aiming for it to be BSS, but you're right that it's
not worth the extra thought when reading the code.

Done.

 
 /* Prototypes */
 static void     event_queue_insert(struct event_base *, struct event *, int);
 static void     event_queue_remove(struct event_base *, struct event *, int);
 static int      event_haveevents(struct event_base *);
 
 static void     event_process_active(struct event_base *);
 
 static int      timeout_next(struct event_base *, struct timeval **);
 static void     timeout_process(struct event_base *);
 static void     timeout_correct(struct event_base *, struct timeval *);
 
-static void
-detect_monotonic(void)
-{
-#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
-        struct timespec ts;
-
-        if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
-                use_monotonic = 1;
-#endif
-}
-
 static int
 gettime(struct event_base *base, struct timeval *tp)
 {
         if (base->tv_cache.tv_sec) {
                 *tp = base->tv_cache;
                 return (0);
         }
 
 #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
-        if (use_monotonic) {
-                struct timespec ts;
+        struct timespec ts;
 
-                if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
-                        return (-1);
-
+        if (no_monotonic_clock == 0 &&
+            clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
                 tp->tv_sec = ts.tv_sec;
                 tp->tv_usec = ts.tv_nsec / 1000;
                 return (0);
         }
 #endif
 
+        no_monotonic_clock = 1;
+
         return (evutil_gettimeofday(tp, NULL));
 }
 
 struct event_base *
 event_init(void)
 {
         struct event_base *base = event_base_new();
 
         if (base != NULL)
                 current_base = base;
 
         return (base);
 }
 
 struct event_base *
 event_base_new(void)
 {
         int i;
         struct event_base *base;
 
         if ((base = calloc(1, sizeof(struct event_base))) == NULL)
                 event_err(1, "%s: calloc", __func__);
 
-        detect_monotonic();
         gettime(base, &base->event_tv);
         
         min_heap_ctor(&base->timeheap);
         TAILQ_INIT(&base->eventqueue);
         base->sig.ev_signal_pair[0] = -1;
         base->sig.ev_signal_pair[1] = -1;
         
         base->evbase = NULL;
         for (i = 0; eventops[i] && !base->evbase; i++) {
                 base->evsel = eventops[i];
@@ skipping 672 matching lines @@
  * monotonic.
  */
 
 static void
 timeout_correct(struct event_base *base, struct timeval *tv)
 {
         struct event **pev;
         unsigned int size;
         struct timeval off;
 
-        if (use_monotonic)
+        if (no_monotonic_clock == 0)
                 return;
 
         /* Check if time is running backwards */
         gettime(base, tv);
         if (evutil_timercmp(tv, &base->event_tv, >=)) {
                 base->event_tv = *tv;
                 return;
         }
 
         event_debug(("%s: time is running backwards, corrected",
@@ skipping 111 matching lines @@
 /* 
  * No thread-safe interface needed - the information should be the same
  * for all threads.
  */
 
 const char *
 event_get_method(void)
 {
         return (current_base->evsel->name);
 }