tor-commits November 2014

tor-commits@lists.torproject.org

24 participants
954 discussions

[tor/master] Make channel_note_destroy_not_pending() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 8907554cf3e4e87515fecde40ae2088fdded523f Author: Andrea Shepard <andrea(a)torproject.org> Date: Fri Dec 13 06:13:05 2013 -0800 Make channel_note_destroy_not_pending() mockable --- src/or/circuitlist.c | 4 ++-- src/or/circuitlist.h | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/or/circuitlist.c b/src/or/circuitlist.c index 9d72ea1..7b4eda3 100644 --- a/src/or/circuitlist.c +++ b/src/or/circuitlist.c @@ -302,8 +302,8 @@ channel_note_destroy_pending(channel_t *chan, circid_t id) /** Called to indicate that a DESTROY is no longer pending on <b>chan</b> with * circuit ID <b>id</b> -- typically, because it has been sent. */ -void -channel_note_destroy_not_pending(channel_t *chan, circid_t id) +MOCK_IMPL(void, channel_note_destroy_not_pending, + (channel_t *chan, circid_t id)) { circuit_t *circ = circuit_get_by_circid_channel_even_if_marked(id,chan); if (circ) { diff --git a/src/or/circuitlist.h b/src/or/circuitlist.h index 03934f9..a8d746b 100644 --- a/src/or/circuitlist.h +++ b/src/or/circuitlist.h @@ -72,7 +72,8 @@ void circuit_free_all(void); void circuits_handle_oom(size_t current_allocation); void channel_note_destroy_pending(channel_t *chan, circid_t id); -void channel_note_destroy_not_pending(channel_t *chan, circid_t id); +MOCK_DECL(void, channel_note_destroy_not_pending, + (channel_t *chan, circid_t id)); #ifdef CIRCUITLIST_PRIVATE STATIC void circuit_free(circuit_t *circ);

1 0

[tor/master] Eliminate some unnecessary smartlists in scheduler.c
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 3530825c53b7a28cf894b64e6d97aa90d0acccae Author: Andrea Shepard <andrea(a)torproject.org> Date: Fri Dec 6 00:04:12 2013 -0800 Eliminate some unnecessary smartlists in scheduler.c --- src/or/channel.c | 3 ++ src/or/channel.h | 23 +++++++++++ src/or/scheduler.c | 112 +++++++++++++++++++++------------------------------- 3 files changed, 70 insertions(+), 68 deletions(-) diff --git a/src/or/channel.c b/src/or/channel.c index 7ed3894..60e59c7 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -806,6 +806,9 @@ channel_init(channel_t *chan) /* It hasn't been open yet. */ chan->has_been_open = 0; + + /* Scheduler state is idle */ + chan->scheduler_state = SCHED_CHAN_IDLE; } /** diff --git a/src/or/channel.h b/src/or/channel.h index 18f7cfc..ced717a 100644 --- a/src/or/channel.h +++ b/src/or/channel.h @@ -57,6 +57,29 @@ struct channel_s { CHANNEL_CLOSE_FOR_ERROR } reason_for_closing; + /** State variable for use by the scheduler */ + enum { + /* + * The channel is not open, or it has a full output buffer but no queued + * cells. + */ + SCHED_CHAN_IDLE = 0, + /* + * The channel has space on its output buffer to write, but no queued + * cells. + */ + SCHED_CHAN_WAITING_FOR_CELLS, + /* + * The scheduler has queued cells but no output buffer space to write. + */ + SCHED_CHAN_WAITING_TO_WRITE, + /* + * The scheduler has both queued cells and output buffer space, and is + * eligible for the scheduler loop. + */ + SCHED_CHAN_PENDING + } scheduler_state; + /** Timestamps for both cell channels and listeners */ time_t timestamp_created; /* Channel created */ time_t timestamp_active; /* Any activity */ diff --git a/src/or/scheduler.c b/src/or/scheduler.c index c4c2632..c1b64df 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -24,12 +24,13 @@ #define SCHED_Q_HIGH_WATER (2 * SCHED_Q_LOW_WATER) /* - * Write scheduling works by keeping track of lists of channels that can + * Write scheduling works by keeping track of which channels can * accept cells, and have cells to write. From the scheduler's perspective, * a channel can be in four possible states: * * 1.) Not open for writes, no cells to send - * - Not much to do here, and the channel will appear in neither list. + * - Not much to do here, and the channel will have scheduler_state == + * SCHED_CHAN_IDLE * - Transitions from: * - Open for writes/has cells by simultaneously draining all circuit * queues and filling the output buffer. @@ -41,7 +42,8 @@ * * 2.) Open for writes, no cells to send * - Not much here either; this will be the state an idle but open channel - * can be expected to settle in. + * can be expected to settle in. It will have scheduler_state == + * SCHED_CHAN_WAITING_FOR_CELLS * - Transitions from: * - Not open for writes/no cells by flushing some of the output * buffer. @@ -55,6 +57,7 @@ * 3.) Not open for writes, cells to send * - This is the state of a busy circuit limited by output bandwidth; * cells have piled up in the circuit queues waiting to be relayed. + * The channel will have scheduler_state == SCHED_CHAN_WAITING_TO_WRITE. * - Transitions from: * - Not open for writes/no cells by arrival of cells on an attached * circuit @@ -66,7 +69,8 @@ * * 4.) Open for writes, cells to send * - This connection is ready to relay some cells and waiting for - * the scheduler to choose it + * the scheduler to choose it. The channel will have scheduler_state == + * SCHED_CHAN_PENDING. * - Transitions from: * - Not open for writes/has cells by the connection_or_flushed_some() * path @@ -91,29 +95,11 @@ /* Scheduler global data structures */ /* - * We keep lists of channels that either have cells queued, can accept - * writes, or both (states 2, 3 and 4 above) - no explicit list of state - * 1 channels is kept, so we don't have to worry about registering new - * channels here or anything. The scheduler will learn about them when - * it needs to. We can check how many channels in state 4 in O(1), so - * the test whether we have anything to do in scheduler_run() is fast - * and there's no harm in calling it opportunistically whenever we get - * the chance. - * - * Note that it takes time O(n) to search for a channel in these smartlists - * or move one; I don't think the number of channels on a relay will be large - * enough for this to be a severe problem, but this would benefit from using - * a doubly-linked list rather than smartlist_t, together with a hash map from - * channel identifiers to pointers to list entries, so we can perform those - * operations in O(log(n)). + * We keep a list of channels that are pending - i.e, have cells to write + * and can accept them to send. The enum scheduler_state in channel_t + * is reserved for our use. */ -/* List of channels that can write but have no cells (state 2 above) */ -static smartlist_t *channels_waiting_for_cells = NULL; - -/* List of channels with cells waiting to write (state 3 above) */ -static smartlist_t *channels_waiting_to_write = NULL; - /* List of channels that can write and have cells (pending work) */ static smartlist_t *channels_pending = NULL; @@ -165,16 +151,6 @@ scheduler_free_all(void) run_sched_ev = NULL; } - if (channels_waiting_for_cells) { - smartlist_free(channels_waiting_for_cells); - channels_waiting_for_cells = NULL; - } - - if (channels_waiting_to_write) { - smartlist_free(channels_waiting_to_write); - channels_waiting_to_write = NULL; - } - if (channels_pending) { smartlist_free(channels_pending); channels_pending = NULL; @@ -255,19 +231,18 @@ void scheduler_channel_doesnt_want_writes(channel_t *chan) { tor_assert(chan); - tor_assert(channels_waiting_for_cells); - tor_assert(channels_waiting_to_write); + tor_assert(channels_pending); /* If it's already in pending, we can put it in waiting_to_write */ - if (smartlist_contains(channels_pending, chan)) { + if (chan->scheduler_state == SCHED_CHAN_PENDING) { /* * It's in channels_pending, so it shouldn't be in any of * the other lists. It can't write any more, so it goes to * channels_waiting_to_write. */ smartlist_remove(channels_pending, chan); - smartlist_add(channels_waiting_to_write, chan); + chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p went from pending " "to waiting_to_write", @@ -278,8 +253,8 @@ scheduler_channel_doesnt_want_writes(channel_t *chan) * either not in any of the lists (nothing to do) or it's already in * waiting_for_cells (remove it, can't write any more). */ - if (smartlist_contains(channels_waiting_for_cells, chan)) { - smartlist_remove(channels_waiting_for_cells, chan); + if (chan->scheduler_state == SCHED_CHAN_WAITING_FOR_CELLS) { + chan->scheduler_state = SCHED_CHAN_IDLE; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p left waiting_for_cells", U64_PRINTF_ARG(chan->global_identifier), chan); @@ -295,18 +270,16 @@ scheduler_channel_has_waiting_cells(channel_t *chan) int became_pending = 0; tor_assert(chan); - tor_assert(channels_waiting_for_cells); - tor_assert(channels_waiting_to_write); tor_assert(channels_pending); /* First, check if this one also writeable */ - if (smartlist_contains(channels_waiting_for_cells, chan)) { + if (chan->scheduler_state == SCHED_CHAN_WAITING_FOR_CELLS) { /* * It's in channels_waiting_for_cells, so it shouldn't be in any of * the other lists. It has waiting cells now, so it goes to * channels_pending. */ - smartlist_remove(channels_waiting_for_cells, chan); + chan->scheduler_state = SCHED_CHAN_PENDING; smartlist_add(channels_pending, chan); log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p went from waiting_for_cells " @@ -319,9 +292,9 @@ scheduler_channel_has_waiting_cells(channel_t *chan) * either not in any of the lists (we add it to waiting_to_write) * or it's already in waiting_to_write or pending (we do nothing) */ - if (!(smartlist_contains(channels_waiting_to_write, chan) || - smartlist_contains(channels_pending, chan))) { - smartlist_add(channels_waiting_to_write, chan); + if (!(chan->scheduler_state == SCHED_CHAN_WAITING_TO_WRITE || + chan->scheduler_state == SCHED_CHAN_PENDING)) { + chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p entered waiting_to_write", U64_PRINTF_ARG(chan->global_identifier), chan); @@ -346,8 +319,6 @@ scheduler_init(void) run_sched_ev = tor_event_new(tor_libevent_get_base(), -1, 0, scheduler_evt_callback, NULL); - channels_waiting_for_cells = smartlist_new(); - channels_waiting_to_write = smartlist_new(); channels_pending = smartlist_new(); queue_heuristic = 0; queue_heuristic_timestamp = approx_time(); @@ -379,14 +350,13 @@ void scheduler_release_channel(channel_t *chan) { tor_assert(chan); - - tor_assert(channels_waiting_for_cells); - tor_assert(channels_waiting_to_write); tor_assert(channels_pending); - smartlist_remove(channels_waiting_for_cells, chan); - smartlist_remove(channels_waiting_to_write, chan); - smartlist_remove(channels_pending, chan); + if (chan->scheduler_state == SCHED_CHAN_PENDING) { + smartlist_remove(channels_pending, chan); + } + + chan->scheduler_state = SCHED_CHAN_IDLE; } /** Run the scheduling algorithm if necessary */ @@ -432,6 +402,13 @@ scheduler_run(void) flushed += flushed_this_time; } + if (flushed < n_cells) { + /* We ran out of cells to flush */ + chan->scheduler_state = SCHED_CHAN_WAITING_FOR_CELLS; + } else { + /* TODO get this right */ + } + log_debug(LD_SCHED, "Scheduler flushed %d cells onto pending channel " U64_FORMAT " at %p", @@ -442,10 +419,13 @@ scheduler_run(void) "Scheduler saw pending channel " U64_FORMAT " at %p with " "no cells writeable", U64_PRINTF_ARG(chan->global_identifier), chan); + /* Put it back to WAITING_TO_WRITE */ + chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; } } else { /* Not getting it this round; put it back on the list */ smartlist_add(channels_pending, chan); + /* It states in SCHED_CHAN_PENDING */ } } SMARTLIST_FOREACH_END(chan); @@ -486,18 +466,15 @@ scheduler_channel_wants_writes(channel_t *chan) int became_pending = 0; tor_assert(chan); - tor_assert(channels_waiting_for_cells); - tor_assert(channels_waiting_to_write); tor_assert(channels_pending); /* If it's already in waiting_to_write, we can put it in pending */ - if (smartlist_contains(channels_waiting_to_write, chan)) { + if (chan->scheduler_state == SCHED_CHAN_WAITING_TO_WRITE) { /* - * It's in channels_waiting_to_write, so it shouldn't be in any of - * the other lists. It can write now, so it goes to channels_pending. + * It can write now, so it goes to channels_pending. */ - smartlist_remove(channels_waiting_to_write, chan); smartlist_add(channels_pending, chan); + chan->scheduler_state = SCHED_CHAN_PENDING; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p went from waiting_to_write " "to pending", @@ -505,13 +482,12 @@ scheduler_channel_wants_writes(channel_t *chan) became_pending = 1; } else { /* - * It's not in waiting_to_write, so it can't become pending; it's - * either not in any of the lists (we add it to waiting_for_cells) - * or it's already in waiting_for_cells or pending (we do nothing) + * It's not in SCHED_CHAN_WAITING_TO_WRITE, so it can't become pending; + * it's either idle and goes to WAITING_FOR_CELLS, or it's a no-op. */ - if (!(smartlist_contains(channels_waiting_for_cells, chan) || - smartlist_contains(channels_pending, chan))) { - smartlist_add(channels_waiting_for_cells, chan); + if (!(chan->scheduler_state == SCHED_CHAN_WAITING_FOR_CELLS || + chan->scheduler_state == SCHED_CHAN_PENDING)) { + chan->scheduler_state = SCHED_CHAN_WAITING_FOR_CELLS; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p entered waiting_for_cells", U64_PRINTF_ARG(chan->global_identifier), chan);

1 0

[tor/master] Use a non-stupid data structure in the scheduler
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit ed1927d6bf8b9d60d40f6fbc20f9e1575a35e59d Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Dec 12 04:22:53 2013 -0800 Use a non-stupid data structure in the scheduler --- src/or/channel.h | 3 + src/or/scheduler.c | 190 ++++++++++++++++++++++++++++++++++++---------------- 2 files changed, 137 insertions(+), 56 deletions(-) diff --git a/src/or/channel.h b/src/or/channel.h index ced717a..023c39d 100644 --- a/src/or/channel.h +++ b/src/or/channel.h @@ -80,6 +80,9 @@ struct channel_s { SCHED_CHAN_PENDING } scheduler_state; + /** Heap index for use by the scheduler */ + int sched_heap_idx; + /** Timestamps for both cell channels and listeners */ time_t timestamp_created; /* Channel created */ time_t timestamp_active; /* Any activity */ diff --git a/src/or/scheduler.c b/src/or/scheduler.c index c1b64df..4f12696 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -24,6 +24,14 @@ #define SCHED_Q_HIGH_WATER (2 * SCHED_Q_LOW_WATER) /* + * Maximum cells to flush in a single call to channel_flush_some_cells(); + * setting this low means more calls, but too high and we could overshoot + * SCHED_Q_HIGH_WATER. + */ + +#define SCHED_MAX_FLUSH_CELLS 16 + +/* * Write scheduling works by keeping track of which channels can * accept cells, and have cells to write. From the scheduler's perspective, * a channel can be in four possible states: @@ -100,7 +108,7 @@ * is reserved for our use. */ -/* List of channels that can write and have cells (pending work) */ +/* Pqueue of channels that can write and have cells (pending work) */ static smartlist_t *channels_pending = NULL; /* @@ -125,7 +133,7 @@ static time_t queue_heuristic_timestamp = 0; /* Scheduler static function declarations */ -static int scheduler_compare_channels(const void **c1_v, const void **c2_v); +static int scheduler_compare_channels(const void *c1_v, const void *c2_v); static void scheduler_evt_callback(evutil_socket_t fd, short events, void *arg); static int scheduler_more_work(void); @@ -162,7 +170,7 @@ scheduler_free_all(void) */ static int -scheduler_compare_channels(const void **c1_v, const void **c2_v) +scheduler_compare_channels(const void *c1_v, const void *c2_v) { channel_t *c1 = NULL, *c2 = NULL; /* These are a workaround for -Wbad-function-cast throwing a fit */ @@ -172,8 +180,8 @@ scheduler_compare_channels(const void **c1_v, const void **c2_v) tor_assert(c1_v); tor_assert(c2_v); - c1 = (channel_t *)(*c1_v); - c2 = (channel_t *)(*c2_v); + c1 = (channel_t *)(c1_v); + c2 = (channel_t *)(c2_v); tor_assert(c1); tor_assert(c2); @@ -241,7 +249,10 @@ scheduler_channel_doesnt_want_writes(channel_t *chan) * the other lists. It can't write any more, so it goes to * channels_waiting_to_write. */ - smartlist_remove(channels_pending, chan); + smartlist_pqueue_remove(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p went from pending " @@ -280,7 +291,10 @@ scheduler_channel_has_waiting_cells(channel_t *chan) * channels_pending. */ chan->scheduler_state = SCHED_CHAN_PENDING; - smartlist_add(channels_pending, chan); + smartlist_pqueue_add(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p went from waiting_for_cells " "to pending", @@ -353,7 +367,10 @@ scheduler_release_channel(channel_t *chan) tor_assert(channels_pending); if (chan->scheduler_state == SCHED_CHAN_PENDING) { - smartlist_remove(channels_pending, chan); + smartlist_pqueue_remove(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); } chan->scheduler_state = SCHED_CHAN_IDLE; @@ -364,10 +381,11 @@ scheduler_release_channel(channel_t *chan) void scheduler_run(void) { - smartlist_t *tmp = NULL; int n_cells, n_chans_before, n_chans_after; uint64_t q_len_before, q_heur_before, q_len_after, q_heur_after; ssize_t flushed, flushed_this_time; + smartlist_t *to_readd = NULL; + channel_t *chan = NULL; log_debug(LD_SCHED, "We have a chance to run the scheduler"); @@ -375,61 +393,118 @@ scheduler_run(void) n_chans_before = smartlist_len(channels_pending); q_len_before = channel_get_global_queue_estimate(); q_heur_before = scheduler_get_queue_heuristic(); - tmp = channels_pending; - channels_pending = smartlist_new(); - - /* - * UGLY HACK: sort the list on each invocation - * - * TODO smarter data structures - */ - smartlist_sort(tmp, scheduler_compare_channels); - - SMARTLIST_FOREACH_BEGIN(tmp, channel_t *, chan) { - if (scheduler_get_queue_heuristic() <= SCHED_Q_HIGH_WATER) { - n_cells = channel_num_cells_writeable(chan); - if (n_cells > 0) { - log_debug(LD_SCHED, - "Scheduler saw pending channel " U64_FORMAT " at %p with " - "%d cells writeable", - U64_PRINTF_ARG(chan->global_identifier), chan, n_cells); - - flushed = 0; - while (flushed < n_cells) { - flushed_this_time = - channel_flush_some_cells(chan, n_cells - flushed); - if (flushed_this_time <= 0) break; - flushed += flushed_this_time; - } - if (flushed < n_cells) { - /* We ran out of cells to flush */ - chan->scheduler_state = SCHED_CHAN_WAITING_FOR_CELLS; - } else { - /* TODO get this right */ - } + while (scheduler_get_queue_heuristic() <= SCHED_Q_HIGH_WATER && + smartlist_len(channels_pending) > 0) { + /* Pop off a channel */ + chan = smartlist_pqueue_pop(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx)); + tor_assert(chan); + + /* Figure out how many cells we can write */ + n_cells = channel_num_cells_writeable(chan); + if (n_cells > 0) { + log_debug(LD_SCHED, + "Scheduler saw pending channel " U64_FORMAT " at %p with " + "%d cells writeable", + U64_PRINTF_ARG(chan->global_identifier), chan, n_cells); + + flushed = 0; + while (flushed < n_cells && + scheduler_get_queue_heuristic() <= SCHED_Q_HIGH_WATER) { + flushed_this_time = + channel_flush_some_cells(chan, + MIN(SCHED_MAX_FLUSH_CELLS, + n_cells - flushed)); + if (flushed_this_time <= 0) break; + flushed += flushed_this_time; + } + if (flushed < n_cells) { + /* We ran out of cells to flush */ + chan->scheduler_state = SCHED_CHAN_WAITING_FOR_CELLS; log_debug(LD_SCHED, - "Scheduler flushed %d cells onto pending channel " - U64_FORMAT " at %p", - (int)flushed, U64_PRINTF_ARG(chan->global_identifier), + "Channel " U64_FORMAT " at %p " + "entered waiting_for_cells from pending", + U64_PRINTF_ARG(chan->global_identifier), chan); } else { - log_info(LD_SCHED, - "Scheduler saw pending channel " U64_FORMAT " at %p with " - "no cells writeable", - U64_PRINTF_ARG(chan->global_identifier), chan); - /* Put it back to WAITING_TO_WRITE */ - chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; + /* The channel may still have some cells */ + if (channel_more_to_flush(chan)) { + /* The channel goes to either pending or waiting_to_write */ + if (channel_num_cells_writeable(chan) > 0) { + /* Add it back to pending later */ + if (!to_readd) to_readd = smartlist_new(); + smartlist_add(to_readd, chan); + log_debug(LD_SCHED, + "Channel " U64_FORMAT " at %p " + "is still pending", + U64_PRINTF_ARG(chan->global_identifier), + chan); + } else { + /* It's waiting to be able to write more */ + chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; + log_debug(LD_SCHED, + "Channel " U64_FORMAT " at %p " + "entered waiting_to_write from pending", + U64_PRINTF_ARG(chan->global_identifier), + chan); + } + } else { + /* No cells left; it can go to idle or waiting_for_cells */ + if (channel_num_cells_writeable(chan) > 0) { + /* + * It can still accept writes, so it goes to + * waiting_for_cells + */ + chan->scheduler_state = SCHED_CHAN_WAITING_FOR_CELLS; + log_debug(LD_SCHED, + "Channel " U64_FORMAT " at %p " + "entered waiting_for_cells from pending", + U64_PRINTF_ARG(chan->global_identifier), + chan); + } else { + /* + * We exactly filled up the output queue with all available + * cells; go to idle. + */ + chan->scheduler_state = SCHED_CHAN_IDLE; + log_debug(LD_SCHED, + "Channel " U64_FORMAT " at %p " + "become idle from pending", + U64_PRINTF_ARG(chan->global_identifier), + chan); + } + } } + + log_debug(LD_SCHED, + "Scheduler flushed %d cells onto pending channel " + U64_FORMAT " at %p", + (int)flushed, U64_PRINTF_ARG(chan->global_identifier), + chan); } else { - /* Not getting it this round; put it back on the list */ - smartlist_add(channels_pending, chan); - /* It states in SCHED_CHAN_PENDING */ + log_info(LD_SCHED, + "Scheduler saw pending channel " U64_FORMAT " at %p with " + "no cells writeable", + U64_PRINTF_ARG(chan->global_identifier), chan); + /* Put it back to WAITING_TO_WRITE */ + chan->scheduler_state = SCHED_CHAN_WAITING_TO_WRITE; } - } SMARTLIST_FOREACH_END(chan); + } - smartlist_free(tmp); + /* Readd any channels we need to */ + if (to_readd) { + SMARTLIST_FOREACH_BEGIN(to_readd, channel_t *, chan) { + chan->scheduler_state = SCHED_CHAN_PENDING; + smartlist_pqueue_add(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); + } SMARTLIST_FOREACH_END(chan); + smartlist_free(to_readd); + } n_chans_after = smartlist_len(channels_pending); q_len_after = channel_get_global_queue_estimate(); @@ -473,7 +548,10 @@ scheduler_channel_wants_writes(channel_t *chan) /* * It can write now, so it goes to channels_pending. */ - smartlist_add(channels_pending, chan); + smartlist_pqueue_add(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); chan->scheduler_state = SCHED_CHAN_PENDING; log_debug(LD_SCHED, "Channel " U64_FORMAT " at %p went from waiting_to_write "

1 0

[tor/master] Make scheduler_release_channel() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 85ee07085281a1fa47d0b44b0addbb54fcfa6061 Author: Andrea Shepard <andrea(a)torproject.org> Date: Fri Dec 13 06:27:00 2013 -0800 Make scheduler_release_channel() mockable --- src/or/scheduler.c | 4 ++-- src/or/scheduler.h | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/or/scheduler.c b/src/or/scheduler.c index 140ff2f..450eb02 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -360,8 +360,8 @@ scheduler_retrigger(void) /** Notify the scheduler of a channel being closed */ -void -scheduler_release_channel(channel_t *chan) +MOCK_IMPL(void, +scheduler_release_channel,(channel_t *chan)) { tor_assert(chan); tor_assert(channels_pending); diff --git a/src/or/scheduler.h b/src/or/scheduler.h index e2d2eb5..9cdf6c1 100644 --- a/src/or/scheduler.h +++ b/src/or/scheduler.h @@ -11,6 +11,7 @@ #include "or.h" #include "channel.h" +#include "testsupport.h" /* Global-visibility scheduler functions */ @@ -25,7 +26,7 @@ void scheduler_channel_has_waiting_cells(channel_t *chan); void scheduler_channel_wants_writes(channel_t *chan); /* Notify the scheduler of a channel being closed */ -void scheduler_release_channel(channel_t *chan); +MOCK_DECL(void,scheduler_release_channel,(channel_t *chan)); /* Notify scheduler of queue size adjustments */ void scheduler_adjust_queue_size(channel_t *chan, char dir, uint64_t adj);

1 0

[tor/master] Implement scheduler_touch_channel()
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit ac1b627e85a41bb734ab22bef268a5145cf83f15 Author: Andrea Shepard <andrea(a)torproject.org> Date: Thu Dec 12 04:29:45 2013 -0800 Implement scheduler_touch_channel() --- src/or/scheduler.c | 24 ++++++++++++++++++++++++ src/or/scheduler.h | 3 +++ 2 files changed, 27 insertions(+) diff --git a/src/or/scheduler.c b/src/or/scheduler.c index 4f12696..140ff2f 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -580,6 +580,30 @@ scheduler_channel_wants_writes(channel_t *chan) } /** + * Notify the scheduler that a channel's position in the pqueue may have + * changed + */ + +void +scheduler_touch_channel(channel_t *chan) +{ + tor_assert(chan); + + if (chan->scheduler_state == SCHED_CHAN_PENDING) { + /* Remove and re-add it */ + smartlist_pqueue_remove(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); + smartlist_pqueue_add(channels_pending, + scheduler_compare_channels, + STRUCT_OFFSET(channel_t, sched_heap_idx), + chan); + } + /* else no-op, since it isn't in the queue */ +} + +/** * Notify the scheduler of a queue size adjustment, to recalculate the * queue heuristic. */ diff --git a/src/or/scheduler.h b/src/or/scheduler.h index 8fe59cb..e2d2eb5 100644 --- a/src/or/scheduler.h +++ b/src/or/scheduler.h @@ -30,5 +30,8 @@ void scheduler_release_channel(channel_t *chan); /* Notify scheduler of queue size adjustments */ void scheduler_adjust_queue_size(channel_t *chan, char dir, uint64_t adj); +/* Notify scheduler that a channel's queue position may have changed */ +void scheduler_touch_channel(channel_t *chan); + #endif /* !defined(TOR_SCHEDULER_H) */

1 0

[tor/master] Refactor channel_get_cell_queue_entry_size() to avoid an unreachable line for test coverage, and fix a nasty lurking memory bug in channel_flush_some_cells_from_outgoing_queue()
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit dabf4c33e2c42024aebb305c17e9caf1d6b6c84b Author: Andrea Shepard <andrea(a)torproject.org> Date: Fri Dec 13 05:55:12 2013 -0800 Refactor channel_get_cell_queue_entry_size() to avoid an unreachable line for test coverage, and fix a nasty lurking memory bug in channel_flush_some_cells_from_outgoing_queue() --- src/or/channel.c | 55 +++++++++++++++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 21 deletions(-) diff --git a/src/or/channel.c b/src/or/channel.c index 60e59c7..9e3e452 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -1741,25 +1741,28 @@ cell_queue_entry_new_var(var_cell_t *var_cell) static size_t channel_get_cell_queue_entry_size(channel_t *chan, cell_queue_entry_t *q) { + size_t rv = 0; + tor_assert(chan); tor_assert(q); switch (q->type) { case CELL_QUEUE_FIXED: - return get_cell_network_size(chan->wide_circ_ids); + rv = get_cell_network_size(chan->wide_circ_ids); break; case CELL_QUEUE_VAR: tor_assert(q->u.var.var_cell); - return get_var_cell_header_size(chan->wide_circ_ids) + - q->u.var.var_cell->payload_len; + rv = get_var_cell_header_size(chan->wide_circ_ids) + + q->u.var.var_cell->payload_len; break; case CELL_QUEUE_PACKED: - return get_cell_network_size(chan->wide_circ_ids); + rv = get_cell_network_size(chan->wide_circ_ids); break; default: tor_assert(1); - return 0; } + + return rv; } /** @@ -2309,6 +2312,7 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, ssize_t flushed = 0; cell_queue_entry_t *q = NULL; size_t cell_size; + int free_q = 0, handed_off = 0; tor_assert(chan); tor_assert(chan->write_cell); @@ -2322,6 +2326,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, if (chan->state == CHANNEL_STATE_OPEN) { while ((unlimited || num_cells > flushed) && NULL != (q = TOR_SIMPLEQ_FIRST(&chan->outgoing_queue))) { + free_q = 0; + handed_off = 0; if (1) { /* Figure out how big it is for statistical purposes */ @@ -2339,8 +2345,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, channel_timestamp_xmit(chan); ++(chan->n_cells_xmitted); chan->n_bytes_xmitted += cell_size; - cell_queue_entry_free(q, 1); - q = NULL; + free_q = 1; + handed_off = 1; } /* Else couldn't write it; leave it on the queue */ } else { @@ -2351,8 +2357,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, "(global ID " U64_FORMAT ").", chan, U64_PRINTF_ARG(chan->global_identifier)); /* Throw it away */ - cell_queue_entry_free(q, 0); - q = NULL; + free_q = 1; + handed_off = 0; } break; case CELL_QUEUE_PACKED: @@ -2363,8 +2369,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, channel_timestamp_xmit(chan); ++(chan->n_cells_xmitted); chan->n_bytes_xmitted += cell_size; - cell_queue_entry_free(q, 1); - q = NULL; + free_q = 1; + handed_off = 1; } /* Else couldn't write it; leave it on the queue */ } else { @@ -2375,8 +2381,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, "(global ID " U64_FORMAT ").", chan, U64_PRINTF_ARG(chan->global_identifier)); /* Throw it away */ - cell_queue_entry_free(q, 0); - q = NULL; + free_q = 1; + handed_off = 0; } break; case CELL_QUEUE_VAR: @@ -2387,8 +2393,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, channel_timestamp_xmit(chan); ++(chan->n_cells_xmitted); chan->n_bytes_xmitted += cell_size; - cell_queue_entry_free(q, 1); - q = NULL; + free_q = 1; + handed_off = 1; } /* Else couldn't write it; leave it on the queue */ } else { @@ -2399,8 +2405,8 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, "(global ID " U64_FORMAT ").", chan, U64_PRINTF_ARG(chan->global_identifier)); /* Throw it away */ - cell_queue_entry_free(q, 0); - q = NULL; + free_q = 1; + handed_off = 0; } break; default: @@ -2410,12 +2416,16 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, "(global ID " U64_FORMAT "; ignoring it." " Someone should fix this.", q->type, chan, U64_PRINTF_ARG(chan->global_identifier)); - cell_queue_entry_free(q, 0); - q = NULL; + free_q = 1; + handed_off = 0; } - /* if q got NULLed out, we used it and should remove the queue entry */ - if (!q) { + /* + * if free_q is set, we used it and should remove the queue entry; + * we have to do the free down here so TOR_SIMPLEQ_REMOVE_HEAD isn't + * accessing freed memory + */ + if (free_q) { TOR_SIMPLEQ_REMOVE_HEAD(&chan->outgoing_queue, next); /* * ...and we handed a cell off to the lower layer, so we should @@ -2428,6 +2438,9 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan, channel_assert_counter_consistency(); /* Update the channel's queue size too */ chan->bytes_in_queue -= cell_size; + /* Finally, free q */ + cell_queue_entry_free(q, handed_off); + q = NULL; } /* No cell removed from list, so we can't go on any further */ else break;

1 0

[tor/master] Make scheduler_channel_doesnt_want_writes() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit fd57840a778f591fa175a1933c0b619741010bd1 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Dec 18 15:31:54 2013 -0800 Make scheduler_channel_doesnt_want_writes() mockable --- src/or/scheduler.c | 4 ++-- src/or/scheduler.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/or/scheduler.c b/src/or/scheduler.c index 450eb02..8a6620b 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -235,8 +235,8 @@ scheduler_evt_callback(evutil_socket_t fd, short events, void *arg) /** Mark a channel as no longer ready to accept writes */ -void -scheduler_channel_doesnt_want_writes(channel_t *chan) +MOCK_IMPL(void, +scheduler_channel_doesnt_want_writes,(channel_t *chan)) { tor_assert(chan); diff --git a/src/or/scheduler.h b/src/or/scheduler.h index 9cdf6c1..0752ae0 100644 --- a/src/or/scheduler.h +++ b/src/or/scheduler.h @@ -21,7 +21,7 @@ void scheduler_init(void); void scheduler_run(void); /* Mark channels as having cells or wanting/not wanting writes */ -void scheduler_channel_doesnt_want_writes(channel_t *chan); +MOCK_DECL(void,scheduler_channel_doesnt_want_writes,(channel_t *chan)); void scheduler_channel_has_waiting_cells(channel_t *chan); void scheduler_channel_wants_writes(channel_t *chan);

1 0

[tor/master] Expose fake channel utility functions in test suite in fakechans.h, and fix a test_channel.c bug
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 79b8f14c25ecbb4cda8fe587f18694dedd3ee9c0 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 00:46:57 2014 -0800 Expose fake channel utility functions in test suite in fakechans.h, and fix a test_channel.c bug --- src/test/fakechans.h | 16 ++++++++++++++++ src/test/test_channel.c | 35 +++++++++++++++++++++++++++++------ 2 files changed, 45 insertions(+), 6 deletions(-) diff --git a/src/test/fakechans.h b/src/test/fakechans.h new file mode 100644 index 0000000..b474810 --- /dev/null +++ b/src/test/fakechans.h @@ -0,0 +1,16 @@ + /* Copyright (c) 2014, The Tor Project, Inc. */ + /* See LICENSE for licensing information */ + +#ifndef TOR_FAKECHANS_H +#define TOR_FAKECHANS_H + +/** + * \file fakechans.h + * \brief Declarations for fake channels for test suite use + */ + +void make_fake_cell(cell_t *c); +void make_fake_var_cell(var_cell_t *c); +channel_t * new_fake_channel(void); + +#endif /* !defined(TOR_FAKECHANS_H) */ diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 9e6ef17..1ab7f32 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -13,7 +13,10 @@ #include "relay.h" /* For init/free stuff */ #include "scheduler.h" + +/* Test suite stuff */ #include "test.h" +#include "fakechans.h" static int test_chan_accept_cells = 0; static int test_cells_written = 0; @@ -31,9 +34,6 @@ static int chan_test_write_cell(channel_t *ch, cell_t *cell); static int chan_test_write_packed_cell(channel_t *ch, packed_cell_t *packed_cell); static int chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell); -static void make_fake_cell(cell_t *c); -static void make_fake_var_cell(var_cell_t *c); -static channel_t * new_fake_channel(void); static void scheduler_channel_doesnt_want_writes_mock(channel_t *ch); static void scheduler_release_channel_mock(channel_t *ch); @@ -150,7 +150,11 @@ chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell) return rv; } -static void +/** + * Fill out c with a new fake cell for test suite use + */ + +void make_fake_cell(cell_t *c) { test_assert(c != NULL); @@ -163,7 +167,11 @@ make_fake_cell(cell_t *c) return; } -static void +/** + * Fill out c with a new fake var_cell for test suite use + */ + +void make_fake_var_cell(var_cell_t *c) { test_assert(c != NULL); @@ -177,7 +185,11 @@ make_fake_var_cell(var_cell_t *c) return; } -static channel_t * +/** + * Set up a new fake channel for the test suite + */ + +channel_t * new_fake_channel(void) { channel_t *chan = tor_malloc_zero(sizeof(channel_t)); @@ -492,6 +504,17 @@ test_channel_multi(void *arg) global_queue_estimate = channel_get_global_queue_estimate(); test_eq(global_queue_estimate, 512); + /* + * Since the fake channels aren't registered, channel_free_all() can't + * see them properly. + */ + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + channel_mark_for_close(ch1); + UNMOCK(scheduler_release_channel); + + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 0); + /* Now free everything */ MOCK(scheduler_release_channel, scheduler_release_channel_mock); channel_free_all();

1 0

[tor/master] Implement channel queue size estimate unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 6e427c30af389fdc15ae3a8d946a46ad5803688c Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Dec 18 13:42:02 2013 -0800 Implement channel queue size estimate unit test --- src/test/test_channel.c | 143 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index c4241db..08abd96 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -18,11 +18,13 @@ static int test_chan_accept_cells = 0; static int test_cells_written = 0; static int test_destroy_not_pending_calls = 0; +static double test_overhead_estimate = 1.0f; static void channel_note_destroy_not_pending_mock(channel_t *ch, circid_t circid); static void chan_test_close(channel_t *ch); static size_t chan_test_num_bytes_queued(channel_t *ch); +static int chan_test_num_cells_writeable(channel_t *ch); static int chan_test_write_cell(channel_t *ch, cell_t *cell); static int chan_test_write_packed_cell(channel_t *ch, packed_cell_t *packed_cell); @@ -31,6 +33,7 @@ static void make_fake_cell(cell_t *c); static void make_fake_var_cell(var_cell_t *c); static channel_t * new_fake_channel(void); static void scheduler_release_channel_mock(channel_t *ch); +static void test_channel_queue_size(void *arg); static void test_channel_write(void *arg); static void @@ -52,6 +55,15 @@ chan_test_close(channel_t *ch) return; } +static double +chan_test_get_overhead_estimate(channel_t *ch) +{ + test_assert(ch); + + done: + return test_overhead_estimate; +} + static size_t chan_test_num_bytes_queued(channel_t *ch) { @@ -62,6 +74,15 @@ chan_test_num_bytes_queued(channel_t *ch) } static int +chan_test_num_cells_writeable(channel_t *ch) +{ + test_assert(ch); + + done: + return 32; +} + +static int chan_test_write_cell(channel_t *ch, cell_t *cell) { int rv = 0; @@ -156,7 +177,9 @@ new_fake_channel(void) channel_init(chan); chan->close = chan_test_close; + chan->get_overhead_estimate = chan_test_get_overhead_estimate; chan->num_bytes_queued = chan_test_num_bytes_queued; + chan->num_cells_writeable = chan_test_num_cells_writeable; chan->write_cell = chan_test_write_cell; chan->write_packed_cell = chan_test_write_packed_cell; chan->write_var_cell = chan_test_write_var_cell; @@ -177,6 +200,125 @@ scheduler_release_channel_mock(channel_t *ch) } static void +test_channel_queue_size(void *arg) +{ + channel_t *ch = NULL; + cell_t *cell = NULL; + int n, old_count; + uint64_t global_queue_estimate; + + (void)arg; + + ch = new_fake_channel(); + test_assert(ch); + + /* Initial queue size update */ + channel_update_xmit_queue_size(ch); + test_eq(ch->bytes_queued_for_xmit, 0); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 0); + + /* Test the call-through to our fake lower layer */ + n = channel_num_cells_writeable(ch); + /* chan_test_num_cells_writeable() always returns 32 */ + test_eq(n, 32); + + /* + * Now we queue some cells and check that channel_num_cells_writeable() + * adjusts properly + */ + + /* tell it not to accept cells */ + test_chan_accept_cells = 0; + /* ...and keep it from trying to flush the queue */ + ch->state = CHANNEL_STATE_MAINT; + + /* Get a fresh cell */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + + old_count = test_cells_written; + channel_write_cell(ch, cell); + /* Assert that it got queued, not written through, correctly */ + test_eq(test_cells_written, old_count); + + /* Now check chan_test_num_cells_writeable() again */ + n = channel_num_cells_writeable(ch); + test_eq(n, 0); /* Should return 0 since we're in CHANNEL_STATE_MAINT */ + + /* Update queue size estimates */ + channel_update_xmit_queue_size(ch); + /* One cell, times an overhead factor of 1.0 */ + test_eq(ch->bytes_queued_for_xmit, 512); + /* Try a different overhead factor */ + test_overhead_estimate = 0.5f; + /* This one should be ignored since it's below 1.0 */ + channel_update_xmit_queue_size(ch); + test_eq(ch->bytes_queued_for_xmit, 512); + /* Now try a larger one */ + test_overhead_estimate = 2.0f; + channel_update_xmit_queue_size(ch); + test_eq(ch->bytes_queued_for_xmit, 1024); + /* Go back to 1.0 */ + test_overhead_estimate = 1.0f; + channel_update_xmit_queue_size(ch); + test_eq(ch->bytes_queued_for_xmit, 512); + /* Check the global estimate too */ + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 512); + + /* Go to open */ + old_count = test_cells_written; + channel_change_state(ch, CHANNEL_STATE_OPEN); + + /* + * It should try to write, but we aren't accepting cells right now, so + * it'll requeue + */ + test_eq(test_cells_written, old_count); + + /* Check the queue size again */ + channel_update_xmit_queue_size(ch); + test_eq(ch->bytes_queued_for_xmit, 512); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 512); + + /* + * Now the cell is in the queue, and we're open, so we should get 31 + * writeable cells. + */ + n = channel_num_cells_writeable(ch); + test_eq(n, 31); + + /* Accept cells again */ + test_chan_accept_cells = 1; + /* ...and re-process the queue */ + old_count = test_cells_written; + channel_flush_cells(ch); + test_eq(test_cells_written, old_count + 1); + + /* Should have 32 writeable now */ + n = channel_num_cells_writeable(ch); + test_eq(n, 32); + + /* Should have queue size estimate of zero */ + channel_update_xmit_queue_size(ch); + test_eq(ch->bytes_queued_for_xmit, 0); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 0); + + /* Okay, now we're done with this one */ + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + channel_mark_for_close(ch); + UNMOCK(scheduler_release_channel); + + done: + tor_free(ch); + + return; +} + +static void test_channel_write(void *arg) { channel_t *ch = NULL; @@ -289,6 +431,7 @@ test_channel_write(void *arg) } struct testcase_t channel_tests[] = { + { "queue_size", test_channel_queue_size, TT_FORK, NULL, NULL }, { "write", test_channel_write, TT_FORK, NULL, NULL }, END_OF_TESTCASES };

