#include <vlib/vlib.h>
#include <vlib/threads.h>
+#include <vnet/classify/vnet_classify.h>
-u8 *vnet_trace_dummy;
+u8 *vnet_trace_placeholder;
/* Helper function for nodes which only trace buffer data. */
void
}
/* Free up all trace buffer memory. */
-always_inline void
+void
clear_trace_buffer (void)
{
int i;
vlib_trace_main_t *tm;
- /* *INDENT-OFF* */
- foreach_vlib_main (
- ({
- tm = &this_vlib_main->trace_main;
+ foreach_vlib_main ()
+ {
+ tm = &this_vlib_main->trace_main;
- tm->trace_enable = 0;
+ tm->trace_enable = 0;
+ vec_free (tm->nodes);
+ }
- for (i = 0; i < vec_len (tm->trace_buffer_pool); i++)
- if (! pool_is_free_index (tm->trace_buffer_pool, i))
- vec_free (tm->trace_buffer_pool[i]);
- pool_free (tm->trace_buffer_pool);
- }));
- /* *INDENT-ON* */
+ foreach_vlib_main ()
+ {
+ tm = &this_vlib_main->trace_main;
+
+ for (i = 0; i < vec_len (tm->trace_buffer_pool); i++)
+ if (!pool_is_free_index (tm->trace_buffer_pool, i))
+ vec_free (tm->trace_buffer_pool[i]);
+ pool_free (tm->trace_buffer_pool);
+ }
}
u8 *
};
/* *INDENT-ON* */
-static int
-trace_cmp (void *a1, void *a2)
+int
+trace_time_cmp (void *a1, void *a2)
{
vlib_trace_header_t **t1 = a1;
vlib_trace_header_t **t2 = a2;
if (tm->filter_flag == 0)
return 1;
+ /*
+ * When capturing a post-mortem dispatch trace,
+ * toss all existing traces once per dispatch cycle.
+ * So we can trace 4 billion pkts without running out of
+ * memory...
+ */
+ if (tm->filter_flag == FILTER_FLAG_POST_MORTEM)
+ return 0;
+
if (tm->filter_flag == FILTER_FLAG_INCLUDE)
{
while (h < e)
*/
n_accepted = 0;
/* *INDENT-OFF* */
- pool_foreach (h, tm->trace_buffer_pool,
- ({
+ pool_foreach (h, tm->trace_buffer_pool)
+ {
accept = filter_accept(tm, h[0]);
if ((n_accepted == tm->filter_count) || !accept)
vec_add1 (traces_to_remove, h);
else
n_accepted++;
- }));
+ }
/* *INDENT-ON* */
/* remove all traces that we don't want to keep */
for (index = 0; index < vec_len (traces_to_remove); index++)
{
trace_index = traces_to_remove[index] - tm->trace_buffer_pool;
- _vec_len (tm->trace_buffer_pool[trace_index]) = 0;
+ vec_set_len (tm->trace_buffer_pool[trace_index], 0);
pool_put_index (tm->trace_buffer_pool, trace_index);
}
/* Get active traces from pool. */
- /* *INDENT-OFF* */
- foreach_vlib_main (
- ({
- fmt = "------------------- Start of thread %d %s -------------------\n";
- s = format (s, fmt, index, vlib_worker_threads[index].name);
-
- tm = &this_vlib_main->trace_main;
-
- trace_apply_filter(this_vlib_main);
-
- traces = 0;
- pool_foreach (h, tm->trace_buffer_pool,
- ({
- vec_add1 (traces, h[0]);
- }));
-
- if (vec_len (traces) == 0)
- {
- s = format (s, "No packets in trace buffer\n");
- goto done;
- }
-
- /* Sort them by increasing time. */
- vec_sort_with_function (traces, trace_cmp);
-
- for (i = 0; i < vec_len (traces); i++)
- {
- if (i == max)
- {
- vlib_cli_output (vm, "Limiting display to %d packets."
- " To display more specify max.", max);
- goto done;
- }
-
- s = format (s, "Packet %d\n%U\n\n", i + 1,
- format_vlib_trace, vm, traces[i]);
- }
-
- done:
- vec_free (traces);
-
- index++;
- }));
- /* *INDENT-ON* */
+ foreach_vlib_main ()
+ {
+ fmt = "------------------- Start of thread %d %s -------------------\n";
+ s = format (s, fmt, index, vlib_worker_threads[index].name);
+
+ tm = &this_vlib_main->trace_main;
+
+ trace_apply_filter (this_vlib_main);
+
+ traces = 0;
+ pool_foreach (h, tm->trace_buffer_pool)
+ {
+ vec_add1 (traces, h[0]);
+ }
+
+ if (vec_len (traces) == 0)
+ {
+ s = format (s, "No packets in trace buffer\n");
+ goto done;
+ }
+
+ /* Sort them by increasing time. */
+ vec_sort_with_function (traces, trace_time_cmp);
+
+ for (i = 0; i < vec_len (traces); i++)
+ {
+ if (i == max)
+ {
+ char *warn = "Limiting display to %d packets."
+ " To display more specify max.";
+ vlib_cli_output (vm, warn, max);
+ s = format (s, warn, max);
+ goto done;
+ }
+
+ s = format (s, "Packet %d\n%U\n\n", i + 1, format_vlib_trace, vm,
+ traces[i]);
+ }
+
+ done:
+ vec_free (traces);
+
+ index++;
+ }
vlib_cli_output (vm, "%v", s);
vec_free (s);
/* *INDENT-ON* */
int vlib_enable_disable_pkt_trace_filter (int enable) __attribute__ ((weak));
+
int
vlib_enable_disable_pkt_trace_filter (int enable)
{
return 0;
}
+void
+vlib_trace_stop_and_clear (void)
+{
+ vlib_enable_disable_pkt_trace_filter (0); /* disble tracing */
+ clear_trace_buffer ();
+}
+
+
+void
+trace_update_capture_options (u32 add, u32 node_index, u32 filter, u8 verbose)
+{
+ vlib_trace_main_t *tm;
+ vlib_trace_node_t *tn;
+
+ if (add == ~0)
+ add = 50;
+
+ foreach_vlib_main ()
+ {
+ tm = &this_vlib_main->trace_main;
+ tm->verbose = verbose;
+ vec_validate (tm->nodes, node_index);
+ tn = tm->nodes + node_index;
+
+ /*
+ * Adding 0 makes no real sense, and there wa no other way
+ * to explicilty zero-out the limits and count, so make
+ * an "add 0" request really be "set to 0".
+ */
+ if (add == 0)
+ tn->limit = tn->count = 0;
+ else
+ tn->limit += add;
+ }
+
+ foreach_vlib_main ()
+ {
+ tm = &this_vlib_main->trace_main;
+ tm->trace_enable = 1;
+ }
+
+ vlib_enable_disable_pkt_trace_filter (! !filter);
+}
+
static clib_error_t *
cli_add_trace_buffer (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
- vlib_trace_main_t *tm;
vlib_node_t *node;
- vlib_trace_node_t *tn;
u32 node_index, add;
u8 verbose = 0;
int filter = 0;
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
- if (vnet_trace_dummy == 0)
- vec_validate_aligned (vnet_trace_dummy, 2048, CLIB_CACHE_LINE_BYTES);
+ if (vnet_trace_placeholder == 0)
+ vec_validate_aligned (vnet_trace_placeholder, 2048,
+ CLIB_CACHE_LINE_BYTES);
while (unformat_check_input (line_input) != (uword) UNFORMAT_END_OF_INPUT)
{
goto done;
}
- if (filter)
+ u32 filter_table = classify_get_trace_chain ();
+ if (filter && filter_table == ~0)
{
- if (vlib_enable_disable_pkt_trace_filter (1 /* enable */ ))
- {
- error = clib_error_create ("No packet trace filter configured...");
- goto done;
- }
+ error = clib_error_create ("No packet trace filter configured...");
+ goto done;
}
- /* *INDENT-OFF* */
- foreach_vlib_main ((
- {
- tm = &this_vlib_main->trace_main;
- tm->verbose = verbose;
- vec_validate (tm->nodes, node_index);
- tn = tm->nodes + node_index;
- tn->limit += add;
- tm->trace_enable = 1;
- }));
- /* *INDENT-ON* */
+ trace_update_capture_options (add, node_index, filter, verbose);
done:
unformat_free (line_input);
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (add_trace_cli,static) = {
.path = "trace add",
- .short_help = "Trace given number of packets",
+ .short_help = "trace add <input-graph-node> <add'l-pkts-for-node-> [filter] [verbose]",
.function = cli_add_trace_buffer,
};
/* *INDENT-ON* */
* criteria (e.g. input sw_if_index, mac address) but for now just checks if
* a specified node is in the trace or not in the trace.
*/
+
+void
+trace_filter_set (u32 node_index, u32 flag, u32 count)
+{
+ foreach_vlib_main ()
+ {
+ vlib_trace_main_t *tm;
+
+ tm = &this_vlib_main->trace_main;
+ tm->filter_node_index = node_index;
+ tm->filter_flag = flag;
+ tm->filter_count = count;
+
+ /*
+ * Clear the trace limits to stop any in-progress tracing
+ * Prevents runaway trace allocations when the filter changes
+ * (or is removed)
+ */
+ vec_free (tm->nodes);
+ }
+}
+
+
static clib_error_t *
cli_filter_trace (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
- vlib_trace_main_t *tm = &vm->trace_main;
u32 filter_node_index;
u32 filter_flag;
u32 filter_count;
("expected 'include NODE COUNT' or 'exclude NODE COUNT' or 'none', got `%U'",
format_unformat_error, input);
- /* *INDENT-OFF* */
- foreach_vlib_main (
- ({
- tm = &this_vlib_main->trace_main;
- tm->filter_node_index = filter_node_index;
- tm->filter_flag = filter_flag;
- tm->filter_count = filter_count;
-
- /*
- * Clear the trace limits to stop any in-progress tracing
- * Prevents runaway trace allocations when the filter changes
- * (or is removed)
- */
- vec_free (tm->nodes);
- }));
- /* *INDENT-ON* */
+ trace_filter_set (filter_node_index, filter_flag, filter_count);
return 0;
}
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (filter_trace_cli,static) = {
.path = "trace filter",
- .short_help = "filter trace output - include NODE COUNT | exclude NODE COUNT | none",
+ .short_help = "trace filter none | [include|exclude] NODE COUNT",
.function = cli_filter_trace,
};
/* *INDENT-ON* */
cli_clear_trace_buffer (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
- vlib_enable_disable_pkt_trace_filter (0 /* enable */ );
- clear_trace_buffer ();
+ vlib_trace_stop_and_clear ();
return 0;
}
};
/* *INDENT-ON* */
-/* Dummy function to get us linked in. */
+/* Placeholder function to get us linked in. */
void
vlib_trace_cli_reference (void)
{
}
-int
-vnet_is_packet_traced (vlib_buffer_t * b,
- u32 classify_table_index, int func)
-__attribute__ ((weak));
+void *
+vlib_add_trace (vlib_main_t * vm,
+ vlib_node_runtime_t * r, vlib_buffer_t * b, u32 n_data_bytes)
+{
+ return vlib_add_trace_inline (vm, r, b, n_data_bytes);
+}
-int
-vnet_is_packet_traced (vlib_buffer_t * b, u32 classify_table_index, int func)
+vlib_is_packet_traced_fn_t *
+vlib_is_packet_traced_function_from_name (const char *name)
+{
+ vlib_trace_filter_function_registration_t *reg =
+ vlib_trace_filter_main.trace_filter_registration;
+ while (reg)
+ {
+ if (clib_strcmp (reg->name, name) == 0)
+ break;
+ reg = reg->next;
+ }
+ if (!reg)
+ return 0;
+ return reg->function;
+}
+
+vlib_is_packet_traced_fn_t *
+vlib_is_packet_traced_default_function ()
+{
+ vlib_trace_filter_function_registration_t *reg =
+ vlib_trace_filter_main.trace_filter_registration;
+ vlib_trace_filter_function_registration_t *tmp_reg = reg;
+ while (reg)
+ {
+ if (reg->priority > tmp_reg->priority)
+ tmp_reg = reg;
+ reg = reg->next;
+ }
+ return tmp_reg->function;
+}
+
+static clib_error_t *
+vlib_trace_filter_function_init (vlib_main_t *vm)
+{
+ vlib_is_packet_traced_fn_t *default_fn =
+ vlib_is_packet_traced_default_function ();
+ foreach_vlib_main ()
+ {
+ vlib_trace_main_t *tm = &this_vlib_main->trace_main;
+ tm->current_trace_filter_function = default_fn;
+ }
+ return 0;
+}
+
+vlib_trace_filter_main_t vlib_trace_filter_main;
+
+VLIB_INIT_FUNCTION (vlib_trace_filter_function_init);
+
+static clib_error_t *
+show_trace_filter_function (vlib_main_t *vm, unformat_input_t *input,
+ vlib_cli_command_t *cmd)
+{
+ vlib_trace_filter_main_t *tfm = &vlib_trace_filter_main;
+ vlib_trace_main_t *tm = &vm->trace_main;
+ vlib_is_packet_traced_fn_t *current_trace_filter_fn =
+ tm->current_trace_filter_function;
+ vlib_trace_filter_function_registration_t *reg =
+ tfm->trace_filter_registration;
+
+ while (reg)
+ {
+ vlib_cli_output (vm, "%sname:%s description: %s priority: %u",
+ reg->function == current_trace_filter_fn ? "(*) " : "",
+ reg->name, reg->description, reg->priority);
+ reg = reg->next;
+ }
+ return 0;
+}
+
+VLIB_CLI_COMMAND (show_trace_filter_function_cli, static) = {
+ .path = "show trace filter function",
+ .short_help = "show trace filter function",
+ .function = show_trace_filter_function,
+};
+
+uword
+unformat_vlib_trace_filter_function (unformat_input_t *input, va_list *args)
{
- clib_warning ("BUG: STUB called");
- return 1;
+ vlib_is_packet_traced_fn_t **res =
+ va_arg (*args, vlib_is_packet_traced_fn_t **);
+ vlib_trace_filter_main_t *tfm = &vlib_trace_filter_main;
+
+ vlib_trace_filter_function_registration_t *reg =
+ tfm->trace_filter_registration;
+ while (reg)
+ {
+ if (unformat (input, reg->name))
+ {
+ *res = reg->function;
+ return 1;
+ }
+ reg = reg->next;
+ }
+ return 0;
}
+void
+vlib_set_trace_filter_function (vlib_is_packet_traced_fn_t *x)
+{
+ foreach_vlib_main ()
+ {
+ this_vlib_main->trace_main.current_trace_filter_function = x;
+ }
+}
+
+static clib_error_t *
+set_trace_filter_function (vlib_main_t *vm, unformat_input_t *input,
+ vlib_cli_command_t *cmd)
+{
+ unformat_input_t _line_input, *line_input = &_line_input;
+ vlib_is_packet_traced_fn_t *res = 0;
+ clib_error_t *error = 0;
+
+ if (!unformat_user (input, unformat_line_input, line_input))
+ return 0;
+
+ while (unformat_check_input (line_input) != (uword) UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (line_input, "%U", unformat_vlib_trace_filter_function,
+ &res))
+ ;
+ else
+ {
+ error = clib_error_create (
+ "expected valid trace filter function, got `%U'",
+ format_unformat_error, line_input);
+ goto done;
+ }
+ }
+ vlib_set_trace_filter_function (res);
+
+done:
+ unformat_free (line_input);
+
+ return error;
+}
+
+VLIB_CLI_COMMAND (set_trace_filter_function_cli, static) = {
+ .path = "set trace filter function",
+ .short_help = "set trace filter function <func_name>",
+ .function = set_trace_filter_function,
+};
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff