torproject/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-12-06 19:41:15 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Expose monotonic time ratchet functions for testing.

Browse Source
This commit is contained in:
Nick Mathewson
2016-07-13 10:18:15 -04:00
parent 7bc4ca7de9
commit 2a217ef723
2 changed files with 91 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/common/compat_time.c
+86 -70
View File
@@ -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
src/common/compat_time.h
+5 -2
View File
@@ -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