src/vlib/unix/main.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * main.c: Unix main routine
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39 #include <vlib/vlib.h>
  40 #include <vlib/unix/unix.h>
  41 #include <vlib/unix/plugin.h>
  42 #include <vppinfra/unix.h>
  43 #include <vppinfra/stack.h>
  44 #include <vppinfra/format_ansi.h>
  45
  46 #include <limits.h>
  47 #include <signal.h>
  48 #include <sys/ucontext.h>
  49 #include <syslog.h>
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include <fcntl.h>
  53 #include <sys/time.h>
  54 #include <sys/resource.h>
  55 #include <unistd.h>
  56
  57 /** Default CLI pager limit is not configured in startup.conf */
  58 #define UNIX_CLI_DEFAULT_PAGER_LIMIT 100000
  59
  60 /** Default CLI history depth if not configured in startup.conf */
  61 #define UNIX_CLI_DEFAULT_HISTORY 50
  62
  63 char *vlib_default_runtime_dir __attribute__ ((weak));
  64 char *vlib_default_runtime_dir = "vlib";
  65
  66 unix_main_t unix_main;
  67 clib_file_main_t file_main;
  68
  69 static clib_error_t *
  70 unix_main_init (vlib_main_t * vm)
  71 {
  72   unix_main_t *um = &unix_main;
  73   um->vlib_main = vm;
  74   return 0;
  75 }
  76
  77 VLIB_INIT_FUNCTION (unix_main_init) =
  78 {
  79   .runs_before = VLIB_INITS ("unix_input_init"),
  80 };
  81
  82 static int
  83 unsetup_signal_handlers (int sig)
  84 {
  85   struct sigaction sa;
  86
  87   sa.sa_handler = SIG_DFL;
  88   sa.sa_flags = 0;
  89   sigemptyset (&sa.sa_mask);
  90   return sigaction (sig, &sa, 0);
  91 }
  92
  93
  94 /* allocate this buffer from mheap when setting up the signal handler.
  95     dangerous to vec_resize it when crashing, mheap itself might have been
  96     corrupted already */
  97 static u8 *syslog_msg = 0;
  98 int vlib_last_signum = 0;
  99 uword vlib_last_faulting_address = 0;
 100
 101 static void
 102 log_one_line ()
 103 {
 104   vec_terminate_c_string (syslog_msg);
 105   if (unix_main.flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG))
 106     fprintf (stderr, "%s\n", syslog_msg);
 107   else
 108     syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg);
 109   vec_reset_length (syslog_msg);
 110 }
 111
 112 static void
 113 unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc)
 114 {
 115   uword fatal = 0;
 116   int color =
 117     (unix_main.flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG)) &&
 118     (unix_main.flags & UNIX_FLAG_NOCOLOR) == 0;
 119
 120   /* These come in handy when looking at core files from optimized images */
 121   vlib_last_signum = signum;
 122   vlib_last_faulting_address = (uword) si->si_addr;
 123
 124   if (color)
 125     syslog_msg = format (syslog_msg, ANSI_FG_BR_RED);
 126
 127   syslog_msg = format (syslog_msg, "received signal %U, PC %U",
 128                        format_signal, signum, format_ucontext_pc, uc);
 129
 130   if (signum == SIGSEGV || signum == SIGBUS)
 131     syslog_msg = format (syslog_msg, ", faulting address %p", si->si_addr);
 132
 133   if (color)
 134     syslog_msg = format (syslog_msg, ANSI_FG_DEFAULT);
 135
 136   log_one_line ();
 137
 138   switch (signum)
 139     {
 140       /* these (caught) signals cause the application to exit */
 141     case SIGTERM:
 142       /*
 143        * Ignore SIGTERM if it's sent before we're ready.
 144        */
 145       if (unix_main.vlib_main && unix_main.vlib_main->main_loop_exit_set)
 146         {
 147           syslog_msg = format (
 148             syslog_msg, "received SIGTERM from PID %d UID %d, exiting...",
 149             si->si_pid, si->si_uid);
 150           log_one_line ();
 151           unix_main.vlib_main->main_loop_exit_now = 1;
 152         }
 153       else
 154         {
 155           syslog_msg = format (syslog_msg, "IGNORE early SIGTERM...");
 156           log_one_line ();
 157         }
 158       break;
 159       /* fall through */
 160     case SIGQUIT:
 161     case SIGINT:
 162     case SIGILL:
 163     case SIGBUS:
 164     case SIGSEGV:
 165     case SIGHUP:
 166     case SIGFPE:
 167     case SIGABRT:
 168       fatal = 1;
 169       break;
 170
 171       /* by default, print a message and continue */
 172     default:
 173       fatal = 0;
 174       break;
 175     }
 176
 177
 178   if (fatal)
 179     {
 180       int skip = 1, index = 0;
 181
 182       foreach_clib_stack_frame (sf)
 183         {
 184           if (sf->is_signal_frame)
 185             {
 186               int pipefd[2];
 187               const int n_bytes = 20;
 188               u8 *ip = (void *) sf->ip;
 189
 190               if (pipe (pipefd) == 0)
 191                 {
 192                   /* check PC points to valid memory */
 193                   if (write (pipefd[1], ip, n_bytes) == n_bytes)
 194                     {
 195                       syslog_msg = format (syslog_msg, "Code: ");
 196                       if (color)
 197                         syslog_msg = format (syslog_msg, ANSI_FG_CYAN);
 198                       for (int i = 0; i < n_bytes; i++)
 199                         syslog_msg = format (syslog_msg, " %02x", ip[i]);
 200                       if (color)
 201                         syslog_msg = format (syslog_msg, ANSI_FG_DEFAULT);
 202                     }
 203                   else
 204                     {
 205                       syslog_msg = format (
 206                         syslog_msg, "PC contains invalid memory address");
 207                     }
 208                   log_one_line ();
 209                   foreach_int (i, 0, 1)
 210                     close (pipefd[i]);
 211                 }
 212               skip = 0;
 213             }
 214
 215           if (skip)
 216             continue;
 217
 218           syslog_msg = format (syslog_msg, "#%-2d ", index++);
 219           if (color)
 220             syslog_msg = format (syslog_msg, ANSI_FG_BLUE);
 221           syslog_msg = format (syslog_msg, "0x%016lx", sf->ip);
 222           if (color)
 223             syslog_msg = format (syslog_msg, ANSI_FG_DEFAULT);
 224
 225           if (sf->name[0])
 226             {
 227               if (color)
 228                 syslog_msg = format (syslog_msg, ANSI_FG_YELLOW);
 229               syslog_msg =
 230                 format (syslog_msg, " %s + 0x%x", sf->name, sf->offset);
 231               if (color)
 232                 syslog_msg = format (syslog_msg, ANSI_FG_DEFAULT);
 233             }
 234
 235           log_one_line ();
 236
 237           if (sf->file_name)
 238             {
 239               if (color)
 240                 syslog_msg = format (syslog_msg, ANSI_FG_GREEN);
 241               syslog_msg = format (syslog_msg, "     from %s", sf->file_name);
 242               if (color)
 243                 syslog_msg = format (syslog_msg, ANSI_FG_DEFAULT);
 244               log_one_line ();
 245             }
 246         }
 247
 248       /* have to remove SIGABRT to avoid recursive - os_exit calling abort() */
 249       unsetup_signal_handlers (SIGABRT);
 250
 251       /* os_exit(1) causes core generation, skip that for SIGINT, SIGHUP */
 252       if (signum == SIGINT || signum == SIGHUP)
 253         os_exit (0);
 254       else
 255         os_exit (1);
 256     }
 257 }
 258
 259 static clib_error_t *
 260 setup_signal_handlers (unix_main_t * um)
 261 {
 262   uword i;
 263   struct sigaction sa;
 264
 265   /* give a big enough buffer for msg, most likely it can avoid vec_resize  */
 266   vec_alloc (syslog_msg, 2048);
 267
 268   for (i = 1; i < 32; i++)
 269     {
 270       clib_memset (&sa, 0, sizeof (sa));
 271       sa.sa_sigaction = (void *) unix_signal_handler;
 272       sa.sa_flags = SA_SIGINFO;
 273
 274       switch (i)
 275         {
 276           /* these signals take the default action */
 277         case SIGKILL:
 278         case SIGCONT:
 279         case SIGSTOP:
 280         case SIGUSR1:
 281         case SIGUSR2:
 282         case SIGPROF:
 283           continue;
 284
 285           /* ignore SIGPIPE, SIGCHLD */
 286         case SIGPIPE:
 287         case SIGCHLD:
 288           sa.sa_sigaction = (void *) SIG_IGN;
 289           break;
 290
 291           /* catch and handle all other signals */
 292         default:
 293           break;
 294         }
 295
 296       if (sigaction (i, &sa, 0) < 0)
 297         return clib_error_return_unix (0, "sigaction %U", format_signal, i);
 298     }
 299
 300   return 0;
 301 }
 302
 303 static void
 304 unix_error_handler (void *arg, u8 * msg, int msg_len)
 305 {
 306   unix_main_t *um = arg;
 307
 308   /* Echo to stderr when interactive or syslog is disabled. */
 309   if (um->flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG))
 310     {
 311       CLIB_UNUSED (int r) = write (2, msg, msg_len);
 312     }
 313   else
 314     {
 315       syslog (LOG_ERR | LOG_DAEMON, "%.*s", msg_len, msg);
 316     }
 317 }
 318
 319 void
 320 vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error)
 321 {
 322   unix_main_t *um = &unix_main;
 323
 324   if (um->flags & UNIX_FLAG_INTERACTIVE || error == 0)
 325     return;
 326
 327   {
 328     u8 *msg = error->what;
 329     u32 len = vec_len (msg);
 330     int msg_len = (len > INT_MAX) ? INT_MAX : len;
 331     syslog (LOG_ERR | LOG_DAEMON, "%.*s", msg_len, msg);
 332   }
 333 }
 334
 335 static uword
 336 startup_config_process (vlib_main_t * vm,
 337                         vlib_node_runtime_t * rt, vlib_frame_t * f)
 338 {
 339   unix_main_t *um = &unix_main;
 340   unformat_input_t in;
 341
 342   vlib_process_suspend (vm, 2.0);
 343
 344   while (um->unix_config_complete == 0)
 345     vlib_process_suspend (vm, 0.1);
 346
 347   if (!um->startup_config_filename)
 348     {
 349       return 0;
 350     }
 351
 352   unformat_init_vector (&in,
 353                         format (0, "exec %s", um->startup_config_filename));
 354
 355   vlib_cli_input (vm, &in, 0, 0);
 356
 357   unformat_free (&in);
 358
 359   return 0;
 360 }
 361
 362 VLIB_REGISTER_NODE (startup_config_node,static) = {
 363     .function = startup_config_process,
 364     .type = VLIB_NODE_TYPE_PROCESS,
 365     .name = "startup-config-process",
 366     .process_log2_n_stack_bytes = 18,
 367 };
 368
 369 static clib_error_t *
 370 unix_config (vlib_main_t * vm, unformat_input_t * input)
 371 {
 372   vlib_global_main_t *vgm = vlib_get_global_main ();
 373   unix_main_t *um = &unix_main;
 374   clib_error_t *error = 0;
 375   gid_t gid;
 376   int pidfd = -1;
 377
 378   /* Defaults */
 379   um->cli_pager_buffer_limit = UNIX_CLI_DEFAULT_PAGER_LIMIT;
 380   um->cli_history_limit = UNIX_CLI_DEFAULT_HISTORY;
 381
 382   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 383     {
 384       char *cli_prompt;
 385       if (unformat (input, "interactive"))
 386         um->flags |= UNIX_FLAG_INTERACTIVE;
 387       else if (unformat (input, "nodaemon"))
 388         um->flags |= UNIX_FLAG_NODAEMON;
 389       else if (unformat (input, "nosyslog"))
 390         um->flags |= UNIX_FLAG_NOSYSLOG;
 391       else if (unformat (input, "nocolor"))
 392         um->flags |= UNIX_FLAG_NOCOLOR;
 393       else if (unformat (input, "nobanner"))
 394         um->flags |= UNIX_FLAG_NOBANNER;
 395       else if (unformat (input, "cli-prompt %s", &cli_prompt))
 396         vlib_unix_cli_set_prompt (cli_prompt);
 397       else
 398         if (unformat (input, "cli-listen %s", &um->cli_listen_socket.config))
 399         ;
 400       else if (unformat (input, "runtime-dir %s", &um->runtime_dir))
 401         ;
 402       else if (unformat (input, "cli-line-mode"))
 403         um->cli_line_mode = 1;
 404       else if (unformat (input, "cli-no-banner"))
 405         um->cli_no_banner = 1;
 406       else if (unformat (input, "cli-no-pager"))
 407         um->cli_no_pager = 1;
 408       else if (unformat (input, "poll-sleep-usec %d", &um->poll_sleep_usec))
 409         ;
 410       else if (unformat (input, "cli-pager-buffer-limit %d",
 411                          &um->cli_pager_buffer_limit))
 412         ;
 413       else
 414         if (unformat (input, "cli-history-limit %d", &um->cli_history_limit))
 415         ;
 416       else if (unformat (input, "coredump-size"))
 417         {
 418           uword coredump_size = 0;
 419           if (unformat (input, "unlimited"))
 420             {
 421               coredump_size = RLIM_INFINITY;
 422             }
 423           else
 424             if (!unformat (input, "%U", unformat_memory_size, &coredump_size))
 425             {
 426               return clib_error_return (0,
 427                                         "invalid coredump-size parameter `%U'",
 428                                         format_unformat_error, input);
 429             }
 430           const struct rlimit new_limit = { coredump_size, coredump_size };
 431           if (0 != setrlimit (RLIMIT_CORE, &new_limit))
 432             {
 433               clib_unix_warning ("prlimit() failed");
 434             }
 435         }
 436       else if (unformat (input, "full-coredump"))
 437         {
 438           int fd;
 439
 440           fd = open ("/proc/self/coredump_filter", O_WRONLY);
 441           if (fd >= 0)
 442             {
 443               if (write (fd, "0x6f\n", 5) != 5)
 444                 clib_unix_warning ("coredump filter write failed!");
 445               close (fd);
 446             }
 447           else
 448             clib_unix_warning ("couldn't open /proc/self/coredump_filter");
 449         }
 450       else if (unformat (input, "startup-config %s",
 451                          &um->startup_config_filename))
 452         ;
 453       else if (unformat (input, "exec %s", &um->startup_config_filename))
 454         ;
 455       else if (unformat (input, "log %s", &um->log_filename))
 456         {
 457           um->log_fd = open ((char *) um->log_filename,
 458                              O_CREAT | O_WRONLY | O_APPEND, 0644);
 459           if (um->log_fd < 0)
 460             {
 461               clib_warning ("couldn't open log '%s'\n", um->log_filename);
 462               um->log_fd = 0;
 463             }
 464           else
 465             {
 466               u8 *lv = 0;
 467               lv = format (0, "%U: ***** Start: PID %d *****\n",
 468                            format_timeval, NULL /* current bat-format */,
 469                            0 /* current bat-time */, getpid ());
 470               {
 471                 int rv __attribute__ ((unused)) =
 472                   write (um->log_fd, lv, vec_len (lv));
 473               }
 474               vec_free (lv);
 475             }
 476         }
 477       else if (unformat (input, "gid %U", unformat_unix_gid, &gid))
 478         {
 479           if (setegid (gid) == -1)
 480             return clib_error_return_unix (0, "setegid");
 481         }
 482       else if (unformat (input, "pidfile %s", &um->pidfile))
 483         ;
 484       else
 485         return clib_error_return (0, "unknown input `%U'",
 486                                   format_unformat_error, input);
 487     }
 488
 489   if (um->runtime_dir == 0)
 490     {
 491       uid_t uid = geteuid ();
 492       if (uid == 00)
 493         um->runtime_dir = format (0, "/run/%s%c",
 494                                   vlib_default_runtime_dir, 0);
 495       else
 496         um->runtime_dir = format (0, "/run/user/%u/%s%c", uid,
 497                                   vlib_default_runtime_dir, 0);
 498     }
 499
 500   /* Ensure the runtime directory is created */
 501   error = vlib_unix_recursive_mkdir ((char *) um->runtime_dir);
 502   if (error)
 503     return error;
 504
 505   if (chdir ((char *) um->runtime_dir) < 0)
 506     return clib_error_return_unix (0, "chdir('%s')", um->runtime_dir);
 507
 508   error = setup_signal_handlers (um);
 509   if (error)
 510     return error;
 511
 512   if (um->pidfile)
 513     {
 514       if ((error = vlib_unix_validate_runtime_file (um,
 515                                                     (char *) um->pidfile,
 516                                                     &um->pidfile)))
 517         return error;
 518
 519       if (((pidfd = open ((char *) um->pidfile,
 520                           O_CREAT | O_WRONLY | O_TRUNC, 0644)) < 0))
 521         {
 522           return clib_error_return_unix (0, "open");
 523         }
 524     }
 525
 526   if (!(um->flags & (UNIX_FLAG_INTERACTIVE | UNIX_FLAG_NOSYSLOG)))
 527     {
 528       openlog (vgm->name, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON);
 529       clib_error_register_handler (unix_error_handler, um);
 530
 531       if (!(um->flags & UNIX_FLAG_NODAEMON) && daemon ( /* chdir to / */ 0,
 532                                                        /* stdin/stdout/stderr -> /dev/null */
 533                                                        0) < 0)
 534         clib_error_return (0, "daemon () fails");
 535     }
 536
 537   if (pidfd >= 0)
 538     {
 539       u8 *lv = format (0, "%d", getpid ());
 540       if (write (pidfd, (char *) lv, vec_len (lv)) != vec_len (lv))
 541         {
 542           vec_free (lv);
 543           close (pidfd);
 544           return clib_error_return_unix (0, "write");
 545         }
 546       vec_free (lv);
 547       close (pidfd);
 548     }
 549
 550   um->unix_config_complete = 1;
 551
 552   return 0;
 553 }
 554
 555 /* unix { ... } configuration. */
 556 /*?
 557  *
 558  * @cfgcmd{interactive}
 559  * Attach CLI to stdin/out and provide a debugging command line interface.
 560  * Implies @c nodaemon.
 561  *
 562  * @cfgcmd{nodaemon}
 563  * Do not fork or background the VPP process. Typically used when invoking
 564  * VPP applications from a process monitor.
 565  *
 566  * @cfgcmd{nosyslog}
 567  * Do not send e.g. clib_warning(...) output to syslog. Used
 568  * when invoking VPP applications from a process monitor which
 569  * pipe stdout/stderr to a dedicated logger service.
 570  *
 571  * @cfgcmd{nocolor}
 572  * Do not use colors in outputs.
 573  * *
 574  * @cfgcmd{nobanner}
 575  * Do not display startup banner.
 576  *
 577  * @cfgcmd{exec, &lt;filename&gt;}
 578  * @par <code>startup-config &lt;filename&gt;</code>
 579  * Read startup operational configuration from @c filename.
 580  * The contents of the file will be performed as though entered at the CLI.
 581  * The two keywords are aliases for the same function; if both are specified,
 582  * only the last will have an effect.
 583  *
 584  * @cfgcmd{log, &lt;filename&gt;}
 585  * Logs the startup configuration and all subsequent CLI commands in
 586  * @c filename.
 587  * Very useful in situations where folks don't remember or can't be bothered
 588  * to include CLI commands in bug reports.
 589  *
 590  * @cfgcmd{pidfile, &lt;filename&gt;}
 591  * Writes the pid of the main thread in @c filename.
 592  *
 593  * @cfgcmd{full-coredump}
 594  * Ask the Linux kernel to dump all memory-mapped address regions, instead
 595  * of just text+data+bss.
 596  *
 597  * @cfgcmd{runtime-dir}
 598  * Define directory where VPP is going to store all runtime files.
 599  * Default is /run/vpp when running as root, /run/user/<UID>/vpp if running as
 600  * an unprivileged user.
 601  *
 602  * @cfgcmd{cli-listen, &lt;address:port&gt;}
 603  * Bind the CLI to listen at the address and port given. @c localhost
 604  * on TCP port @c 5002, given as <tt>cli-listen localhost:5002</tt>,
 605  * is typical.
 606  *
 607  * @cfgcmd{cli-line-mode}
 608  * Disable character-by-character I/O on stdin. Useful when combined with,
 609  * for example, <tt>emacs M-x gud-gdb</tt>.
 610  *
 611  * @cfgcmd{cli-prompt, &lt;string&gt;}
 612  * Configure the CLI prompt to be @c string.
 613  *
 614  * @cfgcmd{cli-history-limit, &lt;nn&gt;}
 615  * Limit command history to @c nn  lines. A value of @c 0
 616  * disables command history. Default value: @c 50
 617  *
 618  * @cfgcmd{cli-no-banner}
 619  * Disable the login banner on stdin and Telnet connections.
 620  *
 621  * @cfgcmd{cli-no-pager}
 622  * Disable the output pager.
 623  *
 624  * @cfgcmd{cli-pager-buffer-limit, &lt;nn&gt;}
 625  * Limit pager buffer to @c nn lines of output.
 626  * A value of @c 0 disables the pager. Default value: @c 100000
 627  *
 628  * @cfgcmd{gid, &lt;nn&gt;}
 629  * Set the effective gid under which the vpp process is to run.
 630  *
 631  * @cfgcmd{poll-sleep-usec, &lt;nn&gt;}
 632  * Set a fixed poll sleep interval between main loop polls.
 633 ?*/
 634 VLIB_EARLY_CONFIG_FUNCTION (unix_config, "unix");
 635
 636 static clib_error_t *
 637 unix_exit (vlib_main_t * vm)
 638 {
 639   /* Close syslog connection. */
 640   closelog ();
 641   return 0;
 642 }
 643
 644 VLIB_MAIN_LOOP_EXIT_FUNCTION (unix_exit);
 645
 646 u8 **vlib_thread_stacks;
 647
 648 static uword
 649 thread0 (uword arg)
 650 {
 651   vlib_main_t *vm = (vlib_main_t *) arg;
 652   vlib_global_main_t *vgm = vlib_get_global_main ();
 653   unformat_input_t input;
 654   int i;
 655
 656   vlib_process_finish_switch_stack (vm);
 657
 658   unformat_init_command_line (&input, (char **) vgm->argv);
 659   i = vlib_main (vm, &input);
 660   unformat_free (&input);
 661
 662   return i;
 663 }
 664
 665 u8 *
 666 vlib_thread_stack_init (uword thread_index)
 667 {
 668   void *stack;
 669   ASSERT (thread_index < vec_len (vlib_thread_stacks));
 670   stack = clib_mem_vm_map_stack (VLIB_THREAD_STACK_SIZE,
 671                                  CLIB_MEM_PAGE_SZ_DEFAULT,
 672                                  "thread stack: thread %u", thread_index);
 673
 674   if (stack == CLIB_MEM_VM_MAP_FAILED)
 675     clib_panic ("failed to allocate thread %u stack", thread_index);
 676
 677   vlib_thread_stacks[thread_index] = stack;
 678   return stack;
 679 }
 680
 681 #ifndef PATH_MAX
 682 #define PATH_MAX 4096
 683 #endif
 684
 685 int
 686 vlib_unix_main (int argc, char *argv[])
 687 {
 688   vlib_global_main_t *vgm = vlib_get_global_main ();
 689   vlib_main_t *vm = vlib_get_first_main (); /* one and only time for this! */
 690   unformat_input_t input;
 691   clib_error_t *e;
 692   int i;
 693
 694   vec_validate_aligned (vgm->vlib_mains, 0, CLIB_CACHE_LINE_BYTES);
 695
 696   vgm->exec_path = (char *) os_get_exec_path ();
 697
 698   if (vgm->exec_path)
 699     {
 700       for (i = vec_len (vgm->exec_path) - 1; i > 0; i--)
 701         if (vgm->exec_path[i - 1] == '/')
 702           break;
 703
 704       vgm->name = 0;
 705
 706       vec_add (vgm->name, vgm->exec_path + i, vec_len (vgm->exec_path) - i);
 707       vec_add1 (vgm->exec_path, 0);
 708       vec_add1 (vgm->name, 0);
 709     }
 710   else
 711     vgm->exec_path = vgm->name = argv[0];
 712
 713   vgm->argv = (u8 **) argv;
 714
 715   clib_time_init (&vm->clib_time);
 716
 717   /* Turn on the event logger at the first possible moment */
 718   vgm->configured_elog_ring_size = 128 << 10;
 719   elog_init (vlib_get_elog_main (), vgm->configured_elog_ring_size);
 720   elog_enable_disable (vlib_get_elog_main (), 1);
 721
 722   unformat_init_command_line (&input, (char **) vgm->argv);
 723   if ((e = vlib_plugin_config (vm, &input)))
 724     {
 725       clib_error_report (e);
 726       return 1;
 727     }
 728   unformat_free (&input);
 729
 730   i = vlib_plugin_early_init (vm);
 731   if (i)
 732     return i;
 733
 734   unformat_init_command_line (&input, (char **) vgm->argv);
 735   if (vgm->init_functions_called == 0)
 736     vgm->init_functions_called = hash_create (0, /* value bytes */ 0);
 737   e = vlib_call_all_config_functions (vm, &input, 1 /* early */ );
 738   if (e != 0)
 739     {
 740       clib_error_report (e);
 741       return 1;
 742     }
 743   unformat_free (&input);
 744
 745   /* always load symbols, for signal handler and mheap memory get/put backtrace */
 746   clib_elf_main_init (vgm->exec_path);
 747
 748   vec_validate (vlib_thread_stacks, 0);
 749   vlib_thread_stack_init (0);
 750
 751   __os_thread_index = 0;
 752   vm->thread_index = 0;
 753
 754   vlib_process_start_switch_stack (vm, 0);
 755   i = clib_calljmp (thread0, (uword) vm,
 756                     (void *) (vlib_thread_stacks[0] +
 757                               VLIB_THREAD_STACK_SIZE));
 758   return i;
 759 }
 760
 761 /*
 762  * fd.io coding-style-patch-verification: ON
 763  *
 764  * Local Variables:
 765  * eval: (c-set-style "gnu")
 766  * End:
 767  */