{
u32 n_left_this_frame, n_buffers_left, *args, n_args_left;
vlib_error_t drop_error;
+ vlib_node_t *n;
- drop_error = vlib_error_set (drop_error_node, drop_error_code);
+ n = vlib_get_node (vm, drop_error_node);
+ drop_error = n->error_heap_index + drop_error_code;
n_buffers_left = n_buffers;
while (n_buffers_left > 0)
/* Reserves given number of error codes for given node. */
void
-vlib_register_errors (vlib_main_t * vm,
- u32 node_index, u32 n_errors, char *error_strings[])
+vlib_register_errors (vlib_main_t *vm, u32 node_index, u32 n_errors,
+ char *error_strings[], vlib_error_desc_t counters[])
{
vlib_error_main_t *em = &vm->error_main;
+ vlib_node_main_t *nm = &vm->node_main;
+
vlib_node_t *n = vlib_get_node (vm, node_index);
uword l;
void *oldheap;
/* Free up any previous error strings. */
if (n->n_errors > 0)
- heap_dealloc (em->error_strings_heap, n->error_heap_handle);
+ heap_dealloc (em->counters_heap, n->error_heap_handle);
n->n_errors = n_errors;
- n->error_strings = error_strings;
+ n->error_counters = counters;
if (n_errors == 0)
return;
- n->error_heap_index =
- heap_alloc (em->error_strings_heap, n_errors, n->error_heap_handle);
-
- l = vec_len (em->error_strings_heap);
+ /* Legacy node */
+ if (!counters)
+ {
+ counters = clib_mem_alloc (sizeof (counters[0]) * n_errors);
+ int i;
+ for (i = 0; i < n_errors; i++)
+ {
+ counters[i].name = error_strings[i];
+ counters[i].desc = error_strings[i];
+ counters[i].severity = VL_COUNTER_SEVERITY_ERROR;
+ }
+ }
- clib_memcpy (vec_elt_at_index (em->error_strings_heap, n->error_heap_index),
- error_strings, n_errors * sizeof (error_strings[0]));
+ n->error_heap_index =
+ heap_alloc (em->counters_heap, n_errors, n->error_heap_handle);
+ l = vec_len (em->counters_heap);
+ clib_memcpy (vec_elt_at_index (em->counters_heap, n->error_heap_index),
+ counters, n_errors * sizeof (counters[0]));
vec_validate (vm->error_elog_event_types, l - 1);
{
vec_reset_length (error_name);
error_name =
- format (error_name, "/err/%v/%s%c", n->name, error_strings[i], 0);
+ format (error_name, "/err/%v/%s%c", n->name, counters[i].name, 0);
vlib_stats_register_error_index (oldheap, error_name, em->counters,
n->error_heap_index + i);
}
uword i;
clib_memset (&t, 0, sizeof (t));
+ if (n_errors > 0)
+ vec_validate (nm->node_by_error, n->error_heap_index + n_errors - 1);
for (i = 0; i < n_errors; i++)
{
t.format = (char *) format (0, "%v %s: %%d",
- n->name, error_strings[i]);
+ n->name, counters[i].name);
vm->error_elog_event_types[n->error_heap_index + i] = t;
+ nm->node_by_error[n->error_heap_index + i] = n->index;
}
}
}
+uword
+unformat_vlib_error (unformat_input_t *input, va_list *args)
+{
+ vlib_main_t *vm = va_arg (*args, vlib_main_t *);
+ const vlib_error_main_t *em = &vm->error_main;
+ vlib_error_t *error_index = va_arg (*args, vlib_error_t *);
+ const vlib_node_t *node;
+ char *error_name;
+ u32 node_index;
+ vlib_error_t i;
+
+ if (!unformat (input, "%U.%s", unformat_vlib_node, vm, &node_index,
+ &error_name))
+ return 0;
+
+ node = vlib_get_node (vm, node_index);
+ for (i = 0; i < node->n_errors; i++)
+ {
+ vlib_error_t ei = node->error_heap_index + i;
+ if (strcmp (em->counters_heap[ei].name, error_name) == 0)
+ {
+ *error_index = ei;
+ vec_free (error_name);
+ return 1;
+ }
+ }
+
+ vec_free (error_name);
+ return 0;
+}
+
+static char *
+sev2str (enum vl_counter_severity_e s)
+{
+ switch (s)
+ {
+ case VL_COUNTER_SEVERITY_ERROR:
+ return "error";
+ case VL_COUNTER_SEVERITY_WARN:
+ return "warn";
+ case VL_COUNTER_SEVERITY_INFO:
+ return "info";
+ default:
+ return "unknown";
+ }
+}
+
static clib_error_t *
show_errors (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
vec_validate (sums, vec_len (em->counters));
if (verbose)
- vlib_cli_output (vm, "%=10s%=40s%=20s%=6s", "Count", "Node", "Reason",
- "Index");
+ vlib_cli_output (vm, "%=10s%=35s%=35s%=10s%=6s", "Count", "Node",
+ "Reason", "Severity", "Index");
else
- vlib_cli_output (vm, "%=10s%=40s%=6s", "Count", "Node", "Reason");
+ vlib_cli_output (vm, "%=10s%=35s%=35s%=10s", "Count", "Node", "Reason",
+ "Severity");
+
+ foreach_vlib_main ()
+ {
+ em = &this_vlib_main->error_main;
+ if (verbose)
+ vlib_cli_output (vm, "Thread %u (%v):", index,
+ vlib_worker_threads[index].name);
- /* *INDENT-OFF* */
- foreach_vlib_main(({
- em = &this_vlib_main->error_main;
+ for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++)
+ {
+ n = vlib_get_node (this_vlib_main, ni);
+ for (code = 0; code < n->n_errors; code++)
+ {
+ i = n->error_heap_index + code;
+ c = em->counters[i];
+ if (i < vec_len (em->counters_last_clear))
+ c -= em->counters_last_clear[i];
+ sums[i] += c;
- if (verbose)
- vlib_cli_output(vm, "Thread %u (%v):", index,
- vlib_worker_threads[index].name);
+ if (c == 0 && verbose < 2)
+ continue;
- for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++)
- {
- n = vlib_get_node (this_vlib_main, ni);
- for (code = 0; code < n->n_errors; code++)
- {
- i = n->error_heap_index + code;
- c = em->counters[i];
- if (i < vec_len (em->counters_last_clear))
- c -= em->counters_last_clear[i];
- sums[i] += c;
-
- if (c == 0 && verbose < 2)
- continue;
-
- if (verbose)
- vlib_cli_output (vm, "%10Ld%=40v%=20s%=6d", c, n->name,
- em->error_strings_heap[i], i);
- else
- vlib_cli_output (vm, "%10d%=40v%s", c, n->name,
- em->error_strings_heap[i]);
- }
- }
- index++;
- }));
- /* *INDENT-ON* */
+ if (verbose)
+ vlib_cli_output (vm, "%10lu%=35v%=35s%=10s%=6d", c, n->name,
+ em->counters_heap[i].desc,
+ sev2str (em->counters_heap[i].severity), i);
+ else
+ vlib_cli_output (vm, "%10lu%=35v%=35s%=10s", c, n->name,
+ em->counters_heap[i].desc,
+ sev2str (em->counters_heap[i].severity));
+ }
+ }
+ index++;
+ }
if (verbose)
vlib_cli_output (vm, "Total:");
if (sums[i])
{
if (verbose)
- vlib_cli_output (vm, "%10Ld%=40v%=20s%=10d", sums[i], n->name,
- em->error_strings_heap[i], i);
+ vlib_cli_output (vm, "%10lu%=40v%=20s%=10d", sums[i], n->name,
+ em->counters_heap[i].desc, i);
}
}
}
vlib_error_main_t *em;
u32 i;
- /* *INDENT-OFF* */
- foreach_vlib_main(({
- em = &this_vlib_main->error_main;
- vec_validate (em->counters_last_clear, vec_len (em->counters) - 1);
- for (i = 0; i < vec_len (em->counters); i++)
- em->counters_last_clear[i] = em->counters[i];
- }));
- /* *INDENT-ON* */
+ foreach_vlib_main ()
+ {
+ em = &this_vlib_main->error_main;
+ vec_validate (em->counters_last_clear, vec_len (em->counters) - 1);
+ for (i = 0; i < vec_len (em->counters); i++)
+ em->counters_last_clear[i] = em->counters[i];
+ }
return 0;
}
Code Review / vpp.git / blobdiff