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

[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

[webwml/master] changed for an easier phrase
by sebastian＠torproject.org 18 Jul '16

18 Jul '16

commit 3900758dfe25b5d56afa517d3cd631f3058beb03 Author: toya <toya(a)muamba.muamba> Date: Sat Jul 16 18:00:24 2016 -0700 changed for an easier phrase --- include/head.wmi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/head.wmi b/include/head.wmi index 15eee5b..99cea11 100644 --- a/include/head.wmi +++ b/include/head.wmi @@ -14,7 +14,7 @@ <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta name="author" content="The Tor Project, Inc."> - <meta name="description" content="A free software implementation of second-generation onion routing, a system enabling its users to communicate anonymously on the Internet. If you can't open the website, email gettor(a)torproject.org for instruction on how to get the Tor Browser."> + <meta name="description" content="Tor is a free software that prevents people from learning your location or browsing habits by letting you communicate anonymously on the Internet. It also helps you bypass censorship online. If you can't open the website, email gettor(a)torproject.org for instruction on how to get the Tor Browser."> <meta name="keywords" content="anonymity online, tor, tor project, censorship circumvention, traffic analysis, anonymous communications research"> <meta property="og:image" content="https://www.torproject.org/images/tor-logo.jpg">

1 0