November 2014 - tor-commits - lists.torproject.org

[tor/master] Expose a useful mock from test_channel.c
by nickm＠torproject.org 27 Nov '14

27 Nov '14

commit bef11b715637ad28f6c8802adf6893e050c05d0a Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 00:58:27 2014 -0800 Expose a useful mock from test_channel.c --- src/test/fakechans.h | 3 +++ src/test/test_channel.c | 3 +-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/test/fakechans.h b/src/test/fakechans.h index b474810..99773e7 100644 --- a/src/test/fakechans.h +++ b/src/test/fakechans.h @@ -13,4 +13,7 @@ void make_fake_cell(cell_t *c); void make_fake_var_cell(var_cell_t *c); channel_t * new_fake_channel(void); +/* Also exposes some a mock used by both test_channel.c and test_relay.c */ +void scheduler_release_channel_mock(channel_t *ch); + #endif /* !defined(TOR_FAKECHANS_H) */ diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 1ab7f32..1ae9810 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -35,7 +35,6 @@ 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 scheduler_channel_doesnt_want_writes_mock(channel_t *ch); -static void scheduler_release_channel_mock(channel_t *ch); static void test_channel_flush(void *arg); static void test_channel_lifecycle(void *arg); @@ -218,7 +217,7 @@ scheduler_channel_doesnt_want_writes_mock(channel_t *ch) return; } -static void +void scheduler_release_channel_mock(channel_t *ch) { (void)ch;

1 0

[tor/master] Implement channel flush unit test
by nickm＠torproject.org 27 Nov '14

27 Nov '14

