X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Fcli.c;h=3215a3264f56784213403d03dc12853f1fecec36;hb=f553a2cbbb8cca84ebf033335ebd2cd26dc19d69;hp=131a5931ac2ad5b12ca230306999c666b0a215fb;hpb=c4abafd83df38051765352785b146277734701f4;p=vpp.git diff --git a/src/vlib/cli.c b/src/vlib/cli.c index 131a5931ac2..3215a3264f5 100644 --- a/src/vlib/cli.c +++ b/src/vlib/cli.c @@ -39,11 +39,15 @@ #include #include +#include #include #include #include #include +/** \file src/vlib/cli.c Debug CLI Implementation + */ + int vl_api_set_elog_trace_api_messages (int enable); int vl_api_get_elog_trace_api_messages (void); @@ -207,29 +211,6 @@ unformat_vlib_cli_sub_command (unformat_input_t * i, va_list * args) vlib_cli_main_t *cm = &vm->cli_main; uword *match_bitmap, is_unique, index; - { - vlib_cli_sub_rule_t *sr; - vlib_cli_parse_rule_t *r; - vec_foreach (sr, c->sub_rules) - { - void **d; - r = vec_elt_at_index (cm->parse_rules, sr->rule_index); - vec_add2 (cm->parse_rule_data, d, 1); - vec_reset_length (d[0]); - if (r->data_size) - d[0] = _vec_resize (d[0], - /* length increment */ 1, - r->data_size, - /* header_bytes */ 0, - /* data align */ sizeof (uword)); - if (unformat_user (i, r->unformat_function, vm, d[0])) - { - *result = vec_elt_at_index (cm->commands, sr->command_index); - return 1; - } - } - } - match_bitmap = vlib_cli_sub_command_match (c, i); is_unique = clib_bitmap_count_set_bits (match_bitmap) == 1; index = ~0; @@ -323,7 +304,7 @@ vlib_cli_get_possible_completions (u8 * str) * autocomplete the next level of subcommands */ help_next_level = (vec_len (str) == 0) || isspace (str[vec_len (str) - 1]); /* *INDENT-OFF* */ - clib_bitmap_foreach(index, match_bitmap, { + clib_bitmap_foreach (index, match_bitmap) { if (help_next_level && is_unique) { c = get_sub_command (vcm, c, index); vec_foreach (sc, c->sub_commands) { @@ -333,7 +314,7 @@ vlib_cli_get_possible_completions (u8 * str) } sc = &c->sub_commands[index]; vec_add1(result, (u8*) sc->name); - }); + } /* *INDENT-ON* */ done: @@ -359,50 +340,12 @@ format_vlib_cli_command_help (u8 * s, va_list * args) return s; } -static u8 * -format_vlib_cli_parse_rule_name (u8 * s, va_list * args) -{ - vlib_cli_parse_rule_t *r = va_arg (*args, vlib_cli_parse_rule_t *); - return format (s, "<%U>", format_c_identifier, r->name); -} - static u8 * format_vlib_cli_path (u8 * s, va_list * args) { u8 *path = va_arg (*args, u8 *); - int i, in_rule; - in_rule = 0; - for (i = 0; i < vec_len (path); i++) - { - switch (path[i]) - { - case '%': - in_rule = 1; - vec_add1 (s, '<'); /* start of */ - break; - case '_': - /* _ -> space in rules. */ - vec_add1 (s, in_rule ? ' ' : '_'); - break; - - case ' ': - if (in_rule) - { - vec_add1 (s, '>'); /* end of */ - in_rule = 0; - } - vec_add1 (s, ' '); - break; - - default: - vec_add1 (s, path[i]); - break; - } - } - - if (in_rule) - vec_add1 (s, '>'); /* terminate */ + s = format (s, "%v", path); return s; } @@ -412,13 +355,10 @@ all_subs (vlib_cli_main_t * cm, vlib_cli_command_t * subs, u32 command_index) { vlib_cli_command_t *c = vec_elt_at_index (cm->commands, command_index); vlib_cli_sub_command_t *sc; - vlib_cli_sub_rule_t *sr; if (c->function) vec_add1 (subs, c[0]); - vec_foreach (sr, c->sub_rules) - subs = all_subs (cm, subs, sr->command_index); vec_foreach (sc, c->sub_commands) subs = all_subs (cm, subs, sc->index); return subs; @@ -481,17 +421,14 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm, vlib_cli_output (vm, "%U", format_vlib_cli_command_help, c, /* is_long */ 1); - else if (vec_len (c->sub_commands) + vec_len (c->sub_rules) == 0) + else if (vec_len (c->sub_commands) == 0) vlib_cli_output (vm, "%v: no sub-commands", c->path); else { + vlib_cli_sub_rule_t *sr, *subs = 0; vlib_cli_sub_command_t *sc; - vlib_cli_sub_rule_t *sr, *subs; - subs = vec_dup (c->sub_rules); - - /* Add in rules if any. */ vec_foreach (sc, c->sub_commands) { vec_add2 (subs, sr, 1); @@ -505,25 +442,11 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm, for (i = 0; i < vec_len (subs); i++) { vlib_cli_command_t *d; - vlib_cli_parse_rule_t *r; d = vec_elt_at_index (cm->commands, subs[i].command_index); - r = - subs[i].rule_index != ~0 ? vec_elt_at_index (cm->parse_rules, - subs - [i].rule_index) : - 0; - - if (r) - vlib_cli_output - (vm, " %-30U %U", - format_vlib_cli_parse_rule_name, r, - format_vlib_cli_command_help, d, /* is_long */ 0); - else - vlib_cli_output - (vm, " %-30v %U", - subs[i].name, - format_vlib_cli_command_help, d, /* is_long */ 0); + vlib_cli_output + (vm, " %-30v %U", subs[i].name, + format_vlib_cli_command_help, d, /* is_long */ 0); } vec_free (subs); @@ -549,6 +472,23 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm, vec_free (string); } + else if (unformat (input, "vpplog %v", &string)) + { + int i; + /* + * Delete leading whitespace, so "vpplog { this and that }" + * and "vpplog this" line up nicely. + */ + for (i = 0; i < vec_len (string); i++) + if (string[i] != ' ') + break; + if (i > 0) + vec_delete (string, i, 0); + + vlib_log_notice (cm->log, "CLI: %v", string); + vec_free (string); + } + else if (unformat (input, "uncomment %U", unformat_vlib_cli_sub_input, &sub_input)) { @@ -584,7 +524,7 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm, } (void) clib_mem_trace_enable_disable (0); - leak_report = format (0, "%U", format_mheap, clib_mem_get_heap (), + leak_report = format (0, "%U", format_clib_mem_heap, 0, 1 /* verbose, i.e. print leaks */ ); clib_mem_trace (0); vlib_cli_output (vm, "%v", leak_report); @@ -635,15 +575,22 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm, { u32 c; } *ed; - ed = ELOG_DATA (&vm->elog_main, e); - ed->c = elog_string (&vm->elog_main, c->path); + ed = ELOG_DATA (vlib_get_elog_main (), e); + ed->c = elog_string (vlib_get_elog_main (), "%v", c->path); } if (!c->is_mp_safe) vlib_worker_thread_barrier_sync (vm); + if (PREDICT_FALSE (vec_len (cm->perf_counter_cbs) != 0)) + clib_call_callbacks (cm->perf_counter_cbs, cm, + c - cm->commands, 0 /* before */ ); + c->hit_counter++; c_error = c->function (vm, si, c); + if (PREDICT_FALSE (vec_len (cm->perf_counter_cbs) != 0)) + clib_call_callbacks (cm->perf_counter_cbs, cm, + c - cm->commands, 1 /* after */ ); if (!c->is_mp_safe) vlib_worker_thread_barrier_release (vm); @@ -660,17 +607,17 @@ vlib_cli_dispatch_sub_commands (vlib_main_t * vm, { u32 c, err; } *ed; - ed = ELOG_DATA (&vm->elog_main, e); - ed->c = elog_string (&vm->elog_main, c->path); + ed = ELOG_DATA (vlib_get_elog_main (), e); + ed->c = elog_string (vlib_get_elog_main (), "%v", c->path); if (c_error) { vec_add1 (c_error->what, 0); - ed->err = elog_string (&vm->elog_main, + ed->err = elog_string (vlib_get_elog_main (), (char *) c_error->what); _vec_len (c_error->what) -= 1; } else - ed->err = elog_string (&vm->elog_main, "OK"); + ed->err = elog_string (vlib_get_elog_main (), "OK"); } if (c_error) @@ -728,7 +675,6 @@ vlib_cli_input (vlib_main_t * vm, vlib_cli_output_function_t * function, uword function_arg) { vlib_process_t *cp = vlib_get_current_process (vm); - vlib_cli_main_t *cm = &vm->cli_main; clib_error_t *error; vlib_cli_output_function_t *save_function; uword save_function_arg; @@ -742,9 +688,8 @@ vlib_cli_input (vlib_main_t * vm, do { - vec_reset_length (cm->parse_rule_data); - error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input, /* parent */ - 0); + error = vlib_cli_dispatch_sub_commands (vm, &vm->cli_main, input, + /* parent */ 0); } while (!error && !unformat (input, "%U", unformat_eof)); @@ -775,6 +720,11 @@ vlib_cli_output (vlib_main_t * vm, char *fmt, ...) s = va_format (0, fmt, &va); va_end (va); + /* some format functions might return 0 + * e.g. show int addr */ + if (NULL == s) + return; + /* Terminate with \n if not present. */ if (vec_len (s) > 0 && s[vec_len (s) - 1] != '\n') vec_add1 (s, '\n'); @@ -811,10 +761,13 @@ static clib_error_t * show_memory_usage (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { + clib_mem_main_t *mm = &clib_mem_main; int verbose __attribute__ ((unused)) = 0; - int api_segment = 0, stats_segment = 0, main_heap = 0; + int api_segment = 0, stats_segment = 0, main_heap = 0, numa_heaps = 0; + int map = 0; clib_error_t *error; u32 index = 0; + int i; uword clib_mem_trace_enable_disable (uword enable); uword was_enabled; @@ -829,6 +782,10 @@ show_memory_usage (vlib_main_t * vm, stats_segment = 1; else if (unformat (input, "main-heap")) main_heap = 1; + else if (unformat (input, "numa-heaps")) + numa_heaps = 1; + else if (unformat (input, "map")) + map = 1; else { error = clib_error_return (0, "unknown input `%U'", @@ -837,16 +794,16 @@ show_memory_usage (vlib_main_t * vm, } } - if ((api_segment + stats_segment + main_heap) == 0) + if ((api_segment + stats_segment + main_heap + numa_heaps + map) == 0) return clib_error_return - (0, "Please supply one of api-segment, stats-segment or main-heap"); + (0, "Need one of api-segment, stats-segment, main-heap, numa-heaps " + "or map"); if (api_segment) { void *oldheap = vl_msg_push_heap (); was_enabled = clib_mem_trace_enable_disable (0); - u8 *s_in_svm = - format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1); + u8 *s_in_svm = format (0, "%U\n", format_clib_mem_heap, 0, 1); vl_msg_pop_heap (oldheap); u8 *s = vec_dup (s_in_svm); @@ -862,8 +819,7 @@ show_memory_usage (vlib_main_t * vm, { void *oldheap = vlib_stats_push_heap (0); was_enabled = clib_mem_trace_enable_disable (0); - u8 *s_in_svm = - format (0, "%U\n", format_mheap, clib_mem_get_heap (), 1); + u8 *s_in_svm = format (0, "%U\n", format_clib_mem_heap, 0, 1); if (oldheap) clib_mem_set_heap (oldheap); u8 *s = vec_dup (s_in_svm); @@ -880,22 +836,7 @@ show_memory_usage (vlib_main_t * vm, vec_free (s); } -#if USE_DLMALLOC == 0 - /* *INDENT-OFF* */ - foreach_vlib_main ( - ({ - mheap_t *h = mheap_header (clib_per_cpu_mheaps[index]); - vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index, - vlib_worker_threads[index].name); - vlib_cli_output (vm, " %U\n", format_page_map, pointer_to_uword (h) - - h->vm_alloc_offset_from_header, - h->vm_alloc_size); - vlib_cli_output (vm, " %U\n", format_mheap, clib_per_cpu_mheaps[index], - verbose); - index++; - })); - /* *INDENT-ON* */ -#else + { if (main_heap) { @@ -908,18 +849,10 @@ show_memory_usage (vlib_main_t * vm, /* *INDENT-OFF* */ foreach_vlib_main ( ({ - struct dlmallinfo mi; - void *mspace; - mspace = clib_per_cpu_mheaps[index]; - - mi = mspace_mallinfo (mspace); vlib_cli_output (vm, "%sThread %d %s\n", index ? "\n":"", index, vlib_worker_threads[index].name); - vlib_cli_output (vm, " %U\n", format_page_map, - pointer_to_uword (mspace_least_addr(mspace)), - mi.arena); - vlib_cli_output (vm, " %U\n", format_mheap, - clib_per_cpu_mheaps[index], + vlib_cli_output (vm, " %U\n", format_clib_mem_heap, + mm->per_cpu_mheaps[index], verbose); index++; })); @@ -928,15 +861,75 @@ show_memory_usage (vlib_main_t * vm, /* Restore the trace flag */ clib_mem_trace_enable_disable (was_enabled); } + if (numa_heaps) + { + for (i = 0; i < ARRAY_LEN (mm->per_numa_mheaps); i++) + { + if (mm->per_numa_mheaps[i] == 0) + continue; + if (mm->per_numa_mheaps[i] == mm->per_cpu_mheaps[i]) + { + vlib_cli_output (vm, "Numa %d uses the main heap...", i); + continue; + } + was_enabled = clib_mem_trace_enable_disable (0); + + vlib_cli_output (vm, "Numa %d:", i); + vlib_cli_output (vm, " %U\n", format_clib_mem_heap, + mm->per_numa_mheaps[index], verbose); + } + } + if (map) + { + clib_mem_page_stats_t stats = { }; + clib_mem_vm_map_hdr_t *hdr = 0; + u8 *s = 0; + int numa = -1; + + s = format (s, "\n%-16s%7s%5s%7s%7s", + "StartAddr", "size", "FD", "PageSz", "Pages"); + while ((numa = vlib_mem_get_next_numa_node (numa)) != -1) + s = format (s, " Numa%u", numa); + s = format (s, " NotMap"); + s = format (s, " Name"); + vlib_cli_output (vm, "%v", s); + vec_reset_length (s); + + while ((hdr = clib_mem_vm_get_next_map_hdr (hdr))) + { + clib_mem_get_page_stats ((void *) hdr->base_addr, + hdr->log2_page_sz, hdr->num_pages, + &stats); + s = format (s, "%016lx%7U", + hdr->base_addr, format_memory_size, + hdr->num_pages << hdr->log2_page_sz); + + if (hdr->fd != -1) + s = format (s, "%5d", hdr->fd); + else + s = format (s, "%5s", " "); + + s = format (s, "%7U%7lu", + format_log2_page_size, hdr->log2_page_sz, + hdr->num_pages); + while ((numa = vlib_mem_get_next_numa_node (numa)) != -1) + s = format (s, "%6lu", stats.per_numa[numa]); + s = format (s, "%7lu", stats.not_mapped); + s = format (s, " %s", hdr->name); + vlib_cli_output (vm, "%v", s); + vec_reset_length (s); + } + vec_free (s); + } } -#endif /* USE_DLMALLOC */ return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_memory_usage_command, static) = { .path = "show memory", - .short_help = "show memory [api-segment][stats-segment][verbose]", + .short_help = "show memory [api-segment][stats-segment][verbose]\n" + " [numa-heaps][map]", .function = show_memory_usage, }; /* *INDENT-ON* */ @@ -979,11 +972,13 @@ enable_disable_memory_trace (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { + clib_mem_main_t *mm = &clib_mem_main; unformat_input_t _line_input, *line_input = &_line_input; int enable = 1; int api_segment = 0; int stats_segment = 0; int main_heap = 0; + u32 numa_id = ~0; void *oldheap; if (!unformat_user (input, unformat_line_input, line_input)) @@ -999,6 +994,8 @@ enable_disable_memory_trace (vlib_main_t * vm, stats_segment = 1; else if (unformat (line_input, "main-heap")) main_heap = 1; + else if (unformat (line_input, "numa-heap %d", &numa_id)) + ; else { unformat_free (line_input); @@ -1007,10 +1004,12 @@ enable_disable_memory_trace (vlib_main_t * vm, } unformat_free (line_input); - if ((api_segment + stats_segment + main_heap + (enable == 0)) == 0) + if ((api_segment + stats_segment + main_heap + (enable == 0) + + (numa_id != ~0)) == 0) { return clib_error_return - (0, "Need one of main-heap, stats-segment or api-segment"); + (0, "Need one of main-heap, stats-segment, api-segment,\n" + "numa-heap or disable"); } /* Turn off current trace, if any */ @@ -1054,80 +1053,32 @@ enable_disable_memory_trace (vlib_main_t * vm, clib_mem_trace (main_heap); } - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = { - .path = "memory-trace", - .short_help = "memory-trace on|off [api-segment][stats-segment][main-heap]\n", - .function = enable_disable_memory_trace, -}; -/* *INDENT-ON* */ - - -static clib_error_t * -test_heap_validate (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) -{ -#if USE_DLMALLOC == 0 - clib_error_t *error = 0; - void *heap; - mheap_t *mheap; - - if (unformat (input, "on")) + if (numa_id != ~0) { - /* *INDENT-OFF* */ - foreach_vlib_main({ - heap = clib_per_cpu_mheaps[this_vlib_main->thread_index]; - mheap = mheap_header(heap); - mheap->flags |= MHEAP_FLAG_VALIDATE; - // Turn off small object cache because it delays detection of errors - mheap->flags &= ~MHEAP_FLAG_SMALL_OBJECT_CACHE; - }); - /* *INDENT-ON* */ - - } - else if (unformat (input, "off")) - { - /* *INDENT-OFF* */ - foreach_vlib_main({ - heap = clib_per_cpu_mheaps[this_vlib_main->thread_index]; - mheap = mheap_header(heap); - mheap->flags &= ~MHEAP_FLAG_VALIDATE; - mheap->flags |= MHEAP_FLAG_SMALL_OBJECT_CACHE; - }); - /* *INDENT-ON* */ + if (numa_id >= ARRAY_LEN (mm->per_numa_mheaps)) + return clib_error_return (0, "Numa %d out of range", numa_id); + if (mm->per_numa_mheaps[numa_id] == 0) + return clib_error_return (0, "Numa %d heap not active", numa_id); + + if (mm->per_numa_mheaps[numa_id] == clib_mem_get_heap ()) + return clib_error_return (0, "Numa %d uses the main heap...", + numa_id); + current_traced_heap = mm->per_numa_mheaps[numa_id]; + oldheap = clib_mem_set_heap (current_traced_heap); + clib_mem_trace (1); + clib_mem_set_heap (oldheap); } - else if (unformat (input, "now")) - { - /* *INDENT-OFF* */ - foreach_vlib_main({ - heap = clib_per_cpu_mheaps[this_vlib_main->thread_index]; - mheap = mheap_header(heap); - mheap_validate(heap); - }); - /* *INDENT-ON* */ - vlib_cli_output (vm, "heap validation complete"); - } - else - { - return clib_error_return (0, "unknown input `%U'", - format_unformat_error, input); - } - return error; -#else - return clib_error_return (0, "unimplemented..."); -#endif /* USE_DLMALLOC */ + return 0; } /* *INDENT-OFF* */ -VLIB_CLI_COMMAND (cmd_test_heap_validate,static) = { - .path = "test heap-validate", - .short_help = " validate heap on future allocs/frees or right now", - .function = test_heap_validate, +VLIB_CLI_COMMAND (enable_disable_memory_trace_command, static) = { + .path = "memory-trace", + .short_help = "memory-trace on|off [api-segment][stats-segment][main-heap]\n" + " [numa-heap ]\n", + .function = enable_disable_memory_trace, }; /* *INDENT-ON* */ @@ -1143,11 +1094,11 @@ restart_cmd_fn (vlib_main_t * vm, unformat_input_t * input, /* Close all known open files */ /* *INDENT-OFF* */ - pool_foreach(f, fm->file_pool, - ({ + pool_foreach (f, fm->file_pool) + { if (f->file_descriptor > 2) close(f->file_descriptor); - })); + } /* *INDENT-ON* */ /* Exec ourself */ @@ -1292,19 +1243,11 @@ add_sub_command (vlib_cli_main_t * cm, uword parent_index, uword child_index) return; } - q = hash_get_mem (cm->parse_rule_index_by_name, sub_name); - if (!q) - { - clib_error ("reference to unknown rule `%%%v' in path `%v'", - sub_name, c->path); - return; - } - hash_set_mem (p->sub_rule_index_by_name, sub_name, vec_len (p->sub_rules)); vec_add2 (p->sub_rules, sr, 1); sr->name = sub_name; - sr->rule_index = q[0]; + sr->rule_index = sr - p->sub_rules; sr->command_index = child_index; return; } @@ -1488,6 +1431,8 @@ vlib_cli_register (vlib_main_t * vm, vlib_cli_command_t * c) return 0; } +#if 0 +/* $$$ turn back on again someday, maybe */ clib_error_t * vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg) { @@ -1520,8 +1465,6 @@ vlib_cli_register_parse_rule (vlib_main_t * vm, vlib_cli_parse_rule_t * r_reg) return error; } -#if 0 -/* $$$ turn back on again someday, maybe */ static clib_error_t *vlib_cli_register_parse_rules (vlib_main_t * vm, vlib_cli_parse_rule_t * lo, @@ -1550,58 +1493,10 @@ done: } #endif -static int -cli_path_compare (void *a1, void *a2) -{ - u8 **s1 = a1; - u8 **s2 = a2; - - if ((vec_len (*s1) < vec_len (*s2)) && - memcmp ((char *) *s1, (char *) *s2, vec_len (*s1)) == 0) - return -1; - - - if ((vec_len (*s1) > vec_len (*s2)) && - memcmp ((char *) *s1, (char *) *s2, vec_len (*s2)) == 0) - return 1; - - return vec_cmp (*s1, *s2); -} - -static clib_error_t * -show_cli_cmd_fn (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) -{ - vlib_cli_main_t *cm = &vm->cli_main; - vlib_cli_command_t *cli; - u8 **paths = 0, **s; - - /* *INDENT-OFF* */ - vec_foreach (cli, cm->commands) - if (vec_len (cli->path) > 0) - vec_add1 (paths, (u8 *) cli->path); - - vec_sort_with_function (paths, cli_path_compare); - - vec_foreach (s, paths) - vlib_cli_output (vm, "%v", *s); - /* *INDENT-ON* */ - - vec_free (paths); - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (show_cli_command, static) = { - .path = "show cli", - .short_help = "Show cli commands", - .function = show_cli_cmd_fn, -}; -/* *INDENT-ON* */ - static clib_error_t * -elog_trace_command_fn (vlib_main_t * vm, - unformat_input_t * input, vlib_cli_command_t * cmd) +event_logger_trace_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) { unformat_input_t _line_input, *line_input = &_line_input; int enable = 1; @@ -1652,7 +1547,7 @@ elog_trace_command_fn (vlib_main_t * vm, */ if (dispatch || circuit) { - elog_main_t *em = &vm->elog_main; + elog_main_t *em = &vlib_global_main.elog_main; em->n_total_events_disable_limit = em->n_total_events + vec_len (em->event_ring); @@ -1690,21 +1585,20 @@ print_status: * * @cliexpar * @clistart - * elog trace api cli barrier - * elog trace api cli barrier disable - * elog trace dispatch - * elog trace circuit-node ethernet-input - * elog trace + * event-logger trace api cli barrier + * event-logger trace api cli barrier disable + * event-logger trace dispatch + * event-logger trace circuit-node ethernet-input * @cliend - * @cliexcmd{elog trace [api][cli][barrier][disable]} + * @cliexcmd{event-logger trace [api][cli][barrier][disable]} ?*/ /* *INDENT-OFF* */ -VLIB_CLI_COMMAND (elog_trace_command, static) = +VLIB_CLI_COMMAND (event_logger_trace_command, static) = { - .path = "elog trace", - .short_help = "elog trace [api][cli][barrier][dispatch]\n" + .path = "event-logger trace", + .short_help = "event-logger trace [api][cli][barrier][dispatch]\n" "[circuit-node e.g. ethernet-input][disable]", - .function = elog_trace_command_fn, + .function = event_logger_trace_command_fn, }; /* *INDENT-ON* */ @@ -1722,6 +1616,205 @@ VLIB_CLI_COMMAND (suspend_command, static) = .path = "suspend", .short_help = "suspend debug CLI for 30ms", .function = suspend_command_fn, + .is_mp_safe = 1, +}; +/* *INDENT-ON* */ + + +static int +sort_cmds_by_path (void *a1, void *a2) +{ + u32 *index1 = a1; + u32 *index2 = a2; + vlib_main_t *vm = vlib_get_main (); + vlib_cli_main_t *cm = &vm->cli_main; + vlib_cli_command_t *c1, *c2; + int i, lmin; + + c1 = vec_elt_at_index (cm->commands, *index1); + c2 = vec_elt_at_index (cm->commands, *index2); + + lmin = vec_len (c1->path); + lmin = (vec_len (c2->path) >= lmin) ? lmin : vec_len (c2->path); + + for (i = 0; i < lmin; i++) + { + if (c1->path[i] < c2->path[i]) + return -1; + else if (c1->path[i] > c2->path[i]) + return 1; + } + + return 0; +} + +typedef struct +{ + vlib_cli_main_t *cm; + u32 parent_command_index; + int show_mp_safe; + int show_not_mp_safe; + int show_hit; + int clear_hit; +} vlib_cli_walk_args_t; + +static void +cli_recursive_walk (vlib_cli_walk_args_t * aa) +{ + vlib_cli_command_t *parent; + vlib_cli_sub_command_t *sub; + vlib_cli_walk_args_t _a, *a = &_a; + vlib_cli_main_t *cm; + int i; + + /* Copy args into this stack frame */ + *a = *aa; + cm = a->cm; + + parent = vec_elt_at_index (cm->commands, a->parent_command_index); + + if (parent->function) + { + if (((a->show_mp_safe && parent->is_mp_safe) + || (a->show_not_mp_safe && !parent->is_mp_safe)) + && (a->show_hit == 0 || parent->hit_counter)) + { + vec_add1 (cm->sort_vector, a->parent_command_index); + } + + if (a->clear_hit) + parent->hit_counter = 0; + } + + for (i = 0; i < vec_len (parent->sub_commands); i++) + { + sub = vec_elt_at_index (parent->sub_commands, i); + a->parent_command_index = sub->index; + cli_recursive_walk (a); + } +} + +static u8 * +format_mp_safe (u8 * s, va_list * args) +{ + vlib_cli_main_t *cm = va_arg (*args, vlib_cli_main_t *); + int show_mp_safe = va_arg (*args, int); + int show_not_mp_safe = va_arg (*args, int); + int show_hit = va_arg (*args, int); + int clear_hit = va_arg (*args, int); + vlib_cli_command_t *c; + vlib_cli_walk_args_t _a, *a = &_a; + int i; + char *format_string = "\n%v"; + + if (show_hit) + format_string = "\n%v: %u"; + + vec_reset_length (cm->sort_vector); + + a->cm = cm; + a->parent_command_index = 0; + a->show_mp_safe = show_mp_safe; + a->show_not_mp_safe = show_not_mp_safe; + a->show_hit = show_hit; + a->clear_hit = clear_hit; + + cli_recursive_walk (a); + + vec_sort_with_function (cm->sort_vector, sort_cmds_by_path); + + for (i = 0; i < vec_len (cm->sort_vector); i++) + { + c = vec_elt_at_index (cm->commands, cm->sort_vector[i]); + s = format (s, format_string, c->path, c->hit_counter); + } + + return s; +} + + +static clib_error_t * +show_cli_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + int show_mp_safe = 0; + int show_not_mp_safe = 0; + int show_hit = 0; + int clear_hit = 0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "mp-safe")) + show_mp_safe = 1; + if (unformat (input, "not-mp-safe")) + show_not_mp_safe = 1; + else if (unformat (input, "hit")) + show_hit = 1; + else if (unformat (input, "clear-hit")) + clear_hit = 1; + else + break; + } + + /* default set: all cli commands */ + if (clear_hit == 0 && (show_mp_safe + show_not_mp_safe) == 0) + show_mp_safe = show_not_mp_safe = 1; + + vlib_cli_output (vm, "%U", format_mp_safe, &vm->cli_main, + show_mp_safe, show_not_mp_safe, show_hit, clear_hit); + if (clear_hit) + vlib_cli_output (vm, "hit counters cleared..."); + + return 0; +} + +/*? + * Displays debug cli command information + * + * @cliexpar + * @cliexstart{show cli [mp-safe][not-mp-safe][hit][clear-hit]} + * + * "show cli" displays the entire debug cli: + * + * abf attach + * abf policy + * adjacency counters + * api trace + * app ns + * bfd key del + * ... and so on ... + * + * "show cli mp-safe" displays mp-safe debug CLI commands: + * + * abf policy + * binary-api + * create vhost-user + * exec + * ip container + * ip mroute + * ip probe-neighbor + * ip route + * ip scan-neighbor + * ip table + * ip6 table + * + * "show cli not-mp-safe" displays debug CLI commands + * which cause worker thread barrier synchronization + * + * "show cli hit" displays commands which have been executed. Qualify + * as desired with "mp-safe" or "not-mp-safe". + * + * "show cli clear-hit" clears the per-command hit counters. + * @cliexend +?*/ + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (show_cli_command, static) = +{ + .path = "show cli", + .short_help = "show cli [mp-safe][not-mp-safe][hit][clear-hit]", + .function = show_cli_command_fn, + .is_mp_safe = 1, }; /* *INDENT-ON* */ @@ -1741,6 +1834,9 @@ vlib_cli_init (vlib_main_t * vm) return error; cmd = cmd->next_cli_command; } + + cm->log = vlib_log_register_class_rate_limit ( + "cli", "log", 0x7FFFFFFF /* aka no rate limit */); return error; }