compat_time.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657
  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 void
  251. monotime_init_internal(void)
  252. {
  253. tor_assert(!monotime_initialized);
  254. int r = mach_timebase_info(&mach_time_info);
  255. tor_assert(r == 0);
  256. tor_assert(mach_time_info.denom != 0);
  257. }
  258. /**
  259. * Set "out" to the most recent monotonic time value
  260. */
  261. void
  262. monotime_get(monotime_t *out)
  263. {
  264. #ifdef TOR_UNIT_TESTS
  265. if (monotime_mocking_enabled) {
  266. out->abstime_ = (mock_time_nsec * mach_time_info.denom)
  267. / mach_time_info.numer;
  268. return;
  269. }
  270. #endif /* defined(TOR_UNIT_TESTS) */
  271. out->abstime_ = mach_absolute_time();
  272. }
  273. /**
  274. * Return the number of nanoseconds between <b>start</b> and <b>end</b>.
  275. */
  276. int64_t
  277. monotime_diff_nsec(const monotime_t *start,
  278. const monotime_t *end)
  279. {
  280. if (BUG(mach_time_info.denom == 0)) {
  281. monotime_init();
  282. }
  283. const int64_t diff_ticks = end->abstime_ - start->abstime_;
  284. const int64_t diff_nsec =
  285. (diff_ticks * mach_time_info.numer) / mach_time_info.denom;
  286. return diff_nsec;
  287. }
  288. /* end of "__APPLE__" */
  289. #elif defined(HAVE_CLOCK_GETTIME)
  290. #ifdef CLOCK_MONOTONIC_COARSE
  291. /**
  292. * Which clock should we use for coarse-grained monotonic time? By default
  293. * this is CLOCK_MONOTONIC_COARSE, but it might not work -- for example,
  294. * if we're compiled with newer Linux headers and then we try to run on
  295. * an old Linux kernel. In that case, we will fall back to CLOCK_MONOTONIC.
  296. */
  297. static int clock_monotonic_coarse = CLOCK_MONOTONIC_COARSE;
  298. #endif /* defined(CLOCK_MONOTONIC_COARSE) */
  299. static void
  300. monotime_init_internal(void)
  301. {
  302. #ifdef CLOCK_MONOTONIC_COARSE
  303. struct timespec ts;
  304. if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) < 0) {
  305. log_info(LD_GENERAL, "CLOCK_MONOTONIC_COARSE isn't working (%s); "
  306. "falling back to CLOCK_MONOTONIC.", strerror(errno));
  307. clock_monotonic_coarse = CLOCK_MONOTONIC;
  308. }
  309. #endif /* defined(CLOCK_MONOTONIC_COARSE) */
  310. }
  311. void
  312. monotime_get(monotime_t *out)
  313. {
  314. #ifdef TOR_UNIT_TESTS
  315. if (monotime_mocking_enabled) {
  316. out->ts_.tv_sec = (time_t) (mock_time_nsec / ONE_BILLION);
  317. out->ts_.tv_nsec = (int) (mock_time_nsec % ONE_BILLION);
  318. return;
  319. }
  320. #endif /* defined(TOR_UNIT_TESTS) */
  321. int r = clock_gettime(CLOCK_MONOTONIC, &out->ts_);
  322. tor_assert(r == 0);
  323. }
  324. #ifdef CLOCK_MONOTONIC_COARSE
  325. void
  326. monotime_coarse_get(monotime_coarse_t *out)
  327. {
  328. #ifdef TOR_UNIT_TESTS
  329. if (monotime_mocking_enabled) {
  330. out->ts_.tv_sec = (time_t) (mock_time_nsec_coarse / ONE_BILLION);
  331. out->ts_.tv_nsec = (int) (mock_time_nsec_coarse % ONE_BILLION);
  332. return;
  333. }
  334. #endif /* defined(TOR_UNIT_TESTS) */
  335. int r = clock_gettime(clock_monotonic_coarse, &out->ts_);
  336. if (PREDICT_UNLIKELY(r < 0) &&
  337. errno == EINVAL &&
  338. clock_monotonic_coarse == CLOCK_MONOTONIC_COARSE) {
  339. /* We should have caught this at startup in monotime_init_internal!
  340. */
  341. log_warn(LD_BUG, "Falling back to non-coarse monotonic time %s initial "
  342. "system start?", monotime_initialized?"after":"without");
  343. clock_monotonic_coarse = CLOCK_MONOTONIC;
  344. r = clock_gettime(clock_monotonic_coarse, &out->ts_);
  345. }
  346. tor_assert(r == 0);
  347. }
  348. #endif /* defined(CLOCK_MONOTONIC_COARSE) */
  349. int64_t
  350. monotime_diff_nsec(const monotime_t *start,
  351. const monotime_t *end)
  352. {
  353. const int64_t diff_sec = end->ts_.tv_sec - start->ts_.tv_sec;
  354. const int64_t diff_nsec = diff_sec * ONE_BILLION +
  355. (end->ts_.tv_nsec - start->ts_.tv_nsec);
  356. return diff_nsec;
  357. }
  358. /* end of "HAVE_CLOCK_GETTIME" */
  359. #elif defined (_WIN32)
  360. /** Result of QueryPerformanceFrequency, in terms needed to
  361. * convert ticks to nanoseconds. */
  362. static int64_t nsec_per_tick_numer = 1;
  363. static int64_t nsec_per_tick_denom = 1;
  364. /** Lock to protect last_pctr and pctr_offset */
  365. static CRITICAL_SECTION monotime_lock;
  366. /** Lock to protect rollover_count and last_tick_count */
  367. static CRITICAL_SECTION monotime_coarse_lock;
  368. typedef ULONGLONG (WINAPI *GetTickCount64_fn_t)(void);
  369. static GetTickCount64_fn_t GetTickCount64_fn = NULL;
  370. static void
  371. monotime_init_internal(void)
  372. {
  373. tor_assert(!monotime_initialized);
  374. BOOL ok = InitializeCriticalSectionAndSpinCount(&monotime_lock, 200);
  375. tor_assert(ok);
  376. ok = InitializeCriticalSectionAndSpinCount(&monotime_coarse_lock, 200);
  377. tor_assert(ok);
  378. LARGE_INTEGER li;
  379. ok = QueryPerformanceFrequency(&li);
  380. tor_assert(ok);
  381. tor_assert(li.QuadPart);
  382. uint64_t n = ONE_BILLION;
  383. uint64_t d = li.QuadPart;
  384. /* We need to simplify this or we'll probably overflow the int64. */
  385. simplify_fraction64(&n, &d);
  386. tor_assert(n <= INT64_MAX);
  387. tor_assert(d <= INT64_MAX);
  388. nsec_per_tick_numer = (int64_t) n;
  389. nsec_per_tick_denom = (int64_t) d;
  390. last_pctr = 0;
  391. pctr_offset = 0;
  392. HANDLE h = load_windows_system_library(TEXT("kernel32.dll"));
  393. if (h) {
  394. GetTickCount64_fn = (GetTickCount64_fn_t)
  395. GetProcAddress(h, "GetTickCount64");
  396. }
  397. // FreeLibrary(h) ?
  398. }
  399. void
  400. monotime_get(monotime_t *out)
  401. {
  402. if (BUG(monotime_initialized == 0)) {
  403. monotime_init();
  404. }
  405. #ifdef TOR_UNIT_TESTS
  406. if (monotime_mocking_enabled) {
  407. out->pcount_ = (mock_time_nsec * nsec_per_tick_denom)
  408. / nsec_per_tick_numer;
  409. return;
  410. }
  411. #endif /* defined(TOR_UNIT_TESTS) */
  412. /* Alas, QueryPerformanceCounter is not always monotonic: see bug list at
  413. https://www.python.org/dev/peps/pep-0418/#windows-queryperformancecounter
  414. */
  415. EnterCriticalSection(&monotime_lock);
  416. LARGE_INTEGER res;
  417. BOOL ok = QueryPerformanceCounter(&res);
  418. tor_assert(ok);
  419. const int64_t count_raw = res.QuadPart;
  420. out->pcount_ = ratchet_performance_counter(count_raw);
  421. LeaveCriticalSection(&monotime_lock);
  422. }
  423. void
  424. monotime_coarse_get(monotime_coarse_t *out)
  425. {
  426. #ifdef TOR_UNIT_TESTS
  427. if (monotime_mocking_enabled) {
  428. out->tick_count_ = mock_time_nsec_coarse / ONE_MILLION;
  429. return;
  430. }
  431. #endif /* defined(TOR_UNIT_TESTS) */
  432. if (GetTickCount64_fn) {
  433. out->tick_count_ = (int64_t)GetTickCount64_fn();
  434. } else {
  435. EnterCriticalSection(&monotime_coarse_lock);
  436. DWORD tick = GetTickCount();
  437. out->tick_count_ = ratchet_coarse_performance_counter(tick);
  438. LeaveCriticalSection(&monotime_coarse_lock);
  439. }
  440. }
  441. int64_t
  442. monotime_diff_nsec(const monotime_t *start,
  443. const monotime_t *end)
  444. {
  445. if (BUG(monotime_initialized == 0)) {
  446. monotime_init();
  447. }
  448. const int64_t diff_ticks = end->pcount_ - start->pcount_;
  449. return (diff_ticks * nsec_per_tick_numer) / nsec_per_tick_denom;
  450. }
  451. int64_t
  452. monotime_coarse_diff_msec(const monotime_coarse_t *start,
  453. const monotime_coarse_t *end)
  454. {
  455. const int64_t diff_ticks = end->tick_count_ - start->tick_count_;
  456. return diff_ticks;
  457. }
  458. int64_t
  459. monotime_coarse_diff_usec(const monotime_coarse_t *start,
  460. const monotime_coarse_t *end)
  461. {
  462. return monotime_coarse_diff_msec(start, end) * 1000;
  463. }
  464. int64_t
  465. monotime_coarse_diff_nsec(const monotime_coarse_t *start,
  466. const monotime_coarse_t *end)
  467. {
  468. return monotime_coarse_diff_msec(start, end) * ONE_MILLION;
  469. }
  470. /* end of "_WIN32" */
  471. #elif defined(MONOTIME_USING_GETTIMEOFDAY)
  472. static tor_mutex_t monotime_lock;
  473. /** Initialize the monotonic timer subsystem. */
  474. static void
  475. monotime_init_internal(void)
  476. {
  477. tor_assert(!monotime_initialized);
  478. tor_mutex_init(&monotime_lock);
  479. }
  480. void
  481. monotime_get(monotime_t *out)
  482. {
  483. if (BUG(monotime_initialized == 0)) {
  484. monotime_init();
  485. }
  486. tor_mutex_acquire(&monotime_lock);
  487. struct timeval timeval_raw;
  488. tor_gettimeofday(&timeval_raw);
  489. ratchet_timeval(&timeval_raw, &out->tv_);
  490. tor_mutex_release(&monotime_lock);
  491. }
  492. int64_t
  493. monotime_diff_nsec(const monotime_t *start,
  494. const monotime_t *end)
  495. {
  496. struct timeval diff;
  497. timersub(&end->tv_, &start->tv_, &diff);
  498. return (diff.tv_sec * ONE_BILLION + diff.tv_usec * 1000);
  499. }
  500. /* end of "MONOTIME_USING_GETTIMEOFDAY" */
  501. #else
  502. #error "No way to implement monotonic timers."
  503. #endif /* defined(__APPLE__) || ... */
  504. /**
  505. * Initialize the monotonic timer subsystem. Must be called before any
  506. * monotonic timer functions. This function is idempotent.
  507. */
  508. void
  509. monotime_init(void)
  510. {
  511. if (!monotime_initialized) {
  512. monotime_init_internal();
  513. monotime_initialized = 1;
  514. monotime_get(&initialized_at);
  515. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  516. monotime_coarse_get(&initialized_at_coarse);
  517. #endif
  518. }
  519. }
  520. int64_t
  521. monotime_diff_usec(const monotime_t *start,
  522. const monotime_t *end)
  523. {
  524. const int64_t nsec = monotime_diff_nsec(start, end);
  525. return CEIL_DIV(nsec, 1000);
  526. }
  527. int64_t
  528. monotime_diff_msec(const monotime_t *start,
  529. const monotime_t *end)
  530. {
  531. const int64_t nsec = monotime_diff_nsec(start, end);
  532. return CEIL_DIV(nsec, ONE_MILLION);
  533. }
  534. uint64_t
  535. monotime_absolute_nsec(void)
  536. {
  537. monotime_t now;
  538. if (BUG(monotime_initialized == 0)) {
  539. monotime_init();
  540. }
  541. monotime_get(&now);
  542. return monotime_diff_nsec(&initialized_at, &now);
  543. }
  544. uint64_t
  545. monotime_absolute_usec(void)
  546. {
  547. return monotime_absolute_nsec() / 1000;
  548. }
  549. uint64_t
  550. monotime_absolute_msec(void)
  551. {
  552. return monotime_absolute_nsec() / ONE_MILLION;
  553. }
  554. #ifdef MONOTIME_COARSE_FN_IS_DIFFERENT
  555. uint64_t
  556. monotime_coarse_absolute_nsec(void)
  557. {
  558. if (BUG(monotime_initialized == 0)) {
  559. monotime_init();
  560. }
  561. monotime_coarse_t now;
  562. monotime_coarse_get(&now);
  563. return monotime_coarse_diff_nsec(&initialized_at_coarse, &now);
  564. }
  565. uint64_t
  566. monotime_coarse_absolute_usec(void)
  567. {
  568. return monotime_coarse_absolute_nsec() / 1000;
  569. }
  570. uint64_t
  571. monotime_coarse_absolute_msec(void)
  572. {
  573. return monotime_coarse_absolute_nsec() / ONE_MILLION;
  574. }
  575. #endif /* defined(MONOTIME_COARSE_FN_IS_DIFFERENT) */