evutil_time.c

   1 /*
   2  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "event2/event-config.h"
  28 #include "evconfig-private.h"
  29
  30 #ifdef _WIN32
  31 #include <winsock2.h>
  32 #define WIN32_LEAN_AND_MEAN
  33 #include <windows.h>
  34 #undef WIN32_LEAN_AND_MEAN
  35 #endif
  36
  37 #include <sys/types.h>
  38 #ifdef EVENT__HAVE_STDLIB_H
  39 #include <stdlib.h>
  40 #endif
  41 #include <errno.h>
  42 #include <limits.h>
  43 #ifndef EVENT__HAVE_GETTIMEOFDAY
  44 #include <sys/timeb.h>
  45 #endif
  46 #if !defined(EVENT__HAVE_NANOSLEEP) && !defined(EVENT__HAVE_USLEEP) && \
  47         !defined(_WIN32)
  48 #include <sys/select.h>
  49 #endif
  50 #include <time.h>
  51 #include <sys/stat.h>
  52 #include <string.h>
  53
  54 /** evutil_usleep_() */
  55 #if defined(_WIN32)
  56 #elif defined(EVENT__HAVE_NANOSLEEP)
  57 #elif defined(EVENT__HAVE_USLEEP)
  58 #include <unistd.h>
  59 #endif
  60
  61 #include "event2/util.h"
  62 #include "util-internal.h"
  63 #include "log-internal.h"
  64 #include "mm-internal.h"
  65
  66 #ifndef EVENT__HAVE_GETTIMEOFDAY
  67 /* No gettimeofday; this must be windows. */
  68 int
  69 evutil_gettimeofday(struct timeval *tv, struct timezone *tz)
  70 {
  71 #ifdef _MSC_VER
  72 #define U64_LITERAL(n) n##ui64
  73 #else
  74 #define U64_LITERAL(n) n##llu
  75 #endif
  76
  77         /* Conversion logic taken from Tor, which in turn took it
  78          * from Perl.  GetSystemTimeAsFileTime returns its value as
  79          * an unaligned (!) 64-bit value containing the number of
  80          * 100-nanosecond intervals since 1 January 1601 UTC. */
  81 #define EPOCH_BIAS U64_LITERAL(116444736000000000)
  82 #define UNITS_PER_SEC U64_LITERAL(10000000)
  83 #define USEC_PER_SEC U64_LITERAL(1000000)
  84 #define UNITS_PER_USEC U64_LITERAL(10)
  85         union {
  86                 FILETIME ft_ft;
  87                 ev_uint64_t ft_64;
  88         } ft;
  89
  90         if (tv == NULL)
  91                 return -1;
  92
  93         GetSystemTimeAsFileTime(&ft.ft_ft);
  94
  95         if (EVUTIL_UNLIKELY(ft.ft_64 < EPOCH_BIAS)) {
  96                 /* Time before the unix epoch. */
  97                 return -1;
  98         }
  99         ft.ft_64 -= EPOCH_BIAS;
 100         tv->tv_sec = (long) (ft.ft_64 / UNITS_PER_SEC);
 101         tv->tv_usec = (long) ((ft.ft_64 / UNITS_PER_USEC) % USEC_PER_SEC);
 102         return 0;
 103 }
 104 #endif
 105
 106 #define MAX_SECONDS_IN_MSEC_LONG \
 107         (((LONG_MAX) - 999) / 1000)
 108
 109 long
 110 evutil_tv_to_msec_(const struct timeval *tv)
 111 {
 112         if (tv->tv_usec > 1000000 || tv->tv_sec > MAX_SECONDS_IN_MSEC_LONG)
 113                 return -1;
 114
 115         return (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000);
 116 }
 117
 118 /*
 119   Replacement for usleep on platforms that don't have one.  Not guaranteed to
 120   be any more finegrained than 1 msec.
 121  */
 122 void
 123 evutil_usleep_(const struct timeval *tv)
 124 {
 125         if (!tv)
 126                 return;
 127 #if defined(_WIN32)
 128         {
 129                 long msec = evutil_tv_to_msec_(tv);
 130                 Sleep((DWORD)msec);
 131         }
 132 #elif defined(EVENT__HAVE_NANOSLEEP)
 133         {
 134                 struct timespec ts;
 135                 ts.tv_sec = tv->tv_sec;
 136                 ts.tv_nsec = tv->tv_usec*1000;
 137                 nanosleep(&ts, NULL);
 138         }
 139 #elif defined(EVENT__HAVE_USLEEP)
 140         /* Some systems don't like to usleep more than 999999 usec */
 141         sleep(tv->tv_sec);
 142         usleep(tv->tv_usec);
 143 #else
 144         {
 145                 struct timeval tv2 = *tv;
 146                 select(0, NULL, NULL, NULL, &tv2);
 147         }
 148 #endif
 149 }
 150
 151 int
 152 evutil_date_rfc1123(char *date, const size_t datelen, const struct tm *tm)
 153 {
 154         static const char *DAYS[] =
 155                 { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
 156         static const char *MONTHS[] =
 157                 { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
 158
 159         time_t t = time(NULL);
 160
 161 #ifndef _WIN32
 162         struct tm sys;
 163 #endif
 164
 165         /* If `tm` is null, set system's current time. */
 166         if (tm == NULL) {
 167 #ifdef _WIN32
 168                 /** TODO: detect _gmtime64()/_gmtime64_s() */
 169                 tm = gmtime(&t);
 170 #else
 171                 gmtime_r(&t, &sys);
 172                 tm = &sys;
 173 #endif
 174         }
 175
 176         return evutil_snprintf(
 177                 date, datelen, "%s, %02d %s %4d %02d:%02d:%02d GMT",
 178                 DAYS[tm->tm_wday], tm->tm_mday, MONTHS[tm->tm_mon],
 179                 1900 + tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec);
 180 }
 181
 182 /*
 183    This function assumes it's called repeatedly with a
 184    not-actually-so-monotonic time source whose outputs are in 'tv'. It
 185    implements a trivial ratcheting mechanism so that the values never go
 186    backwards.
 187  */
 188 static void
 189 adjust_monotonic_time(struct evutil_monotonic_timer *base,
 190     struct timeval *tv)
 191 {
 192         evutil_timeradd(tv, &base->adjust_monotonic_clock, tv);
 193
 194         if (evutil_timercmp(tv, &base->last_time, <)) {
 195                 /* Guess it wasn't monotonic after all. */
 196                 struct timeval adjust;
 197                 evutil_timersub(&base->last_time, tv, &adjust);
 198                 evutil_timeradd(&adjust, &base->adjust_monotonic_clock,
 199                     &base->adjust_monotonic_clock);
 200                 *tv = base->last_time;
 201         }
 202         base->last_time = *tv;
 203 }
 204
 205 /*
 206    Allocate a new struct evutil_monotonic_timer
 207  */
 208 struct evutil_monotonic_timer *
 209 evutil_monotonic_timer_new(void)
 210 {
 211   struct evutil_monotonic_timer *p = NULL;
 212
 213   p = mm_malloc(sizeof(*p));
 214   if (!p) goto done;
 215
 216   memset(p, 0, sizeof(*p));
 217
 218  done:
 219   return p;
 220 }
 221
 222 /*
 223    Free a struct evutil_monotonic_timer
 224  */
 225 void
 226 evutil_monotonic_timer_free(struct evutil_monotonic_timer *timer)
 227 {
 228   if (timer) {
 229     mm_free(timer);
 230   }
 231 }
 232
 233 /*
 234    Set up a struct evutil_monotonic_timer for initial use
 235  */
 236 int
 237 evutil_configure_monotonic_time(struct evutil_monotonic_timer *timer,
 238                                 int flags)
 239 {
 240   return evutil_configure_monotonic_time_(timer, flags);
 241 }
 242
 243 /*
 244    Query the current monotonic time
 245  */
 246 int
 247 evutil_gettime_monotonic(struct evutil_monotonic_timer *timer,
 248                          struct timeval *tp)
 249 {
 250   return evutil_gettime_monotonic_(timer, tp);
 251 }
 252
 253
 254 #if defined(HAVE_POSIX_MONOTONIC)
 255 /* =====
 256    The POSIX clock_gettime() interface provides a few ways to get at a
 257    monotonic clock.  CLOCK_MONOTONIC is most widely supported.  Linux also
 258    provides a CLOCK_MONOTONIC_COARSE with accuracy of about 1-4 msec.
 259
 260    On all platforms I'm aware of, CLOCK_MONOTONIC really is monotonic.
 261    Platforms don't agree about whether it should jump on a sleep/resume.
 262  */
 263
 264 int
 265 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
 266     int flags)
 267 {
 268         /* CLOCK_MONOTONIC exists on FreeBSD, Linux, and Solaris.  You need to
 269          * check for it at runtime, because some older kernel versions won't
 270          * have it working. */
 271 #ifdef CLOCK_MONOTONIC_COARSE
 272         const int precise = flags & EV_MONOT_PRECISE;
 273 #endif
 274         const int fallback = flags & EV_MONOT_FALLBACK;
 275         struct timespec ts;
 276
 277 #ifdef CLOCK_MONOTONIC_COARSE
 278         if (CLOCK_MONOTONIC_COARSE < 0) {
 279                 /* Technically speaking, nothing keeps CLOCK_* from being
 280                  * negative (as far as I know). This check and the one below
 281                  * make sure that it's safe for us to use -1 as an "unset"
 282                  * value. */
 283                 event_errx(1,"I didn't expect CLOCK_MONOTONIC_COARSE to be < 0");
 284         }
 285         if (! precise && ! fallback) {
 286                 if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0) {
 287                         base->monotonic_clock = CLOCK_MONOTONIC_COARSE;
 288                         return 0;
 289                 }
 290         }
 291 #endif
 292         if (!fallback && clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
 293                 base->monotonic_clock = CLOCK_MONOTONIC;
 294                 return 0;
 295         }
 296
 297         if (CLOCK_MONOTONIC < 0) {
 298                 event_errx(1,"I didn't expect CLOCK_MONOTONIC to be < 0");
 299         }
 300
 301         base->monotonic_clock = -1;
 302         return 0;
 303 }
 304
 305 int
 306 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
 307     struct timeval *tp)
 308 {
 309         struct timespec ts;
 310
 311         if (base->monotonic_clock < 0) {
 312                 if (evutil_gettimeofday(tp, NULL) < 0)
 313                         return -1;
 314                 adjust_monotonic_time(base, tp);
 315                 return 0;
 316         }
 317
 318         if (clock_gettime(base->monotonic_clock, &ts) == -1)
 319                 return -1;
 320         tp->tv_sec = ts.tv_sec;
 321         tp->tv_usec = ts.tv_nsec / 1000;
 322
 323         return 0;
 324 }
 325 #endif
 326
 327 #if defined(HAVE_MACH_MONOTONIC)
 328 /* ======
 329    Apple is a little late to the POSIX party.  And why not?  Instead of
 330    clock_gettime(), they provide mach_absolute_time().  Its units are not
 331    fixed; we need to use mach_timebase_info() to get the right functions to
 332    convert its units into nanoseconds.
 333
 334    To all appearances, mach_absolute_time() seems to be honest-to-goodness
 335    monotonic.  Whether it stops during sleep or not is unspecified in
 336    principle, and dependent on CPU architecture in practice.
 337  */
 338
 339 int
 340 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
 341     int flags)
 342 {
 343         const int fallback = flags & EV_MONOT_FALLBACK;
 344         struct mach_timebase_info mi;
 345         memset(base, 0, sizeof(*base));
 346         /* OSX has mach_absolute_time() */
 347         if (!fallback &&
 348             mach_timebase_info(&mi) == 0 &&
 349             mach_absolute_time() != 0) {
 350                 /* mach_timebase_info tells us how to convert
 351                  * mach_absolute_time() into nanoseconds, but we
 352                  * want to use microseconds instead. */
 353                 mi.denom *= 1000;
 354                 memcpy(&base->mach_timebase_units, &mi, sizeof(mi));
 355         } else {
 356                 base->mach_timebase_units.numer = 0;
 357         }
 358         return 0;
 359 }
 360
 361 int
 362 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
 363     struct timeval *tp)
 364 {
 365         ev_uint64_t abstime, usec;
 366         if (base->mach_timebase_units.numer == 0) {
 367                 if (evutil_gettimeofday(tp, NULL) < 0)
 368                         return -1;
 369                 adjust_monotonic_time(base, tp);
 370                 return 0;
 371         }
 372
 373         abstime = mach_absolute_time();
 374         usec = (abstime * base->mach_timebase_units.numer)
 375             / (base->mach_timebase_units.denom);
 376         tp->tv_sec = usec / 1000000;
 377         tp->tv_usec = usec % 1000000;
 378
 379         return 0;
 380 }
 381 #endif
 382
 383 #if defined(HAVE_WIN32_MONOTONIC)
 384 /* =====
 385    Turn we now to Windows.  Want monontonic time on Windows?
 386
 387    Windows has QueryPerformanceCounter(), which gives time most high-
 388    resolution time.  It's a pity it's not so monotonic in practice; it's
 389    also got some fun bugs, especially: with older Windowses, under
 390    virtualizations, with funny hardware, on multiprocessor systems, and so
 391    on.  PEP418 [1] has a nice roundup of the issues here.
 392
 393    There's GetTickCount64() on Vista and later, which gives a number of 1-msec
 394    ticks since startup.  The accuracy here might be as bad as 10-20 msec, I
 395    hear.  There's an undocumented function (NtSetTimerResolution) that
 396    allegedly increases the accuracy. Good luck!
 397
 398    There's also GetTickCount(), which is only 32 bits, but seems to be
 399    supported on pre-Vista versions of Windows.  Apparently, you can coax
 400    another 14 bits out of it, giving you 2231 years before rollover.
 401
 402    The less said about timeGetTime() the better.
 403
 404    "We don't care.  We don't have to.  We're the Phone Company."
 405             -- Lily Tomlin, SNL
 406
 407    Our strategy, if precise timers are turned off, is to just use the best
 408    GetTickCount equivalent available.  If we've been asked for precise timing,
 409    then we mostly[2] assume that GetTickCount is monotonic, and correct
 410    GetPerformanceCounter to approximate it.
 411
 412    [1] http://www.python.org/dev/peps/pep-0418
 413    [2] Of course, we feed the Windows stuff into adjust_monotonic_time()
 414        anyway, just in case it isn't.
 415
 416  */
 417 /*
 418     Parts of our logic in the win32 timer code here are closely based on
 419     BitTorrent's libUTP library.  That code is subject to the following
 420     license:
 421
 422       Copyright (c) 2010 BitTorrent, Inc.
 423
 424       Permission is hereby granted, free of charge, to any person obtaining a
 425       copy of this software and associated documentation files (the
 426       "Software"), to deal in the Software without restriction, including
 427       without limitation the rights to use, copy, modify, merge, publish,
 428       distribute, sublicense, and/or sell copies of the Software, and to
 429       permit persons to whom the Software is furnished to do so, subject to
 430       the following conditions:
 431
 432       The above copyright notice and this permission notice shall be included
 433       in all copies or substantial portions of the Software.
 434
 435       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 436       OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 437       MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 438       NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 439       LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 440       OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 441       WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 442 */
 443
 444 static ev_uint64_t
 445 evutil_GetTickCount_(struct evutil_monotonic_timer *base)
 446 {
 447         if (base->GetTickCount64_fn) {
 448                 /* Let's just use GetTickCount64 if we can. */
 449                 return base->GetTickCount64_fn();
 450         } else if (base->GetTickCount_fn) {
 451                 /* Greg Hazel assures me that this works, that BitTorrent has
 452                  * done it for years, and this it won't turn around and
 453                  * bite us.  He says they found it on some game programmers'
 454                  * forum some time around 2007.
 455                  */
 456                 ev_uint64_t v = base->GetTickCount_fn();
 457                 return (DWORD)v | ((v >> 18) & 0xFFFFFFFF00000000);
 458         } else {
 459                 /* Here's the fallback implementation. We have to use
 460                  * GetTickCount() with its given signature, so we only get
 461                  * 32 bits worth of milliseconds, which will roll ove every
 462                  * 49 days or so.  */
 463                 DWORD ticks = GetTickCount();
 464                 if (ticks < base->last_tick_count) {
 465                         base->adjust_tick_count += ((ev_uint64_t)1) << 32;
 466                 }
 467                 base->last_tick_count = ticks;
 468                 return ticks + base->adjust_tick_count;
 469         }
 470 }
 471
 472 int
 473 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
 474     int flags)
 475 {
 476         const int precise = flags & EV_MONOT_PRECISE;
 477         const int fallback = flags & EV_MONOT_FALLBACK;
 478         HANDLE h;
 479         memset(base, 0, sizeof(*base));
 480
 481         h = evutil_load_windows_system_library_(TEXT("kernel32.dll"));
 482         if (h != NULL && !fallback) {
 483                 base->GetTickCount64_fn = (ev_GetTickCount_func)GetProcAddress(h, "GetTickCount64");
 484                 base->GetTickCount_fn = (ev_GetTickCount_func)GetProcAddress(h, "GetTickCount");
 485         }
 486
 487         base->first_tick = base->last_tick_count = evutil_GetTickCount_(base);
 488         if (precise && !fallback) {
 489                 LARGE_INTEGER freq;
 490                 if (QueryPerformanceFrequency(&freq)) {
 491                         LARGE_INTEGER counter;
 492                         QueryPerformanceCounter(&counter);
 493                         base->first_counter = counter.QuadPart;
 494                         base->usec_per_count = 1.0e6 / freq.QuadPart;
 495                         base->use_performance_counter = 1;
 496                 }
 497         }
 498
 499         return 0;
 500 }
 501
 502 static inline ev_int64_t
 503 abs64(ev_int64_t i)
 504 {
 505         return i < 0 ? -i : i;
 506 }
 507
 508
 509 int
 510 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
 511     struct timeval *tp)
 512 {
 513         ev_uint64_t ticks = evutil_GetTickCount_(base);
 514         if (base->use_performance_counter) {
 515                 /* Here's a trick we took from BitTorrent's libutp, at Greg
 516                  * Hazel's recommendation.  We use QueryPerformanceCounter for
 517                  * our high-resolution timer, but use GetTickCount*() to keep
 518                  * it sane, and adjust_monotonic_time() to keep it monotonic.
 519                  */
 520                 LARGE_INTEGER counter;
 521                 ev_int64_t counter_elapsed, counter_usec_elapsed, ticks_elapsed;
 522                 QueryPerformanceCounter(&counter);
 523                 counter_elapsed = (ev_int64_t)
 524                     (counter.QuadPart - base->first_counter);
 525                 ticks_elapsed = ticks - base->first_tick;
 526                 /* TODO: This may upset VC6. If you need this to work with
 527                  * VC6, please supply an appropriate patch. */
 528                 counter_usec_elapsed = (ev_int64_t)
 529                     (counter_elapsed * base->usec_per_count);
 530
 531                 if (abs64(ticks_elapsed*1000 - counter_usec_elapsed) > 1000000) {
 532                         /* It appears that the QueryPerformanceCounter()
 533                          * result is more than 1 second away from
 534                          * GetTickCount() result. Let's adjust it to be as
 535                          * accurate as we can; adjust_monotnonic_time() below
 536                          * will keep it monotonic. */
 537                         counter_usec_elapsed = ticks_elapsed * 1000;
 538                         base->first_counter = (ev_uint64_t) (counter.QuadPart - counter_usec_elapsed / base->usec_per_count);
 539                 }
 540                 tp->tv_sec = (time_t) (counter_usec_elapsed / 1000000);
 541                 tp->tv_usec = counter_usec_elapsed % 1000000;
 542
 543         } else {
 544                 /* We're just using GetTickCount(). */
 545                 tp->tv_sec = (time_t) (ticks / 1000);
 546                 tp->tv_usec = (ticks % 1000) * 1000;
 547         }
 548         adjust_monotonic_time(base, tp);
 549
 550         return 0;
 551 }
 552 #endif
 553
 554 #if defined(HAVE_FALLBACK_MONOTONIC)
 555 /* =====
 556    And if none of the other options work, let's just use gettimeofday(), and
 557    ratchet it forward so that it acts like a monotonic timer, whether it
 558    wants to or not.
 559  */
 560
 561 int
 562 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
 563     int precise)
 564 {
 565         memset(base, 0, sizeof(*base));
 566         return 0;
 567 }
 568
 569 int
 570 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
 571     struct timeval *tp)
 572 {
 573         if (evutil_gettimeofday(tp, NULL) < 0)
 574                 return -1;
 575         adjust_monotonic_time(base, tp);
 576         return 0;
 577
 578 }
 579 #endif