#include <vlib/vlib.h>
#include <vppinfra/heap.h>
+#include <vlib/stat_weak_inlines.h>
uword
vlib_error_drop_buffers (vlib_main_t * vm,
{
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)
return n_buffers;
}
-void vlib_stats_register_error_index (u8 *, u64 *, u64)
- __attribute__ ((weak));
-void
-vlib_stats_register_error_index (u8 * notused, u64 * notused2, u64 notused3)
-{
-};
-
-void vlib_stats_pop_heap2 (void *, u32, void *) __attribute__ ((weak));
-void
-vlib_stats_pop_heap2 (void *notused, u32 notused2, void *notused3)
-{
-};
-
-
/* 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[])
+ u32 node_index, u32 n_errors, char *error_strings[],
+ vl_counter_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;
- void *vlib_stats_push_heap (void) __attribute__ ((weak));
ASSERT (vlib_get_thread_index () == 0);
/* 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]; // XXX Make name saner
+ 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);
/* Switch to the stats segment ... */
- oldheap = vlib_stats_push_heap ();
+ oldheap = vlib_stats_push_heap (0);
/* Allocate a counter/elog type for each error. */
vec_validate (em->counters, l - 1);
/* Register counter indices in the stat segment directory */
{
int i;
- u8 *error_name;
+ u8 *error_name = 0;
for (i = 0; i < n_errors; i++)
{
- error_name = format (0, "/err/%v/%s%c", n->name, error_strings[i], 0);
- /* Note: error_name consumed by the following call */
- vlib_stats_register_error_index (error_name, em->counters,
+ vec_reset_length (error_name);
+ error_name =
+ 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);
}
+
+ vec_free (error_name);
}
/* (re)register the em->counters base address, switch back to main heap */
- vlib_stats_pop_heap2 (em->counters, vm->thread_index, oldheap);
+ vlib_stats_pop_heap2 (em->counters, vm->thread_index, oldheap, 1);
{
elog_event_type_t t;
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;
}
}
}
+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");
/* *INDENT-OFF* */
continue;
if (verbose)
- vlib_cli_output (vm, "%10Ld%=40v%=20s%=6d", c, n->name,
- em->error_strings_heap[i], i);
+ vlib_cli_output (vm, "%10lu%=35v%=35s%=10s%=6d", c, n->name,
+ em->counters_heap[i].name,
+ sev2str(em->counters_heap[i].severity), i);
else
- vlib_cli_output (vm, "%10d%=40v%s", c, n->name,
- em->error_strings_heap[i]);
+ vlib_cli_output (vm, "%10lu%=35v%=35s%=10s", c, n->name,
+ em->counters_heap[i].name,
+ sev2str(em->counters_heap[i].severity));
}
}
index++;
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].name, i);
}
}
}
Code Review / vpp.git / blobdiff