X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Ferror.c;h=7d502d777a3b47957f35a32564046b0cbdd66320;hb=acaee3d36e141b096ff0f04ca213283f217ca173;hp=691e6396d971db64d7241919063ab7be8cc004f9;hpb=a3d5986a35743a3ca1020155bed8267b5246d155;p=vpp.git diff --git a/src/vlib/error.c b/src/vlib/error.c index 691e6396d97..7d502d777a3 100644 --- a/src/vlib/error.c +++ b/src/vlib/error.c @@ -39,6 +39,7 @@ #include #include +#include uword vlib_error_drop_buffers (vlib_main_t * vm, @@ -51,8 +52,10 @@ 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) @@ -109,86 +112,54 @@ vlib_error_drop_buffers (vlib_main_t * vm, return n_buffers; } -/* Convenience node to drop a vector of buffers with a "misc error". */ -static uword -misc_drop_buffers (vlib_main_t * vm, - vlib_node_runtime_t * node, vlib_frame_t * frame) -{ - return vlib_error_drop_buffers (vm, node, vlib_frame_vector_args (frame), - /* buffer stride */ 1, - frame->n_vectors, - /* next */ 0, - node->node_index, - /* error */ 0); -} - -static char *misc_drop_buffers_error_strings[] = { - [0] = "misc. errors", -}; - -/* *INDENT-OFF* */ -VLIB_REGISTER_NODE (misc_drop_buffers_node,static) = { - .function = misc_drop_buffers, - .name = "misc-drop-buffers", - .vector_size = sizeof (u32), - .n_errors = 1, - .n_next_nodes = 1, - .next_nodes = { - "error-drop", - }, - .error_strings = misc_drop_buffers_error_strings, -}; -/* *INDENT-ON* */ - -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); @@ -205,34 +176,56 @@ vlib_register_errors (vlib_main_t * vm, /* 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) @@ -253,10 +246,11 @@ show_errors (vlib_main_t * vm, 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* */ @@ -282,11 +276,13 @@ show_errors (vlib_main_t * vm, 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++; @@ -305,8 +301,8 @@ show_errors (vlib_main_t * vm, 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); } } }