|
@@ -2047,14 +2047,6 @@ static size_t total_cells_allocated = 0;
|
|
|
/** A memory pool to allocate packed_cell_t objects. */
|
|
|
static mp_pool_t *cell_pool = NULL;
|
|
|
|
|
|
-/** Memory pool to allocate insertion_time_elem_t objects used for cell
|
|
|
- * statistics. */
|
|
|
-static mp_pool_t *it_pool = NULL;
|
|
|
-
|
|
|
-/** Memory pool to allocate insertion_command_elem_t objects used for cell
|
|
|
- * statistics if CELL_STATS events are enabled. */
|
|
|
-static mp_pool_t *ic_pool = NULL;
|
|
|
-
|
|
|
/** Allocate structures to hold cells. */
|
|
|
void
|
|
|
init_cell_pool(void)
|
|
@@ -2073,14 +2065,6 @@ free_cell_pool(void)
|
|
|
mp_pool_destroy(cell_pool);
|
|
|
cell_pool = NULL;
|
|
|
}
|
|
|
- if (it_pool) {
|
|
|
- mp_pool_destroy(it_pool);
|
|
|
- it_pool = NULL;
|
|
|
- }
|
|
|
- if (ic_pool) {
|
|
|
- mp_pool_destroy(ic_pool);
|
|
|
- ic_pool = NULL;
|
|
|
- }
|
|
|
}
|
|
|
|
|
|
/** Free excess storage in cell pool. */
|
|
@@ -2153,57 +2137,6 @@ cell_queue_append(cell_queue_t *queue, packed_cell_t *cell)
|
|
|
++queue->n;
|
|
|
}
|
|
|
|
|
|
-/** Append command of type <b>command</b> in direction to <b>queue</b> for
|
|
|
- * CELL_STATS event. */
|
|
|
-static void
|
|
|
-cell_command_queue_append(cell_queue_t *queue, uint8_t command)
|
|
|
-{
|
|
|
- insertion_command_queue_t *ic_queue = queue->insertion_commands;
|
|
|
- if (!ic_pool)
|
|
|
- ic_pool = mp_pool_new(sizeof(insertion_command_elem_t), 1024);
|
|
|
- if (!ic_queue) {
|
|
|
- ic_queue = tor_malloc_zero(sizeof(insertion_command_queue_t));
|
|
|
- queue->insertion_commands = ic_queue;
|
|
|
- }
|
|
|
- if (ic_queue->last && ic_queue->last->command == command) {
|
|
|
- ic_queue->last->counter++;
|
|
|
- } else {
|
|
|
- insertion_command_elem_t *elem = mp_pool_get(ic_pool);
|
|
|
- elem->next = NULL;
|
|
|
- elem->command = command;
|
|
|
- elem->counter = 1;
|
|
|
- if (ic_queue->last) {
|
|
|
- ic_queue->last->next = elem;
|
|
|
- ic_queue->last = elem;
|
|
|
- } else {
|
|
|
- ic_queue->first = ic_queue->last = elem;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-/** Retrieve oldest command from <b>queue</b> and write it to
|
|
|
- * <b>command</b> for CELL_STATS event. Return 0 for success, -1
|
|
|
- * otherwise. */
|
|
|
-static int
|
|
|
-cell_command_queue_pop(uint8_t *command, cell_queue_t *queue)
|
|
|
-{
|
|
|
- int res = -1;
|
|
|
- insertion_command_queue_t *ic_queue = queue->insertion_commands;
|
|
|
- if (ic_queue && ic_queue->first) {
|
|
|
- insertion_command_elem_t *ic_elem = ic_queue->first;
|
|
|
- ic_elem->counter--;
|
|
|
- if (ic_elem->counter < 1) {
|
|
|
- ic_queue->first = ic_elem->next;
|
|
|
- if (ic_elem == ic_queue->last)
|
|
|
- ic_queue->last = NULL;
|
|
|
- mp_pool_release(ic_elem);
|
|
|
- }
|
|
|
- *command = ic_elem->command;
|
|
|
- res = 0;
|
|
|
- }
|
|
|
- return res;
|
|
|
-}
|
|
|
-
|
|
|
/** Append a newly allocated copy of <b>cell</b> to the end of the
|
|
|
* <b>exitward</b> (or app-ward) <b>queue</b> of <b>circ</b>. If
|
|
|
* <b>use_stats</b> is true, record statistics about the cell.
|
|
@@ -2215,52 +2148,12 @@ cell_queue_append_packed_copy(circuit_t *circ, cell_queue_t *queue,
|
|
|
{
|
|
|
struct timeval now;
|
|
|
packed_cell_t *copy = packed_cell_copy(cell, wide_circ_ids);
|
|
|
+ (void)circ;
|
|
|
+ (void)exitward;
|
|
|
+ (void)use_stats;
|
|
|
tor_gettimeofday_cached(&now);
|
|
|
copy->inserted_time = (uint32_t)tv_to_msec(&now);
|
|
|
|
|
|
- /* Remember the time when this cell was put in the queue. */
|
|
|
- /*XXXX This may be obsoleted by inserted_time */
|
|
|
- if ((get_options()->CellStatistics ||
|
|
|
- get_options()->TestingEnableCellStatsEvent) && use_stats) {
|
|
|
- uint32_t added;
|
|
|
- insertion_time_queue_t *it_queue = queue->insertion_times;
|
|
|
- if (!it_pool)
|
|
|
- it_pool = mp_pool_new(sizeof(insertion_time_elem_t), 1024);
|
|
|
-
|
|
|
-#define SECONDS_IN_A_DAY 86400L
|
|
|
- added = (uint32_t)(((now.tv_sec % SECONDS_IN_A_DAY) * 100L)
|
|
|
- + ((uint32_t)now.tv_usec / (uint32_t)10000L));
|
|
|
- if (!it_queue) {
|
|
|
- it_queue = tor_malloc_zero(sizeof(insertion_time_queue_t));
|
|
|
- queue->insertion_times = it_queue;
|
|
|
- }
|
|
|
- if (it_queue->last && it_queue->last->insertion_time == added) {
|
|
|
- it_queue->last->counter++;
|
|
|
- } else {
|
|
|
- insertion_time_elem_t *elem = mp_pool_get(it_pool);
|
|
|
- elem->next = NULL;
|
|
|
- elem->insertion_time = added;
|
|
|
- elem->counter = 1;
|
|
|
- if (it_queue->last) {
|
|
|
- it_queue->last->next = elem;
|
|
|
- it_queue->last = elem;
|
|
|
- } else {
|
|
|
- it_queue->first = it_queue->last = elem;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /* Remember that we added a cell to the queue, and remember the cell
|
|
|
- * command. */
|
|
|
- if (get_options()->TestingEnableCellStatsEvent && circ) {
|
|
|
- testing_cell_stats_entry_t *ent =
|
|
|
- tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
|
|
|
- ent->command = cell->command;
|
|
|
- ent->exitward = exitward;
|
|
|
- if (!circ->testing_cell_stats)
|
|
|
- circ->testing_cell_stats = smartlist_new();
|
|
|
- smartlist_add(circ->testing_cell_stats, ent);
|
|
|
- cell_command_queue_append(queue, cell->command);
|
|
|
- }
|
|
|
cell_queue_append(queue, copy);
|
|
|
}
|
|
|
|
|
@@ -2283,14 +2176,6 @@ cell_queue_clear(cell_queue_t *queue)
|
|
|
}
|
|
|
TOR_SIMPLEQ_INIT(&queue->head);
|
|
|
queue->n = 0;
|
|
|
- if (queue->insertion_times) {
|
|
|
- while (queue->insertion_times->first) {
|
|
|
- insertion_time_elem_t *elem = queue->insertion_times->first;
|
|
|
- queue->insertion_times->first = elem->next;
|
|
|
- mp_pool_release(elem);
|
|
|
- }
|
|
|
- tor_free(queue->insertion_times);
|
|
|
- }
|
|
|
}
|
|
|
|
|
|
/** Extract and return the cell at the head of <b>queue</b>; return NULL if
|
|
@@ -2311,9 +2196,7 @@ cell_queue_pop(cell_queue_t *queue)
|
|
|
size_t
|
|
|
packed_cell_mem_cost(void)
|
|
|
{
|
|
|
- return sizeof(packed_cell_t) + MP_POOL_ITEM_OVERHEAD +
|
|
|
- get_options()->CellStatistics ?
|
|
|
- (sizeof(insertion_time_elem_t)+MP_POOL_ITEM_OVERHEAD) : 0;
|
|
|
+ return sizeof(packed_cell_t) + MP_POOL_ITEM_OVERHEAD;
|
|
|
}
|
|
|
|
|
|
/** Check whether we've got too much space used for cells. If so,
|
|
@@ -2443,6 +2326,17 @@ set_streams_blocked_on_circ(circuit_t *circ, channel_t *chan,
|
|
|
return n;
|
|
|
}
|
|
|
|
|
|
+/** Extract the command from a packed cell. */
|
|
|
+static uint8_t
|
|
|
+packed_cell_get_command(const packed_cell_t *cell, int wide_circ_ids)
|
|
|
+{
|
|
|
+ if (wide_circ_ids) {
|
|
|
+ return get_uint8(cell->body+4);
|
|
|
+ } else {
|
|
|
+ return get_uint8(cell->body+2);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
/** Pull as many cells as possible (but no more than <b>max</b>) from the
|
|
|
* queue of the first active circuit on <b>chan</b>, and write them to
|
|
|
* <b>chan</b>->outbuf. Return the number of cells written. Advance
|
|
@@ -2504,55 +2398,30 @@ channel_flush_from_first_active_circuit(channel_t *chan, int max)
|
|
|
/* Calculate the exact time that this cell has spent in the queue. */
|
|
|
if (get_options()->CellStatistics ||
|
|
|
get_options()->TestingEnableCellStatsEvent) {
|
|
|
+ uint32_t msec_waiting;
|
|
|
struct timeval tvnow;
|
|
|
- uint32_t flushed;
|
|
|
- uint32_t cell_waiting_time;
|
|
|
- insertion_time_queue_t *it_queue = queue->insertion_times;
|
|
|
tor_gettimeofday_cached(&tvnow);
|
|
|
- flushed = (uint32_t)((tvnow.tv_sec % SECONDS_IN_A_DAY) * 100L +
|
|
|
- (uint32_t)tvnow.tv_usec / (uint32_t)10000L);
|
|
|
- if (!it_queue || !it_queue->first) {
|
|
|
- log_info(LD_GENERAL, "Cannot determine insertion time of cell. "
|
|
|
- "Looks like the CellStatistics option was "
|
|
|
- "recently enabled.");
|
|
|
- } else {
|
|
|
- insertion_time_elem_t *elem = it_queue->first;
|
|
|
- cell_waiting_time =
|
|
|
- (uint32_t)((flushed * 10L + SECONDS_IN_A_DAY * 1000L -
|
|
|
- elem->insertion_time * 10L) %
|
|
|
- (SECONDS_IN_A_DAY * 1000L));
|
|
|
-#undef SECONDS_IN_A_DAY
|
|
|
- elem->counter--;
|
|
|
- if (elem->counter < 1) {
|
|
|
- it_queue->first = elem->next;
|
|
|
- if (elem == it_queue->last)
|
|
|
- it_queue->last = NULL;
|
|
|
- mp_pool_release(elem);
|
|
|
- }
|
|
|
- if (get_options()->CellStatistics && !CIRCUIT_IS_ORIGIN(circ)) {
|
|
|
- or_circ = TO_OR_CIRCUIT(circ);
|
|
|
- or_circ->total_cell_waiting_time += cell_waiting_time;
|
|
|
- or_circ->processed_cells++;
|
|
|
- }
|
|
|
- if (get_options()->TestingEnableCellStatsEvent) {
|
|
|
- uint8_t command;
|
|
|
- if (cell_command_queue_pop(&command, queue) < 0) {
|
|
|
- log_info(LD_GENERAL, "Cannot determine command of cell. "
|
|
|
- "Looks like the CELL_STATS event was "
|
|
|
- "recently enabled.");
|
|
|
- } else {
|
|
|
- testing_cell_stats_entry_t *ent =
|
|
|
- tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
|
|
|
- ent->command = command;
|
|
|
- ent->waiting_time = (unsigned int)cell_waiting_time / 10;
|
|
|
- ent->removed = 1;
|
|
|
- if (circ->n_chan == chan)
|
|
|
- ent->exitward = 1;
|
|
|
- if (!circ->testing_cell_stats)
|
|
|
- circ->testing_cell_stats = smartlist_new();
|
|
|
- smartlist_add(circ->testing_cell_stats, ent);
|
|
|
- }
|
|
|
- }
|
|
|
+ msec_waiting = ((uint32_t)tv_to_msec(&tvnow)) - cell->inserted_time;
|
|
|
+
|
|
|
+ if (get_options()->CellStatistics && !CIRCUIT_IS_ORIGIN(circ)) {
|
|
|
+ or_circ = TO_OR_CIRCUIT(circ);
|
|
|
+ or_circ->total_cell_waiting_time += msec_waiting;
|
|
|
+ or_circ->processed_cells++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (get_options()->TestingEnableCellStatsEvent) {
|
|
|
+ uint8_t command = packed_cell_get_command(cell, chan->wide_circ_ids);
|
|
|
+
|
|
|
+ testing_cell_stats_entry_t *ent =
|
|
|
+ tor_malloc_zero(sizeof(testing_cell_stats_entry_t));
|
|
|
+ ent->command = command;
|
|
|
+ ent->waiting_time = msec_waiting / 10;
|
|
|
+ ent->removed = 1;
|
|
|
+ if (circ->n_chan == chan)
|
|
|
+ ent->exitward = 1;
|
|
|
+ if (!circ->testing_cell_stats)
|
|
|
+ circ->testing_cell_stats = smartlist_new();
|
|
|
+ smartlist_add(circ->testing_cell_stats, ent);
|
|
|
}
|
|
|
}
|
|
|
|