From 4834641dce809fbb6fd4a586a823446970d19c1d Mon Sep 17 00:00:00 2001 From: vagrant Date: Wed, 21 Aug 2013 11:44:28 -0400 Subject: [PATCH 1/6] Make circ_times static and add accessor functions. Change the global circ_times to a static variable and use accessor functions throughout the code, instead of accessing it directly. --- src/or/channel.c | 2 +- src/or/circuitbuild.c | 27 +++++++++++++++------------ src/or/circuitlist.c | 2 +- src/or/circuitstats.c | 21 +++++++++++++++++++-- src/or/circuitstats.h | 4 +++- src/or/circuituse.c | 37 ++++++++++++++++++++----------------- src/or/connection_or.c | 8 ++++---- src/or/entrynodes.c | 2 +- src/or/networkstatus.c | 3 ++- src/or/statefile.c | 5 +++-- 10 files changed, 69 insertions(+), 42 deletions(-) diff --git a/src/or/channel.c b/src/or/channel.c index 48bbf7902a..8743437297 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -2361,7 +2361,7 @@ channel_do_open_actions(channel_t *chan) started_here = channel_is_outgoing(chan); if (started_here) { - circuit_build_times_network_is_live(&circ_times); + circuit_build_times_network_is_live(get_circuit_build_times()); rep_hist_note_connect_succeeded(chan->identity_digest, now); if (entry_guard_register_connect_status( chan->identity_digest, 1, 0, now) < 0) { diff --git a/src/or/circuitbuild.c b/src/or/circuitbuild.c index 21fc2aeda3..c144f274ad 100644 --- a/src/or/circuitbuild.c +++ b/src/or/circuitbuild.c @@ -772,20 +772,23 @@ circuit_send_next_onion_skin(origin_circuit_t *circ) * it off at, we probably had a suspend event along this codepath, * and we should discard the value. */ - if (timediff < 0 || timediff > 2*circ_times.close_ms+1000) { + if (timediff < 0 || timediff > 2*get_circuit_build_close_time()+1000) { log_notice(LD_CIRC, "Strange value for circuit build time: %ldmsec. " "Assuming clock jump. Purpose %d (%s)", timediff, circ->base_.purpose, circuit_purpose_to_string(circ->base_.purpose)); } else if (!circuit_build_times_disabled()) { /* Only count circuit times if the network is live */ - if (circuit_build_times_network_check_live(&circ_times)) { - circuit_build_times_add_time(&circ_times, (build_time_t)timediff); - circuit_build_times_set_timeout(&circ_times); + if (circuit_build_times_network_check_live( + get_circuit_build_times())) { + circuit_build_times_add_time(get_circuit_build_times(), + (build_time_t)timediff); + circuit_build_times_set_timeout(get_circuit_build_times()); } if (circ->base_.purpose != CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT) { - circuit_build_times_network_circ_success(&circ_times); + circuit_build_times_network_circ_success( + get_circuit_build_times()); } } } @@ -2273,7 +2276,7 @@ pathbias_measure_use_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); guard->path_bias_disabled = 1; guard->bad_since = approx_time(); entry_guards_changed(); @@ -2299,7 +2302,7 @@ pathbias_measure_use_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); } } else if (pathbias_get_use_success_count(guard)/guard->use_attempts < pathbias_get_notice_use_rate(options)) { @@ -2323,7 +2326,7 @@ pathbias_measure_use_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); } } } @@ -2379,7 +2382,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); guard->path_bias_disabled = 1; guard->bad_since = approx_time(); entry_guards_changed(); @@ -2405,7 +2408,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); } } else if (pathbias_get_close_success_count(guard)/guard->circ_attempts < pathbias_get_warn_rate(options)) { @@ -2430,7 +2433,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); } } else if (pathbias_get_close_success_count(guard)/guard->circ_attempts < pathbias_get_notice_rate(options)) { @@ -2453,7 +2456,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(circ_times.close_ms/1000)); + tor_lround(get_circuit_build_close_time()/1000)); } } } diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c index 69c4c4b139..1edea85972 100644 --- a/src/or/circuitlist.c +++ b/src/or/circuitlist.c @@ -678,7 +678,7 @@ origin_circuit_new(void) init_circuit_base(TO_CIRCUIT(circ)); - circ_times.last_circ_at = approx_time(); + get_circuit_build_times()->last_circ_at = approx_time(); return circ; } diff --git a/src/or/circuitstats.c b/src/or/circuitstats.c index 95129f9a43..88ed350a89 100644 --- a/src/or/circuitstats.c +++ b/src/or/circuitstats.c @@ -26,8 +26,7 @@ // vary in their own latency. The downside of this is that guards // can change frequently, so we'd be building a lot more circuits // most likely. -/* XXXX024 Make this static; add accessor functions. */ -circuit_build_times_t circ_times; +static circuit_build_times_t circ_times; #ifdef TOR_UNIT_TESTS /** If set, we're running the unit tests: we should avoid clobbering @@ -37,6 +36,24 @@ static int unit_tests = 0; #define unit_tests 0 #endif +circuit_build_times_t * +get_circuit_build_times(void) +{ + return &circ_times; +} + +double +get_circuit_build_close_time(void) +{ + return circ_times.close_ms; +} + +double +get_circuit_build_timeout(void) +{ + return circ_times.timeout_ms; +} + /** * This function decides if CBT learning should be disabled. It returns * true if one or more of the following four conditions are met: diff --git a/src/or/circuitstats.h b/src/or/circuitstats.h index 53ba2b2d2e..2381bf9091 100644 --- a/src/or/circuitstats.h +++ b/src/or/circuitstats.h @@ -12,7 +12,9 @@ #ifndef TOR_CIRCUITSTATS_H #define TOR_CIRCUITSTATS_H -extern circuit_build_times_t circ_times; +circuit_build_times_t *get_circuit_build_times(void); +double get_circuit_build_close_time(void); +double get_circuit_build_timeout(void); int circuit_build_times_disabled(void); int circuit_build_times_enough_to_compute(circuit_build_times_t *cbt); diff --git a/src/or/circuituse.c b/src/or/circuituse.c index 7beaa4e49c..57079f0a45 100644 --- a/src/or/circuituse.c +++ b/src/or/circuituse.c @@ -442,12 +442,12 @@ circuit_expire_building(void) * RTTs = 4a + 3b + 2c * RTTs = 9h */ - SET_CUTOFF(general_cutoff, circ_times.timeout_ms); - SET_CUTOFF(begindir_cutoff, circ_times.timeout_ms); + SET_CUTOFF(general_cutoff, get_circuit_build_timeout()); + SET_CUTOFF(begindir_cutoff, get_circuit_build_timeout()); /* > 3hop circs seem to have a 1.0 second delay on their cannibalized * 4th hop. */ - SET_CUTOFF(fourhop_cutoff, circ_times.timeout_ms * (10/6.0) + 1000); + SET_CUTOFF(fourhop_cutoff, get_circuit_build_timeout() * (10/6.0) + 1000); /* CIRCUIT_PURPOSE_C_ESTABLISH_REND behaves more like a RELAY cell. * Use the stream cutoff (more or less). */ @@ -456,20 +456,20 @@ circuit_expire_building(void) /* Be lenient with cannibalized circs. They already survived the official * CBT, and they're usually not performance-critical. */ SET_CUTOFF(cannibalized_cutoff, - MAX(circ_times.close_ms*(4/6.0), + MAX(get_circuit_build_close_time()*(4/6.0), options->CircuitStreamTimeout * 1000) + 1000); /* Intro circs have an extra round trip (and are also 4 hops long) */ - SET_CUTOFF(c_intro_cutoff, circ_times.timeout_ms * (14/6.0) + 1000); + SET_CUTOFF(c_intro_cutoff, get_circuit_build_timeout() * (14/6.0) + 1000); /* Server intro circs have an extra round trip */ - SET_CUTOFF(s_intro_cutoff, circ_times.timeout_ms * (9/6.0) + 1000); + SET_CUTOFF(s_intro_cutoff, get_circuit_build_timeout() * (9/6.0) + 1000); - SET_CUTOFF(close_cutoff, circ_times.close_ms); - SET_CUTOFF(extremely_old_cutoff, circ_times.close_ms*2 + 1000); + SET_CUTOFF(close_cutoff, get_circuit_build_close_time()); + SET_CUTOFF(extremely_old_cutoff, get_circuit_build_close_time()*2 + 1000); SET_CUTOFF(hs_extremely_old_cutoff, - MAX(circ_times.close_ms*2 + 1000, + MAX(get_circuit_build_close_time()*2 + 1000, options->SocksTimeout * 1000)); TOR_LIST_FOREACH(next_circ, circuit_get_global_list(), head) { @@ -545,12 +545,14 @@ circuit_expire_building(void) * was a timeout, and the timeout value needs to reset if we * see enough of them. Note this means we also need to avoid * double-counting below, too. */ - circuit_build_times_count_timeout(&circ_times, first_hop_succeeded); + circuit_build_times_count_timeout(get_circuit_build_times(), + first_hop_succeeded); TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout = 1; } continue; } else { static ratelim_t relax_timeout_limit = RATELIM_INIT(3600); + const double build_close_ms = get_circuit_build_close_time(); log_fn_ratelim(&relax_timeout_limit, LOG_NOTICE, LD_CIRC, "No circuits are opened. Relaxed timeout for circuit %d " "(a %s %d-hop circuit in state %s with channel state %s) to " @@ -561,7 +563,8 @@ circuit_expire_building(void) TO_ORIGIN_CIRCUIT(victim)->build_state->desired_path_len, circuit_state_to_string(victim->state), channel_state_to_string(victim->n_chan->state), - (long)circ_times.close_ms, num_live_entry_guards(0)); + (long)build_close_ms, + num_live_entry_guards(0)); } } @@ -641,7 +644,7 @@ circuit_expire_building(void) } if (circuit_timeout_want_to_count_circ(TO_ORIGIN_CIRCUIT(victim)) && - circuit_build_times_enough_to_compute(&circ_times)) { + circuit_build_times_enough_to_compute(get_circuit_build_times())) { /* Circuits are allowed to last longer for measurement. * Switch their purpose and wait. */ if (victim->purpose != CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT) { @@ -655,7 +658,7 @@ circuit_expire_building(void) * have a timeout. We also want to avoid double-counting * already "relaxed" circuits, which are counted above. */ if (!TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout) { - circuit_build_times_count_timeout(&circ_times, + circuit_build_times_count_timeout(get_circuit_build_times(), first_hop_succeeded); } continue; @@ -673,10 +676,10 @@ circuit_expire_building(void) (long)(now.tv_sec - victim->timestamp_began.tv_sec), victim->purpose, circuit_purpose_to_string(victim->purpose)); - } else if (circuit_build_times_count_close(&circ_times, + } else if (circuit_build_times_count_close(get_circuit_build_times(), first_hop_succeeded, victim->timestamp_created.tv_sec)) { - circuit_build_times_set_timeout(&circ_times); + circuit_build_times_set_timeout(get_circuit_build_times()); } } } @@ -939,7 +942,7 @@ circuit_predict_and_launch_new(void) * we can still build circuits preemptively as needed. */ if (num < MAX_UNUSED_OPEN_CIRCUITS-2 && get_options()->LearnCircuitBuildTimeout && - circuit_build_times_needs_circuits_now(&circ_times)) { + circuit_build_times_needs_circuits_now(get_circuit_build_times())) { flags = CIRCLAUNCH_NEED_CAPACITY; log_info(LD_CIRC, "Have %d clean circs need another buildtime test circ.", num); @@ -1075,7 +1078,7 @@ circuit_expire_old_circuits_clientside(void) cutoff = now; if (get_options()->LearnCircuitBuildTimeout && - circuit_build_times_needs_circuits(&circ_times)) { + circuit_build_times_needs_circuits(get_circuit_build_times())) { /* Circuits should be shorter lived if we need more of them * for learning a good build timeout */ cutoff.tv_sec -= IDLE_TIMEOUT_WHILE_LEARNING; diff --git a/src/or/connection_or.c b/src/or/connection_or.c index 31fd6d6739..b7e72fd346 100644 --- a/src/or/connection_or.c +++ b/src/or/connection_or.c @@ -1749,7 +1749,7 @@ connection_tls_finish_handshake(or_connection_t *conn) digest_rcvd) < 0) return -1; - circuit_build_times_network_is_live(&circ_times); + circuit_build_times_network_is_live(get_circuit_build_times()); if (tor_tls_used_v1_handshake(conn->tls)) { conn->link_proto = 1; @@ -1783,7 +1783,7 @@ connection_or_launch_v3_or_handshake(or_connection_t *conn) tor_assert(connection_or_nonopen_was_started_here(conn)); tor_assert(tor_tls_received_v3_certificate(conn->tls)); - circuit_build_times_network_is_live(&circ_times); + circuit_build_times_network_is_live(get_circuit_build_times()); connection_or_change_state(conn, OR_CONN_STATE_OR_HANDSHAKING_V3); if (connection_init_or_handshake_state(conn, 1) < 0) @@ -2016,7 +2016,7 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn) if (conn->chan) channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan)); - circuit_build_times_network_is_live(&circ_times); + circuit_build_times_network_is_live(get_circuit_build_times()); channel_tls_handle_var_cell(var_cell, conn); var_cell_free(var_cell); } else { @@ -2032,7 +2032,7 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn) if (conn->chan) channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan)); - circuit_build_times_network_is_live(&circ_times); + circuit_build_times_network_is_live(get_circuit_build_times()); connection_fetch_from_buf(buf, cell_network_size, TO_CONN(conn)); /* retrieve cell info from buf (create the host-order struct from the diff --git a/src/or/entrynodes.c b/src/or/entrynodes.c index cadc70ec7a..b3764a9416 100644 --- a/src/or/entrynodes.c +++ b/src/or/entrynodes.c @@ -2279,6 +2279,6 @@ entry_guards_free_all(void) clear_bridge_list(); smartlist_free(bridge_list); bridge_list = NULL; - circuit_build_times_free_timeouts(&circ_times); + circuit_build_times_free_timeouts(get_circuit_build_times()); } diff --git a/src/or/networkstatus.c b/src/or/networkstatus.c index 3f995a9f6c..8b4a79156b 100644 --- a/src/or/networkstatus.c +++ b/src/or/networkstatus.c @@ -1822,7 +1822,8 @@ networkstatus_set_current_consensus(const char *consensus, * current consensus really alter our view of any OR's rate limits? */ connection_or_update_token_buckets(get_connection_array(), options); - circuit_build_times_new_consensus_params(&circ_times, current_consensus); + circuit_build_times_new_consensus_params(get_circuit_build_times(), + current_consensus); } if (directory_caches_dir_info(options)) { diff --git a/src/or/statefile.c b/src/or/statefile.c index 8736c35a2d..4b61fde39c 100644 --- a/src/or/statefile.c +++ b/src/or/statefile.c @@ -238,7 +238,8 @@ or_state_set(or_state_t *new_state) tor_free(err); ret = -1; } - if (circuit_build_times_parse_state(&circ_times, global_state) < 0) { + if (circuit_build_times_parse_state( + get_circuit_build_times(),global_state) < 0) { ret = -1; } return ret; @@ -405,7 +406,7 @@ or_state_save(time_t now) * to avoid redundant writes. */ entry_guards_update_state(global_state); rep_hist_update_state(global_state); - circuit_build_times_update_state(&circ_times, global_state); + circuit_build_times_update_state(get_circuit_build_times(), global_state); if (accounting_is_enabled(get_options())) accounting_run_housekeeping(now); From e1c9b43b8efbc76ab3a6decf47d6d1ef1967ef77 Mon Sep 17 00:00:00 2001 From: Nick Mathewson Date: Wed, 21 Aug 2013 11:59:19 -0400 Subject: [PATCH 2/6] Rename get_circuit_nbuild_* to end with _ms --- src/or/circuitbuild.c | 17 +++++++++-------- src/or/circuitstats.c | 4 ++-- src/or/circuitstats.h | 4 ++-- src/or/circuituse.c | 20 ++++++++++---------- 4 files changed, 23 insertions(+), 22 deletions(-) diff --git a/src/or/circuitbuild.c b/src/or/circuitbuild.c index c144f274ad..cb2f423ee3 100644 --- a/src/or/circuitbuild.c +++ b/src/or/circuitbuild.c @@ -772,7 +772,8 @@ circuit_send_next_onion_skin(origin_circuit_t *circ) * it off at, we probably had a suspend event along this codepath, * and we should discard the value. */ - if (timediff < 0 || timediff > 2*get_circuit_build_close_time()+1000) { + if (timediff < 0 || + timediff > 2*get_circuit_build_close_time_ms()+1000) { log_notice(LD_CIRC, "Strange value for circuit build time: %ldmsec. " "Assuming clock jump. Purpose %d (%s)", timediff, circ->base_.purpose, @@ -2276,7 +2277,7 @@ pathbias_measure_use_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); guard->path_bias_disabled = 1; guard->bad_since = approx_time(); entry_guards_changed(); @@ -2302,7 +2303,7 @@ pathbias_measure_use_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); } } else if (pathbias_get_use_success_count(guard)/guard->use_attempts < pathbias_get_notice_use_rate(options)) { @@ -2326,7 +2327,7 @@ pathbias_measure_use_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); } } } @@ -2382,7 +2383,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); guard->path_bias_disabled = 1; guard->bad_since = approx_time(); entry_guards_changed(); @@ -2408,7 +2409,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); } } else if (pathbias_get_close_success_count(guard)/guard->circ_attempts < pathbias_get_warn_rate(options)) { @@ -2433,7 +2434,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); } } else if (pathbias_get_close_success_count(guard)/guard->circ_attempts < pathbias_get_notice_rate(options)) { @@ -2456,7 +2457,7 @@ pathbias_measure_close_rate(entry_guard_t *guard) tor_lround(guard->unusable_circuits), tor_lround(guard->collapsed_circuits), tor_lround(guard->timeouts), - tor_lround(get_circuit_build_close_time()/1000)); + tor_lround(get_circuit_build_close_time_ms()/1000)); } } } diff --git a/src/or/circuitstats.c b/src/or/circuitstats.c index 88ed350a89..25813decf5 100644 --- a/src/or/circuitstats.c +++ b/src/or/circuitstats.c @@ -43,13 +43,13 @@ get_circuit_build_times(void) } double -get_circuit_build_close_time(void) +get_circuit_build_close_time_ms(void) { return circ_times.close_ms; } double -get_circuit_build_timeout(void) +get_circuit_build_timeout_ms(void) { return circ_times.timeout_ms; } diff --git a/src/or/circuitstats.h b/src/or/circuitstats.h index 2381bf9091..4115b68654 100644 --- a/src/or/circuitstats.h +++ b/src/or/circuitstats.h @@ -13,8 +13,8 @@ #define TOR_CIRCUITSTATS_H circuit_build_times_t *get_circuit_build_times(void); -double get_circuit_build_close_time(void); -double get_circuit_build_timeout(void); +double get_circuit_build_close_time_ms(void); +double get_circuit_build_timeout_ms(void); int circuit_build_times_disabled(void); int circuit_build_times_enough_to_compute(circuit_build_times_t *cbt); diff --git a/src/or/circuituse.c b/src/or/circuituse.c index 57079f0a45..919ca35d19 100644 --- a/src/or/circuituse.c +++ b/src/or/circuituse.c @@ -442,12 +442,12 @@ circuit_expire_building(void) * RTTs = 4a + 3b + 2c * RTTs = 9h */ - SET_CUTOFF(general_cutoff, get_circuit_build_timeout()); - SET_CUTOFF(begindir_cutoff, get_circuit_build_timeout()); + SET_CUTOFF(general_cutoff, get_circuit_build_timeout_ms()); + SET_CUTOFF(begindir_cutoff, get_circuit_build_timeout_ms()); /* > 3hop circs seem to have a 1.0 second delay on their cannibalized * 4th hop. */ - SET_CUTOFF(fourhop_cutoff, get_circuit_build_timeout() * (10/6.0) + 1000); + SET_CUTOFF(fourhop_cutoff, get_circuit_build_timeout_ms() * (10/6.0) + 1000); /* CIRCUIT_PURPOSE_C_ESTABLISH_REND behaves more like a RELAY cell. * Use the stream cutoff (more or less). */ @@ -456,20 +456,20 @@ circuit_expire_building(void) /* Be lenient with cannibalized circs. They already survived the official * CBT, and they're usually not performance-critical. */ SET_CUTOFF(cannibalized_cutoff, - MAX(get_circuit_build_close_time()*(4/6.0), + MAX(get_circuit_build_close_time_ms()*(4/6.0), options->CircuitStreamTimeout * 1000) + 1000); /* Intro circs have an extra round trip (and are also 4 hops long) */ - SET_CUTOFF(c_intro_cutoff, get_circuit_build_timeout() * (14/6.0) + 1000); + SET_CUTOFF(c_intro_cutoff, get_circuit_build_timeout_ms() * (14/6.0) + 1000); /* Server intro circs have an extra round trip */ - SET_CUTOFF(s_intro_cutoff, get_circuit_build_timeout() * (9/6.0) + 1000); + SET_CUTOFF(s_intro_cutoff, get_circuit_build_timeout_ms() * (9/6.0) + 1000); - SET_CUTOFF(close_cutoff, get_circuit_build_close_time()); - SET_CUTOFF(extremely_old_cutoff, get_circuit_build_close_time()*2 + 1000); + SET_CUTOFF(close_cutoff, get_circuit_build_close_time_ms()); + SET_CUTOFF(extremely_old_cutoff, get_circuit_build_close_time_ms()*2 + 1000); SET_CUTOFF(hs_extremely_old_cutoff, - MAX(get_circuit_build_close_time()*2 + 1000, + MAX(get_circuit_build_close_time_ms()*2 + 1000, options->SocksTimeout * 1000)); TOR_LIST_FOREACH(next_circ, circuit_get_global_list(), head) { @@ -552,7 +552,7 @@ circuit_expire_building(void) continue; } else { static ratelim_t relax_timeout_limit = RATELIM_INIT(3600); - const double build_close_ms = get_circuit_build_close_time(); + const double build_close_ms = get_circuit_build_close_time_ms(); log_fn_ratelim(&relax_timeout_limit, LOG_NOTICE, LD_CIRC, "No circuits are opened. Relaxed timeout for circuit %d " "(a %s %d-hop circuit in state %s with channel state %s) to " From 775c491502e43f0490023b2917c4e1a05b38b5b8 Mon Sep 17 00:00:00 2001 From: Nick Mathewson Date: Wed, 21 Aug 2013 12:10:05 -0400 Subject: [PATCH 3/6] Separate mutable/const accessors for circuit_build_times (These have proved invaluable for other global accessors.) --- src/or/channel.c | 2 +- src/or/circuitbuild.c | 6 +++--- src/or/circuitlist.c | 2 +- src/or/circuitstats.c | 22 ++++++++++++++-------- src/or/circuitstats.h | 13 +++++++------ src/or/circuituse.c | 12 +++++++----- src/or/connection_or.c | 8 ++++---- src/or/entrynodes.c | 2 +- src/or/networkstatus.c | 2 +- src/or/statefile.c | 2 +- 10 files changed, 40 insertions(+), 31 deletions(-) diff --git a/src/or/channel.c b/src/or/channel.c index 8743437297..7f395490c9 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -2361,7 +2361,7 @@ channel_do_open_actions(channel_t *chan) started_here = channel_is_outgoing(chan); if (started_here) { - circuit_build_times_network_is_live(get_circuit_build_times()); + circuit_build_times_network_is_live(get_circuit_build_times_mutable()); rep_hist_note_connect_succeeded(chan->identity_digest, now); if (entry_guard_register_connect_status( chan->identity_digest, 1, 0, now) < 0) { diff --git a/src/or/circuitbuild.c b/src/or/circuitbuild.c index cb2f423ee3..a203ceeef1 100644 --- a/src/or/circuitbuild.c +++ b/src/or/circuitbuild.c @@ -782,14 +782,14 @@ circuit_send_next_onion_skin(origin_circuit_t *circ) /* Only count circuit times if the network is live */ if (circuit_build_times_network_check_live( get_circuit_build_times())) { - circuit_build_times_add_time(get_circuit_build_times(), + circuit_build_times_add_time(get_circuit_build_times_mutable(), (build_time_t)timediff); - circuit_build_times_set_timeout(get_circuit_build_times()); + circuit_build_times_set_timeout(get_circuit_build_times_mutable()); } if (circ->base_.purpose != CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT) { circuit_build_times_network_circ_success( - get_circuit_build_times()); + get_circuit_build_times_mutable()); } } } diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c index 1edea85972..50caf370d9 100644 --- a/src/or/circuitlist.c +++ b/src/or/circuitlist.c @@ -678,7 +678,7 @@ origin_circuit_new(void) init_circuit_base(TO_CIRCUIT(circ)); - get_circuit_build_times()->last_circ_at = approx_time(); + get_circuit_build_times_mutable()->last_circ_at = approx_time(); return circ; } diff --git a/src/or/circuitstats.c b/src/or/circuitstats.c index 25813decf5..0d60a1936f 100644 --- a/src/or/circuitstats.c +++ b/src/or/circuitstats.c @@ -36,12 +36,18 @@ static int unit_tests = 0; #define unit_tests 0 #endif -circuit_build_times_t * +const circuit_build_times_t * get_circuit_build_times(void) { return &circ_times; } +circuit_build_times_t * +get_circuit_build_times_mutable(void) +{ + return &circ_times; +} + double get_circuit_build_close_time_ms(void) { @@ -175,7 +181,7 @@ circuit_build_times_min_circs_to_observe(void) /** Return true iff cbt has recorded enough build times that we * want to start acting on the timeout it implies. */ int -circuit_build_times_enough_to_compute(circuit_build_times_t *cbt) +circuit_build_times_enough_to_compute(const circuit_build_times_t *cbt) { return cbt->total_build_times >= circuit_build_times_min_circs_to_observe(); } @@ -578,7 +584,7 @@ circuit_build_times_add_time(circuit_build_times_t *cbt, build_time_t time) * Return maximum circuit build time */ static build_time_t -circuit_build_times_max(circuit_build_times_t *cbt) +circuit_build_times_max(const circuit_build_times_t *cbt) { int i = 0; build_time_t max_build_time = 0; @@ -619,7 +625,7 @@ circuit_build_times_min(circuit_build_times_t *cbt) * The return value must be freed by the caller. */ static uint32_t * -circuit_build_times_create_histogram(circuit_build_times_t *cbt, +circuit_build_times_create_histogram(const circuit_build_times_t *cbt, build_time_t *nbins) { uint32_t *histogram; @@ -709,7 +715,7 @@ circuit_build_times_get_xm(circuit_build_times_t *cbt) * the or_state_t state structure. */ void -circuit_build_times_update_state(circuit_build_times_t *cbt, +circuit_build_times_update_state(const circuit_build_times_t *cbt, or_state_t *state) { uint32_t *histogram; @@ -1146,7 +1152,7 @@ circuit_build_times_initial_alpha(circuit_build_times_t *cbt, * Returns true if we need circuits to be built */ int -circuit_build_times_needs_circuits(circuit_build_times_t *cbt) +circuit_build_times_needs_circuits(const circuit_build_times_t *cbt) { /* Return true if < MIN_CIRCUITS_TO_OBSERVE */ return !circuit_build_times_enough_to_compute(cbt); @@ -1157,7 +1163,7 @@ circuit_build_times_needs_circuits(circuit_build_times_t *cbt) * right now. */ int -circuit_build_times_needs_circuits_now(circuit_build_times_t *cbt) +circuit_build_times_needs_circuits_now(const circuit_build_times_t *cbt) { return circuit_build_times_needs_circuits(cbt) && approx_time()-cbt->last_circ_at > circuit_build_times_test_frequency(); @@ -1290,7 +1296,7 @@ circuit_build_times_network_close(circuit_build_times_t *cbt, * in the case of recent liveness changes. */ int -circuit_build_times_network_check_live(circuit_build_times_t *cbt) +circuit_build_times_network_check_live(const circuit_build_times_t *cbt) { if (cbt->liveness.nonlive_timeouts > 0) { return 0; diff --git a/src/or/circuitstats.h b/src/or/circuitstats.h index 4115b68654..196af3fab4 100644 --- a/src/or/circuitstats.h +++ b/src/or/circuitstats.h @@ -12,13 +12,14 @@ #ifndef TOR_CIRCUITSTATS_H #define TOR_CIRCUITSTATS_H -circuit_build_times_t *get_circuit_build_times(void); +const circuit_build_times_t *get_circuit_build_times(void); +circuit_build_times_t *get_circuit_build_times_mutable(void); double get_circuit_build_close_time_ms(void); double get_circuit_build_timeout_ms(void); int circuit_build_times_disabled(void); -int circuit_build_times_enough_to_compute(circuit_build_times_t *cbt); -void circuit_build_times_update_state(circuit_build_times_t *cbt, +int circuit_build_times_enough_to_compute(const circuit_build_times_t *cbt); +void circuit_build_times_update_state(const circuit_build_times_t *cbt, or_state_t *state); int circuit_build_times_parse_state(circuit_build_times_t *cbt, or_state_t *state); @@ -29,9 +30,9 @@ int circuit_build_times_count_close(circuit_build_times_t *cbt, void circuit_build_times_set_timeout(circuit_build_times_t *cbt); int circuit_build_times_add_time(circuit_build_times_t *cbt, build_time_t time); -int circuit_build_times_needs_circuits(circuit_build_times_t *cbt); +int circuit_build_times_needs_circuits(const circuit_build_times_t *cbt); -int circuit_build_times_needs_circuits_now(circuit_build_times_t *cbt); +int circuit_build_times_needs_circuits_now(const circuit_build_times_t *cbt); void circuit_build_times_init(circuit_build_times_t *cbt); void circuit_build_times_free_timeouts(circuit_build_times_t *cbt); void circuit_build_times_new_consensus_params(circuit_build_times_t *cbt, @@ -61,7 +62,7 @@ void circuitbuild_running_unit_tests(void); /* Network liveness functions */ void circuit_build_times_network_is_live(circuit_build_times_t *cbt); -int circuit_build_times_network_check_live(circuit_build_times_t *cbt); +int circuit_build_times_network_check_live(const circuit_build_times_t *cbt); void circuit_build_times_network_circ_success(circuit_build_times_t *cbt); #endif diff --git a/src/or/circuituse.c b/src/or/circuituse.c index 919ca35d19..e3c0d0cbd8 100644 --- a/src/or/circuituse.c +++ b/src/or/circuituse.c @@ -545,7 +545,7 @@ circuit_expire_building(void) * was a timeout, and the timeout value needs to reset if we * see enough of them. Note this means we also need to avoid * double-counting below, too. */ - circuit_build_times_count_timeout(get_circuit_build_times(), + circuit_build_times_count_timeout(get_circuit_build_times_mutable(), first_hop_succeeded); TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout = 1; } @@ -658,8 +658,9 @@ circuit_expire_building(void) * have a timeout. We also want to avoid double-counting * already "relaxed" circuits, which are counted above. */ if (!TO_ORIGIN_CIRCUIT(victim)->relaxed_timeout) { - circuit_build_times_count_timeout(get_circuit_build_times(), - first_hop_succeeded); + circuit_build_times_count_timeout( + get_circuit_build_times_mutable(), + first_hop_succeeded); } continue; } @@ -676,10 +677,11 @@ circuit_expire_building(void) (long)(now.tv_sec - victim->timestamp_began.tv_sec), victim->purpose, circuit_purpose_to_string(victim->purpose)); - } else if (circuit_build_times_count_close(get_circuit_build_times(), + } else if (circuit_build_times_count_close( + get_circuit_build_times_mutable(), first_hop_succeeded, victim->timestamp_created.tv_sec)) { - circuit_build_times_set_timeout(get_circuit_build_times()); + circuit_build_times_set_timeout(get_circuit_build_times_mutable()); } } } diff --git a/src/or/connection_or.c b/src/or/connection_or.c index b7e72fd346..7912bfb7fc 100644 --- a/src/or/connection_or.c +++ b/src/or/connection_or.c @@ -1749,7 +1749,7 @@ connection_tls_finish_handshake(or_connection_t *conn) digest_rcvd) < 0) return -1; - circuit_build_times_network_is_live(get_circuit_build_times()); + circuit_build_times_network_is_live(get_circuit_build_times_mutable()); if (tor_tls_used_v1_handshake(conn->tls)) { conn->link_proto = 1; @@ -1783,7 +1783,7 @@ connection_or_launch_v3_or_handshake(or_connection_t *conn) tor_assert(connection_or_nonopen_was_started_here(conn)); tor_assert(tor_tls_received_v3_certificate(conn->tls)); - circuit_build_times_network_is_live(get_circuit_build_times()); + circuit_build_times_network_is_live(get_circuit_build_times_mutable()); connection_or_change_state(conn, OR_CONN_STATE_OR_HANDSHAKING_V3); if (connection_init_or_handshake_state(conn, 1) < 0) @@ -2016,7 +2016,7 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn) if (conn->chan) channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan)); - circuit_build_times_network_is_live(get_circuit_build_times()); + circuit_build_times_network_is_live(get_circuit_build_times_mutable()); channel_tls_handle_var_cell(var_cell, conn); var_cell_free(var_cell); } else { @@ -2032,7 +2032,7 @@ connection_or_process_cells_from_inbuf(or_connection_t *conn) if (conn->chan) channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan)); - circuit_build_times_network_is_live(get_circuit_build_times()); + circuit_build_times_network_is_live(get_circuit_build_times_mutable()); connection_fetch_from_buf(buf, cell_network_size, TO_CONN(conn)); /* retrieve cell info from buf (create the host-order struct from the diff --git a/src/or/entrynodes.c b/src/or/entrynodes.c index b3764a9416..b66cc2b0d8 100644 --- a/src/or/entrynodes.c +++ b/src/or/entrynodes.c @@ -2279,6 +2279,6 @@ entry_guards_free_all(void) clear_bridge_list(); smartlist_free(bridge_list); bridge_list = NULL; - circuit_build_times_free_timeouts(get_circuit_build_times()); + circuit_build_times_free_timeouts(get_circuit_build_times_mutable()); } diff --git a/src/or/networkstatus.c b/src/or/networkstatus.c index 8b4a79156b..35a20b06ca 100644 --- a/src/or/networkstatus.c +++ b/src/or/networkstatus.c @@ -1822,7 +1822,7 @@ networkstatus_set_current_consensus(const char *consensus, * current consensus really alter our view of any OR's rate limits? */ connection_or_update_token_buckets(get_connection_array(), options); - circuit_build_times_new_consensus_params(get_circuit_build_times(), + circuit_build_times_new_consensus_params(get_circuit_build_times_mutable(), current_consensus); } diff --git a/src/or/statefile.c b/src/or/statefile.c index 4b61fde39c..db9091ca27 100644 --- a/src/or/statefile.c +++ b/src/or/statefile.c @@ -239,7 +239,7 @@ or_state_set(or_state_t *new_state) ret = -1; } if (circuit_build_times_parse_state( - get_circuit_build_times(),global_state) < 0) { + get_circuit_build_times_mutable(),global_state) < 0) { ret = -1; } return ret; From 49b8acc61872a35165cc1375edc4dcdeabfc68b4 Mon Sep 17 00:00:00 2001 From: Nick Mathewson Date: Wed, 21 Aug 2013 12:12:21 -0400 Subject: [PATCH 4/6] changes file for 6153 --- changes/6153_circuittime_accessor | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 changes/6153_circuittime_accessor diff --git a/changes/6153_circuittime_accessor b/changes/6153_circuittime_accessor new file mode 100644 index 0000000000..16f1f557d5 --- /dev/null +++ b/changes/6153_circuittime_accessor @@ -0,0 +1,4 @@ + o Code simplification and refactoring: + + - Add a set of accessor functions for the circuit timeout data + structure. Fixes ticket 6153; patch from "piet". From 79cad08b4f9afd13a7151b8e15ae6481df82478f Mon Sep 17 00:00:00 2001 From: Nick Mathewson Date: Wed, 21 Aug 2013 12:17:20 -0400 Subject: [PATCH 5/6] Documentation for new cbt accessors --- src/or/circuitstats.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/or/circuitstats.c b/src/or/circuitstats.c index 0d60a1936f..e7b4b36bbd 100644 --- a/src/or/circuitstats.c +++ b/src/or/circuitstats.c @@ -36,24 +36,31 @@ static int unit_tests = 0; #define unit_tests 0 #endif +/** Return a pointer to the data structure describing our current circuit + * build time history and computations. */ const circuit_build_times_t * get_circuit_build_times(void) { return &circ_times; } +/** As get_circuit_build_times, but return a mutable pointer. */ circuit_build_times_t * get_circuit_build_times_mutable(void) { return &circ_times; } +/** Return the time to wait before actually closing an under-construction, in + * milliseconds. */ double get_circuit_build_close_time_ms(void) { return circ_times.close_ms; } +/** Return the time to wait before giving up on an under-construction circuit, + * in milliseconds. */ double get_circuit_build_timeout_ms(void) { From 8920fc545738393fc8320b61bac897f67a66e6c9 Mon Sep 17 00:00:00 2001 From: Nick Mathewson Date: Wed, 21 Aug 2013 12:37:35 -0400 Subject: [PATCH 6/6] Hide the contents of the circuit_build_times structure. There were only two functions outside of circuitstats that actually wanted to know what was inside this. Making the structure itself hidden should help isolation and prevent us from spaghettifying the thing more. --- src/or/circuitlist.c | 2 +- src/or/circuitstats.c | 51 ++++++++++++++++++++++++++++++++++++++++--- src/or/circuitstats.h | 29 ++++++++++++++++++++++++ src/or/control.c | 21 ++++-------------- src/or/control.h | 4 ++-- src/or/or.h | 25 +-------------------- 6 files changed, 85 insertions(+), 47 deletions(-) diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c index 50caf370d9..bb74594ecd 100644 --- a/src/or/circuitlist.c +++ b/src/or/circuitlist.c @@ -678,7 +678,7 @@ origin_circuit_new(void) init_circuit_base(TO_CIRCUIT(circ)); - get_circuit_build_times_mutable()->last_circ_at = approx_time(); + circuit_build_times_update_last_circ(get_circuit_build_times_mutable()); return circ; } diff --git a/src/or/circuitstats.c b/src/or/circuitstats.c index e7b4b36bbd..8fdef58858 100644 --- a/src/or/circuitstats.c +++ b/src/or/circuitstats.c @@ -18,6 +18,10 @@ #undef log #include +static void cbt_control_event_buildtimeout_set( + const circuit_build_times_t *cbt, + buildtimeout_set_event_t type); + #define CBT_BIN_TO_MS(bin) ((bin)*CBT_BIN_WIDTH + (CBT_BIN_WIDTH/2)) /** Global list of circuit build times */ @@ -505,7 +509,7 @@ circuit_build_times_init(circuit_build_times_t *cbt) cbt->liveness.timeouts_after_firsthop = NULL; } cbt->close_ms = cbt->timeout_ms = circuit_build_times_get_initial_timeout(); - control_event_buildtimeout_set(cbt, BUILDTIMEOUT_SET_EVENT_RESET); + cbt_control_event_buildtimeout_set(cbt, BUILDTIMEOUT_SET_EVENT_RESET); } /** @@ -1369,7 +1373,7 @@ circuit_build_times_network_check_changed(circuit_build_times_t *cbt) = circuit_build_times_get_initial_timeout(); } - control_event_buildtimeout_set(cbt, BUILDTIMEOUT_SET_EVENT_RESET); + cbt_control_event_buildtimeout_set(cbt, BUILDTIMEOUT_SET_EVENT_RESET); log_notice(LD_CIRC, "Your network connection speed appears to have changed. Resetting " @@ -1551,7 +1555,7 @@ circuit_build_times_set_timeout(circuit_build_times_t *cbt) } } - control_event_buildtimeout_set(cbt, BUILDTIMEOUT_SET_EVENT_COMPUTED); + cbt_control_event_buildtimeout_set(cbt, BUILDTIMEOUT_SET_EVENT_COMPUTED); timeout_rate = circuit_build_times_timeout_rate(cbt); @@ -1597,3 +1601,44 @@ circuitbuild_running_unit_tests(void) } #endif +void +circuit_build_times_update_last_circ(circuit_build_times_t *cbt) +{ + cbt->last_circ_at = approx_time(); +} + +static void +cbt_control_event_buildtimeout_set(const circuit_build_times_t *cbt, + buildtimeout_set_event_t type) +{ + char *args = NULL; + double qnt; + + switch(type) { + case BUILDTIMEOUT_SET_EVENT_RESET: + case BUILDTIMEOUT_SET_EVENT_SUSPENDED: + case BUILDTIMEOUT_SET_EVENT_DISCARD: + qnt = 1.0; + break; + case BUILDTIMEOUT_SET_EVENT_COMPUTED: + case BUILDTIMEOUT_SET_EVENT_RESUME: + default: + qnt = circuit_build_times_quantile_cutoff(); + break; + } + + tor_asprintf(&args, "TOTAL_TIMES=%lu " + "TIMEOUT_MS=%lu XM=%lu ALPHA=%f CUTOFF_QUANTILE=%f " + "TIMEOUT_RATE=%f CLOSE_MS=%lu CLOSE_RATE=%f", + (unsigned long)cbt->total_build_times, + (unsigned long)cbt->timeout_ms, + (unsigned long)cbt->Xm, cbt->alpha, qnt, + circuit_build_times_timeout_rate(cbt), + (unsigned long)cbt->close_ms, + circuit_build_times_close_rate(cbt)); + + control_event_buildtimeout_set(type, args); + + tor_free(args); + +} diff --git a/src/or/circuitstats.h b/src/or/circuitstats.h index 196af3fab4..38a7e4efa8 100644 --- a/src/or/circuitstats.h +++ b/src/or/circuitstats.h @@ -40,6 +40,8 @@ void circuit_build_times_new_consensus_params(circuit_build_times_t *cbt, double circuit_build_times_timeout_rate(const circuit_build_times_t *cbt); double circuit_build_times_close_rate(const circuit_build_times_t *cbt); +void circuit_build_times_update_last_circ(circuit_build_times_t *cbt); + #ifdef CIRCUITSTATS_PRIVATE STATIC double circuit_build_times_calculate_timeout(circuit_build_times_t *cbt, double quantile); @@ -65,5 +67,32 @@ void circuit_build_times_network_is_live(circuit_build_times_t *cbt); int circuit_build_times_network_check_live(const circuit_build_times_t *cbt); void circuit_build_times_network_circ_success(circuit_build_times_t *cbt); +#ifdef CIRCUITSTATS_PRIVATE +/** Structure for circuit build times history */ +struct circuit_build_times_s{ + /** The circular array of recorded build times in milliseconds */ + build_time_t circuit_build_times[CBT_NCIRCUITS_TO_OBSERVE]; + /** Current index in the circuit_build_times circular array */ + int build_times_idx; + /** Total number of build times accumulated. Max CBT_NCIRCUITS_TO_OBSERVE */ + int total_build_times; + /** Information about the state of our local network connection */ + network_liveness_t liveness; + /** Last time we built a circuit. Used to decide to build new test circs */ + time_t last_circ_at; + /** "Minimum" value of our pareto distribution (actually mode) */ + build_time_t Xm; + /** alpha exponent for pareto dist. */ + double alpha; + /** Have we computed a timeout? */ + int have_computed_timeout; + /** The exact value for that timeout in milliseconds. Stored as a double + * to maintain precision from calculations to and from quantile value. */ + double timeout_ms; + /** How long we wait before actually closing the circuit. */ + double close_ms; +}; +#endif + #endif diff --git a/src/or/control.c b/src/or/control.c index 81df00cf92..fc4809b399 100644 --- a/src/or/control.c +++ b/src/or/control.c @@ -4163,32 +4163,26 @@ control_event_newconsensus(const networkstatus_t *consensus) /** Called when we compute a new circuitbuildtimeout */ int -control_event_buildtimeout_set(const circuit_build_times_t *cbt, - buildtimeout_set_event_t type) +control_event_buildtimeout_set(buildtimeout_set_event_t type, + const char *args) { const char *type_string = NULL; - double qnt; if (!control_event_is_interesting(EVENT_BUILDTIMEOUT_SET)) return 0; - qnt = circuit_build_times_quantile_cutoff(); - switch (type) { case BUILDTIMEOUT_SET_EVENT_COMPUTED: type_string = "COMPUTED"; break; case BUILDTIMEOUT_SET_EVENT_RESET: type_string = "RESET"; - qnt = 1.0; break; case BUILDTIMEOUT_SET_EVENT_SUSPENDED: type_string = "SUSPENDED"; - qnt = 1.0; break; case BUILDTIMEOUT_SET_EVENT_DISCARD: type_string = "DISCARD"; - qnt = 1.0; break; case BUILDTIMEOUT_SET_EVENT_RESUME: type_string = "RESUME"; @@ -4199,15 +4193,8 @@ control_event_buildtimeout_set(const circuit_build_times_t *cbt, } send_control_event(EVENT_BUILDTIMEOUT_SET, ALL_FORMATS, - "650 BUILDTIMEOUT_SET %s TOTAL_TIMES=%lu " - "TIMEOUT_MS=%lu XM=%lu ALPHA=%f CUTOFF_QUANTILE=%f " - "TIMEOUT_RATE=%f CLOSE_MS=%lu CLOSE_RATE=%f\r\n", - type_string, (unsigned long)cbt->total_build_times, - (unsigned long)cbt->timeout_ms, - (unsigned long)cbt->Xm, cbt->alpha, qnt, - circuit_build_times_timeout_rate(cbt), - (unsigned long)cbt->close_ms, - circuit_build_times_close_rate(cbt)); + "650 BUILDTIMEOUT_SET %s %s\r\n", + type_string, args); return 0; } diff --git a/src/or/control.h b/src/or/control.h index be9476ea3f..1a44768cee 100644 --- a/src/or/control.h +++ b/src/or/control.h @@ -73,8 +73,8 @@ int control_event_server_status(int severity, const char *format, ...) int control_event_guard(const char *nickname, const char *digest, const char *status); int control_event_conf_changed(const smartlist_t *elements); -int control_event_buildtimeout_set(const circuit_build_times_t *cbt, - buildtimeout_set_event_t type); +int control_event_buildtimeout_set(buildtimeout_set_event_t type, + const char *args); int control_event_signal(uintptr_t signal); int init_control_cookie_authentication(int enabled); diff --git a/src/or/or.h b/src/or/or.h index 2daf12b82d..041421ed42 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -4471,30 +4471,7 @@ typedef struct { int after_firsthop_idx; } network_liveness_t; -/** Structure for circuit build times history */ -typedef struct { - /** The circular array of recorded build times in milliseconds */ - build_time_t circuit_build_times[CBT_NCIRCUITS_TO_OBSERVE]; - /** Current index in the circuit_build_times circular array */ - int build_times_idx; - /** Total number of build times accumulated. Max CBT_NCIRCUITS_TO_OBSERVE */ - int total_build_times; - /** Information about the state of our local network connection */ - network_liveness_t liveness; - /** Last time we built a circuit. Used to decide to build new test circs */ - time_t last_circ_at; - /** "Minimum" value of our pareto distribution (actually mode) */ - build_time_t Xm; - /** alpha exponent for pareto dist. */ - double alpha; - /** Have we computed a timeout? */ - int have_computed_timeout; - /** The exact value for that timeout in milliseconds. Stored as a double - * to maintain precision from calculations to and from quantile value. */ - double timeout_ms; - /** How long we wait before actually closing the circuit. */ - double close_ms; -} circuit_build_times_t; +typedef struct circuit_build_times_s circuit_build_times_t; /********************************* config.c ***************************/