FD.io VPP  v18.01-8-g0eacf49
Vector Packet Processing
main.c
Go to the documentation of this file.
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 
43 #include <signal.h>
44 #include <sys/ucontext.h>
45 #include <syslog.h>
46 #include <sys/types.h>
47 #include <sys/stat.h>
48 #include <fcntl.h>
49 #include <sys/time.h>
50 #include <sys/resource.h>
51 #include <unistd.h>
52 
53 /** Default CLI pager limit is not configured in startup.conf */
54 #define UNIX_CLI_DEFAULT_PAGER_LIMIT 100000
55 
56 /** Default CLI history depth if not configured in startup.conf */
57 #define UNIX_CLI_DEFAULT_HISTORY 50
58 
59 char *vlib_default_runtime_dir __attribute__ ((weak));
60 char *vlib_default_runtime_dir = "vlib";
61 
64 
65 static clib_error_t *
67 {
68  unix_main_t *um = &unix_main;
69  um->vlib_main = vm;
71 }
72 
74 
75 static void
76 unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc)
77 {
78  uword fatal = 0;
79  u8 *msg = 0;
80 
81  msg = format (msg, "received signal %U, PC %U",
82  format_signal, signum, format_ucontext_pc, uc);
83 
84  if (signum == SIGSEGV)
85  msg = format (msg, ", faulting address %p", si->si_addr);
86 
87  switch (signum)
88  {
89  /* these (caught) signals cause the application to exit */
90  case SIGTERM:
91  if (unix_main.vlib_main->main_loop_exit_set)
92  {
93  syslog (LOG_ERR | LOG_DAEMON, "received SIGTERM, exiting...");
94  unix_main.vlib_main->main_loop_exit_now = 1;
95  }
96  break;
97  /* fall through */
98  case SIGQUIT:
99  case SIGINT:
100  case SIGILL:
101  case SIGBUS:
102  case SIGSEGV:
103  case SIGHUP:
104  case SIGFPE:
105  fatal = 1;
106  break;
107 
108  /* by default, print a message and continue */
109  default:
110  fatal = 0;
111  break;
112  }
113 
114  /* Null terminate. */
115  vec_add1 (msg, 0);
116 
117  if (fatal)
118  {
119  syslog (LOG_ERR | LOG_DAEMON, "%s", msg);
120  os_exit (1);
121  }
122  else
123  clib_warning ("%s", msg);
124 
125  vec_free (msg);
126 }
127 
128 static clib_error_t *
130 {
131  uword i;
132  struct sigaction sa;
133 
134  for (i = 1; i < 32; i++)
135  {
136  memset (&sa, 0, sizeof (sa));
137  sa.sa_sigaction = (void *) unix_signal_handler;
138  sa.sa_flags = SA_SIGINFO;
139 
140  switch (i)
141  {
142  /* these signals take the default action */
143  case SIGABRT:
144  case SIGKILL:
145  case SIGSTOP:
146  case SIGUSR1:
147  case SIGUSR2:
148  continue;
149 
150  /* ignore SIGPIPE, SIGCHLD */
151  case SIGPIPE:
152  case SIGCHLD:
153  sa.sa_sigaction = (void *) SIG_IGN;
154  break;
155 
156  /* catch and handle all other signals */
157  default:
158  break;
159  }
160 
161  if (sigaction (i, &sa, 0) < 0)
162  return clib_error_return_unix (0, "sigaction %U", format_signal, i);
163  }
164 
165  return 0;
166 }
167 
168 static void
169 unix_error_handler (void *arg, u8 * msg, int msg_len)
170 {
171  unix_main_t *um = arg;
172 
173  /* Echo to stderr when interactive. */
174  if (um->flags & UNIX_FLAG_INTERACTIVE)
175  {
176  CLIB_UNUSED (int r) = write (2, msg, msg_len);
177  }
178  else
179  {
180  char save = msg[msg_len - 1];
181 
182  /* Null Terminate. */
183  msg[msg_len - 1] = 0;
184 
185  syslog (LOG_ERR | LOG_DAEMON, "%s", msg);
186 
187  msg[msg_len - 1] = save;
188  }
189 }
190 
191 void
193 {
194  unix_main_t *um = &unix_main;
195 
196  if (um->flags & UNIX_FLAG_INTERACTIVE || error == 0)
197  return;
198 
199  {
200  char save;
201  u8 *msg;
202  u32 msg_len;
203 
204  msg = error->what;
205  msg_len = vec_len (msg);
206 
207  /* Null Terminate. */
208  save = msg[msg_len - 1];
209  msg[msg_len - 1] = 0;
210 
211  syslog (LOG_ERR | LOG_DAEMON, "%s", msg);
212 
213  msg[msg_len - 1] = save;
214  }
215 }
216 
217 static uword
220 {
221  unix_main_t *um = &unix_main;
222  u8 *buf = 0;
223  uword l, n = 1;
224 
225  vlib_process_suspend (vm, 2.0);
226 
227  while (um->unix_config_complete == 0)
228  vlib_process_suspend (vm, 0.1);
229 
230  if (um->startup_config_filename)
231  {
232  unformat_input_t sub_input;
233  int fd;
234  struct stat s;
235  char *fn = (char *) um->startup_config_filename;
236 
237  fd = open (fn, O_RDONLY);
238  if (fd < 0)
239  {
240  clib_warning ("failed to open `%s'", fn);
241  return 0;
242  }
243 
244  if (fstat (fd, &s) < 0)
245  {
246  clib_warning ("failed to stat `%s'", fn);
247  bail:
248  close (fd);
249  return 0;
250  }
251 
252  if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
253  {
254  clib_warning ("not a regular file: `%s'", fn);
255  goto bail;
256  }
257 
258  while (n > 0)
259  {
260  l = vec_len (buf);
261  vec_resize (buf, 4096);
262  n = read (fd, buf + l, 4096);
263  if (n > 0)
264  {
265  _vec_len (buf) = l + n;
266  if (n < 4096)
267  break;
268  }
269  else
270  break;
271  }
272  if (um->log_fd && vec_len (buf))
273  {
274  u8 *lv = 0;
275  lv = format (lv, "%U: ***** Startup Config *****\n%v",
276  format_timeval, 0 /* current bat-time */ ,
277  0 /* current bat-format */ ,
278  buf);
279  {
280  int rv __attribute__ ((unused)) =
281  write (um->log_fd, lv, vec_len (lv));
282  }
283  vec_reset_length (lv);
284  lv = format (lv, "%U: ***** End Startup Config *****\n",
285  format_timeval, 0 /* current bat-time */ ,
286  0 /* current bat-format */ );
287  {
288  int rv __attribute__ ((unused)) =
289  write (um->log_fd, lv, vec_len (lv));
290  }
291  vec_free (lv);
292  }
293 
294  if (vec_len (buf))
295  {
296  unformat_init_vector (&sub_input, buf);
297  vlib_cli_input (vm, &sub_input, 0, 0);
298  /* frees buf for us */
299  unformat_free (&sub_input);
300  }
301  close (fd);
302  }
303  return 0;
304 }
305 
306 /* *INDENT-OFF* */
307 VLIB_REGISTER_NODE (startup_config_node,static) = {
308  .function = startup_config_process,
309  .type = VLIB_NODE_TYPE_PROCESS,
310  .name = "startup-config-process",
311 };
312 /* *INDENT-ON* */
313 
314 static clib_error_t *
316 {
317  unix_main_t *um = &unix_main;
318  clib_error_t *error = 0;
319  gid_t gid;
320  int pidfd = -1;
321 
322  /* Defaults */
325 
327  {
328  char *cli_prompt;
329  if (unformat (input, "interactive"))
331  else if (unformat (input, "nodaemon"))
332  um->flags |= UNIX_FLAG_NODAEMON;
333  else if (unformat (input, "cli-prompt %s", &cli_prompt))
334  vlib_unix_cli_set_prompt (cli_prompt);
335  else
336  if (unformat (input, "cli-listen %s", &um->cli_listen_socket.config))
337  ;
338  else if (unformat (input, "runtime-dir %s", &um->runtime_dir))
339  ;
340  else if (unformat (input, "cli-line-mode"))
341  um->cli_line_mode = 1;
342  else if (unformat (input, "cli-no-banner"))
343  um->cli_no_banner = 1;
344  else if (unformat (input, "cli-no-pager"))
345  um->cli_no_pager = 1;
346  else if (unformat (input, "cli-pager-buffer-limit %d",
348  ;
349  else
350  if (unformat (input, "cli-history-limit %d", &um->cli_history_limit))
351  ;
352  else if (unformat (input, "coredump-size"))
353  {
354  uword coredump_size = 0;
355  if (unformat (input, "unlimited"))
356  {
357  coredump_size = RLIM_INFINITY;
358  }
359  else
360  if (!unformat (input, "%U", unformat_memory_size, &coredump_size))
361  {
362  return clib_error_return (0,
363  "invalid coredump-size parameter `%U'",
364  format_unformat_error, input);
365  }
366  const struct rlimit new_limit = { coredump_size, coredump_size };
367  if (0 != setrlimit (RLIMIT_CORE, &new_limit))
368  {
369  clib_unix_warning ("prlimit() failed");
370  }
371  }
372  else if (unformat (input, "full-coredump"))
373  {
374  int fd;
375 
376  fd = open ("/proc/self/coredump_filter", O_WRONLY);
377  if (fd >= 0)
378  {
379  if (write (fd, "0x6f\n", 5) != 5)
380  clib_unix_warning ("coredump filter write failed!");
381  close (fd);
382  }
383  else
384  clib_unix_warning ("couldn't open /proc/self/coredump_filter");
385  }
386  else if (unformat (input, "startup-config %s",
388  ;
389  else if (unformat (input, "exec %s", &um->startup_config_filename))
390  ;
391  else if (unformat (input, "log %s", &um->log_filename))
392  {
393  um->log_fd = open ((char *) um->log_filename,
394  O_CREAT | O_WRONLY | O_APPEND, 0644);
395  if (um->log_fd < 0)
396  {
397  clib_warning ("couldn't open log '%s'\n", um->log_filename);
398  um->log_fd = 0;
399  }
400  else
401  {
402  u8 *lv = 0;
403  lv = format (0, "%U: ***** Start: PID %d *****\n",
404  format_timeval, 0 /* current bat-time */ ,
405  0 /* current bat-format */ ,
406  getpid ());
407  {
408  int rv __attribute__ ((unused)) =
409  write (um->log_fd, lv, vec_len (lv));
410  }
411  vec_free (lv);
412  }
413  }
414  else if (unformat (input, "gid %U", unformat_unix_gid, &gid))
415  {
416  if (setegid (gid) == -1)
417  return clib_error_return_unix (0, "setegid");
418  }
419  else if (unformat (input, "pidfile %s", &um->pidfile))
420  ;
421  else
422  return clib_error_return (0, "unknown input `%U'",
423  format_unformat_error, input);
424  }
425 
426  if (um->runtime_dir == 0)
427  {
428  uid_t uid = geteuid ();
429  if (uid == 00)
430  um->runtime_dir = format (0, "/run/%s%c",
431  vlib_default_runtime_dir, 0);
432  else
433  um->runtime_dir = format (0, "/run/user/%u/%s%c", uid,
434  vlib_default_runtime_dir, 0);
435  }
436 
437  error = setup_signal_handlers (um);
438  if (error)
439  return error;
440 
441  if (um->pidfile)
442  {
443  if ((error = vlib_unix_validate_runtime_file (um,
444  (char *) um->pidfile,
445  &um->pidfile)))
446  return error;
447 
448  if (((pidfd = open ((char *) um->pidfile,
449  O_CREAT | O_WRONLY | O_TRUNC, 0644)) < 0))
450  {
451  return clib_error_return_unix (0, "open");
452  }
453  }
454 
455  if (!(um->flags & UNIX_FLAG_INTERACTIVE))
456  {
457  openlog (vm->name, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON);
459 
460  if (!(um->flags & UNIX_FLAG_NODAEMON) && daemon ( /* chdir to / */ 0,
461  /* stdin/stdout/stderr -> /dev/null */
462  0) < 0)
463  clib_error_return (0, "daemon () fails");
464  }
465 
466  if (pidfd >= 0)
467  {
468  u8 *lv = format (0, "%d", getpid ());
469  if (write (pidfd, (char *) lv, vec_len (lv)) != vec_len (lv))
470  {
471  vec_free (lv);
472  close (pidfd);
473  return clib_error_return_unix (0, "write");
474  }
475  vec_free (lv);
476  close (pidfd);
477  }
478 
479  um->unix_config_complete = 1;
480 
481  return 0;
482 }
483 
484 /* unix { ... } configuration. */
485 /*?
486  *
487  * @cfgcmd{interactive}
488  * Attach CLI to stdin/out and provide a debugging command line interface.
489  * Implies @c nodaemon.
490  *
491  * @cfgcmd{nodaemon}
492  * Do not fork or background the VPP process. Typically used when invoking
493  * VPP applications from a process monitor.
494  *
495  * @cfgcmd{exec, &lt;filename&gt;}
496  * @par <code>startup-config &lt;filename&gt;</code>
497  * Read startup operational configuration from @c filename.
498  * The contents of the file will be performed as though entered at the CLI.
499  * The two keywords are aliases for the same function; if both are specified,
500  * only the last will have an effect.
501  *
502  * @cfgcmd{log, &lt;filename&gt;}
503  * Logs the startup configuration and all subsequent CLI commands in
504  * @c filename.
505  * Very useful in situations where folks don't remember or can't be bothered
506  * to include CLI commands in bug reports.
507  *
508  * @cfgcmd{pidfile, &lt;filename&gt;}
509  * Writes the pid of the main thread in @c filename.
510  *
511  * @cfgcmd{full-coredump}
512  * Ask the Linux kernel to dump all memory-mapped address regions, instead
513  * of just text+data+bss.
514  *
515  * @cfgcmd{runtime-dir}
516  * Define directory where VPP is going to store all runtime files.
517  * Default is /run/vpp.
518  *
519  * @cfgcmd{cli-listen, &lt;address:port&gt;}
520  * Bind the CLI to listen at the address and port given. @clocalhost
521  * on TCP port @c 5002, given as <tt>cli-listen localhost:5002</tt>,
522  * is typical.
523  *
524  * @cfgcmd{cli-line-mode}
525  * Disable character-by-character I/O on stdin. Useful when combined with,
526  * for example, <tt>emacs M-x gud-gdb</tt>.
527  *
528  * @cfgcmd{cli-prompt, &lt;string&gt;}
529  * Configure the CLI prompt to be @c string.
530  *
531  * @cfgcmd{cli-history-limit, &lt;nn&gt;}
532  * Limit commmand history to @c nn lines. A value of @c 0
533  * disables command history. Default value: @c 50
534  *
535  * @cfgcmd{cli-no-banner}
536  * Disable the login banner on stdin and Telnet connections.
537  *
538  * @cfgcmd{cli-no-pager}
539  * Disable the output pager.
540  *
541  * @cfgcmd{cli-pager-buffer-limit, &lt;nn&gt;}
542  * Limit pager buffer to @c nn lines of output.
543  * A value of @c 0 disables the pager. Default value: @c 100000
544 ?*/
546 
547 static clib_error_t *
549 {
550  /* Close syslog connection. */
551  closelog ();
552  return 0;
553 }
554 
556 
558 
559 static uword
561 {
562  vlib_main_t *vm = (vlib_main_t *) arg;
563  unformat_input_t input;
564  int i;
565 
566  unformat_init_command_line (&input, (char **) vm->argv);
567  i = vlib_main (vm, &input);
568  unformat_free (&input);
569 
570  return i;
571 }
572 
573 u8 *
575 {
576  vec_validate (vlib_thread_stacks, thread_index);
577  vlib_thread_stacks[thread_index] = clib_mem_alloc_aligned
579 
580  /*
581  * Disallow writes to the bottom page of the stack, to
582  * catch stack overflows.
583  */
584  if (mprotect (vlib_thread_stacks[thread_index],
585  clib_mem_get_page_size (), PROT_READ) < 0)
586  clib_unix_warning ("thread stack");
587  return vlib_thread_stacks[thread_index];
588 }
589 
590 int
591 vlib_unix_main (int argc, char *argv[])
592 {
593  vlib_main_t *vm = &vlib_global_main; /* one and only time for this! */
594  unformat_input_t input;
595  clib_error_t *e;
596  int i;
597 
598  vm->argv = (u8 **) argv;
599  vm->name = argv[0];
600  vm->heap_base = clib_mem_get_heap ();
601  ASSERT (vm->heap_base);
602 
603  unformat_init_command_line (&input, (char **) vm->argv);
604  if ((e = vlib_plugin_config (vm, &input)))
605  {
606  clib_error_report (e);
607  return 1;
608  }
609  unformat_free (&input);
610 
611  i = vlib_plugin_early_init (vm);
612  if (i)
613  return i;
614 
615  unformat_init_command_line (&input, (char **) vm->argv);
616  if (vm->init_functions_called == 0)
617  vm->init_functions_called = hash_create (0, /* value bytes */ 0);
618  e = vlib_call_all_config_functions (vm, &input, 1 /* early */ );
619  if (e != 0)
620  {
621  clib_error_report (e);
622  return 1;
623  }
624  unformat_free (&input);
625 
627 
628  __os_thread_index = 0;
629  vm->thread_index = 0;
630 
631  i = clib_calljmp (thread0, (uword) vm,
632  (void *) (vlib_thread_stacks[0] +
634  return i;
635 }
636 
637 /*
638  * fd.io coding-style-patch-verification: ON
639  *
640  * Local Variables:
641  * eval: (c-set-style "gnu")
642  * End:
643  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:432
int vlib_unix_main(int argc, char *argv[])
Definition: main.c:591
unix_main_t unix_main
Definition: main.c:62
vlib_main_t vlib_global_main
Definition: main.c:1637
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define CLIB_UNUSED(x)
Definition: clib.h:79
static clib_error_t * unix_input_init(vlib_main_t *vm)
Definition: input.c:259
void vlib_cli_input(vlib_main_t *vm, unformat_input_t *input, vlib_cli_output_function_t *function, uword function_arg)
Definition: cli.c:643
u32 flags
Definition: unix.h:58
volatile int unix_config_complete
Definition: unix.h:81
u32 cli_pager_buffer_limit
Definition: unix.h:97
void vlib_unix_cli_set_prompt(char *prompt)
Set the CLI prompt.
Definition: cli.c:2909
u32 thread_index
Definition: main.h:173
u32 main_loop_exit_set
Definition: main.h:87
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
static clib_error_t * unix_main_init(vlib_main_t *vm)
Definition: main.c:66
clib_error_t * vlib_plugin_config(vlib_main_t *vm, unformat_input_t *input)
Definition: plugin.c:476
unformat_function_t unformat_unix_gid
Definition: format.h:315
static clib_error_t * unix_exit(vlib_main_t *vm)
Definition: main.c:548
static void unix_signal_handler(int signum, siginfo_t *si, ucontext_t *uc)
Definition: main.c:76
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
void clib_error_register_handler(clib_error_handler_func_t func, void *arg)
Definition: error.c:75
clib_socket_t cli_listen_socket
Definition: unix.h:64
static void unix_error_handler(void *arg, u8 *msg, int msg_len)
Definition: main.c:169
#define UNIX_FLAG_NODAEMON
Definition: unix.h:61
int log_fd
Definition: unix.h:85
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:448
u8 * format_timeval(u8 *s, va_list *args)
Definition: unix-formats.c:761
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
u8 * pidfile
Definition: unix.h:78
#define clib_error_return(e, args...)
Definition: error.h:99
clib_file_main_t file_main
Definition: main.c:63
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:237
void os_exit(int code)
Definition: main.c:278
vlib_main_t * vlib_main
Definition: unix.h:56
#define vlib_call_init_function(vm, x)
Definition: init.h:162
int vlib_plugin_early_init(vlib_main_t *vm)
Definition: plugin.c:349
char * name
Definition: main.h:100
int cli_line_mode
Definition: unix.h:88
struct _unformat_input_t unformat_input_t
#define clib_error_return_unix(e, args...)
Definition: error.h:102
int cli_no_banner
Definition: unix.h:94
void unformat_init_command_line(unformat_input_t *input, char *argv[])
Definition: unformat.c:1007
u8 * startup_config_filename
Definition: unix.h:72
u8 ** vlib_thread_stacks
Definition: main.c:557
uword * init_functions_called
Definition: main.h:170
u32 cli_history_limit
Definition: unix.h:91
void unformat_init_vector(unformat_input_t *input, u8 *vector_string)
Definition: unformat.c:1031
u8 ** argv
Definition: main.h:190
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
Definition: init.h:140
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
vlib_main_t * vm
Definition: buffer.c:283
void vlib_unix_error_report(vlib_main_t *vm, clib_error_t *error)
Definition: main.c:192
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
void * heap_base
Definition: main.h:103
int cli_no_pager
Definition: unix.h:100
#define VLIB_MAIN_LOOP_EXIT_FUNCTION(x)
Definition: init.h:116
#define clib_warning(format, args...)
Definition: error.h:59
#define UNIX_CLI_DEFAULT_PAGER_LIMIT
Default CLI pager limit is not configured in startup.conf.
Definition: main.c:54
static void * clib_mem_get_heap(void)
Definition: mem.h:220
#define hash_create(elts, value_bytes)
Definition: hash.h:681
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
static uword thread0(uword arg)
Definition: main.c:560
#define UNIX_FLAG_INTERACTIVE
Definition: unix.h:60
#define clib_error_report(e)
Definition: error.h:113
u64 uword
Definition: types.h:112
int vlib_main(vlib_main_t *volatile vm, unformat_input_t *input)
Definition: main.c:1676
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define UNIX_CLI_DEFAULT_HISTORY
Default CLI history depth if not configured in startup.conf.
Definition: main.c:57
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
u8 * format_signal(u8 *s, va_list *args)
Definition: unix-formats.c:847
clib_error_t * vlib_call_all_config_functions(vlib_main_t *vm, unformat_input_t *input, int is_early)
Definition: init.c:94
#define clib_unix_warning(format, args...)
Definition: error.h:68
#define VLIB_THREAD_STACK_SIZE
Definition: threads.h:82
static clib_error_t * unix_config(vlib_main_t *vm, unformat_input_t *input)
Definition: main.c:315
unformat_function_t unformat_memory_size
Definition: format.h:294
clib_error_t * vlib_unix_validate_runtime_file(unix_main_t *um, const char *path, u8 **full_path)
Definition: util.c:137
static void * clib_mem_alloc_aligned(uword size, uword align)
Definition: mem.h:120
uword clib_calljmp(uword(*func)(uword func_arg), uword func_arg, void *stack)
volatile u32 main_loop_exit_now
Definition: main.h:89
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 * runtime_dir
Definition: unix.h:75
static uword startup_config_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: main.c:218
uword clib_mem_get_page_size(void)
Definition: mem_mheap.c:110
static clib_error_t * setup_signal_handlers(unix_main_t *um)
Definition: main.c:129
u8 * vlib_thread_stack_init(uword thread_index)
Definition: main.c:574
u8 * log_filename
Definition: unix.h:84
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
u8 * format_ucontext_pc(u8 *s, va_list *args)
Definition: unix-formats.c:898
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169