commit ba294ff2dcdbf75c49a478cd9f0ad20fc0ad4b50 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Dec 18 17:07:54 2013 -0800 Implement channel flush unit test --- src/test/test_channel.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index c47d292..9e6ef17 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -37,6 +37,7 @@ 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); +static void test_channel_flush(void *arg); static void test_channel_lifecycle(void *arg); static void test_channel_multi(void *arg); static void test_channel_queue_size(void *arg); @@ -217,6 +218,65 @@ scheduler_release_channel_mock(channel_t *ch) } static void +test_channel_flush(void *arg) +{ + channel_t *ch = NULL; + cell_t *cell = NULL; + packed_cell_t *p_cell = NULL; + var_cell_t *v_cell = NULL; + int init_count; + + (void)arg; + + init_cell_pool(); + + ch = new_fake_channel(); + test_assert(ch); + + /* Cache the original count */ + init_count = test_cells_written; + + /* Stop accepting so we can queue some */ + test_chan_accept_cells = 0; + + /* Queue a regular cell */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch, cell); + /* It should be queued, so assert that we didn't write it */ + test_eq(test_cells_written, init_count); + + /* Queue a var cell */ + v_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); + make_fake_var_cell(v_cell); + channel_write_var_cell(ch, v_cell); + /* It should be queued, so assert that we didn't write it */ + test_eq(test_cells_written, init_count); + + /* Try a packed cell now */ + p_cell = packed_cell_new(); + test_assert(p_cell); + channel_write_packed_cell(ch, p_cell); + /* It should be queued, so assert that we didn't write it */ + test_eq(test_cells_written, init_count); + + /* Now allow writes through again */ + test_chan_accept_cells = 1; + + /* ...and flush */ + channel_flush_cells(ch); + + /* All three should have gone through */ + test_eq(test_cells_written, init_count + 3); + + done: + tor_free(ch); + free_cell_pool(); + + return; +} + +static void test_channel_lifecycle(void *arg) { channel_t *ch1 = NULL, *ch2 = NULL; @@ -676,6 +736,7 @@ test_channel_write(void *arg) } struct testcase_t channel_tests[] = { + { "flush", test_channel_flush, TT_FORK, NULL, NULL }, { "lifecycle", test_channel_lifecycle, TT_FORK, NULL, NULL }, { "multi", test_channel_multi, TT_FORK, NULL, NULL }, { "queue_size", test_channel_queue_size, TT_FORK, NULL, NULL },

1 0

[tor/master] Implement two-channel queue estimate test
by nickm＠torproject.org 27 Nov '14

27 Nov '14

commit e00fde17975810d7cc420fb185dd84591f89b7a5 Author: Andrea Shepard <andrea(a)torproject.org> Date: Wed Dec 18 15:04:00 2013 -0800 Implement two-channel queue estimate test --- src/test/test_channel.c | 133 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 08abd96..acbfca1 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -33,6 +33,8 @@ 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_multi(void *arg); static void test_channel_queue_size(void *arg); static void test_channel_write(void *arg); @@ -200,6 +202,136 @@ scheduler_release_channel_mock(channel_t *ch) } static void +test_channel_multi(void *arg) +{ + channel_t *ch1 = NULL, *ch2 = NULL; + uint64_t global_queue_estimate; + cell_t *cell = NULL; + + (void)arg; + + /* Accept cells to lower layer */ + test_chan_accept_cells = 1; + /* Use default overhead factor */ + test_overhead_estimate = 1.0f; + + ch1 = new_fake_channel(); + test_assert(ch1); + ch2 = new_fake_channel(); + test_assert(ch2); + + /* Initial queue size update */ + channel_update_xmit_queue_size(ch1); + test_eq(ch1->bytes_queued_for_xmit, 0); + channel_update_xmit_queue_size(ch2); + test_eq(ch2->bytes_queued_for_xmit, 0); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 0); + + /* Queue some cells, check queue estimates */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch1, cell); + + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch2, cell); + + channel_update_xmit_queue_size(ch1); + channel_update_xmit_queue_size(ch2); + test_eq(ch1->bytes_queued_for_xmit, 0); + test_eq(ch2->bytes_queued_for_xmit, 0); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 0); + + /* Stop accepting cells at lower layer */ + test_chan_accept_cells = 0; + + /* Queue some cells and check queue estimates */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch1, cell); + + channel_update_xmit_queue_size(ch1); + test_eq(ch1->bytes_queued_for_xmit, 512); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 512); + + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch2, cell); + + channel_update_xmit_queue_size(ch2); + test_eq(ch2->bytes_queued_for_xmit, 512); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 1024); + + /* Allow cells through again */ + test_chan_accept_cells = 1; + + /* Flush chan 2 */ + channel_flush_cells(ch2); + + /* Update and check queue sizes */ + channel_update_xmit_queue_size(ch1); + channel_update_xmit_queue_size(ch2); + test_eq(ch1->bytes_queued_for_xmit, 512); + test_eq(ch2->bytes_queued_for_xmit, 0); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 512); + + /* Flush chan 1 */ + channel_flush_cells(ch1); + + /* Update and check queue sizes */ + channel_update_xmit_queue_size(ch1); + channel_update_xmit_queue_size(ch2); + test_eq(ch1->bytes_queued_for_xmit, 0); + test_eq(ch2->bytes_queued_for_xmit, 0); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 0); + + /* Now block again */ + test_chan_accept_cells = 0; + + /* Queue some cells */ + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch1, cell); + + cell = tor_malloc_zero(sizeof(cell_t)); + make_fake_cell(cell); + channel_write_cell(ch2, cell); + + /* Check the estimates */ + channel_update_xmit_queue_size(ch1); + channel_update_xmit_queue_size(ch2); + test_eq(ch1->bytes_queued_for_xmit, 512); + test_eq(ch2->bytes_queued_for_xmit, 512); + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 1024); + + /* Now close channel 2; it should be subtracted from the global queue */ + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + channel_mark_for_close(ch2); + UNMOCK(scheduler_release_channel); + + global_queue_estimate = channel_get_global_queue_estimate(); + test_eq(global_queue_estimate, 512); + + /* Now free everything */ + MOCK(scheduler_release_channel, scheduler_release_channel_mock); + channel_free_all(); + UNMOCK(scheduler_release_channel); + + done: + tor_free(ch1); + tor_free(ch2); + + return; +} + +static void test_channel_queue_size(void *arg) { channel_t *ch = NULL; @@ -431,6 +563,7 @@ test_channel_write(void *arg) } struct testcase_t channel_tests[] = { + { "multi", test_channel_multi, TT_FORK, NULL, NULL }, { "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] Make scheduler_channel_doesnt_want_writes() mockable
by nickm＠torproject.org 27 Nov '14

27 Nov '14

commit ade60890d013e8af25f432cca97193bdc8659701 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Jan 21 02:49:21 2014 -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 8a6620b..367480c 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -275,8 +275,8 @@ scheduler_channel_doesnt_want_writes,(channel_t *chan)) /** Mark a channel as having waiting cells */ -void -scheduler_channel_has_waiting_cells(channel_t *chan) +MOCK_IMPL(void, +scheduler_channel_has_waiting_cells,(channel_t *chan)) { int became_pending = 0; diff --git a/src/or/scheduler.h b/src/or/scheduler.h index 0752ae0..7f59ec4 100644 --- a/src/or/scheduler.h +++ b/src/or/scheduler.h @@ -22,7 +22,7 @@ void scheduler_run(void); /* Mark channels as having cells or wanting/not wanting writes */ MOCK_DECL(void,scheduler_channel_doesnt_want_writes,(channel_t *chan)); -void scheduler_channel_has_waiting_cells(channel_t *chan); +MOCK_DECL(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 */

1 0

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

27 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

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

27 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] Expose fake channel utility functions in test suite in fakechans.h, and fix a test_channel.c bug
by nickm＠torproject.org 27 Nov '14

27 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] Make scheduler_channel_doesnt_want_writes() mockable
by nickm＠torproject.org 27 Nov '14

27 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] 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 27 Nov '14

27 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] Implement scheduler_touch_channel()
by nickm＠torproject.org 27 Nov '14

27 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