X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvlib%2Funix%2Fmain.c;h=f09a537a48daed240a6ec1506353d631c01a2b9a;hb=1c95e12b0dd2b4902a289328e8e54fde6eed0623;hp=6b96cc0db47bfc91426efafda3a93706ea19cc02;hpb=c8c44ebea155f15a9e3067fe05228a1e932185fc;p=vpp.git diff --git a/src/vlib/unix/main.c b/src/vlib/unix/main.c index 6b96cc0db47..f09a537a48d 100644 --- a/src/vlib/unix/main.c +++ b/src/vlib/unix/main.c @@ -40,6 +40,7 @@ #include #include +#include #include #include #include @@ -48,6 +49,7 @@ #include #include #include +#include /** Default CLI pager limit is not configured in startup.conf */ #define UNIX_CLI_DEFAULT_PAGER_LIMIT 100000 @@ -55,42 +57,76 @@ /** Default CLI history depth if not configured in startup.conf */ #define UNIX_CLI_DEFAULT_HISTORY 50 +char *vlib_default_runtime_dir __attribute__ ((weak)); +char *vlib_default_runtime_dir = "vlib"; unix_main_t unix_main; +clib_file_main_t file_main; static clib_error_t * unix_main_init (vlib_main_t * vm) { unix_main_t *um = &unix_main; um->vlib_main = vm; - return vlib_call_init_function (vm, unix_input_init); + return 0; } -VLIB_INIT_FUNCTION (unix_main_init); +/* *INDENT-OFF* */ +VLIB_INIT_FUNCTION (unix_main_init) = +{ + .runs_before = VLIB_INITS ("unix_input_init"), +}; +/* *INDENT-ON* */ + +static int +unsetup_signal_handlers (int sig) +{ + struct sigaction sa; + + sa.sa_handler = SIG_DFL; + sa.sa_flags = 0; + sigemptyset (&sa.sa_mask); + return sigaction (sig, &sa, 0); +} + + +/* allocate this buffer from mheap when setting up the signal handler. + dangerous to vec_resize it when crashing, mheap itself might have been + corrupted already */ +static u8 *syslog_msg = 0; +int vlib_last_signum = 0; +uword vlib_last_faulting_address = 0; static void unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc) { - uword fatal; - u8 *msg = 0; + uword fatal = 0; + + /* These come in handy when looking at core files from optimized images */ + vlib_last_signum = signum; + vlib_last_faulting_address = (uword) si->si_addr; - msg = format (msg, "received signal %U, PC %U", - format_signal, signum, format_ucontext_pc, uc); + syslog_msg = format (syslog_msg, "received signal %U, PC %U", + format_signal, signum, format_ucontext_pc, uc); if (signum == SIGSEGV) - msg = format (msg, ", faulting address %p", si->si_addr); + syslog_msg = format (syslog_msg, ", faulting address %p", si->si_addr); switch (signum) { /* these (caught) signals cause the application to exit */ case SIGTERM: - if (unix_main.vlib_main->main_loop_exit_set) + /* + * Ignore SIGTERM if it's sent before we're ready. + */ + if (unix_main.vlib_main && unix_main.vlib_main->main_loop_exit_set) { syslog (LOG_ERR | LOG_DAEMON, "received SIGTERM, exiting..."); - - clib_longjmp (&unix_main.vlib_main->main_loop_exit, - VLIB_MAIN_LOOP_EXIT_CLI); + unix_main.vlib_main->main_loop_exit_now = 1; } + else + syslog (LOG_ERR | LOG_DAEMON, "IGNORE early SIGTERM..."); + break; /* fall through */ case SIGQUIT: case SIGINT: @@ -99,6 +135,7 @@ unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc) case SIGSEGV: case SIGHUP: case SIGFPE: + case SIGABRT: fatal = 1; break; @@ -109,17 +146,39 @@ unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc) } /* Null terminate. */ - vec_add1 (msg, 0); + vec_add1 (syslog_msg, 0); if (fatal) { - syslog (LOG_ERR | LOG_DAEMON, "%s", msg); - os_exit (1); + syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg); + + /* Address of callers: outer first, inner last. */ + uword callers[15]; + uword n_callers = clib_backtrace (callers, ARRAY_LEN (callers), 0); + int i; + for (i = 0; i < n_callers; i++) + { + vec_reset_length (syslog_msg); + + syslog_msg = + format (syslog_msg, "#%-2d 0x%016lx %U%c", i, callers[i], + format_clib_elf_symbol_with_address, callers[i], 0); + + syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg); + } + + /* have to remove SIGABRT to avoid recursive - os_exit calling abort() */ + unsetup_signal_handlers (SIGABRT); + + /* os_exit(1) causes core generation, skip that for SIGINT, SIGHUP */ + if (signum == SIGINT || signum == SIGHUP) + os_exit (0); + else + os_exit (1); } else - clib_warning ("%s", msg); + clib_warning ("%s", syslog_msg); - vec_free (msg); } static clib_error_t * @@ -128,20 +187,24 @@ setup_signal_handlers (unix_main_t * um) uword i; struct sigaction sa; + /* give a big enough buffer for msg, most likely it can avoid vec_resize */ + vec_alloc (syslog_msg, 2048); + for (i = 1; i < 32; i++) { - memset (&sa, 0, sizeof (sa)); + clib_memset (&sa, 0, sizeof (sa)); sa.sa_sigaction = (void *) unix_signal_handler; sa.sa_flags = SA_SIGINFO; switch (i) { /* these signals take the default action */ - case SIGABRT: case SIGKILL: + case SIGCONT: case SIGSTOP: case SIGUSR1: case SIGUSR2: + case SIGPROF: continue; /* ignore SIGPIPE, SIGCHLD */ @@ -167,21 +230,14 @@ unix_error_handler (void *arg, u8 * msg, int msg_len) { unix_main_t *um = arg; - /* Echo to stderr when interactive. */ - if (um->flags & UNIX_FLAG_INTERACTIVE) + /* Echo to stderr when interactive or syslog is disabled. */ + if (um->flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG)) { CLIB_UNUSED (int r) = write (2, msg, msg_len); } else { - char save = msg[msg_len - 1]; - - /* Null Terminate. */ - msg[msg_len - 1] = 0; - - syslog (LOG_ERR | LOG_DAEMON, "%s", msg); - - msg[msg_len - 1] = save; + syslog (LOG_ERR | LOG_DAEMON, "%.*s", msg_len, msg); } } @@ -194,20 +250,10 @@ vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error) return; { - char save; - u8 *msg; - u32 msg_len; - - msg = error->what; - msg_len = vec_len (msg); - - /* Null Terminate. */ - save = msg[msg_len - 1]; - msg[msg_len - 1] = 0; - - syslog (LOG_ERR | LOG_DAEMON, "%s", msg); - - msg[msg_len - 1] = save; + u8 *msg = error->what; + u32 len = vec_len (msg); + int msg_len = (len > INT_MAX) ? INT_MAX : len; + syslog (LOG_ERR | LOG_DAEMON, "%.*s", msg_len, msg); } } @@ -216,87 +262,25 @@ startup_config_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) { unix_main_t *um = &unix_main; - u8 *buf = 0; - uword l, n = 1; + unformat_input_t in; vlib_process_suspend (vm, 2.0); while (um->unix_config_complete == 0) vlib_process_suspend (vm, 0.1); - if (um->startup_config_filename) + if (!um->startup_config_filename) { - unformat_input_t sub_input; - int fd; - struct stat s; - char *fn = (char *) um->startup_config_filename; + return 0; + } - fd = open (fn, O_RDONLY); - if (fd < 0) - { - clib_warning ("failed to open `%s'", fn); - return 0; - } + unformat_init_vector (&in, + format (0, "exec %s", um->startup_config_filename)); - if (fstat (fd, &s) < 0) - { - clib_warning ("failed to stat `%s'", fn); - bail: - close (fd); - return 0; - } + vlib_cli_input (vm, &in, 0, 0); - if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode))) - { - clib_warning ("not a regular file: `%s'", fn); - goto bail; - } - - while (n > 0) - { - l = vec_len (buf); - vec_resize (buf, 4096); - n = read (fd, buf + l, 4096); - if (n > 0) - { - _vec_len (buf) = l + n; - if (n < 4096) - break; - } - else - break; - } - if (um->log_fd && vec_len (buf)) - { - u8 *lv = 0; - lv = format (lv, "%U: ***** Startup Config *****\n%v", - format_timeval, 0 /* current bat-time */ , - 0 /* current bat-format */ , - buf); - { - int rv __attribute__ ((unused)) = - write (um->log_fd, lv, vec_len (lv)); - } - vec_reset_length (lv); - lv = format (lv, "%U: ***** End Startup Config *****\n", - format_timeval, 0 /* current bat-time */ , - 0 /* current bat-format */ ); - { - int rv __attribute__ ((unused)) = - write (um->log_fd, lv, vec_len (lv)); - } - vec_free (lv); - } + unformat_free (&in); - if (vec_len (buf)) - { - unformat_init_vector (&sub_input, buf); - vlib_cli_input (vm, &sub_input, 0, 0); - /* frees buf for us */ - unformat_free (&sub_input); - } - close (fd); - } return 0; } @@ -305,14 +289,18 @@ VLIB_REGISTER_NODE (startup_config_node,static) = { .function = startup_config_process, .type = VLIB_NODE_TYPE_PROCESS, .name = "startup-config-process", + .process_log2_n_stack_bytes = 18, }; /* *INDENT-ON* */ static clib_error_t * unix_config (vlib_main_t * vm, unformat_input_t * input) { + vlib_global_main_t *vgm = vlib_get_global_main (); unix_main_t *um = &unix_main; clib_error_t *error = 0; + gid_t gid; + int pidfd = -1; /* Defaults */ um->cli_pager_buffer_limit = UNIX_CLI_DEFAULT_PAGER_LIMIT; @@ -325,17 +313,27 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) um->flags |= UNIX_FLAG_INTERACTIVE; else if (unformat (input, "nodaemon")) um->flags |= UNIX_FLAG_NODAEMON; + else if (unformat (input, "nosyslog")) + um->flags |= UNIX_FLAG_NOSYSLOG; + else if (unformat (input, "nocolor")) + um->flags |= UNIX_FLAG_NOCOLOR; + else if (unformat (input, "nobanner")) + um->flags |= UNIX_FLAG_NOBANNER; else if (unformat (input, "cli-prompt %s", &cli_prompt)) vlib_unix_cli_set_prompt (cli_prompt); else if (unformat (input, "cli-listen %s", &um->cli_listen_socket.config)) ; + else if (unformat (input, "runtime-dir %s", &um->runtime_dir)) + ; else if (unformat (input, "cli-line-mode")) um->cli_line_mode = 1; else if (unformat (input, "cli-no-banner")) um->cli_no_banner = 1; else if (unformat (input, "cli-no-pager")) um->cli_no_pager = 1; + else if (unformat (input, "poll-sleep-usec %d", &um->poll_sleep_usec)) + ; else if (unformat (input, "cli-pager-buffer-limit %d", &um->cli_pager_buffer_limit)) ; @@ -394,9 +392,8 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) { u8 *lv = 0; lv = format (0, "%U: ***** Start: PID %d *****\n", - format_timeval, 0 /* current bat-time */ , - 0 /* current bat-format */ , - getpid ()); + format_timeval, NULL /* current bat-format */, + 0 /* current bat-time */, getpid ()); { int rv __attribute__ ((unused)) = write (um->log_fd, lv, vec_len (lv)); @@ -404,18 +401,58 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) vec_free (lv); } } + else if (unformat (input, "gid %U", unformat_unix_gid, &gid)) + { + if (setegid (gid) == -1) + return clib_error_return_unix (0, "setegid"); + } + else if (unformat (input, "pidfile %s", &um->pidfile)) + ; else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); } - if (!(um->flags & UNIX_FLAG_INTERACTIVE)) + if (um->runtime_dir == 0) + { + uid_t uid = geteuid (); + if (uid == 00) + um->runtime_dir = format (0, "/run/%s%c", + vlib_default_runtime_dir, 0); + else + um->runtime_dir = format (0, "/run/user/%u/%s%c", uid, + vlib_default_runtime_dir, 0); + } + + /* Ensure the runtime directory is created */ + error = vlib_unix_recursive_mkdir ((char *) um->runtime_dir); + if (error) + return error; + + if (chdir ((char *) um->runtime_dir) < 0) + return clib_error_return_unix (0, "chdir('%s')", um->runtime_dir); + + error = setup_signal_handlers (um); + if (error) + return error; + + if (um->pidfile) { - error = setup_signal_handlers (um); - if (error) + if ((error = vlib_unix_validate_runtime_file (um, + (char *) um->pidfile, + &um->pidfile))) return error; - openlog (vm->name, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON); + if (((pidfd = open ((char *) um->pidfile, + O_CREAT | O_WRONLY | O_TRUNC, 0644)) < 0)) + { + return clib_error_return_unix (0, "open"); + } + } + + if (!(um->flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG))) + { + openlog (vgm->name, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON); clib_error_register_handler (unix_error_handler, um); if (!(um->flags & UNIX_FLAG_NODAEMON) && daemon ( /* chdir to / */ 0, @@ -423,6 +460,20 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) 0) < 0) clib_error_return (0, "daemon () fails"); } + + if (pidfd >= 0) + { + u8 *lv = format (0, "%d", getpid ()); + if (write (pidfd, (char *) lv, vec_len (lv)) != vec_len (lv)) + { + vec_free (lv); + close (pidfd); + return clib_error_return_unix (0, "write"); + } + vec_free (lv); + close (pidfd); + } + um->unix_config_complete = 1; return 0; @@ -439,6 +490,17 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) * Do not fork or background the VPP process. Typically used when invoking * VPP applications from a process monitor. * + * @cfgcmd{nosyslog} + * Do not send e.g. clib_warning(...) output to syslog. Used + * when invoking VPP applications from a process monitor which + * pipe stdout/stderr to a dedicated logger service. + * + * @cfgcmd{nocolor} + * Do not use colors in outputs. + * * + * @cfgcmd{nobanner} + * Do not display startup banner. + * * @cfgcmd{exec, <filename>} * @par startup-config <filename> * Read startup operational configuration from @c filename. @@ -452,12 +514,20 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) * Very useful in situations where folks don't remember or can't be bothered * to include CLI commands in bug reports. * + * @cfgcmd{pidfile, <filename>} + * Writes the pid of the main thread in @c filename. + * * @cfgcmd{full-coredump} * Ask the Linux kernel to dump all memory-mapped address regions, instead * of just text+data+bss. * + * @cfgcmd{runtime-dir} + * Define directory where VPP is going to store all runtime files. + * Default is /run/vpp when running as root, /run/user//vpp if running as + * an unprivileged user. + * * @cfgcmd{cli-listen, <address:port>} - * Bind the CLI to listen at the address and port given. @clocalhost + * Bind the CLI to listen at the address and port given. @c localhost * on TCP port @c 5002, given as cli-listen localhost:5002, * is typical. * @@ -469,7 +539,7 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) * Configure the CLI prompt to be @c string. * * @cfgcmd{cli-history-limit, <nn>} - * Limit commmand history to @c nn lines. A value of @c 0 + * Limit command history to @c nn lines. A value of @c 0 * disables command history. Default value: @c 50 * * @cfgcmd{cli-no-banner} @@ -481,8 +551,14 @@ unix_config (vlib_main_t * vm, unformat_input_t * input) * @cfgcmd{cli-pager-buffer-limit, <nn>} * Limit pager buffer to @c nn lines of output. * A value of @c 0 disables the pager. Default value: @c 100000 + * + * @cfgcmd{gid, <nn>} + * Set the effective gid under which the vpp process is to run. + * + * @cfgcmd{poll-sleep-usec, <nn>} + * Set a fixed poll sleep interval between main loop polls. ?*/ -VLIB_CONFIG_FUNCTION (unix_config, "unix"); +VLIB_EARLY_CONFIG_FUNCTION (unix_config, "unix"); static clib_error_t * unix_exit (vlib_main_t * vm) @@ -500,32 +576,76 @@ static uword thread0 (uword arg) { vlib_main_t *vm = (vlib_main_t *) arg; + vlib_global_main_t *vgm = vlib_get_global_main (); unformat_input_t input; int i; - unformat_init_command_line (&input, (char **) vm->argv); + vlib_process_finish_switch_stack (vm); + + unformat_init_command_line (&input, (char **) vgm->argv); i = vlib_main (vm, &input); unformat_free (&input); return i; } +u8 * +vlib_thread_stack_init (uword thread_index) +{ + void *stack; + ASSERT (thread_index < vec_len (vlib_thread_stacks)); + stack = clib_mem_vm_map_stack (VLIB_THREAD_STACK_SIZE, + CLIB_MEM_PAGE_SZ_DEFAULT, + "thread stack: thread %u", thread_index); + + if (stack == CLIB_MEM_VM_MAP_FAILED) + clib_panic ("failed to allocate thread %u stack", thread_index); + + vlib_thread_stacks[thread_index] = stack; + return stack; +} + +#ifndef PATH_MAX +#define PATH_MAX 4096 +#endif + int vlib_unix_main (int argc, char *argv[]) { - vlib_main_t *vm = &vlib_global_main; /* one and only time for this! */ - vlib_thread_main_t *tm = &vlib_thread_main; + vlib_global_main_t *vgm = vlib_get_global_main (); + vlib_main_t *vm = vlib_get_first_main (); /* one and only time for this! */ unformat_input_t input; - u8 *thread_stacks; clib_error_t *e; + char buffer[PATH_MAX]; int i; - vm->argv = (u8 **) argv; - vm->name = argv[0]; - vm->heap_base = clib_mem_get_heap (); - ASSERT (vm->heap_base); + vec_validate_aligned (vgm->vlib_mains, 0, CLIB_CACHE_LINE_BYTES); - unformat_init_command_line (&input, (char **) vm->argv); + if ((i = readlink ("/proc/self/exe", buffer, sizeof (buffer) - 1)) > 0) + { + int j; + buffer[i] = 0; + vgm->exec_path = vec_new (char, i + 1); + clib_memcpy_fast (vgm->exec_path, buffer, i + 1); + for (j = i - 1; j > 0; j--) + if (buffer[j - 1] == '/') + break; + vgm->name = vec_new (char, i - j + 1); + clib_memcpy_fast (vgm->name, buffer + j, i - j + 1); + } + else + vgm->exec_path = vgm->name = argv[0]; + + vgm->argv = (u8 **) argv; + + clib_time_init (&vm->clib_time); + + /* Turn on the event logger at the first possible moment */ + vgm->configured_elog_ring_size = 128 << 10; + elog_init (vlib_get_elog_main (), vgm->configured_elog_ring_size); + elog_enable_disable (vlib_get_elog_main (), 1); + + unformat_init_command_line (&input, (char **) vgm->argv); if ((e = vlib_plugin_config (vm, &input))) { clib_error_report (e); @@ -537,9 +657,9 @@ vlib_unix_main (int argc, char *argv[]) if (i) return i; - unformat_init_command_line (&input, (char **) vm->argv); - if (vm->init_functions_called == 0) - vm->init_functions_called = hash_create (0, /* value bytes */ 0); + unformat_init_command_line (&input, (char **) vgm->argv); + if (vgm->init_functions_called == 0) + vgm->init_functions_called = hash_create (0, /* value bytes */ 0); e = vlib_call_all_config_functions (vm, &input, 1 /* early */ ); if (e != 0) { @@ -548,30 +668,16 @@ vlib_unix_main (int argc, char *argv[]) } unformat_free (&input); - /* - * allocate n x VLIB_THREAD_STACK_SIZE stacks, aligned to a - * VLIB_THREAD_STACK_SIZE boundary - * See also: os_get_cpu_number() in vlib/vlib/threads.c - */ - thread_stacks = clib_mem_alloc_aligned - ((uword) tm->n_thread_stacks * VLIB_THREAD_STACK_SIZE, - VLIB_THREAD_STACK_SIZE); - - vec_validate (vlib_thread_stacks, tm->n_thread_stacks - 1); - for (i = 0; i < vec_len (vlib_thread_stacks); i++) - { - vlib_thread_stacks[i] = thread_stacks; + /* always load symbols, for signal handler and mheap memory get/put backtrace */ + clib_elf_main_init (vgm->exec_path); - /* - * Disallow writes to the bottom page of the stack, to - * catch stack overflows. - */ - if (mprotect (thread_stacks, clib_mem_get_page_size (), PROT_READ) < 0) - clib_unix_warning ("thread stack"); + vec_validate (vlib_thread_stacks, 0); + vlib_thread_stack_init (0); - thread_stacks += VLIB_THREAD_STACK_SIZE; - } + __os_thread_index = 0; + vm->thread_index = 0; + vlib_process_start_switch_stack (vm, 0); i = clib_calljmp (thread0, (uword) vm, (void *) (vlib_thread_stacks[0] + VLIB_THREAD_STACK_SIZE));