X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Ferror.c;h=de2020f08cb6791dfc69fe6623d9627f06dbc01f;hb=6a07348f4a5312310c01fdd5af937ce26580eb2d;hp=e4ed4ee37ee43b0c1c0e2c76575cabb2c90ebf46;hpb=586afd762bfa149f5ca167bd5fd5a0cd59ce94fe;p=vpp.git diff --git a/src/vlib/error.c b/src/vlib/error.c index e4ed4ee37ee..de2020f08cb 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,91 +112,170 @@ 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) +static u8 * +format_stats_counter_name (u8 *s, va_list *va) { - return vlib_error_drop_buffers (vm, node, vlib_frame_args (frame), - /* buffer stride */ 1, - frame->n_vectors, - /* next */ 0, - node->node_index, - /* error */ 0); + u8 *id = va_arg (*va, u8 *); + + for (u32 i = 0; id[i] != 0; i++) + vec_add1 (s, id[i] == ' ' ? ' ' : id[i]); + + return s; } -static char *misc_drop_buffers_error_strings[] = { - [0] = "misc. errors", -}; +void +vlib_unregister_errors (vlib_main_t *vm, u32 node_index) +{ + vlib_error_main_t *em = &vm->error_main; + vlib_node_t *n = vlib_get_node (vm, node_index); + vlib_error_desc_t *cd; -/* *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* */ + if (n->n_errors > 0) + { + cd = vec_elt_at_index (em->counters_heap, n->error_heap_index); + for (u32 i = 0; i < n->n_errors; i++) + vlib_stats_remove_entry (cd[i].stats_entry_index); + heap_dealloc (em->counters_heap, n->error_heap_handle); + n->n_errors = 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); + vlib_error_desc_t *cd; + u32 n_threads = vlib_get_n_threads (); + elog_event_type_t t = {}; uword l; + u64 **sc; ASSERT (vlib_get_thread_index () == 0); + vlib_stats_segment_lock (); + /* Free up any previous error strings. */ - if (n->n_errors > 0) - heap_dealloc (em->error_strings_heap, n->error_heap_handle); + vlib_unregister_errors (vm, node_index); n->n_errors = n_errors; - n->error_strings = error_strings; + n->error_counters = counters; if (n_errors == 0) - return; + goto done; n->error_heap_index = - heap_alloc (em->error_strings_heap, n_errors, n->error_heap_handle); - - l = vec_len (em->error_strings_heap); + heap_alloc (em->counters_heap, n_errors, n->error_heap_handle); + l = vec_len (em->counters_heap); + cd = vec_elt_at_index (em->counters_heap, n->error_heap_index); - clib_memcpy (vec_elt_at_index (em->error_strings_heap, n->error_heap_index), - error_strings, n_errors * sizeof (error_strings[0])); + /* Legacy node */ + if (!counters) + { + for (int i = 0; i < n_errors; i++) + { + cd[i].name = error_strings[i]; + cd[i].desc = error_strings[i]; + cd[i].severity = VL_COUNTER_SEVERITY_ERROR; + } + } + else + clib_memcpy (cd, counters, n_errors * sizeof (counters[0])); - /* Allocate a counter/elog type for each error. */ - vec_validate (em->counters, l - 1); vec_validate (vm->error_elog_event_types, l - 1); - /* Zero counters for re-registrations of errors. */ - if (n->error_heap_index + n_errors <= vec_len (em->counters_last_clear)) - clib_memcpy (em->counters + n->error_heap_index, - em->counters_last_clear + n->error_heap_index, - n_errors * sizeof (em->counters[0])); - else - memset (em->counters + n->error_heap_index, - 0, n_errors * sizeof (em->counters[0])); - - { - elog_event_type_t t; - uword i; - - memset (&t, 0, sizeof (t)); - for (i = 0; i < n_errors; i++) - { - t.format = (char *) format (0, "%v %s: %%d", - n->name, error_strings[i]); - vm->error_elog_event_types[n->error_heap_index + i] = t; - } - } + if (em->stats_err_entry_index == 0) + em->stats_err_entry_index = vlib_stats_add_counter_vector ("/node/errors"); + + ASSERT (em->stats_err_entry_index != 0 && em->stats_err_entry_index != ~0); + + vlib_stats_validate (em->stats_err_entry_index, n_threads - 1, l - 1); + sc = vlib_stats_get_entry_data_pointer (em->stats_err_entry_index); + + for (int i = 0; i < n_threads; i++) + { + vlib_main_t *tvm = vlib_get_main_by_index (i); + vlib_error_main_t *tem = &tvm->error_main; + tem->counters = sc[i]; + + /* Zero counters for re-registrations of errors. */ + if (n->error_heap_index + n_errors <= vec_len (tem->counters_last_clear)) + clib_memcpy (tem->counters + n->error_heap_index, + tem->counters_last_clear + n->error_heap_index, + n_errors * sizeof (tem->counters[0])); + else + clib_memset (tem->counters + n->error_heap_index, 0, + n_errors * sizeof (tem->counters[0])); + } + + /* Register counter indices in the stat segment directory */ + for (int i = 0; i < n_errors; i++) + cd[i].stats_entry_index = vlib_stats_add_symlink ( + em->stats_err_entry_index, n->error_heap_index + i, "/err/%v/%U", + n->name, format_stats_counter_name, cd[i].name); + + vec_validate (nm->node_by_error, n->error_heap_index + n_errors - 1); + + for (u32 i = 0; i < n_errors; i++) + { + t.format = (char *) format (0, "%v %s: %%d", n->name, cd[i].name); + vec_free (vm->error_elog_event_types[n->error_heap_index + i].format); + vm->error_elog_event_types[n->error_heap_index + i] = t; + nm->node_by_error[n->error_heap_index + i] = n->index; + } + +done: + vlib_stats_segment_unlock (); +} + +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 * @@ -216,45 +298,46 @@ 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"); - - - /* *INDENT-OFF* */ - foreach_vlib_main(({ - em = &this_vlib_main->error_main; - - if (verbose) - vlib_cli_output(vm, "Thread %u (%v):", index, - vlib_worker_threads[index].name); - - 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* */ + 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); + + 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, "%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:"); @@ -268,8 +351,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].desc, i); } } } @@ -280,7 +363,7 @@ show_errors (vlib_main_t * vm, } /* *INDENT-OFF* */ -VLIB_CLI_COMMAND (cli_show_errors, static) = { +VLIB_CLI_COMMAND (vlib_cli_show_errors) = { .path = "show errors", .short_help = "Show error counts", .function = show_errors, @@ -302,14 +385,13 @@ clear_error_counters (vlib_main_t * vm, 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; }