compat_libevent.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629
  1. /* Copyright (c) 2009-2015, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file compat_libevent.c
  5. * \brief Wrappers to handle porting between different versions of libevent.
  6. *
  7. * In an ideal world, we'd just use Libevent 2.0 from now on. But as of June
  8. * 2012, Libevent 1.4 is still all over, and some poor souls are stuck on
  9. * Libevent 1.3e. */
  10. #include "orconfig.h"
  11. #include "compat.h"
  12. #define COMPAT_LIBEVENT_PRIVATE
  13. #include "compat_libevent.h"
  14. #include "crypto.h"
  15. #include "util.h"
  16. #include "torlog.h"
  17. #ifdef HAVE_EVENT2_EVENT_H
  18. #include <event2/event.h>
  19. #include <event2/thread.h>
  20. #ifdef USE_BUFFEREVENTS
  21. #include <event2/bufferevent.h>
  22. #endif
  23. #else
  24. #include <event.h>
  25. #endif
  26. /** A string which, if it appears in a libevent log, should be ignored. */
  27. static const char *suppress_msg = NULL;
  28. /** Callback function passed to event_set_log() so we can intercept
  29. * log messages from libevent. */
  30. STATIC void
  31. libevent_logging_callback(int severity, const char *msg)
  32. {
  33. char buf[1024];
  34. size_t n;
  35. if (suppress_msg && strstr(msg, suppress_msg))
  36. return;
  37. n = strlcpy(buf, msg, sizeof(buf));
  38. if (n && n < sizeof(buf) && buf[n-1] == '\n') {
  39. buf[n-1] = '\0';
  40. }
  41. switch (severity) {
  42. case _EVENT_LOG_DEBUG:
  43. log_debug(LD_NOCB|LD_NET, "Message from libevent: %s", buf);
  44. break;
  45. case _EVENT_LOG_MSG:
  46. log_info(LD_NOCB|LD_NET, "Message from libevent: %s", buf);
  47. break;
  48. case _EVENT_LOG_WARN:
  49. log_warn(LD_NOCB|LD_GENERAL, "Warning from libevent: %s", buf);
  50. break;
  51. case _EVENT_LOG_ERR:
  52. log_err(LD_NOCB|LD_GENERAL, "Error from libevent: %s", buf);
  53. break;
  54. default:
  55. log_warn(LD_NOCB|LD_GENERAL, "Message [%d] from libevent: %s",
  56. severity, buf);
  57. break;
  58. }
  59. }
  60. /** Set hook to intercept log messages from libevent. */
  61. void
  62. configure_libevent_logging(void)
  63. {
  64. event_set_log_callback(libevent_logging_callback);
  65. }
  66. /** Ignore any libevent log message that contains <b>msg</b>. */
  67. void
  68. suppress_libevent_log_msg(const char *msg)
  69. {
  70. suppress_msg = msg;
  71. }
  72. #ifndef HAVE_EVENT2_EVENT_H
  73. /** Work-alike replacement for event_new() on pre-Libevent-2.0 systems. */
  74. struct event *
  75. tor_event_new(struct event_base *base, int sock, short what,
  76. void (*cb)(int, short, void *), void *arg)
  77. {
  78. struct event *e = tor_malloc_zero(sizeof(struct event));
  79. event_set(e, sock, what, cb, arg);
  80. if (! base)
  81. base = tor_libevent_get_base();
  82. event_base_set(base, e);
  83. return e;
  84. }
  85. /** Work-alike replacement for evtimer_new() on pre-Libevent-2.0 systems. */
  86. struct event *
  87. tor_evtimer_new(struct event_base *base,
  88. void (*cb)(int, short, void *), void *arg)
  89. {
  90. return tor_event_new(base, -1, 0, cb, arg);
  91. }
  92. /** Work-alike replacement for evsignal_new() on pre-Libevent-2.0 systems. */
  93. struct event *
  94. tor_evsignal_new(struct event_base * base, int sig,
  95. void (*cb)(int, short, void *), void *arg)
  96. {
  97. return tor_event_new(base, sig, EV_SIGNAL|EV_PERSIST, cb, arg);
  98. }
  99. /** Work-alike replacement for event_free() on pre-Libevent-2.0 systems,
  100. * except tolerate tor_event_free(NULL). */
  101. void
  102. tor_event_free(struct event *ev)
  103. {
  104. if (ev == NULL)
  105. return;
  106. event_del(ev);
  107. tor_free(ev);
  108. }
  109. #else
  110. /* Wrapper for event_free() that tolerates tor_event_free(NULL) */
  111. void
  112. tor_event_free(struct event *ev)
  113. {
  114. if (ev == NULL)
  115. return;
  116. event_free(ev);
  117. }
  118. #endif
  119. /** Global event base for use by the main thread. */
  120. struct event_base *the_event_base = NULL;
  121. /* This is what passes for version detection on OSX. We set
  122. * MACOSX_KQUEUE_IS_BROKEN to true iff we're on a version of OSX before
  123. * 10.4.0 (aka 1040). */
  124. #ifdef __APPLE__
  125. #ifdef __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
  126. #define MACOSX_KQUEUE_IS_BROKEN \
  127. (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1040)
  128. #else
  129. #define MACOSX_KQUEUE_IS_BROKEN 0
  130. #endif
  131. #endif
  132. #ifdef USE_BUFFEREVENTS
  133. static int using_iocp_bufferevents = 0;
  134. static void tor_libevent_set_tick_timeout(int msec_per_tick);
  135. int
  136. tor_libevent_using_iocp_bufferevents(void)
  137. {
  138. return using_iocp_bufferevents;
  139. }
  140. #endif
  141. /** Initialize the Libevent library and set up the event base. */
  142. void
  143. tor_libevent_initialize(tor_libevent_cfg *torcfg)
  144. {
  145. tor_assert(the_event_base == NULL);
  146. /* some paths below don't use torcfg, so avoid unused variable warnings */
  147. (void)torcfg;
  148. #ifdef HAVE_EVENT2_EVENT_H
  149. {
  150. int attempts = 0;
  151. int using_threads;
  152. struct event_config *cfg;
  153. retry:
  154. ++attempts;
  155. using_threads = 0;
  156. cfg = event_config_new();
  157. tor_assert(cfg);
  158. #if defined(_WIN32) && defined(USE_BUFFEREVENTS)
  159. if (! torcfg->disable_iocp) {
  160. evthread_use_windows_threads();
  161. event_config_set_flag(cfg, EVENT_BASE_FLAG_STARTUP_IOCP);
  162. using_iocp_bufferevents = 1;
  163. using_threads = 1;
  164. } else {
  165. using_iocp_bufferevents = 0;
  166. }
  167. #elif defined(__COVERITY__)
  168. /* Avoid a 'dead code' warning below. */
  169. using_threads = ! torcfg->disable_iocp;
  170. #endif
  171. if (!using_threads) {
  172. /* Telling Libevent not to try to turn locking on can avoid a needless
  173. * socketpair() attempt. */
  174. event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK);
  175. }
  176. #if defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= V(2,0,7)
  177. if (torcfg->num_cpus > 0)
  178. event_config_set_num_cpus_hint(cfg, torcfg->num_cpus);
  179. #endif
  180. #if LIBEVENT_VERSION_NUMBER >= V(2,0,9)
  181. /* We can enable changelist support with epoll, since we don't give
  182. * Libevent any dup'd fds. This lets us avoid some syscalls. */
  183. event_config_set_flag(cfg, EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST);
  184. #endif
  185. the_event_base = event_base_new_with_config(cfg);
  186. event_config_free(cfg);
  187. if (using_threads && the_event_base == NULL && attempts < 2) {
  188. /* This could be a socketpair() failure, which can happen sometimes on
  189. * windows boxes with obnoxious firewall rules. Downgrade and try
  190. * again. */
  191. #if defined(_WIN32) && defined(USE_BUFFEREVENTS)
  192. if (torcfg->disable_iocp == 0) {
  193. log_warn(LD_GENERAL, "Unable to initialize Libevent. Trying again "
  194. "with IOCP disabled.");
  195. } else
  196. #endif
  197. {
  198. log_warn(LD_GENERAL, "Unable to initialize Libevent. Trying again.");
  199. }
  200. torcfg->disable_iocp = 1;
  201. goto retry;
  202. }
  203. }
  204. #else
  205. the_event_base = event_init();
  206. #endif
  207. if (!the_event_base) {
  208. log_err(LD_GENERAL, "Unable to initialize Libevent: cannot continue.");
  209. exit(1);
  210. }
  211. /* Making this a NOTICE for now so we can link bugs to a libevent versions
  212. * or methods better. */
  213. log_info(LD_GENERAL,
  214. "Initialized libevent version %s using method %s. Good.",
  215. event_get_version(), tor_libevent_get_method());
  216. #ifdef USE_BUFFEREVENTS
  217. tor_libevent_set_tick_timeout(torcfg->msec_per_tick);
  218. #endif
  219. }
  220. /** Return the current Libevent event base that we're set up to use. */
  221. MOCK_IMPL(struct event_base *,
  222. tor_libevent_get_base, (void))
  223. {
  224. return the_event_base;
  225. }
  226. /** Return the name of the Libevent backend we're using. */
  227. const char *
  228. tor_libevent_get_method(void)
  229. {
  230. #ifdef HAVE_EVENT2_EVENT_H
  231. return event_base_get_method(the_event_base);
  232. #else
  233. return event_get_method();
  234. #endif
  235. }
  236. /** Return the le_version_t for the version of libevent specified in the
  237. * string <b>v</b>. If the version is very new or uses an unrecognized
  238. * version, format, return LE_OTHER. */
  239. STATIC le_version_t
  240. tor_decode_libevent_version(const char *v)
  241. {
  242. unsigned major, minor, patchlevel;
  243. char c, e, extra;
  244. int fields;
  245. /* Try the new preferred "1.4.11-stable" format.
  246. * Also accept "1.4.14b-stable". */
  247. fields = tor_sscanf(v, "%u.%u.%u%c%c", &major, &minor, &patchlevel, &c, &e);
  248. if (fields == 3 ||
  249. ((fields == 4 || fields == 5 ) && (c == '-' || c == '_')) ||
  250. (fields == 5 && TOR_ISALPHA(c) && (e == '-' || e == '_'))) {
  251. return V(major,minor,patchlevel);
  252. }
  253. /* Try the old "1.3e" format. */
  254. fields = tor_sscanf(v, "%u.%u%c%c", &major, &minor, &c, &extra);
  255. if (fields == 3 && TOR_ISALPHA(c)) {
  256. return V_OLD(major, minor, c);
  257. } else if (fields == 2) {
  258. return V(major, minor, 0);
  259. }
  260. return LE_OTHER;
  261. }
  262. /** Return an integer representing the binary interface of a Libevent library.
  263. * Two different versions with different numbers are sure not to be binary
  264. * compatible. Two different versions with the same numbers have a decent
  265. * chance of binary compatibility.*/
  266. STATIC int
  267. le_versions_compatibility(le_version_t v)
  268. {
  269. if (v == LE_OTHER)
  270. return 0;
  271. if (v < V_OLD(1,0,'c'))
  272. return 1;
  273. else if (v < V(1,4,0))
  274. return 2;
  275. else if (v < V(1,4,99))
  276. return 3;
  277. else if (v < V(2,0,1))
  278. return 4;
  279. else /* Everything 2.0 and later should be compatible. */
  280. return 5;
  281. }
  282. /** Return a string representation of the version of the currently running
  283. * version of Libevent. */
  284. const char *
  285. tor_libevent_get_version_str(void)
  286. {
  287. return event_get_version();
  288. }
  289. #if defined(LIBEVENT_VERSION)
  290. #define HEADER_VERSION LIBEVENT_VERSION
  291. #elif defined(_EVENT_VERSION)
  292. #define HEADER_VERSION _EVENT_VERSION
  293. #endif
  294. /** Return a string representation of the version of Libevent that was used
  295. * at compilation time. */
  296. const char *
  297. tor_libevent_get_header_version_str(void)
  298. {
  299. return HEADER_VERSION;
  300. }
  301. /** See whether the headers we were built against differ from the library we
  302. * linked against so much that we're likely to crash. If so, warn the
  303. * user. */
  304. void
  305. tor_check_libevent_header_compatibility(void)
  306. {
  307. (void) le_versions_compatibility;
  308. (void) tor_decode_libevent_version;
  309. /* In libevent versions before 2.0, it's hard to keep binary compatibility
  310. * between upgrades, and unpleasant to detect when the version we compiled
  311. * against is unlike the version we have linked against. Here's how. */
  312. #if defined(HEADER_VERSION)
  313. /* We have a header-file version and a function-call version. Easy. */
  314. if (strcmp(HEADER_VERSION, event_get_version())) {
  315. le_version_t v1, v2;
  316. int compat1 = -1, compat2 = -1;
  317. int verybad;
  318. v1 = tor_decode_libevent_version(HEADER_VERSION);
  319. v2 = tor_decode_libevent_version(event_get_version());
  320. compat1 = le_versions_compatibility(v1);
  321. compat2 = le_versions_compatibility(v2);
  322. verybad = compat1 != compat2;
  323. tor_log(verybad ? LOG_WARN : LOG_NOTICE,
  324. LD_GENERAL, "We were compiled with headers from version %s "
  325. "of Libevent, but we're using a Libevent library that says it's "
  326. "version %s.", HEADER_VERSION, event_get_version());
  327. if (verybad)
  328. log_warn(LD_GENERAL, "This will almost certainly make Tor crash.");
  329. else
  330. log_info(LD_GENERAL, "I think these versions are binary-compatible.");
  331. }
  332. #else
  333. /* event_get_version but no _EVENT_VERSION. We might be in 1.4.0-beta or
  334. earlier, where that's normal. To see whether we were compiled with an
  335. earlier version, let's see whether the struct event defines MIN_HEAP_IDX.
  336. */
  337. #ifdef HAVE_STRUCT_EVENT_MIN_HEAP_IDX
  338. /* The header files are 1.4.0-beta or later. If the version is not
  339. * 1.4.0-beta, we are incompatible. */
  340. {
  341. if (strcmp(event_get_version(), "1.4.0-beta")) {
  342. log_warn(LD_GENERAL, "It's a little hard to tell, but you seem to have "
  343. "Libevent 1.4.0-beta header files, whereas you have linked "
  344. "against Libevent %s. This will probably make Tor crash.",
  345. event_get_version());
  346. }
  347. }
  348. #else
  349. /* Our headers are 1.3e or earlier. If the library version is not 1.4.x or
  350. later, we're probably fine. */
  351. {
  352. const char *v = event_get_version();
  353. if ((v[0] == '1' && v[2] == '.' && v[3] > '3') || v[0] > '1') {
  354. log_warn(LD_GENERAL, "It's a little hard to tell, but you seem to have "
  355. "Libevent header file from 1.3e or earlier, whereas you have "
  356. "linked against Libevent %s. This will probably make Tor "
  357. "crash.", event_get_version());
  358. }
  359. }
  360. #endif
  361. /* Your libevent is ancient. */
  362. #endif
  363. }
  364. /*
  365. If possible, we're going to try to use Libevent's periodic timer support,
  366. since it does a pretty good job of making sure that periodic events get
  367. called exactly M seconds apart, rather than starting each one exactly M
  368. seconds after the time that the last one was run.
  369. */
  370. #ifdef HAVE_EVENT2_EVENT_H
  371. #define HAVE_PERIODIC
  372. #define PERIODIC_FLAGS EV_PERSIST
  373. #else
  374. #define PERIODIC_FLAGS 0
  375. #endif
  376. /** Represents a timer that's run every N microseconds by Libevent. */
  377. struct periodic_timer_t {
  378. /** Underlying event used to implement this periodic event. */
  379. struct event *ev;
  380. /** The callback we'll be invoking whenever the event triggers */
  381. void (*cb)(struct periodic_timer_t *, void *);
  382. /** User-supplied data for the callback */
  383. void *data;
  384. #ifndef HAVE_PERIODIC
  385. /** If Libevent doesn't know how to invoke events every N microseconds,
  386. * we'll need to remember the timeout interval here. */
  387. struct timeval tv;
  388. #endif
  389. };
  390. /** Libevent callback to implement a periodic event. */
  391. static void
  392. periodic_timer_cb(evutil_socket_t fd, short what, void *arg)
  393. {
  394. periodic_timer_t *timer = arg;
  395. (void) what;
  396. (void) fd;
  397. #ifndef HAVE_PERIODIC
  398. /** reschedule the event as needed. */
  399. event_add(timer->ev, &timer->tv);
  400. #endif
  401. timer->cb(timer, timer->data);
  402. }
  403. /** Create and schedule a new timer that will run every <b>tv</b> in
  404. * the event loop of <b>base</b>. When the timer fires, it will
  405. * run the timer in <b>cb</b> with the user-supplied data in <b>data</b>. */
  406. periodic_timer_t *
  407. periodic_timer_new(struct event_base *base,
  408. const struct timeval *tv,
  409. void (*cb)(periodic_timer_t *timer, void *data),
  410. void *data)
  411. {
  412. periodic_timer_t *timer;
  413. tor_assert(base);
  414. tor_assert(tv);
  415. tor_assert(cb);
  416. timer = tor_malloc_zero(sizeof(periodic_timer_t));
  417. if (!(timer->ev = tor_event_new(base, -1, PERIODIC_FLAGS,
  418. periodic_timer_cb, timer))) {
  419. tor_free(timer);
  420. return NULL;
  421. }
  422. timer->cb = cb;
  423. timer->data = data;
  424. #ifndef HAVE_PERIODIC
  425. memcpy(&timer->tv, tv, sizeof(struct timeval));
  426. #endif
  427. event_add(timer->ev, (struct timeval *)tv); /*drop const for old libevent*/
  428. return timer;
  429. }
  430. /** Stop and free a periodic timer */
  431. void
  432. periodic_timer_free(periodic_timer_t *timer)
  433. {
  434. if (!timer)
  435. return;
  436. tor_event_free(timer->ev);
  437. tor_free(timer);
  438. }
  439. #ifdef USE_BUFFEREVENTS
  440. static const struct timeval *one_tick = NULL;
  441. /**
  442. * Return a special timeout to be passed whenever libevent's O(1) timeout
  443. * implementation should be used. Only use this when the timer is supposed
  444. * to fire after msec_per_tick ticks have elapsed.
  445. */
  446. const struct timeval *
  447. tor_libevent_get_one_tick_timeout(void)
  448. {
  449. tor_assert(one_tick);
  450. return one_tick;
  451. }
  452. /** Initialize the common timeout that we'll use to refill the buckets every
  453. * time a tick elapses. */
  454. static void
  455. tor_libevent_set_tick_timeout(int msec_per_tick)
  456. {
  457. struct event_base *base = tor_libevent_get_base();
  458. struct timeval tv;
  459. tor_assert(! one_tick);
  460. tv.tv_sec = msec_per_tick / 1000;
  461. tv.tv_usec = (msec_per_tick % 1000) * 1000;
  462. one_tick = event_base_init_common_timeout(base, &tv);
  463. }
  464. static struct bufferevent *
  465. tor_get_root_bufferevent(struct bufferevent *bev)
  466. {
  467. struct bufferevent *u;
  468. while ((u = bufferevent_get_underlying(bev)) != NULL)
  469. bev = u;
  470. return bev;
  471. }
  472. int
  473. tor_set_bufferevent_rate_limit(struct bufferevent *bev,
  474. struct ev_token_bucket_cfg *cfg)
  475. {
  476. return bufferevent_set_rate_limit(tor_get_root_bufferevent(bev), cfg);
  477. }
  478. int
  479. tor_add_bufferevent_to_rate_limit_group(struct bufferevent *bev,
  480. struct bufferevent_rate_limit_group *g)
  481. {
  482. return bufferevent_add_to_rate_limit_group(tor_get_root_bufferevent(bev), g);
  483. }
  484. #endif
  485. int
  486. tor_init_libevent_rng(void)
  487. {
  488. int rv = 0;
  489. #ifdef HAVE_EVUTIL_SECURE_RNG_INIT
  490. char buf[256];
  491. if (evutil_secure_rng_init() < 0) {
  492. rv = -1;
  493. }
  494. /* Older libevent -- manually initialize the RNG */
  495. crypto_rand(buf, 32);
  496. evutil_secure_rng_add_bytes(buf, 32);
  497. evutil_secure_rng_get_bytes(buf, sizeof(buf));
  498. #endif
  499. return rv;
  500. }
  501. #if defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= V(2,1,1) \
  502. && !defined(TOR_UNIT_TESTS)
  503. void
  504. tor_gettimeofday_cached(struct timeval *tv)
  505. {
  506. event_base_gettimeofday_cached(the_event_base, tv);
  507. }
  508. void
  509. tor_gettimeofday_cache_clear(void)
  510. {
  511. event_base_update_cache_time(the_event_base);
  512. }
  513. #else
  514. /** Cache the current hi-res time; the cache gets reset when libevent
  515. * calls us. */
  516. static struct timeval cached_time_hires = {0, 0};
  517. /** Return a fairly recent view of the current time. */
  518. void
  519. tor_gettimeofday_cached(struct timeval *tv)
  520. {
  521. if (cached_time_hires.tv_sec == 0) {
  522. tor_gettimeofday(&cached_time_hires);
  523. }
  524. *tv = cached_time_hires;
  525. }
  526. /** Reset the cached view of the current time, so that the next time we try
  527. * to learn it, we will get an up-to-date value. */
  528. void
  529. tor_gettimeofday_cache_clear(void)
  530. {
  531. cached_time_hires.tv_sec = 0;
  532. }
  533. #ifdef TOR_UNIT_TESTS
  534. /** For testing: force-update the cached time to a given value. */
  535. void
  536. tor_gettimeofday_cache_set(const struct timeval *tv)
  537. {
  538. tor_assert(tv);
  539. memcpy(&cached_time_hires, tv, sizeof(*tv));
  540. }
  541. #endif
  542. #endif
  543. /**
  544. * As tor_gettimeofday_cached, but can never move backwards in time.
  545. *
  546. * The returned value may diverge from wall-clock time, since wall-clock time
  547. * can trivially be adjusted backwards, and this can't. Don't mix wall-clock
  548. * time with these values in the same calculation.
  549. *
  550. * Depending on implementation, this function may or may not "smooth out" huge
  551. * jumps forward in wall-clock time. It may or may not keep its results
  552. * advancing forward (as opposed to stalling) if the wall-clock time goes
  553. * backwards. The current implementation does neither of of these.
  554. *
  555. * This function is not thread-safe; do not call it outside the main thread.
  556. *
  557. * In future versions of Tor, this may return a time does not have its
  558. * origin at the Unix epoch.
  559. */
  560. void
  561. tor_gettimeofday_cached_monotonic(struct timeval *tv)
  562. {
  563. struct timeval last_tv = { 0, 0 };
  564. tor_gettimeofday_cached(tv);
  565. if (timercmp(tv, &last_tv, OP_LT)) {
  566. memcpy(tv, &last_tv, sizeof(struct timeval));
  567. } else {
  568. memcpy(&last_tv, tv, sizeof(struct timeval));
  569. }
  570. }