July 2016 - tor-commits - lists.torproject.org

[tor/master] Use coarse monotonic timer instead of cached monotonized libevent time.
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit c7558c906a1069308f8f4519b8c93245fbca9efd Author: Nick Mathewson <nickm(a)torproject.org> Date: Fri Jul 8 15:24:21 2016 -0400 Use coarse monotonic timer instead of cached monotonized libevent time. --- src/or/buffers.c | 9 ++++----- src/or/circuitlist.c | 6 ++---- src/or/relay.c | 4 +--- 3 files changed, 7 insertions(+), 12 deletions(-) diff --git a/src/or/buffers.c b/src/or/buffers.c index 8b9a53c..970d17e 100644 --- a/src/or/buffers.c +++ b/src/or/buffers.c @@ -405,7 +405,7 @@ static chunk_t * buf_add_chunk_with_capacity(buf_t *buf, size_t capacity, int capped) { chunk_t *chunk; - struct timeval now; + if (CHUNK_ALLOC_SIZE(capacity) < buf->default_chunk_size) { chunk = chunk_new_with_alloc_size(buf->default_chunk_size); } else if (capped && CHUNK_ALLOC_SIZE(capacity) > MAX_CHUNK_ALLOC) { @@ -414,8 +414,7 @@ buf_add_chunk_with_capacity(buf_t *buf, size_t capacity, int capped) chunk = chunk_new_with_alloc_size(preferred_chunk_size(capacity)); } - tor_gettimeofday_cached_monotonic(&now); - chunk->inserted_time = (uint32_t)tv_to_msec(&now); + chunk->inserted_time = (uint32_t)monotime_coarse_absolute_msec(); if (buf->tail) { tor_assert(buf->head); @@ -430,8 +429,8 @@ buf_add_chunk_with_capacity(buf_t *buf, size_t capacity, int capped) } /** Return the age of the oldest chunk in the buffer buf, in - * milliseconds. Requires the current time, in truncated milliseconds since - * the epoch, as its input now. + * milliseconds. Requires the current monotonic time, in truncated msec, + * as its input now. */ uint32_t buf_get_oldest_chunk_timestamp(const buf_t *buf, uint32_t now) diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c index d2ba7d4..5c69164 100644 --- a/src/or/circuitlist.c +++ b/src/or/circuitlist.c @@ -2015,7 +2015,7 @@ circuit_max_queued_cell_age(const circuit_t *c, uint32_t now) /** Return the age in milliseconds of the oldest buffer chunk on conn, * where age is taken in milliseconds before the time now (in truncated - * milliseconds since the epoch). If the connection has no data, treat + * absolute monotonic msec). If the connection has no data, treat * it as having age zero. **/ static uint32_t @@ -2138,7 +2138,6 @@ circuits_handle_oom(size_t current_allocation) size_t mem_recovered=0; int n_circuits_killed=0; int n_dirconns_killed=0; - struct timeval now; uint32_t now_ms; log_notice(LD_GENERAL, "We're low on memory. Killing circuits with " "over-long queues. (This behavior is controlled by " @@ -2152,8 +2151,7 @@ circuits_handle_oom(size_t current_allocation) mem_to_recover = current_allocation - mem_target; } - tor_gettimeofday_cached_monotonic(&now); - now_ms = (uint32_t)tv_to_msec(&now); + now_ms = (uint32_t)monotime_coarse_absolute_msec(); circlist = circuit_get_global_list(); SMARTLIST_FOREACH_BEGIN(circlist, circuit_t *, circ) { diff --git a/src/or/relay.c b/src/or/relay.c index fb8c8e7..a815a55 100644 --- a/src/or/relay.c +++ b/src/or/relay.c @@ -2320,14 +2320,12 @@ cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue, int exitward, const cell_t *cell, int wide_circ_ids, int use_stats) { - struct timeval now; packed_cell_t *copy = packed_cell_copy(cell, wide_circ_ids); (void)circ; (void)exitward; (void)use_stats; - tor_gettimeofday_cached_monotonic(&now); - copy->inserted_time = (uint32_t)tv_to_msec(&now); + copy->inserted_time = (uint32_t) monotime_coarse_absolute_msec(); cell_queue_append(queue, copy); }

1 0

[tor/master] Expose monotonic time ratchet functions for testing.
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit 2a217ef72392d685e6c9b48b2be3b467a8244b48 Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Jul 13 10:18:15 2016 -0400 Expose monotonic time ratchet functions for testing. --- src/common/compat_time.c | 156 ++++++++++++++++++++++++++--------------------- src/common/compat_time.h | 7 ++- 2 files changed, 91 insertions(+), 72 deletions(-) diff --git a/src/common/compat_time.c b/src/common/compat_time.c index bbbca33..de39566 100644 --- a/src/common/compat_time.c +++ b/src/common/compat_time.c @@ -118,6 +118,89 @@ tor_gettimeofday(struct timeval *timeval) /** True iff monotime_init has been called. */ static int monotime_initialized = 0; +/* "ratchet" functions for monotonic time. */ + +#if defined(_WIN32) || defined(TOR_UNIT_TESTS) + +/** Protected by lock: last value returned by monotime_get(). */ +static int64_t last_pctr = 0; +/** Protected by lock: offset we must add to monotonic time values. */ +static int64_t pctr_offset = 0; +/* If we are using GetTickCount(), how many times has it rolled over? */ +static uint32_t rollover_count = 0; +/* If we are using GetTickCount(), what's the last value it returned? */ +static int64_t last_tick_count = 0; + +/** Helper for windows: Called with a sequence of times that are supposed + * to be monotonic; increments them as appropriate so that they actually + * _are_ monotonic. + * + * Caller must hold lock. */ +STATIC int64_t +ratchet_performance_counter(int64_t count_raw) +{ + /* must hold lock */ + const int64_t count_adjusted = count_raw + pctr_offset; + + if (PREDICT_UNLIKELY(count_adjusted < last_pctr)) { + /* Monotonicity failed! Pretend no time elapsed. */ + pctr_offset = last_pctr - count_raw; + return last_pctr; + } else { + last_pctr = count_adjusted; + return count_adjusted; + } +} + +STATIC int64_t +ratchet_coarse_performance_counter(const int64_t count_raw) +{ + int64_t count = count_raw + (((int64_t)rollover_count) << 32); + while (PREDICT_UNLIKELY(count < last_tick_count)) { + ++rollover_count; + count = count_raw + (((int64_t)rollover_count) << 32); + } + last_tick_count = count; + return count; +} +#endif + +#if defined(MONOTIME_USING_GETTIMEOFDAY) || defined(TOR_UNIT_TESTS) +static struct timeval last_timeofday = { 0, 0 }; +static struct timeval timeofday_offset = { 0, 0 }; + +/** Helper for gettimeofday(): Called with a sequence of times that are + * supposed to be monotonic; increments them as appropriate so that they + * actually _are_ monotonic. + * + * Caller must hold lock. */ +STATIC void +ratchet_timeval(const struct timeval *timeval_raw, struct timeval *out) +{ + /* must hold lock */ + timeradd(timeval_raw, &timeofday_offset, out); + if (PREDICT_UNLIKELY(timercmp(out, &last_timeofday, <))) { + /* time ran backwards. Instead, declare that no time occurred. */ + timersub(&last_timeofday, timeval_raw, &timeofday_offset); + memcpy(out, &last_timeofday, sizeof(struct timeval)); + } else { + memcpy(&last_timeofday, out, sizeof(struct timeval)); + } +} +#endif + +#ifdef TOR_UNIT_TESTS +/** For testing: reset all the ratchets */ +void +monotime_reset_ratchets_for_testing(void) +{ + last_pctr = pctr_offset = last_tick_count = 0; + rollover_count = 0; + memset(&last_timeofday, 0, sizeof(struct timeval)); + memset(&timeofday_offset, 0, sizeof(struct timeval)); +} +#endif + #ifdef __APPLE__ /** Initialized on startup: tells is how to convert from ticks to @@ -201,17 +284,9 @@ monotime_diff_nsec(const monotime_t *start, /** Result of QueryPerformanceFrequency, as an int64_t. */ static int64_t ticks_per_second = 0; -/** Protected by lock: last value returned by monotime_get(). */ -static int64_t last_pctr = 0; -/** Protected by lock: offset we must add to monotonic time values. */ -static int64_t pctr_offset = 0; /** Lock to protect last_pctr and pctr_offset */ static CRITICAL_SECTION monotime_lock; -/* If we are using GetTickCount(), how many times has it rolled over? */ -static uint32_t rollover_count = 0; -/* If we are using GetTickCount(), what's the last value it returned? */ -static int64_t last_tick_count = 0; -/** Lock to protect rollover_count and */ +/** Lock to protect rollover_count and last_tick_count */ static CRITICAL_SECTION monotime_coarse_lock; typedef ULONGLONG (WINAPI *GetTickCount64_fn_t)(void); @@ -241,39 +316,6 @@ monotime_init_internal(void) // FreeLibrary(h) ? } -/** Helper for windows: Called with a sequence of times that are supposed - * to be monotonic; increments them as appropriate so that they actually - * _are_ monotonic. - * - * Caller must hold lock. */ -STATIC int64_t -ratchet_performance_counter(int64_t count_raw) -{ - /* must hold lock */ - const int64_t count_adjusted = count_raw + pctr_offset; - - if (PREDICT_UNLIKELY(count_adjusted < last_pctr)) { - /* Monotonicity failed! Pretend no time elapsed. */ - pctr_offset = last_pctr - count_raw; - return last_pctr; - } else { - last_pctr = count_adjusted; - return count_adjusted; - } -} - -STATIC int64_t -ratchet_coarse_performance_counter(const int64_t count_raw) -{ - int64_t count = count_raw + (((int64_t)rollover_count) << 32); - while (PREDICT_UNLIKELY(count < last_tick_count)) { - ++rollover_count; - count = count_raw + (((int64_t)rollover_count) << 32); - } - last_tick_count = count; - return count; -} - void monotime_get(monotime_t *out) { @@ -344,9 +386,6 @@ monotime_coarse_diff_nsec(const monotime_coarse_t *start, /* end of "_WIN32" */ #elif defined(MONOTIME_USING_GETTIMEOFDAY) -static int monotime_initialized = 0; -static struct timeval last_timeofday = { 0, 0 }; -static struct timeval timeofday_offset = { 0, 0 }; static tor_mutex_t monotime_lock; /** Initialize the monotonic timer subsystem. */ @@ -357,25 +396,6 @@ monotime_init_internal(void) tor_mutex_init(&monotime_lock); } -/** Helper for gettimeofday(): Called with a sequence of times that are - * supposed to be monotonic; increments them as appropriate so that they - * actually _are_ monotonic. - * - * Caller must hold lock. */ -STATIC void -ratchet_timeval(const struct timeval *timeval_raw, struct timeval *out) -{ - /* must hold lock */ - timeradd(timeval_raw, &timeofday_offset, out); - if (PREDICT_UNLIKELY(timercmp(out, &last_timeofday, <))) { - /* time ran backwards. Instead, declare that no time occurred. */ - timersub(&last_timeofday, timeval_raw, &timeofday_offset); - memcpy(out, &last_timeofday, sizeof(struct timeval)); - } else { - memcpy(&last_timeofday, out, sizeof(struct timeval)); - } -} - void monotime_get(monotime_t *out) { @@ -474,16 +494,12 @@ monotime_coarse_absolute_nsec(void) uint64_t monotime_coarse_absolute_usec(void) { - monotime_coarse_t now; - monotime_coarse_get(&now); - return monotime_coarse_diff_usec(&initialized_at_coarse, &now); + return monotime_coarse_absolute_nsec() / 1000; } uint64_t monotime_coarse_absolute_msec(void) { - monotime_coarse_t now; - monotime_coarse_get(&now); - return monotime_coarse_diff_msec(&initialized_at_coarse, &now); + return monotime_coarse_absolute_nsec() / ONE_MILLION; } #endif diff --git a/src/common/compat_time.h b/src/common/compat_time.h index d69af8f..8d61bc2 100644 --- a/src/common/compat_time.h +++ b/src/common/compat_time.h @@ -133,14 +133,17 @@ void tor_sleep_msec(int msec); #endif #ifdef COMPAT_TIME_PRIVATE -#ifdef _WIN32 +#if defined(_WIN32) || defined(TOR_UNIT_TESTS) STATIC int64_t ratchet_performance_counter(int64_t count_raw); STATIC int64_t ratchet_coarse_performance_counter(int64_t count_raw); #endif -#ifdef MONOTIME_USING_GETTIMEOFDAY +#if defined(MONOTIME_USING_GETTIMEOFDAY) || defined(TOR_UNIT_TESTS) STATIC void ratchet_timeval(const struct timeval *timeval_raw, struct timeval *out); #endif +#ifdef TOR_UNIT_TESTS +void monotime_reset_ratchets_for_testing(void); +#endif #endif #endif

1 0

[tor/master] Be sure to call monotime_init() at startup.
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit 1e3cf1cc8321ec29acaae6acb22340f0e2f5e9da Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Jul 19 11:40:21 2016 +0200 Be sure to call monotime_init() at startup. --- src/or/main.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/or/main.c b/src/or/main.c index 404d741..76af910 100644 --- a/src/or/main.c +++ b/src/or/main.c @@ -3646,6 +3646,8 @@ tor_main(int argc, char *argv[]) #endif } + monotime_init(); + switch (get_options()->command) { case CMD_RUN_TOR: #ifdef NT_SERVICE

1 0

[tor/master] Basic portable monotonic timer implementation
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit dc6f5d1dc1ccc86f32b39b939a5f83c35865d666 Author: Nick Mathewson <nickm(a)torproject.org> Date: Fri Jul 8 12:53:51 2016 -0400 Basic portable monotonic timer implementation This code uses QueryPerformanceCounter() [**] on Windows, mach_absolute_time() on OSX, clock_gettime() where available, and gettimeofday() [*] elsewhere. Timer types are stored in an opaque OS-specific format; the only supported operation is to compute the difference between two timers. [*] As you know, gettimeofday() isn't monotonic, so we include a simple ratchet function to ensure that it only moves forward. [**] As you may not know, QueryPerformanceCounter() isn't actually always as monotonic as you might like it to be, so we ratchet that one too. We also include a "coarse monotonic timer" for cases where we don't actually need high-resolution time. This is GetTickCount{,64}() on Windows, clock_gettime(CLOCK_MONOTONIC_COARSE) on Linux, and falls back to regular monotonic time elsewhere. --- src/common/compat_time.c | 381 ++++++++++++++++++++++++++++++++++++++++++++++- src/common/compat_time.h | 121 +++++++++++++++ 2 files changed, 501 insertions(+), 1 deletion(-) diff --git a/src/common/compat_time.c b/src/common/compat_time.c index 866c288..bbbca33 100644 --- a/src/common/compat_time.c +++ b/src/common/compat_time.c @@ -9,7 +9,7 @@ * timers, etc. **/ -#define COMPAT_PRIVATE +#define COMPAT_TIME_PRIVATE #include "compat.h" #ifdef _WIN32 @@ -30,6 +30,10 @@ #endif #endif +#ifdef __APPLE__ +#include <mach/mach_time.h> +#endif + #include "torlog.h" #include "util.h" #include "container.h" @@ -108,3 +112,378 @@ tor_gettimeofday(struct timeval *timeval) return; } +#define ONE_MILLION ((int64_t) (1000 * 1000)) +#define ONE_BILLION ((int64_t) (1000 * 1000 * 1000)) + +/** True iff monotime_init has been called. */ +static int monotime_initialized = 0; + +#ifdef __APPLE__ + +/** Initialized on startup: tells is how to convert from ticks to + * nanoseconds. + */ +static struct mach_timebase_info mach_time_info; + +static void +monotime_init_internal(void) +{ + tor_assert(!monotime_initialized); + int r = mach_timebase_info(&mach_time_info); + tor_assert(r == 0); + tor_assert(mach_time_info.denom != 0); +} + +/** + * Set "out" to the most recent monotonic time value + */ +void +monotime_get(monotime_t *out) +{ + out->abstime_ = mach_absolute_time(); +} + +/** + * Return the number of nanoseconds between start and end. + */ +int64_t +monotime_diff_nsec(const monotime_t *start, + const monotime_t *end) +{ + if (BUG(mach_time_info.denom == 0)) { + monotime_init(); + } + const int64_t diff_ticks = end->abstime_ - start->abstime_; + const int64_t diff_nsec = + (diff_ticks * mach_time_info.numer) / mach_time_info.denom; + return diff_nsec; +} + +/* end of "__APPLE__" */ +#elif defined(HAVE_CLOCK_GETTIME) + +static void +monotime_init_internal(void) +{ + /* no action needed. */ +} + +void +monotime_get(monotime_t *out) +{ + int r = clock_gettime(CLOCK_MONOTONIC, &out->ts_); + tor_assert(r == 0); +} + +#ifdef CLOCK_MONOTONIC_COARSE +void +monotime_coarse_get(monotime_coarse_t *out) +{ + int r = clock_gettime(CLOCK_MONOTONIC_COARSE, &out->ts_); + tor_assert(r == 0); +} +#endif + +int64_t +monotime_diff_nsec(const monotime_t *start, + const monotime_t *end) +{ + const int64_t diff_sec = end->ts_.tv_sec - start->ts_.tv_sec; + const int64_t diff_nsec = diff_sec * ONE_BILLION + + (end->ts_.tv_nsec - start->ts_.tv_nsec); + + return diff_nsec; +} + +/* end of "HAVE_CLOCK_GETTIME" */ +#elif defined (_WIN32) + +/** Result of QueryPerformanceFrequency, as an int64_t. */ +static int64_t ticks_per_second = 0; + +/** Protected by lock: last value returned by monotime_get(). */ +static int64_t last_pctr = 0; +/** Protected by lock: offset we must add to monotonic time values. */ +static int64_t pctr_offset = 0; +/** Lock to protect last_pctr and pctr_offset */ +static CRITICAL_SECTION monotime_lock; +/* If we are using GetTickCount(), how many times has it rolled over? */ +static uint32_t rollover_count = 0; +/* If we are using GetTickCount(), what's the last value it returned? */ +static int64_t last_tick_count = 0; +/** Lock to protect rollover_count and */ +static CRITICAL_SECTION monotime_coarse_lock; + +typedef ULONGLONG (WINAPI *GetTickCount64_fn_t)(void); +static GetTickCount64_fn_t GetTickCount64_fn = NULL; + +static void +monotime_init_internal(void) +{ + tor_assert(!monotime_initialized); + BOOL ok = InitializeCriticalSectionAndSpinCount(&monotime_lock, 200); + tor_assert(ok); + ok = InitializeCriticalSectionAndSpinCount(&monotime_coarse_lock, 200); + tor_assert(ok); + LARGE_INTEGER li; + ok = QueryPerformanceFrequency(&li); + tor_assert(ok); + tor_assert(li.QuadPart); + ticks_per_second = li.QuadPart; + last_pctr = 0; + pctr_offset = 0; + + HANDLE h = load_windows_system_library(TEXT("kernel32.dll")); + if (h) { + GetTickCount64_fn = (GetTickCount64_fn_t) + GetProcAddress(h, "GetTickCount64"); + } + // FreeLibrary(h) ? +} + +/** Helper for windows: Called with a sequence of times that are supposed + * to be monotonic; increments them as appropriate so that they actually + * _are_ monotonic. + * + * Caller must hold lock. */ +STATIC int64_t +ratchet_performance_counter(int64_t count_raw) +{ + /* must hold lock */ + const int64_t count_adjusted = count_raw + pctr_offset; + + if (PREDICT_UNLIKELY(count_adjusted < last_pctr)) { + /* Monotonicity failed! Pretend no time elapsed. */ + pctr_offset = last_pctr - count_raw; + return last_pctr; + } else { + last_pctr = count_adjusted; + return count_adjusted; + } +} + +STATIC int64_t +ratchet_coarse_performance_counter(const int64_t count_raw) +{ + int64_t count = count_raw + (((int64_t)rollover_count) << 32); + while (PREDICT_UNLIKELY(count < last_tick_count)) { + ++rollover_count; + count = count_raw + (((int64_t)rollover_count) << 32); + } + last_tick_count = count; + return count; +} + +void +monotime_get(monotime_t *out) +{ + if (BUG(monotime_initialized == 0)) { + monotime_init(); + } + + /* Alas, QueryPerformanceCounter is not always monotonic: see bug list at + + https://www.python.org/dev/peps/pep-0418/#windows-queryperformancecounter + */ + + EnterCriticalSection(&monotime_lock); + LARGE_INTEGER res; + BOOL ok = QueryPerformanceCounter(&res); + tor_assert(ok); + const int64_t count_raw = res.QuadPart; + out->pcount_ = ratchet_performance_counter(count_raw); + LeaveCriticalSection(&monotime_lock); +} + +void +monotime_coarse_get(monotime_coarse_t *out) +{ + if (GetTickCount64_fn) { + out->tick_count_ = (int64_t)GetTickCount64_fn(); + } else { + EnterCriticalSection(&monotime_coarse_lock); + DWORD tick = GetTickCount(); + out->tick_count_ = ratchet_coarse_performance_counter(tick); + LeaveCriticalSection(&monotime_coarse_lock); + } +} + +int64_t +monotime_diff_nsec(const monotime_t *start, + const monotime_t *end) +{ + if (BUG(monotime_initialized == 0)) { + monotime_init(); + } + const int64_t diff_ticks = end->pcount_ - start->pcount_; + return (diff_ticks * ONE_BILLION) / ticks_per_second; +} + +int64_t +monotime_coarse_diff_msec(const monotime_coarse_t *start, + const monotime_coarse_t *end) +{ + const int64_t diff_ticks = end->tick_count_ - start->tick_count_; + return diff_ticks; +} + +int64_t +monotime_coarse_diff_usec(const monotime_coarse_t *start, + const monotime_coarse_t *end) +{ + return monotime_coarse_diff_msec(start, end) * 1000; +} + +int64_t +monotime_coarse_diff_nsec(const monotime_coarse_t *start, + const monotime_coarse_t *end) +{ + return monotime_coarse_diff_msec(start, end) * ONE_MILLION; +} + +/* end of "_WIN32" */ +#elif defined(MONOTIME_USING_GETTIMEOFDAY) + +static int monotime_initialized = 0; +static struct timeval last_timeofday = { 0, 0 }; +static struct timeval timeofday_offset = { 0, 0 }; +static tor_mutex_t monotime_lock; + +/** Initialize the monotonic timer subsystem. */ +static void +monotime_init_internal(void) +{ + tor_assert(!monotime_initialized); + tor_mutex_init(&monotime_lock); +} + +/** Helper for gettimeofday(): Called with a sequence of times that are + * supposed to be monotonic; increments them as appropriate so that they + * actually _are_ monotonic. + * + * Caller must hold lock. */ +STATIC void +ratchet_timeval(const struct timeval *timeval_raw, struct timeval *out) +{ + /* must hold lock */ + timeradd(timeval_raw, &timeofday_offset, out); + if (PREDICT_UNLIKELY(timercmp(out, &last_timeofday, <))) { + /* time ran backwards. Instead, declare that no time occurred. */ + timersub(&last_timeofday, timeval_raw, &timeofday_offset); + memcpy(out, &last_timeofday, sizeof(struct timeval)); + } else { + memcpy(&last_timeofday, out, sizeof(struct timeval)); + } +} + +void +monotime_get(monotime_t *out) +{ + if (BUG(monotime_initialized == 0)) { + monotime_init(); + } + + tor_mutex_acquire(&monotime_lock); + struct timeval timeval_raw; + tor_gettimeofday(&timeval_raw); + ratchet_timeval(&timeval_raw, &out->tv_); + tor_mutex_release(&monotime_lock); +} + +int64_t +monotime_diff_nsec(const monotime_t *start, + const monotime_t *end) +{ + struct timeval diff; + timersub(&end->tv_, &start->tv_, &diff); + return (diff.tv_sec * ONE_BILLION + diff.tv_usec * 1000); +} + +/* end of "MONOTIME_USING_GETTIMEOFDAY" */ +#else +#error "No way to implement monotonic timers." +#endif + +static monotime_t initialized_at; +#ifdef MONOTIME_COARSE_FN_IS_DIFFERENT +static monotime_coarse_t initialized_at_coarse; +#endif + +/** + * Initialize the monotonic timer subsystem. Must be called before any + * monotonic timer functions. This function is idempotent. + */ +void +monotime_init(void) +{ + if (!monotime_initialized) { + monotime_init_internal(); + monotime_get(&initialized_at); +#ifdef MONOTIME_COARSE_FN_IS_DIFFERENT + monotime_coarse_get(&initialized_at_coarse); +#endif + monotime_initialized = 1; + } +} + +int64_t +monotime_diff_usec(const monotime_t *start, + const monotime_t *end) +{ + const int64_t nsec = monotime_diff_nsec(start, end); + return CEIL_DIV(nsec, 1000); +} + +int64_t +monotime_diff_msec(const monotime_t *start, + const monotime_t *end) +{ + const int64_t nsec = monotime_diff_nsec(start, end); + return CEIL_DIV(nsec, ONE_MILLION); +} + +uint64_t +monotime_absolute_nsec(void) +{ + monotime_t now; + monotime_get(&now); + return monotime_diff_nsec(&initialized_at, &now); +} + +uint64_t +monotime_absolute_usec(void) +{ + return monotime_absolute_nsec() / 1000; +} + +uint64_t +monotime_absolute_msec(void) +{ + return monotime_absolute_nsec() / ONE_MILLION; +} + +#ifdef MONOTIME_COARSE_FN_IS_DIFFERENT +uint64_t +monotime_coarse_absolute_nsec(void) +{ + monotime_coarse_t now; + monotime_coarse_get(&now); + return monotime_coarse_diff_nsec(&initialized_at_coarse, &now); +} + +uint64_t +monotime_coarse_absolute_usec(void) +{ + monotime_coarse_t now; + monotime_coarse_get(&now); + return monotime_coarse_diff_usec(&initialized_at_coarse, &now); +} + +uint64_t +monotime_coarse_absolute_msec(void) +{ + monotime_coarse_t now; + monotime_coarse_get(&now); + return monotime_coarse_diff_msec(&initialized_at_coarse, &now); +} +#endif diff --git a/src/common/compat_time.h b/src/common/compat_time.h index 56126ba..d69af8f 100644 --- a/src/common/compat_time.h +++ b/src/common/compat_time.h @@ -3,11 +3,28 @@ * Copyright (c) 2007-2016, The Tor Project, Inc. */ /* See LICENSE for licensing information */ +/** + * \file compat_time.h + * + * \brief Functions and types for monotonic times. + * + * monotime_* functions try to provide a high-resolution monotonic timer with + * something the best resolution the system provides. monotime_coarse_* + * functions run faster (if the operating system gives us a way to do that) + * but produce a less accurate timer: accuracy will probably be on the order + * of tens of milliseconds. + */ + #ifndef TOR_COMPAT_TIME_H #define TOR_COMPAT_TIME_H #include "orconfig.h" +#if defined(HAVE_CLOCK_GETTIME) +/* to ensure definition of CLOCK_MONOTONIC_COARSE if it's there */ +#include <time.h> +#endif + #if !defined(HAVE_GETTIMEOFDAY) && !defined(HAVE_STRUCT_TIMEVAL_TV_SEC) /** Implementation of timeval for platforms that don't have it. */ struct timeval { @@ -16,11 +33,115 @@ struct timeval { }; #endif +/** Represents a monotonic timer in a platform-dependent way. */ +typedef struct monotime_t { +#ifdef __APPLE__ + /* On apple, there is a 64-bit counter whose precision we must look up. */ + uint64_t abstime_; +#elif defined(HAVE_CLOCK_GETTIME) + /* It sure would be nice to use clock_gettime(). Posix is a nice thing. */ + struct timespec ts_; +#elif defined (_WIN32) + /* On Windows, there is a 64-bit counter whose precision we must look up. */ + int64_t pcount_; +#else +#define MONOTIME_USING_GETTIMEOFDAY + /* Otherwise, we will be stuck using gettimeofday. */ + struct timeval tv_; +#endif +} monotime_t; + +#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC_COARSE) +#define MONOTIME_COARSE_FN_IS_DIFFERENT +#define monotime_coarse_t monotime_t +#elif defined(_WIN32) +#define MONOTIME_COARSE_FN_IS_DIFFERENT +#define MONOTIME_COARSE_TYPE_IS_DIFFERENT +/** Represents a coarse monotonic time in a platform-independent way. */ +typedef struct monotime_coarse_t { + uint64_t tick_count_; +} monotime_coarse_t; +#else +#define monotime_coarse_t monotime_t +#endif + +/** + * Initialize the timing subsystem. This function is idempotent. + */ +void monotime_init(void); +/** + * Set out to the current time. + */ +void monotime_get(monotime_t *out); +/** + * Return the number of nanoseconds between start and end. + */ +int64_t monotime_diff_nsec(const monotime_t *start, const monotime_t *end); +/** + * Return the number of microseconds between start and end. + */ +int64_t monotime_diff_usec(const monotime_t *start, const monotime_t *end); +/** + * Return the number of milliseconds between start and end. + */ +int64_t monotime_diff_msec(const monotime_t *start, const monotime_t *end); +/** + * Return the number of nanoseconds since the timer system was initialized. + */ +uint64_t monotime_absolute_nsec(void); +/** + * Return the number of microseconds since the timer system was initialized. + */ +uint64_t monotime_absolute_usec(void); +/** + * Return the number of milliseconds since the timer system was initialized. + */ +uint64_t monotime_absolute_msec(void); + +#if defined(MONOTIME_COARSE_FN_IS_DIFFERENT) +/** + * Set out to the current coarse time. + */ +void monotime_coarse_get(monotime_coarse_t *out); +uint64_t monotime_coarse_absolute_nsec(void); +uint64_t monotime_coarse_absolute_usec(void); +uint64_t monotime_coarse_absolute_msec(void); +#else +#define monotime_coarse_get monotime_get +#define monotime_coarse_absolute_nsec monotime_absolute_nsec +#define monotime_coarse_absolute_usec monotime_absolute_usec +#define monotime_coarse_absolute_msec monotime_absolute_msec +#endif + +#if defined(MONOTIME_COARSE_TYPE_IS_DIFFERENT) +int64_t monotime_coarse_diff_nsec(const monotime_coarse_t *start, + const monotime_coarse_t *end); +int64_t monotime_coarse_diff_usec(const monotime_coarse_t *start, + const monotime_coarse_t *end); +int64_t monotime_coarse_diff_msec(const monotime_coarse_t *start, + const monotime_coarse_t *end); +#else +#define monotime_coarse_diff_nsec monotime_diff_nsec +#define monotime_coarse_diff_usec monotime_diff_usec +#define monotime_coarse_diff_msec monotime_diff_msec +#endif + void tor_gettimeofday(struct timeval *timeval); #ifdef TOR_UNIT_TESTS void tor_sleep_msec(int msec); #endif +#ifdef COMPAT_TIME_PRIVATE +#ifdef _WIN32 +STATIC int64_t ratchet_performance_counter(int64_t count_raw); +STATIC int64_t ratchet_coarse_performance_counter(int64_t count_raw); +#endif +#ifdef MONOTIME_USING_GETTIMEOFDAY +STATIC void ratchet_timeval(const struct timeval *timeval_raw, + struct timeval *out); +#endif +#endif + #endif

1 0

[tor/master] Merge branch 'monotonic_v2_squashed'
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit 558f7d3701ef0236e0bf2886dca538cfe1ad18bd Merge: 94c27d4 1e3cf1c Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Jul 19 11:42:26 2016 +0200 Merge branch 'monotonic_v2_squashed' changes/monotonic | 6 + src/common/compat.c | 91 +------- src/common/compat.h | 15 +- src/common/compat_libevent.c | 30 --- src/common/compat_libevent.h | 1 - src/common/compat_time.c | 513 +++++++++++++++++++++++++++++++++++++++++++ src/common/compat_time.h | 150 +++++++++++++ src/common/include.am | 1 + src/common/timers.c | 50 ++--- src/common/timers.h | 3 +- src/or/buffers.c | 9 +- src/or/circuitlist.c | 6 +- src/or/main.c | 2 + src/or/relay.c | 4 +- src/test/test-timers.c | 20 +- src/test/test_util.c | 125 +++++++++++ 16 files changed, 856 insertions(+), 170 deletions(-)

1 0

[tor/master] Changes file for monotonic time branch.
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit 493142d91f7a553b26094308ebd2694dd30c3e0e Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Jul 13 10:25:04 2016 -0400 Changes file for monotonic time branch. --- changes/monotonic | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/changes/monotonic b/changes/monotonic new file mode 100644 index 0000000..7143f69 --- /dev/null +++ b/changes/monotonic @@ -0,0 +1,6 @@ + o Minor features (backend): + - Tor now uses the operating system's monotonic timers (where available) + for internal fine-grained timing. Previously we would look at the + system clock, and then attempt to compensate for the clock running + backwards. Closes ticket 18908. +

1 0

[tor/master] Make sure initialized_at is initialized before use.
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit 6ba415d4000712aecaf3d11903db5699f143569d Author: Nick Mathewson <nickm(a)torproject.org> Date: Tue Jul 19 11:36:43 2016 +0200 Make sure initialized_at is initialized before use. --- src/common/compat_time.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/common/compat_time.c b/src/common/compat_time.c index de39566..b7d69cf 100644 --- a/src/common/compat_time.c +++ b/src/common/compat_time.c @@ -466,6 +466,10 @@ uint64_t monotime_absolute_nsec(void) { monotime_t now; + if (BUG(monotime_initialized == 0)) { + monotime_init(); + } + monotime_get(&now); return monotime_diff_nsec(&initialized_at, &now); } @@ -486,6 +490,10 @@ monotime_absolute_msec(void) uint64_t monotime_coarse_absolute_nsec(void) { + if (BUG(monotime_initialized == 0)) { + monotime_init(); + } + monotime_coarse_t now; monotime_coarse_get(&now); return monotime_coarse_diff_nsec(&initialized_at_coarse, &now);

1 0

[tor/master] Unit tests for monotonic time
by nickm＠torproject.org 19 Jul '16

19 Jul '16

commit abcb8ce25dbd2d76d3b84ea2aacbfc7d69d41eee Author: Nick Mathewson <nickm(a)torproject.org> Date: Wed Jul 13 10:23:00 2016 -0400 Unit tests for monotonic time --- src/test/test_util.c | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) diff --git a/src/test/test_util.c b/src/test/test_util.c index 19763fb..38df7bb 100644 --- a/src/test/test_util.c +++ b/src/test/test_util.c @@ -5,6 +5,7 @@ #include "orconfig.h" #define COMPAT_PRIVATE +#define COMPAT_TIME_PRIVATE #define CONTROL_PRIVATE #define UTIL_PRIVATE #include "or.h" @@ -5285,6 +5286,128 @@ test_util_calloc_check(void *arg) ; } +static void +test_util_monotonic_time(void *arg) +{ + (void)arg; + + monotime_t mt1, mt2; + monotime_coarse_t mtc1, mtc2; + uint64_t nsec1, nsec2, usec1, msec1; + uint64_t nsecc1, nsecc2, usecc1, msecc1; + + monotime_get(&mt1); + monotime_coarse_get(&mtc1); + nsec1 = monotime_absolute_nsec(); + usec1 = monotime_absolute_usec(); + msec1 = monotime_absolute_msec(); + nsecc1 = monotime_coarse_absolute_nsec(); + usecc1 = monotime_coarse_absolute_usec(); + msecc1 = monotime_coarse_absolute_msec(); + + tor_sleep_msec(200); + + monotime_get(&mt2); + monotime_coarse_get(&mtc2); + nsec2 = monotime_absolute_nsec(); + nsecc2 = monotime_coarse_absolute_nsec(); + + /* We need to be a little careful here since we don't know the system load. + */ + tt_i64_op(monotime_diff_msec(&mt1, &mt2), OP_GE, 175); + tt_i64_op(monotime_diff_msec(&mt1, &mt2), OP_LT, 1000); + tt_i64_op(monotime_coarse_diff_msec(&mtc1, &mtc2), OP_GE, 125); + tt_i64_op(monotime_coarse_diff_msec(&mtc1, &mtc2), OP_LT, 1000); + tt_u64_op(nsec2-nsec1, OP_GE, 175000000); + tt_u64_op(nsec2-nsec1, OP_LT, 1000000000); + tt_u64_op(nsecc2-nsecc1, OP_GE, 125000000); + tt_u64_op(nsecc2-nsecc1, OP_LT, 1000000000); + + tt_u64_op(msec1, OP_GE, nsec1 / 1000000); + tt_u64_op(usec1, OP_GE, nsec1 / 1000); + tt_u64_op(msecc1, OP_GE, nsecc1 / 1000000); + tt_u64_op(usecc1, OP_GE, nsecc1 / 1000); + tt_u64_op(msec1, OP_LE, nsec1 / 1000000 + 1); + tt_u64_op(usec1, OP_LE, nsec1 / 1000 +10); + tt_u64_op(msecc1, OP_LE, nsecc1 / 1000000 + 1); + tt_u64_op(usecc1, OP_LE, nsecc1 / 1000 + 10); + + done: + ; +} + +static void +test_util_monotonic_time_ratchet(void *arg) +{ + (void)arg; + monotime_reset_ratchets_for_testing(); + + /* win32, performance counter ratchet. */ + tt_i64_op(100, OP_EQ, ratchet_performance_counter(100)); + tt_i64_op(101, OP_EQ, ratchet_performance_counter(101)); + tt_i64_op(2000, OP_EQ, ratchet_performance_counter(2000)); + tt_i64_op(2000, OP_EQ, ratchet_performance_counter(100)); + tt_i64_op(2005, OP_EQ, ratchet_performance_counter(105)); + tt_i64_op(3005, OP_EQ, ratchet_performance_counter(1105)); + tt_i64_op(3005, OP_EQ, ratchet_performance_counter(1000)); + tt_i64_op(3010, OP_EQ, ratchet_performance_counter(1005)); + + /* win32, GetTickCounts32 ratchet-and-rollover-detector. */ + const int64_t R = ((int64_t)1) << 32; + tt_i64_op(5, OP_EQ, ratchet_coarse_performance_counter(5)); + tt_i64_op(1000, OP_EQ, ratchet_coarse_performance_counter(1000)); + tt_i64_op(5+R, OP_EQ, ratchet_coarse_performance_counter(5)); + tt_i64_op(10+R, OP_EQ, ratchet_coarse_performance_counter(10)); + tt_i64_op(4+R*2, OP_EQ, ratchet_coarse_performance_counter(4)); + + /* gettimeofday regular ratchet. */ + struct timeval tv_in = {0,0}, tv_out; + tv_in.tv_usec = 9000; + + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 9000); + tt_i64_op(tv_out.tv_sec, OP_EQ, 0); + + tv_in.tv_sec = 1337; + tv_in.tv_usec = 0; + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 0); + tt_i64_op(tv_out.tv_sec, OP_EQ, 1337); + + tv_in.tv_sec = 1336; + tv_in.tv_usec = 500000; + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 0); + tt_i64_op(tv_out.tv_sec, OP_EQ, 1337); + + tv_in.tv_sec = 1337; + tv_in.tv_usec = 0; + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 500000); + tt_i64_op(tv_out.tv_sec, OP_EQ, 1337); + + tv_in.tv_sec = 1337; + tv_in.tv_usec = 600000; + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 100000); + tt_i64_op(tv_out.tv_sec, OP_EQ, 1338); + + tv_in.tv_sec = 1000; + tv_in.tv_usec = 1000; + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 100000); + tt_i64_op(tv_out.tv_sec, OP_EQ, 1338); + + tv_in.tv_sec = 2000; + tv_in.tv_usec = 2000; + ratchet_timeval(&tv_in, &tv_out); + tt_int_op(tv_out.tv_usec, OP_EQ, 101000); + tt_i64_op(tv_out.tv_sec, OP_EQ, 2338); + + done: + ; +} + #define UTIL_LEGACY(name) \ { #name, test_util_ ## name , 0, NULL, NULL } @@ -5373,6 +5496,8 @@ struct testcase_t util_tests[] = { UTIL_TEST(touch_file, 0), UTIL_TEST_NO_WIN(pwdb, TT_FORK), UTIL_TEST(calloc_check, 0), + UTIL_TEST(monotonic_time, 0), + UTIL_TEST(monotonic_time_ratchet, TT_FORK), END_OF_TESTCASES };

1 0

[translation/https_everywhere_completed] Update translations for https_everywhere_completed
by translation＠torproject.org 19 Jul '16

19 Jul '16

commit 14c7fd5c60747c86a453bb55365db4d210c8b055 Author: Translation commit bot <translation(a)torproject.org> Date: Tue Jul 19 08:15:31 2016 +0000 Update translations for https_everywhere_completed --- nl/https-everywhere.dtd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nl/https-everywhere.dtd b/nl/https-everywhere.dtd index 0630e50..62d2db1 100644 --- a/nl/https-everywhere.dtd +++ b/nl/https-everywhere.dtd @@ -20,7 +20,7 @@ <!ENTITY https-everywhere.menu.observatory "SSL-observatoriumvoorkeuren"> <!ENTITY https-everywhere.menu.globalEnable "HTTPS Everywhere inschakelen"> <!ENTITY https-everywhere.menu.globalDisable "HTTPS Everywhere uitschakelen"> -<!ENTITY https-everywhere.menu.blockHttpRequests "Blokkeer alle HTTP verzoeken"> +<!ENTITY https-everywhere.menu.blockUnencryptedRequests "Blokkeer alle onversleutelde verzoeken"> <!ENTITY https-everywhere.menu.showCounter "Toon Teller"> <!ENTITY https-everywhere.menu.viewAllRules "Toon Alle Regels">

1 0

[translation/https_everywhere] Update translations for https_everywhere
by translation＠torproject.org 19 Jul '16

19 Jul '16

commit 9c4f353d8c849ceb16861ae3771fcae004924007 Author: Translation commit bot <translation(a)torproject.org> Date: Tue Jul 19 08:15:26 2016 +0000 Update translations for https_everywhere --- nl/https-everywhere.dtd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nl/https-everywhere.dtd b/nl/https-everywhere.dtd index bdfe458..62d2db1 100644 --- a/nl/https-everywhere.dtd +++ b/nl/https-everywhere.dtd @@ -20,7 +20,7 @@ <!ENTITY https-everywhere.menu.observatory "SSL-observatoriumvoorkeuren"> <!ENTITY https-everywhere.menu.globalEnable "HTTPS Everywhere inschakelen"> <!ENTITY https-everywhere.menu.globalDisable "HTTPS Everywhere uitschakelen"> -<!ENTITY https-everywhere.menu.blockUnencryptedRequests "Block all unencrypted requests"> +<!ENTITY https-everywhere.menu.blockUnencryptedRequests "Blokkeer alle onversleutelde verzoeken"> <!ENTITY https-everywhere.menu.showCounter "Toon Teller"> <!ENTITY https-everywhere.menu.viewAllRules "Toon Alle Regels">

1 0