compat_time.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840
  1. /* Copyright (c) 2003-2004, Roger Dingledine
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /**
  6. * \file compat_time.c
  7. * \brief Portable wrappers for finding out the current time, running
  8. * timers, etc.
  9. **/
  10. #define COMPAT_TIME_PRIVATE
  11. #include "compat.h"
  12. #ifdef _WIN32
  13. #include <winsock2.h>
  14. #include <windows.h>
  15. #endif
  16. #ifdef HAVE_SYS_TYPES_H
  17. #include <sys/types.h>
  18. #endif
  19. #ifdef HAVE_UNISTD_H
  20. #include <unistd.h>
  21. #endif
  22. #ifdef TOR_UNIT_TESTS
  23. #if !defined(HAVE_USLEEP) && defined(HAVE_SYS_SELECT_H)
  24. /* as fallback implementation for tor_sleep_msec */
  25. #include <sys/select.h>
  26. #endif
  27. #endif /* defined(TOR_UNIT_TESTS) */
  28. #ifdef __APPLE__
  29. #include <mach/mach_time.h>
  30. #endif
  31. #include "torlog.h"
  32. #include "util.h"
  33. #include "container.h"
  34. #ifndef HAVE_GETTIMEOFDAY
  35. #ifdef HAVE_FTIME
  36. #include <sys/timeb.h>
  37. #endif
  38. #endif
  39. #ifdef _WIN32
  40. #undef HAVE_CLOCK_GETTIME
  41. #endif
  42. #ifdef TOR_UNIT_TESTS
  43. /** Delay for <b>msec</b> milliseconds. Only used in tests. */
  44. void
  45. tor_sleep_msec(int msec)
  46. {
  47. #ifdef _WIN32
  48. Sleep(msec);
  49. #elif defined(HAVE_USLEEP)
  50. sleep(msec / 1000);
  51. /* Some usleep()s hate sleeping more than 1 sec */
  52. usleep((msec % 1000) * 1000);
  53. #elif defined(HAVE_SYS_SELECT_H)
  54. struct timeval tv = { msec / 1000, (msec % 1000) * 1000};
  55. select(0, NULL, NULL, NULL, &tv);
  56. #else
  57. sleep(CEIL_DIV(msec, 1000));
  58. #endif /* defined(_WIN32) || ... */
  59. }
  60. #endif /* defined(TOR_UNIT_TESTS) */
  61. /** Set *timeval to the current time of day. On error, log and terminate.
  62. * (Same as gettimeofday(timeval,NULL), but never returns -1.)
  63. */
  64. void
  65. tor_gettimeofday(struct timeval *timeval)
  66. {
  67. #ifdef _WIN32
  68. /* Epoch bias copied from perl: number of units between windows epoch and
  69. * Unix epoch. */
  70. #define EPOCH_BIAS U64_LITERAL(116444736000000000)
  71. #define UNITS_PER_SEC U64_LITERAL(10000000)
  72. #define USEC_PER_SEC U64_LITERAL(1000000)
  73. #define UNITS_PER_USEC U64_LITERAL(10)
  74. union {
  75. uint64_t ft_64;
  76. FILETIME ft_ft;
  77. } ft;
  78. /* number of 100-nsec units since Jan 1, 1601 */
  79. GetSystemTimeAsFileTime(&ft.ft_ft);
  80. if (ft.ft_64 < EPOCH_BIAS) {
  81. /* LCOV_EXCL_START */
  82. log_err(LD_GENERAL,"System time is before 1970; failing.");
  83. exit(1); // exit ok: system clock is broken.
  84. /* LCOV_EXCL_STOP */
  85. }
  86. ft.ft_64 -= EPOCH_BIAS;
  87. timeval->tv_sec = (unsigned) (ft.ft_64 / UNITS_PER_SEC);
  88. timeval->tv_usec = (unsigned) ((ft.ft_64 / UNITS_PER_USEC) % USEC_PER_SEC);
  89. #elif defined(HAVE_GETTIMEOFDAY)
  90. if (gettimeofday(timeval, NULL)) {
  91. /* LCOV_EXCL_START */
  92. log_err(LD_GENERAL,"gettimeofday failed.");
  93. /* If gettimeofday dies, we have either given a bad timezone (we didn't),
  94. or segfaulted.*/
  95. exit(1); // exit ok: gettimeofday failed.
  96. /* LCOV_EXCL_STOP */
  97. }
  98. #elif defined(HAVE_FTIME)
  99. struct timeb tb;
  100. ftime(&tb);
  101. timeval->tv_sec = tb.time;
  102. timeval->tv_usec = tb.millitm * 1000;
  103. #else
  104. #error "No way to get time."
  105. #endif /* defined(_WIN32) || ... */
  106. return;
  107. }
  108. #define ONE_MILLION ((int64_t) (1000 * 1000))
  109. #define ONE_BILLION ((int64_t) (1000 * 1000 * 1000))
  110. /** True iff monotime_init has been called. */
  111. static int monotime_initialized = 0;
  112. static monotime_t initialized_at;
  113. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  114. static monotime_coarse_t initialized_at_coarse;
  115. #endif
  116. #ifdef TOR_UNIT_TESTS
  117. /** True if we are running unit tests and overriding the current monotonic
  118. * time. Note that mocked monotonic time might not be monotonic.
  119. */
  120. static int monotime_mocking_enabled = 0;
  121. static monotime_t initialized_at_saved;
  122. static int64_t mock_time_nsec = 0;
  123. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  124. static int64_t mock_time_nsec_coarse = 0;
  125. static monotime_coarse_t initialized_at_coarse_saved;
  126. #endif
  127. void
  128. monotime_enable_test_mocking(void)
  129. {
  130. if (BUG(monotime_initialized == 0)) {
  131. monotime_init();
  132. }
  133. tor_assert_nonfatal(monotime_mocking_enabled == 0);
  134. monotime_mocking_enabled = 1;
  135. memcpy(&initialized_at_saved,
  136. &initialized_at, sizeof(monotime_t));
  137. memset(&initialized_at, 0, sizeof(monotime_t));
  138. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  139. memcpy(&initialized_at_coarse_saved,
  140. &initialized_at_coarse, sizeof(monotime_coarse_t));
  141. memset(&initialized_at_coarse, 0, sizeof(monotime_coarse_t));
  142. #endif
  143. }
  144. void
  145. monotime_disable_test_mocking(void)
  146. {
  147. tor_assert_nonfatal(monotime_mocking_enabled == 1);
  148. monotime_mocking_enabled = 0;
  149. memcpy(&initialized_at,
  150. &initialized_at_saved, sizeof(monotime_t));
  151. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  152. memcpy(&initialized_at_coarse,
  153. &initialized_at_coarse_saved, sizeof(monotime_coarse_t));
  154. #endif
  155. }
  156. void
  157. monotime_set_mock_time_nsec(int64_t nsec)
  158. {
  159. tor_assert_nonfatal(monotime_mocking_enabled == 1);
  160. mock_time_nsec = nsec;
  161. }
  162. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  163. void
  164. monotime_coarse_set_mock_time_nsec(int64_t nsec)
  165. {
  166. tor_assert_nonfatal(monotime_mocking_enabled == 1);
  167. mock_time_nsec_coarse = nsec;
  168. }
  169. #endif /* defined(MONOTIME_COARSE_FN_IS_DIFFERENT) */
  170. #endif /* defined(TOR_UNIT_TESTS) */
  171. /* "ratchet" functions for monotonic time. */
  172. #if defined(_WIN32) || defined(TOR_UNIT_TESTS)
  173. /** Protected by lock: last value returned by monotime_get(). */
  174. static int64_t last_pctr = 0;
  175. /** Protected by lock: offset we must add to monotonic time values. */
  176. static int64_t pctr_offset = 0;
  177. /* If we are using GetTickCount(), how many times has it rolled over? */
  178. static uint32_t rollover_count = 0;
  179. /* If we are using GetTickCount(), what's the last value it returned? */
  180. static int64_t last_tick_count = 0;
  181. /** Helper for windows: Called with a sequence of times that are supposed
  182. * to be monotonic; increments them as appropriate so that they actually
  183. * _are_ monotonic.
  184. *
  185. * Caller must hold lock. */
  186. STATIC int64_t
  187. ratchet_performance_counter(int64_t count_raw)
  188. {
  189. /* must hold lock */
  190. const int64_t count_adjusted = count_raw + pctr_offset;
  191. if (PREDICT_UNLIKELY(count_adjusted < last_pctr)) {
  192. /* Monotonicity failed! Pretend no time elapsed. */
  193. pctr_offset = last_pctr - count_raw;
  194. return last_pctr;
  195. } else {
  196. last_pctr = count_adjusted;
  197. return count_adjusted;
  198. }
  199. }
  200. STATIC int64_t
  201. ratchet_coarse_performance_counter(const int64_t count_raw)
  202. {
  203. int64_t count = count_raw + (((int64_t)rollover_count) << 32);
  204. while (PREDICT_UNLIKELY(count < last_tick_count)) {
  205. ++rollover_count;
  206. count = count_raw + (((int64_t)rollover_count) << 32);
  207. }
  208. last_tick_count = count;
  209. return count;
  210. }
  211. #endif /* defined(_WIN32) || defined(TOR_UNIT_TESTS) */
  212. #if defined(MONOTIME_USING_GETTIMEOFDAY) || defined(TOR_UNIT_TESTS)
  213. static struct timeval last_timeofday = { 0, 0 };
  214. static struct timeval timeofday_offset = { 0, 0 };
  215. /** Helper for gettimeofday(): Called with a sequence of times that are
  216. * supposed to be monotonic; increments them as appropriate so that they
  217. * actually _are_ monotonic.
  218. *
  219. * Caller must hold lock. */
  220. STATIC void
  221. ratchet_timeval(const struct timeval *timeval_raw, struct timeval *out)
  222. {
  223. /* must hold lock */
  224. timeradd(timeval_raw, &timeofday_offset, out);
  225. if (PREDICT_UNLIKELY(timercmp(out, &last_timeofday, OP_LT))) {
  226. /* time ran backwards. Instead, declare that no time occurred. */
  227. timersub(&last_timeofday, timeval_raw, &timeofday_offset);
  228. memcpy(out, &last_timeofday, sizeof(struct timeval));
  229. } else {
  230. memcpy(&last_timeofday, out, sizeof(struct timeval));
  231. }
  232. }
  233. #endif /* defined(MONOTIME_USING_GETTIMEOFDAY) || defined(TOR_UNIT_TESTS) */
  234. #ifdef TOR_UNIT_TESTS
  235. /** For testing: reset all the ratchets */
  236. void
  237. monotime_reset_ratchets_for_testing(void)
  238. {
  239. last_pctr = pctr_offset = last_tick_count = 0;
  240. rollover_count = 0;
  241. memset(&last_timeofday, 0, sizeof(struct timeval));
  242. memset(&timeofday_offset, 0, sizeof(struct timeval));
  243. }
  244. #endif /* defined(TOR_UNIT_TESTS) */
  245. #ifdef __APPLE__
  246. /** Initialized on startup: tells is how to convert from ticks to
  247. * nanoseconds.
  248. */
  249. static struct mach_timebase_info mach_time_info;
  250. static int monotime_shift = 0;
  251. static void
  252. monotime_init_internal(void)
  253. {
  254. tor_assert(!monotime_initialized);
  255. int r = mach_timebase_info(&mach_time_info);
  256. tor_assert(r == 0);
  257. tor_assert(mach_time_info.denom != 0);
  258. {
  259. // approximate only.
  260. uint64_t ns_per_tick = mach_time_info.numer / mach_time_info.denom;
  261. uint64_t ms_per_tick = ns_per_tick * ONE_MILLION;
  262. // requires that tor_log2(0) == 0.
  263. monotime_shift = tor_log2(ms_per_tick);
  264. }
  265. }
  266. /**
  267. * Set "out" to the most recent monotonic time value
  268. */
  269. void
  270. monotime_get(monotime_t *out)
  271. {
  272. #ifdef TOR_UNIT_TESTS
  273. if (monotime_mocking_enabled) {
  274. out->abstime_ = (mock_time_nsec * mach_time_info.denom)
  275. / mach_time_info.numer;
  276. return;
  277. }
  278. #endif /* defined(TOR_UNIT_TESTS) */
  279. out->abstime_ = mach_absolute_time();
  280. }
  281. #if defined(HAVE_MACH_APPROXIMATE_TIME)
  282. void
  283. monotime_coarse_get(monotime_coarse_t *out)
  284. {
  285. #ifdef TOR_UNIT_TESTS
  286. if (monotime_mocking_enabled) {
  287. out->abstime_ = (mock_time_nsec_coarse * mach_time_info.denom)
  288. / mach_time_info.numer;
  289. return;
  290. }
  291. #endif /* defined(TOR_UNIT_TESTS) */
  292. out->abstime_ = mach_approximate_time();
  293. }
  294. #endif
  295. /**
  296. * Return the number of nanoseconds between <b>start</b> and <b>end</b>.
  297. */
  298. int64_t
  299. monotime_diff_nsec(const monotime_t *start,
  300. const monotime_t *end)
  301. {
  302. if (BUG(mach_time_info.denom == 0)) {
  303. monotime_init();
  304. }
  305. const int64_t diff_ticks = end->abstime_ - start->abstime_;
  306. const int64_t diff_nsec =
  307. (diff_ticks * mach_time_info.numer) / mach_time_info.denom;
  308. return diff_nsec;
  309. }
  310. uint32_t
  311. monotime_coarse_to_stamp(const monotime_coarse_t *t)
  312. {
  313. return (uint32_t)(t->abstime_ >> monotime_shift);
  314. }
  315. int
  316. monotime_is_zero(const monotime_t *val)
  317. {
  318. return val->abstime_ == 0;
  319. }
  320. void
  321. monotime_add_msec(monotime_t *out, const monotime_t *val, uint32_t msec)
  322. {
  323. const uint64_t nsec = msec * ONE_MILLION;
  324. const uint64_t ticks = (nsec * mach_time_info.denom) / mach_time_info.numer;
  325. out->abstime_ = val->abstime_ + ticks;
  326. }
  327. /* end of "__APPLE__" */
  328. #elif defined(HAVE_CLOCK_GETTIME)
  329. #ifdef CLOCK_MONOTONIC_COARSE
  330. /**
  331. * Which clock should we use for coarse-grained monotonic time? By default
  332. * this is CLOCK_MONOTONIC_COARSE, but it might not work -- for example,
  333. * if we're compiled with newer Linux headers and then we try to run on
  334. * an old Linux kernel. In that case, we will fall back to CLOCK_MONOTONIC.
  335. */
  336. static int clock_monotonic_coarse = CLOCK_MONOTONIC_COARSE;
  337. #endif /* defined(CLOCK_MONOTONIC_COARSE) */
  338. static void
  339. monotime_init_internal(void)
  340. {
  341. #ifdef CLOCK_MONOTONIC_COARSE
  342. struct timespec ts;
  343. if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) < 0) {
  344. log_info(LD_GENERAL, "CLOCK_MONOTONIC_COARSE isn't working (%s); "
  345. "falling back to CLOCK_MONOTONIC.", strerror(errno));
  346. clock_monotonic_coarse = CLOCK_MONOTONIC;
  347. }
  348. #endif /* defined(CLOCK_MONOTONIC_COARSE) */
  349. }
  350. void
  351. monotime_get(monotime_t *out)
  352. {
  353. #ifdef TOR_UNIT_TESTS
  354. if (monotime_mocking_enabled) {
  355. out->ts_.tv_sec = (time_t) (mock_time_nsec / ONE_BILLION);
  356. out->ts_.tv_nsec = (int) (mock_time_nsec % ONE_BILLION);
  357. return;
  358. }
  359. #endif /* defined(TOR_UNIT_TESTS) */
  360. int r = clock_gettime(CLOCK_MONOTONIC, &out->ts_);
  361. tor_assert(r == 0);
  362. }
  363. #ifdef CLOCK_MONOTONIC_COARSE
  364. void
  365. monotime_coarse_get(monotime_coarse_t *out)
  366. {
  367. #ifdef TOR_UNIT_TESTS
  368. if (monotime_mocking_enabled) {
  369. out->ts_.tv_sec = (time_t) (mock_time_nsec_coarse / ONE_BILLION);
  370. out->ts_.tv_nsec = (int) (mock_time_nsec_coarse % ONE_BILLION);
  371. return;
  372. }
  373. #endif /* defined(TOR_UNIT_TESTS) */
  374. int r = clock_gettime(clock_monotonic_coarse, &out->ts_);
  375. if (PREDICT_UNLIKELY(r < 0) &&
  376. errno == EINVAL &&
  377. clock_monotonic_coarse == CLOCK_MONOTONIC_COARSE) {
  378. /* We should have caught this at startup in monotime_init_internal!
  379. */
  380. log_warn(LD_BUG, "Falling back to non-coarse monotonic time %s initial "
  381. "system start?", monotime_initialized?"after":"without");
  382. clock_monotonic_coarse = CLOCK_MONOTONIC;
  383. r = clock_gettime(clock_monotonic_coarse, &out->ts_);
  384. }
  385. tor_assert(r == 0);
  386. }
  387. #endif /* defined(CLOCK_MONOTONIC_COARSE) */
  388. int64_t
  389. monotime_diff_nsec(const monotime_t *start,
  390. const monotime_t *end)
  391. {
  392. const int64_t diff_sec = end->ts_.tv_sec - start->ts_.tv_sec;
  393. const int64_t diff_nsec = diff_sec * ONE_BILLION +
  394. (end->ts_.tv_nsec - start->ts_.tv_nsec);
  395. return diff_nsec;
  396. }
  397. /* This value is ONE_BILLION >> 20. */
  398. static const uint32_t STAMP_TICKS_PER_SECOND = 953;
  399. uint32_t
  400. monotime_coarse_to_stamp(const monotime_coarse_t *t)
  401. {
  402. uint32_t nsec = (uint32_t)t->ts_.tv_nsec;
  403. uint32_t sec = (uint32_t)t->ts_.tv_sec;
  404. return (sec * STAMP_TICKS_PER_SECOND) + (nsec >> 20);
  405. }
  406. int
  407. monotime_is_zero(const monotime_t *val)
  408. {
  409. return val->ts_.tv_sec == 0 && val->ts_.tv_nsec == 0;
  410. }
  411. void
  412. monotime_add_msec(monotime_t *out, const monotime_t *val, uint32_t msec)
  413. {
  414. const uint32_t sec = msec / 1000;
  415. const uint32_t msec_remainder = msec % 1000;
  416. out->ts_.tv_sec = val->ts_.tv_sec + sec;
  417. out->ts_.tv_nsec = val->ts_.tv_nsec + (msec_remainder * ONE_MILLION);
  418. if (out->ts_.tv_nsec > ONE_BILLION) {
  419. out->ts_.tv_nsec -= ONE_BILLION;
  420. out->ts_.tv_sec += 1;
  421. }
  422. }
  423. /* end of "HAVE_CLOCK_GETTIME" */
  424. #elif defined (_WIN32)
  425. /** Result of QueryPerformanceFrequency, in terms needed to
  426. * convert ticks to nanoseconds. */
  427. static int64_t nsec_per_tick_numer = 1;
  428. static int64_t nsec_per_tick_denom = 1;
  429. /** Lock to protect last_pctr and pctr_offset */
  430. static CRITICAL_SECTION monotime_lock;
  431. /** Lock to protect rollover_count and last_tick_count */
  432. static CRITICAL_SECTION monotime_coarse_lock;
  433. typedef ULONGLONG (WINAPI *GetTickCount64_fn_t)(void);
  434. static GetTickCount64_fn_t GetTickCount64_fn = NULL;
  435. static void
  436. monotime_init_internal(void)
  437. {
  438. tor_assert(!monotime_initialized);
  439. BOOL ok = InitializeCriticalSectionAndSpinCount(&monotime_lock, 200);
  440. tor_assert(ok);
  441. ok = InitializeCriticalSectionAndSpinCount(&monotime_coarse_lock, 200);
  442. tor_assert(ok);
  443. LARGE_INTEGER li;
  444. ok = QueryPerformanceFrequency(&li);
  445. tor_assert(ok);
  446. tor_assert(li.QuadPart);
  447. uint64_t n = ONE_BILLION;
  448. uint64_t d = li.QuadPart;
  449. /* We need to simplify this or we'll probably overflow the int64. */
  450. simplify_fraction64(&n, &d);
  451. tor_assert(n <= INT64_MAX);
  452. tor_assert(d <= INT64_MAX);
  453. nsec_per_tick_numer = (int64_t) n;
  454. nsec_per_tick_denom = (int64_t) d;
  455. last_pctr = 0;
  456. pctr_offset = 0;
  457. HANDLE h = load_windows_system_library(TEXT("kernel32.dll"));
  458. if (h) {
  459. GetTickCount64_fn = (GetTickCount64_fn_t)
  460. GetProcAddress(h, "GetTickCount64");
  461. }
  462. // FreeLibrary(h) ?
  463. }
  464. void
  465. monotime_get(monotime_t *out)
  466. {
  467. if (BUG(monotime_initialized == 0)) {
  468. monotime_init();
  469. }
  470. #ifdef TOR_UNIT_TESTS
  471. if (monotime_mocking_enabled) {
  472. out->pcount_ = (mock_time_nsec * nsec_per_tick_denom)
  473. / nsec_per_tick_numer;
  474. return;
  475. }
  476. #endif /* defined(TOR_UNIT_TESTS) */
  477. /* Alas, QueryPerformanceCounter is not always monotonic: see bug list at
  478. https://www.python.org/dev/peps/pep-0418/#windows-queryperformancecounter
  479. */
  480. EnterCriticalSection(&monotime_lock);
  481. LARGE_INTEGER res;
  482. BOOL ok = QueryPerformanceCounter(&res);
  483. tor_assert(ok);
  484. const int64_t count_raw = res.QuadPart;
  485. out->pcount_ = ratchet_performance_counter(count_raw);
  486. LeaveCriticalSection(&monotime_lock);
  487. }
  488. void
  489. monotime_coarse_get(monotime_coarse_t *out)
  490. {
  491. #ifdef TOR_UNIT_TESTS
  492. if (monotime_mocking_enabled) {
  493. out->tick_count_ = mock_time_nsec_coarse / ONE_MILLION;
  494. return;
  495. }
  496. #endif /* defined(TOR_UNIT_TESTS) */
  497. if (GetTickCount64_fn) {
  498. out->tick_count_ = (int64_t)GetTickCount64_fn();
  499. } else {
  500. EnterCriticalSection(&monotime_coarse_lock);
  501. DWORD tick = GetTickCount();
  502. out->tick_count_ = ratchet_coarse_performance_counter(tick);
  503. LeaveCriticalSection(&monotime_coarse_lock);
  504. }
  505. }
  506. int64_t
  507. monotime_diff_nsec(const monotime_t *start,
  508. const monotime_t *end)
  509. {
  510. if (BUG(monotime_initialized == 0)) {
  511. monotime_init();
  512. }
  513. const int64_t diff_ticks = end->pcount_ - start->pcount_;
  514. return (diff_ticks * nsec_per_tick_numer) / nsec_per_tick_denom;
  515. }
  516. int64_t
  517. monotime_coarse_diff_msec(const monotime_coarse_t *start,
  518. const monotime_coarse_t *end)
  519. {
  520. const int64_t diff_ticks = end->tick_count_ - start->tick_count_;
  521. return diff_ticks;
  522. }
  523. int64_t
  524. monotime_coarse_diff_usec(const monotime_coarse_t *start,
  525. const monotime_coarse_t *end)
  526. {
  527. return monotime_coarse_diff_msec(start, end) * 1000;
  528. }
  529. int64_t
  530. monotime_coarse_diff_nsec(const monotime_coarse_t *start,
  531. const monotime_coarse_t *end)
  532. {
  533. return monotime_coarse_diff_msec(start, end) * ONE_MILLION;
  534. }
  535. static const uint32_t STAMP_TICKS_PER_SECOND = 1000;
  536. uint32_t
  537. monotime_coarse_to_stamp(const monotime_coarse_t *t)
  538. {
  539. return (uint32_t) t->tick_count_;
  540. }
  541. int
  542. monotime_is_zero(const monotime_t *val)
  543. {
  544. return val->pcount_ == 0;
  545. }
  546. int
  547. monotime_coarse_is_zero(const monotime_coarse_t *val)
  548. {
  549. return val->tick_count_ == 0;
  550. }
  551. void
  552. monotime_add_msec(monotime_t *out, const monotime_t *val, uint32_t msec)
  553. {
  554. const uint64_t nsec = msec * ONE_MILLION;
  555. const uint64_t ticks = (nsec * nsec_per_tick_denom) / nsec_per_tick_numer;
  556. out->pcount_ = val->pcount_ + ticks;
  557. }
  558. void
  559. monotime_coarse_add_msec(monotime_coarse_t *out, const monotime_coarse_t *val,
  560. uint32_t msec)
  561. {
  562. out->tick_count_ = val->tick_count_ + msec;
  563. }
  564. /* end of "_WIN32" */
  565. #elif defined(MONOTIME_USING_GETTIMEOFDAY)
  566. static tor_mutex_t monotime_lock;
  567. /** Initialize the monotonic timer subsystem. */
  568. static void
  569. monotime_init_internal(void)
  570. {
  571. tor_assert(!monotime_initialized);
  572. tor_mutex_init(&monotime_lock);
  573. }
  574. void
  575. monotime_get(monotime_t *out)
  576. {
  577. if (BUG(monotime_initialized == 0)) {
  578. monotime_init();
  579. }
  580. tor_mutex_acquire(&monotime_lock);
  581. struct timeval timeval_raw;
  582. tor_gettimeofday(&timeval_raw);
  583. ratchet_timeval(&timeval_raw, &out->tv_);
  584. tor_mutex_release(&monotime_lock);
  585. }
  586. int64_t
  587. monotime_diff_nsec(const monotime_t *start,
  588. const monotime_t *end)
  589. {
  590. struct timeval diff;
  591. timersub(&end->tv_, &start->tv_, &diff);
  592. return (diff.tv_sec * ONE_BILLION + diff.tv_usec * 1000);
  593. }
  594. /* This value is ONE_MILLION >> 10. */
  595. static const uint32_t STAMP_TICKS_PER_SECOND = 976;
  596. uint32_t
  597. monotime_coarse_to_stamp(const monotime_coarse_t *t)
  598. {
  599. const uint32_t usec = (uint32_t)t->tv_.tv_usec;
  600. const uint32_t sec = (uint32_t)t->tv_.tv_sec;
  601. return (sec * STAMP_TICKS_PER_SECOND) | (nsec >> 10);
  602. }
  603. int
  604. monotime_is_zero(const monotime_t *val)
  605. {
  606. return val->tv_.tv_sec == 0 && val->tv_.tv_usec == 0;
  607. }
  608. void
  609. monotime_add_msec(monotime_t *out, const monotime_t *val, uint32_t msec)
  610. {
  611. const uint32_t sec = msec / 1000;
  612. const uint32_t msec_remainder = msec % 1000;
  613. out->tv_.tv_sec = val->tv_.tv_sec + sec;
  614. out->tv_.tv_usec = val->tv_.tv_nsec + (msec_remainder * 1000);
  615. if (out->tv_.tv_usec > ONE_MILLION) {
  616. out->tv_.tv_usec -= ONE_MILLION;
  617. out->tv_.tv_sec += 1;
  618. }
  619. }
  620. /* end of "MONOTIME_USING_GETTIMEOFDAY" */
  621. #else
  622. #error "No way to implement monotonic timers."
  623. #endif /* defined(__APPLE__) || ... */
  624. /**
  625. * Initialize the monotonic timer subsystem. Must be called before any
  626. * monotonic timer functions. This function is idempotent.
  627. */
  628. void
  629. monotime_init(void)
  630. {
  631. if (!monotime_initialized) {
  632. monotime_init_internal();
  633. monotime_initialized = 1;
  634. monotime_get(&initialized_at);
  635. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  636. monotime_coarse_get(&initialized_at_coarse);
  637. #endif
  638. }
  639. }
  640. void
  641. monotime_zero(monotime_t *out)
  642. {
  643. memset(out, 0, sizeof(*out));
  644. }
  645. #ifdef MONOTIME_COARSE_TYPE_IS_DIFFERENT
  646. void
  647. monotime_coarse_zero(monotime_coarse_t *out)
  648. {
  649. memset(out, 0, sizeof(*out));
  650. }
  651. #endif
  652. int64_t
  653. monotime_diff_usec(const monotime_t *start,
  654. const monotime_t *end)
  655. {
  656. const int64_t nsec = monotime_diff_nsec(start, end);
  657. return CEIL_DIV(nsec, 1000);
  658. }
  659. int64_t
  660. monotime_diff_msec(const monotime_t *start,
  661. const monotime_t *end)
  662. {
  663. const int64_t nsec = monotime_diff_nsec(start, end);
  664. return CEIL_DIV(nsec, ONE_MILLION);
  665. }
  666. uint64_t
  667. monotime_absolute_nsec(void)
  668. {
  669. monotime_t now;
  670. if (BUG(monotime_initialized == 0)) {
  671. monotime_init();
  672. }
  673. monotime_get(&now);
  674. return monotime_diff_nsec(&initialized_at, &now);
  675. }
  676. uint64_t
  677. monotime_absolute_usec(void)
  678. {
  679. return monotime_absolute_nsec() / 1000;
  680. }
  681. uint64_t
  682. monotime_absolute_msec(void)
  683. {
  684. return monotime_absolute_nsec() / ONE_MILLION;
  685. }
  686. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  687. uint64_t
  688. monotime_coarse_absolute_nsec(void)
  689. {
  690. if (BUG(monotime_initialized == 0)) {
  691. monotime_init();
  692. }
  693. monotime_coarse_t now;
  694. monotime_coarse_get(&now);
  695. return monotime_coarse_diff_nsec(&initialized_at_coarse, &now);
  696. }
  697. uint64_t
  698. monotime_coarse_absolute_usec(void)
  699. {
  700. return monotime_coarse_absolute_nsec() / 1000;
  701. }
  702. uint64_t
  703. monotime_coarse_absolute_msec(void)
  704. {
  705. return monotime_coarse_absolute_nsec() / ONE_MILLION;
  706. }
  707. #else
  708. #define initialized_at_coarse initialized_at
  709. #endif /* defined(MONOTIME_COARSE_FN_IS_DIFFERENT) */
  710. /**
  711. * Return the current time "stamp" as described by monotime_coarse_to_stamp.
  712. */
  713. uint32_t
  714. monotime_coarse_get_stamp(void)
  715. {
  716. monotime_coarse_t now;
  717. monotime_coarse_get(&now);
  718. return monotime_coarse_to_stamp(&now);
  719. }
  720. #ifdef __APPLE__
  721. uint64_t
  722. monotime_coarse_stamp_units_to_approx_msec(uint64_t units)
  723. {
  724. /* Recover as much precision as we can. */
  725. uint64_t abstime_diff = (units << monotime_shift);
  726. return (abstime_diff * mach_time_info.numer) /
  727. (mach_time_info.denom * ONE_MILLION);
  728. }
  729. #else
  730. uint64_t
  731. monotime_coarse_stamp_units_to_approx_msec(uint64_t units)
  732. {
  733. return (units * 1000) / STAMP_TICKS_PER_SECOND;
  734. }
  735. #endif