X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp%2Fvnet%2Fmain.c;h=a95d6a75993cdbd6fafd1e31ea8acfa4667d2596;hb=332bc084dd15a2c7b7b26bb00775c835c9630e8a;hp=e4695e1ea4c78844b8410f8fde6448b2df769481;hpb=7cd468a3d7dee7d6c92f69a0bb7061ae208ec727;p=vpp.git diff --git a/src/vpp/vnet/main.c b/src/vpp/vnet/main.c index e4695e1ea4c..a95d6a75993 100644 --- a/src/vpp/vnet/main.c +++ b/src/vpp/vnet/main.c @@ -13,74 +13,68 @@ * limitations under the License. */ +#define _GNU_SOURCE +#include +#include + #include #include #include +#include #include #include - +#include #include - -#if DPDK -#include +#include /* - * Called by the dpdk driver's rte_delay_us() function. - * Return 0 to have the dpdk do a regular delay loop. - * Return 1 if to skip the delay loop because we are suspending - * the calling vlib process instead. + * Load plugins from /usr/lib/vpp_plugins by default */ -int -rte_delay_us_override (unsigned us) -{ - vlib_main_t *vm; - - /* Don't bother intercepting for short delays */ - if (us < 10) - return 0; - - /* - * Only intercept if we are in a vlib process. - * If we are called from a vlib worker thread or the vlib main - * thread then do not intercept. (Must not be called from an - * independent pthread). - */ - if (os_get_cpu_number () == 0) - { - /* - * We're in the vlib main thread or a vlib process. Make sure - * the process is running and we're not still initializing. - */ - vm = vlib_get_main (); - if (vlib_in_process_context (vm)) - { - /* Only suspend for the admin_down_process */ - vlib_process_t *proc = vlib_get_current_process (vm); - if (!(proc->flags & VLIB_PROCESS_IS_RUNNING) || - (proc->node_runtime.function != admin_up_down_process)) - return 0; - - f64 delay = 1e-6 * us; - vlib_process_suspend (vm, delay); - return 1; - } - } - return 0; // no override -} +char *vlib_plugin_path = NULL; +char *vlib_plugin_app_version = VPP_BUILD_VER; +char *vat_plugin_path = NULL; -#if RTE_VERSION >= RTE_VERSION_NUM(16, 11, 0, 0) static void -rte_delay_us_override_cb (unsigned us) +vpp_find_plugin_path () { - if (rte_delay_us_override (us) == 0) - rte_delay_us_block (us); + extern char *vat_plugin_path; + char *p, path[PATH_MAX]; + int rv; + u8 *s; + + /* find executable path */ + if ((rv = readlink ("/proc/self/exe", path, PATH_MAX - 1)) == -1) + return; + + /* readlink doesn't provide null termination */ + path[rv] = 0; + + /* strip filename */ + if ((p = strrchr (path, '/')) == 0) + return; + *p = 0; + + /* strip bin/ */ + if ((p = strrchr (path, '/')) == 0) + return; + *p = 0; + + s = format (0, "%s/lib/" CLIB_TARGET_TRIPLET "/vpp_plugins:" + "%s/lib/vpp_plugins", path, path); + vec_add1 (s, 0); + vlib_plugin_path = (char *) s; + + s = format (0, "%s/lib/" CLIB_TARGET_TRIPLET "/vpp_api_test_plugins:" + "%s/lib/vpp_api_test_plugins", path, path); + vec_add1 (s, 0); + vat_plugin_path = (char *) s; } -#endif -#endif static void vpe_main_init (vlib_main_t * vm) { + void vat_plugin_hash_create (void); + if (CLIB_DEBUG > 0) vlib_unix_cli_set_prompt ("DBGvpp# "); else @@ -89,28 +83,19 @@ vpe_main_init (vlib_main_t * vm) /* Turn off network stack components which we don't want */ vlib_mark_init_function_complete (vm, srp_init); -#if DPDK -#if RTE_VERSION >= RTE_VERSION_NUM(16, 11, 0, 0) - /* register custom delay function */ - rte_delay_us_callback_register (rte_delay_us_override_cb); -#endif -#endif + /* + * Create the binary api plugin hashes before loading plugins + */ + vat_plugin_hash_create (); + + if (!vlib_plugin_path) + vpp_find_plugin_path (); } /* - * Load plugins from /usr/lib/vpp_plugins by default + * Default path for runtime data */ -char *vlib_plugin_path = "/usr/lib/vpp_plugins"; - -void * -vnet_get_handoff_structure (void) -{ - static vnet_plugin_handoff_t _rv, *rv = &_rv; - - rv->vnet_main = vnet_get_main (); - rv->ethernet_main = ðernet_main; - return (void *) rv; -} +char *vlib_default_runtime_dir = "vpp"; int main (int argc, char *argv[]) @@ -121,7 +106,9 @@ main (int argc, char *argv[]) uword main_heap_size = (1ULL << 30); u8 *sizep; u32 size; - void vlib_set_get_handoff_structure_cb (void *cb); + int main_core = 1; + cpu_set_t cpuset; + void *main_heap; #if __x86_64__ CLIB_UNUSED (const char *msg) @@ -174,10 +161,17 @@ main (int argc, char *argv[]) } argv_ = calloc (1, sizeof (char *)); if (argv_ == NULL) - return 1; + { + fclose (fp); + return 1; + } arg = strndup (argv[0], 1024); if (arg == NULL) - return 1; + { + fclose (fp); + free (argv_); + return 1; + } argv_[0] = arg; while (1) @@ -228,6 +222,11 @@ main (int argc, char *argv[]) if (i < (argc - 1)) vlib_plugin_path = argv[++i]; } + if (!strncmp (argv[i], "test_plugin_path", 16)) + { + if (i < (argc - 1)) + vat_plugin_path = argv[++i]; + } else if (!strncmp (argv[i], "heapsize", 8)) { sizep = (u8 *) argv[i + 1]; @@ -253,22 +252,42 @@ main (int argc, char *argv[]) else if (*sizep == 'm' || *sizep == 'M') main_heap_size <<= 20; } + else if (!strncmp (argv[i], "main-core", 9)) + { + if (i < (argc - 1)) + { + errno = 0; + unsigned long x = strtol (argv[++i], 0, 0); + if (errno == 0) + main_core = x; + } + } } defaulted: + /* set process affinity for main thread */ + CPU_ZERO (&cpuset); + CPU_SET (main_core, &cpuset); + pthread_setaffinity_np (pthread_self (), sizeof (cpu_set_t), &cpuset); + /* Set up the plugin message ID allocator right now... */ vl_msg_api_set_first_available_msg_id (VL_MSG_FIRST_AVAILABLE); /* Allocate main heap */ - if (clib_mem_init (0, main_heap_size)) + if ((main_heap = clib_mem_init_thread_safe (0, main_heap_size))) { + vlib_worker_thread_t tmp; + + /* Figure out which numa runs the main thread */ + vlib_get_thread_core_numa (&tmp, main_core); + __os_numa_index = tmp.numa_id; + + /* and use the main heap as that numa's numa heap */ + clib_mem_set_per_numa_heap (main_heap); + vm->init_functions_called = hash_create (0, /* value bytes */ 0); vpe_main_init (vm); -#if DPDK == 0 - unix_physmem_init (vm, 0 /* fail_if_physical_memory_not_present */ ); -#endif - vlib_set_get_handoff_structure_cb (&vnet_get_handoff_structure); return vlib_unix_main (argc, argv); } else @@ -302,7 +321,7 @@ heapsize_config (vlib_main_t * vm, unformat_input_t * input) VLIB_CONFIG_FUNCTION (heapsize_config, "heapsize"); static clib_error_t * -plugin_path_config (vlib_main_t * vm, unformat_input_t * input) +dummy_path_config (vlib_main_t * vm, unformat_input_t * input) { u8 *junk; @@ -320,14 +339,30 @@ plugin_path_config (vlib_main_t * vm, unformat_input_t * input) return 0; } +static clib_error_t * +plugin_path_config (vlib_main_t * vm, unformat_input_t * input) +{ + return dummy_path_config (vm, input); +} + VLIB_CONFIG_FUNCTION (plugin_path_config, "plugin_path"); +static clib_error_t * +test_plugin_path_config (vlib_main_t * vm, unformat_input_t * input) +{ + return dummy_path_config (vm, input); +} + +VLIB_CONFIG_FUNCTION (test_plugin_path_config, "test_plugin_path"); + void vl_msg_api_post_mortem_dump (void); +void elog_post_mortem_dump (void); void os_panic (void) { vl_msg_api_post_mortem_dump (); + elog_post_mortem_dump (); abort (); } @@ -350,12 +385,21 @@ os_exit (int code) recursion_block = 1; vl_msg_api_post_mortem_dump (); + elog_post_mortem_dump (); vhost_user_unmap_all (); abort (); } exit (code); } +#ifdef BARRIER_TRACING +void +vl_msg_api_barrier_trace_context (const char *context) +{ + vlib_worker_threads[0].barrier_context = context; +} +#endif + void vl_msg_api_barrier_sync (void) { @@ -382,29 +426,96 @@ vlib_app_num_thread_stacks_needed (void) * messages! */ -#if CLIB_DEBUG > 0 +#include + +typedef struct +{ + u8 *name; + u64 actual_virt_size; + u64 configured_virt_size; +} name_sort_t; + +static int +name_sort_cmp (void *a1, void *a2) +{ + name_sort_t *n1 = a1; + name_sort_t *n2 = a2; + + return strcmp ((char *) n1->name, (char *) n2->name); +} static clib_error_t * -test_crash_command_fn (vlib_main_t * vm, - unformat_input_t * input, vlib_cli_command_t * cmd) +show_bihash_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - u64 *p = (u64 *) 0xdefec8ed; + int i; + clib_bihash_8_8_t *h; + u64 total_actual_virt_size = 0; + u64 total_configured_virt_size = 0; + u64 actual_virt_size; + u64 configured_virt_size; + name_sort_t *names = 0; + name_sort_t *this; + int verbose = 0; + + if (unformat (input, "verbose")) + verbose = 1; + + for (i = 0; i < vec_len (clib_all_bihashes); i++) + { + h = (clib_bihash_8_8_t *) clib_all_bihashes[i]; + if (alloc_arena (h) || verbose) + { + vec_add2 (names, this, 1); + this->name = format (0, "%s%c", h->name, 0); + configured_virt_size = h->memory_size; + actual_virt_size = alloc_arena (h) ? h->memory_size : 0ULL; + this->actual_virt_size = actual_virt_size; + this->configured_virt_size = configured_virt_size; + total_actual_virt_size += actual_virt_size; + total_configured_virt_size += configured_virt_size; + } + } + + vec_sort_with_function (names, name_sort_cmp); + + vlib_cli_output (vm, "%-30s %8s %s", "Name", "Actual", "Configured"); + + for (i = 0; i < vec_len (names); i++) + { + vlib_cli_output (vm, "%-30s %8U %U", names[i].name, + format_memory_size, + names[i].actual_virt_size, + format_memory_size, names[i].configured_virt_size); + vec_free (names[i].name); + } - *p = 0xdeadbeef; + vec_free (names); - /* Not so much... */ + vlib_cli_output (vm, "%-30s %8U %U", "Total", + format_memory_size, total_actual_virt_size, + format_memory_size, total_configured_virt_size); return 0; } /* *INDENT-OFF* */ -VLIB_CLI_COMMAND (test_crash_command, static) = { - .path = "test crash", - .short_help = "crash the bus!", - .function = test_crash_command_fn, +VLIB_CLI_COMMAND (show_bihash_command, static) = +{ + .path = "show bihash", + .short_help = "show bihash", + .function = show_bihash_command_fn, }; /* *INDENT-ON* */ -#endif +#ifdef CLIB_SANITIZE_ADDR +/* default options for Address Sanitizer */ +const char * +__asan_default_options (void) +{ + return + "unmap_shadow_on_exit=1:disable_coredump=0:abort_on_error=1:detect_leaks=0"; +} +#endif /* CLIB_SANITIZE_ADDR */ /* * fd.io coding-style-patch-verification: ON