1 0

[tor/master] Unit tests for channel_get_cell_queue_entry_size() and channel_write_*() functions
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 6d886787e3e112693dc8ac9cda021c93eaefee8b Author: Andrea Shepard <andrea(a)torproject.org> Date: Fri Dec 13 06:34:46 2013 -0800 Unit tests for channel_get_cell_queue_entry_size() and channel_write_*() functions --- src/test/Makefile.nmake | 2 +- src/test/include.am | 1 + src/test/test.c | 3 + src/test/test_channel.c | 295 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 300 insertions(+), 1 deletion(-) diff --git a/src/test/Makefile.nmake b/src/test/Makefile.nmake index 822431f..fceef99 100644 --- a/src/test/Makefile.nmake +++ b/src/test/Makefile.nmake @@ -11,7 +11,7 @@ LIBS = ..\..\..\build-alpha\lib\libevent.lib \ ws2_32.lib advapi32.lib shell32.lib \ crypt32.lib gdi32.lib user32.lib -TEST_OBJECTS = test.obj test_addr.obj test_containers.obj \ +TEST_OBJECTS = test.obj test_addr.obj test_channel.obj test_containers.obj \ test_controller_events.ogj test_crypto.obj test_data.obj test_dir.obj \ test_microdesc.obj test_pt.obj test_util.obj test_config.obj \ test_cell_formats.obj test_replay.obj test_introduce.obj tinytest.obj \ diff --git a/src/test/include.am b/src/test/include.am index 77c92f1..547f23b 100644 --- a/src/test/include.am +++ b/src/test/include.am @@ -20,6 +20,7 @@ src_test_test_SOURCES = \ src/test/test_addr.c \ src/test/test_buffers.c \ src/test/test_cell_formats.c \ + src/test/test_channel.c \ src/test/test_circuitlist.c \ src/test/test_circuitmux.c \ src/test/test_containers.c \ diff --git a/src/test/test.c b/src/test/test.c index cfbe203..4d4f6f2 100644 --- a/src/test/test.c +++ b/src/test/test.c @@ -1308,6 +1308,8 @@ extern struct testcase_t oom_tests[]; extern struct testcase_t policy_tests[]; extern struct testcase_t status_tests[]; extern struct testcase_t routerset_tests[]; +extern struct testcase_t router_tests[]; +extern struct testcase_t channel_tests[]; static struct testgroup_t testgroups[] = { { "", test_array }, @@ -1340,6 +1342,7 @@ static struct testgroup_t testgroups[] = { { "policy/" , policy_tests }, { "status/" , status_tests }, { "routerset/" , routerset_tests }, + { "channel/", channel_tests }, END_OF_GROUPS }; diff --git a/src/test/test_channel.c b/src/test/test_channel.c new file mode 100644 index 0000000..c4241db --- /dev/null +++ b/src/test/test_channel.c @@ -0,0 +1,295 @@ +/* Copyright (c) 2013, The Tor Project, Inc. */ +/* See LICENSE for licensing information */ + +#define TOR_CHANNEL_INTERNAL_ +#include "or.h" +#include "channel.h" +/* For channel_note_destroy_not_pending */ +#include "circuitlist.h" +/* For var_cell_free */ +#include "connection_or.h" +/* For packed_cell stuff */ +#define RELAY_PRIVATE +#include "relay.h" +/* For init/free stuff */ +#include "scheduler.h" +#include "test.h" + +static int test_chan_accept_cells = 0; +static int test_cells_written = 0; +static int test_destroy_not_pending_calls = 0; + +static void channel_note_destroy_not_pending_mock(channel_t *ch, + circid_t circid); +static void chan_test_close(channel_t *ch); +static size_t chan_test_num_bytes_queued(channel_t *ch); +static int chan_test_write_cell(channel_t *ch, cell_t *cell); +static int chan_test_write_packed_cell(channel_t *ch, + packed_cell_t *packed_cell); +static int chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell); +static void make_fake_cell(cell_t *c); +static void make_fake_var_cell(var_cell_t *c); +static channel_t * new_fake_channel(void); +static void scheduler_release_channel_mock(channel_t *ch); +static void test_channel_write(void *arg); + +static void +channel_note_destroy_not_pending_mock(channel_t *ch, + circid_t circid) +{ + (void)ch; + (void)circid; + + ++test_destroy_not_pending_calls; +} + +static void +chan_test_close(channel_t *ch) +{ + test_assert(ch); + + done: + return; +} + +static size_t +chan_test_num_bytes_queued(channel_t *ch) +{ + test_assert(ch); + + done: + return 0; +} + +static int +chan_test_write_cell(channel_t *ch, cell_t *cell) +{ + int rv = 0; + + test_assert(ch); + test_assert(cell); + + if (test_chan_accept_cells) { + /* Free the cell and bump the counter */ + tor_free(cell); + ++test_cells_written; + rv = 1; + } + /* else return 0, we didn't accept it */ + + done: + return rv; +} + +static int +chan_test_write_packed_cell(channel_t *ch, + packed_cell_t *packed_cell) +{ + int rv = 0; + + test_assert(ch); + test_assert(packed_cell); + + if (test_chan_accept_cells) { + /* Free the cell and bump the counter */ + packed_cell_free(packed_cell); + ++test_cells_written; + rv = 1; + } + /* else return 0, we didn't accept it */ + + done: + return rv; +} + +static int +chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell) +{ + int rv = 0; + + test_assert(ch); + test_assert(var_cell); + + if (test_chan_accept_cells) { + /* Free the cell and bump the counter */ + var_cell_free(var_cell); + ++test_cells_written; + rv = 1; + } + /* else return 0, we didn't accept it */ + + done: + return rv; +} + +static void +make_fake_cell(cell_t *c) +{ + test_assert(c != NULL); + + c->circ_id = 1; + c->command = CELL_RELAY; + memset(c->payload, 0, CELL_PAYLOAD_SIZE); + + done: + return; +} + +static void +make_fake_var_cell(var_cell_t *c) +{ + test_assert(c != NULL); + + c->circ_id = 1; + c->command = CELL_VERSIONS; + c->payload_len = CELL_PAYLOAD_SIZE / 2; + memset(c->payload, 0, c->payload_len); + + done: + return; +} + +static channel_t * +new_fake_channel(void) +{ + channel_t *chan = tor_malloc_zero(sizeof(channel_t)); + channel_init(chan); + + chan->close = chan_test_close; + chan->num_bytes_queued = chan_test_num_bytes_queued; + chan->write_cell = chan_test_write_cell; + chan->write_packed_cell = chan_test_write_packed_cell; + chan->write_var_cell = chan_test_write_var_cell; + chan->state = CHANNEL_STATE_OPEN; + + return chan; +} + +static void +scheduler_release_channel_mock(channel_t *ch) +{ + (void)ch; + + /* Increment counter */ + ++test_releases_count; + + return; +} + +static void +test_channel_write(void *arg) +{ + channel_t *ch = NULL; + cell_t *cell = tor_malloc_zero(sizeof(cell_t)); + packed_cell_t *packed_cell = NULL; + var_cell_t *var_cell = + tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); + int old_count; + + (void)arg; + + init_cell_pool(); + + packed_cell = packed_cell_new(); + test_assert(packed_cell); + + ch = new_fake_channel(); + test_assert(ch); + make_fake_cell(cell); + make_fake_var_cell(var_cell); + + /* Tell it to accept cells */ + test_chan_accept_cells = 1; + + old_count = test_cells_written; + channel_write_cell(ch, cell); + test_assert(test_cells_written == old_count + 1); + + channel_write_var_cell(ch, var_cell); + test_assert(test_cells_written == old_count + 2); + + channel_write_packed_cell(ch, packed_cell); + test_assert(test_cells_written == old_count + 3); + + /* Now we test queueing; tell it not to accept cells */ + test_chan_accept_cells = 0; + /* ...and keep it from trying to flush the queue */ + ch->state = CHANNEL_STATE_MAINT; + + /* Get a fresh cell */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + + old_count = test_cells_written; + channel_write_cell(ch, cell); + test_assert(test_cells_written == old_count); + + /* + * Now change back to open with channel_change_state() and assert that it + * gets drained from the queue. + */ + test_chan_accept_cells = 1; + channel_change_state(ch, CHANNEL_STATE_OPEN); + test_assert(test_cells_written == old_count + 1); + + /* + * Check the note destroy case + */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + cell->command = CELL_DESTROY; + + /* Set up the mock */ + MOCK(channel_note_destroy_not_pending, + channel_note_destroy_not_pending_mock); + + old_count = test_destroy_not_pending_calls; + channel_write_cell(ch, cell); + test_assert(test_destroy_not_pending_calls == old_count + 1); + + /* Now send a non-destroy and check we don't call it */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch, cell); + test_assert(test_destroy_not_pending_calls == old_count + 1); + + UNMOCK(channel_note_destroy_not_pending); + + /* + * Now switch it to CLOSING so we can test the discard-cells case + * in the channel_write_*() functions. + */ + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + channel_mark_for_close(ch); + UNMOCK(scheduler_release_channel); + + /* Send cells that will drop in the closing state */ + old_count = test_cells_written; + + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch, cell); + test_assert(test_cells_written == old_count); + + var_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); + make_fake_var_cell(var_cell); + channel_write_var_cell(ch, var_cell); + test_assert(test_cells_written == old_count); + + packed_cell = packed_cell_new(); + channel_write_packed_cell(ch, packed_cell); + test_assert(test_cells_written == old_count); + + free_cell_pool(); + + done: + tor_free(ch); + + return; +} + +struct testcase_t channel_tests[] = { + { "write", test_channel_write, TT_FORK, NULL, NULL }, + END_OF_TESTCASES +}; +

1 0

← Newer
1
...
5
6
7
8
9
10
11
...
96
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits November 2014