blob: 24ae416dbf42f8891b29e3f7b6eeb06af94fa350 [file] [log] [blame]
Ed Warnickecb9cada2015-12-08 15:45:58 -07001/*
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>
Klement Sekerac8c44eb2017-03-02 11:13:30 +010049#include <sys/time.h>
50#include <sys/resource.h>
Damjan Mariona54230d2017-06-21 11:57:07 +020051#include <unistd.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070052
Chris Luke7afda3a2016-04-25 13:49:22 -040053/** 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
Damjan Marion57d963f2017-07-20 19:17:06 +020059char *vlib_default_runtime_dir __attribute__ ((weak));
Damjan Marionc67787b2017-08-30 17:12:25 +020060char *vlib_default_runtime_dir = "vlib";
Chris Luke7afda3a2016-04-25 13:49:22 -040061
Ed Warnickecb9cada2015-12-08 15:45:58 -070062unix_main_t unix_main;
Damjan Marion56dd5432017-09-08 19:52:02 +020063clib_file_main_t file_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -070064
65static clib_error_t *
66unix_main_init (vlib_main_t * vm)
67{
Dave Barach9b8ffd92016-07-08 08:13:45 -040068 unix_main_t *um = &unix_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -070069 um->vlib_main = vm;
70 return vlib_call_init_function (vm, unix_input_init);
71}
72
73VLIB_INIT_FUNCTION (unix_main_init);
74
Kingwel Xie497deaf2018-06-15 04:56:24 -040075static int
76unsetup_signal_handlers (int sig)
77{
78 struct sigaction sa;
79
80 sa.sa_handler = SIG_DFL;
81 sa.sa_flags = 0;
82 sigemptyset (&sa.sa_mask);
83 return sigaction (sig, &sa, 0);
84}
85
86
87/* allocate this buffer from mheap when setting up the signal handler.
88 dangerous to vec_resize it when crashing, mheap itself might have been
89 corruptted already */
90static u8 *syslog_msg = 0;
Dave Barach9e52ef62019-02-28 17:52:57 -050091static int last_signum = 0;
92static uword last_faulting_address = 0;
Kingwel Xie497deaf2018-06-15 04:56:24 -040093
Dave Barach9b8ffd92016-07-08 08:13:45 -040094static void
95unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc)
Ed Warnickecb9cada2015-12-08 15:45:58 -070096{
Dave Barach903651c2017-10-13 19:16:56 -040097 uword fatal = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -070098
Dave Barach9e52ef62019-02-28 17:52:57 -050099 /* These come in handy when looking at core files from optimized images */
100 last_signum = signum;
101 last_faulting_address = (uword) si->si_addr;
102
Kingwel Xie497deaf2018-06-15 04:56:24 -0400103 syslog_msg = format (syslog_msg, "received signal %U, PC %U",
104 format_signal, signum, format_ucontext_pc, uc);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700105
106 if (signum == SIGSEGV)
Kingwel Xie497deaf2018-06-15 04:56:24 -0400107 syslog_msg = format (syslog_msg, ", faulting address %p", si->si_addr);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700108
109 switch (signum)
110 {
111 /* these (caught) signals cause the application to exit */
112 case SIGTERM:
Dave Barachd1e17d02019-03-21 18:01:48 -0400113 /*
114 * Ignore SIGTERM if it's sent before we're ready.
115 */
116 if (unix_main.vlib_main && unix_main.vlib_main->main_loop_exit_set)
Dave Barach9b8ffd92016-07-08 08:13:45 -0400117 {
118 syslog (LOG_ERR | LOG_DAEMON, "received SIGTERM, exiting...");
Dave Barach903651c2017-10-13 19:16:56 -0400119 unix_main.vlib_main->main_loop_exit_now = 1;
Dave Barach9b8ffd92016-07-08 08:13:45 -0400120 }
Dave Barachd1e17d02019-03-21 18:01:48 -0400121 else
122 syslog (LOG_ERR | LOG_DAEMON, "IGNORE early SIGTERM...");
Dave Barach903651c2017-10-13 19:16:56 -0400123 break;
Dave Barachb2a6e252016-07-27 10:00:58 -0400124 /* fall through */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700125 case SIGQUIT:
126 case SIGINT:
127 case SIGILL:
128 case SIGBUS:
129 case SIGSEGV:
130 case SIGHUP:
131 case SIGFPE:
Kingwel Xie497deaf2018-06-15 04:56:24 -0400132 case SIGABRT:
Ed Warnickecb9cada2015-12-08 15:45:58 -0700133 fatal = 1;
134 break;
135
136 /* by default, print a message and continue */
137 default:
138 fatal = 0;
139 break;
140 }
141
142 /* Null terminate. */
Kingwel Xie497deaf2018-06-15 04:56:24 -0400143 vec_add1 (syslog_msg, 0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700144
145 if (fatal)
146 {
Kingwel Xie497deaf2018-06-15 04:56:24 -0400147 syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg);
148
149 /* Address of callers: outer first, inner last. */
150 uword callers[15];
151 uword n_callers = clib_backtrace (callers, ARRAY_LEN (callers), 0);
152 int i;
153 for (i = 0; i < n_callers; i++)
154 {
155 vec_reset_length (syslog_msg);
156
157 syslog_msg =
158 format (syslog_msg, "#%-2d 0x%016lx %U%c", i, callers[i],
159 format_clib_elf_symbol_with_address, callers[i], 0);
160
161 syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg);
162 }
163
164 /* have to remove SIGABRT to avoid recusive - os_exit calling abort() */
165 unsetup_signal_handlers (SIGABRT);
166
Ed Warnickecb9cada2015-12-08 15:45:58 -0700167 os_exit (1);
168 }
169 else
Kingwel Xie497deaf2018-06-15 04:56:24 -0400170 clib_warning ("%s", syslog_msg);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700171
Ed Warnickecb9cada2015-12-08 15:45:58 -0700172}
173
174static clib_error_t *
175setup_signal_handlers (unix_main_t * um)
176{
177 uword i;
178 struct sigaction sa;
179
Kingwel Xie497deaf2018-06-15 04:56:24 -0400180 /* give a big enough buffer for msg, most likely it can avoid vec_resize */
181 vec_alloc (syslog_msg, 2048);
182
Ed Warnickecb9cada2015-12-08 15:45:58 -0700183 for (i = 1; i < 32; i++)
184 {
Dave Barachb7b92992018-10-17 10:38:51 -0400185 clib_memset (&sa, 0, sizeof (sa));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700186 sa.sa_sigaction = (void *) unix_signal_handler;
187 sa.sa_flags = SA_SIGINFO;
188
189 switch (i)
190 {
Dave Barach9b8ffd92016-07-08 08:13:45 -0400191 /* these signals take the default action */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700192 case SIGKILL:
193 case SIGSTOP:
Dave Barach9b8ffd92016-07-08 08:13:45 -0400194 case SIGUSR1:
195 case SIGUSR2:
Ed Warnickecb9cada2015-12-08 15:45:58 -0700196 continue;
197
Dave Barach9b8ffd92016-07-08 08:13:45 -0400198 /* ignore SIGPIPE, SIGCHLD */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700199 case SIGPIPE:
200 case SIGCHLD:
201 sa.sa_sigaction = (void *) SIG_IGN;
202 break;
203
Dave Barach9b8ffd92016-07-08 08:13:45 -0400204 /* catch and handle all other signals */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700205 default:
206 break;
207 }
208
209 if (sigaction (i, &sa, 0) < 0)
210 return clib_error_return_unix (0, "sigaction %U", format_signal, i);
211 }
212
213 return 0;
214}
215
Dave Barach9b8ffd92016-07-08 08:13:45 -0400216static void
217unix_error_handler (void *arg, u8 * msg, int msg_len)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700218{
Dave Barach9b8ffd92016-07-08 08:13:45 -0400219 unix_main_t *um = arg;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700220
221 /* Echo to stderr when interactive. */
222 if (um->flags & UNIX_FLAG_INTERACTIVE)
223 {
224 CLIB_UNUSED (int r) = write (2, msg, msg_len);
225 }
226 else
227 {
228 char save = msg[msg_len - 1];
229
230 /* Null Terminate. */
Dave Barach9b8ffd92016-07-08 08:13:45 -0400231 msg[msg_len - 1] = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700232
233 syslog (LOG_ERR | LOG_DAEMON, "%s", msg);
234
Dave Barach9b8ffd92016-07-08 08:13:45 -0400235 msg[msg_len - 1] = save;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700236 }
237}
238
Dave Barach9b8ffd92016-07-08 08:13:45 -0400239void
240vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700241{
Dave Barach9b8ffd92016-07-08 08:13:45 -0400242 unix_main_t *um = &unix_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700243
Dave Barach9b8ffd92016-07-08 08:13:45 -0400244 if (um->flags & UNIX_FLAG_INTERACTIVE || error == 0)
245 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700246
Dave Barach9b8ffd92016-07-08 08:13:45 -0400247 {
248 char save;
249 u8 *msg;
250 u32 msg_len;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700251
Dave Barach9b8ffd92016-07-08 08:13:45 -0400252 msg = error->what;
253 msg_len = vec_len (msg);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700254
Dave Barach9b8ffd92016-07-08 08:13:45 -0400255 /* Null Terminate. */
256 save = msg[msg_len - 1];
257 msg[msg_len - 1] = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700258
Dave Barach9b8ffd92016-07-08 08:13:45 -0400259 syslog (LOG_ERR | LOG_DAEMON, "%s", msg);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700260
Dave Barach9b8ffd92016-07-08 08:13:45 -0400261 msg[msg_len - 1] = save;
262 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700263}
264
265static uword
266startup_config_process (vlib_main_t * vm,
Dave Barach9b8ffd92016-07-08 08:13:45 -0400267 vlib_node_runtime_t * rt, vlib_frame_t * f)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700268{
Dave Barach9b8ffd92016-07-08 08:13:45 -0400269 unix_main_t *um = &unix_main;
270 u8 *buf = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700271 uword l, n = 1;
272
273 vlib_process_suspend (vm, 2.0);
274
275 while (um->unix_config_complete == 0)
276 vlib_process_suspend (vm, 0.1);
277
Dave Barach9b8ffd92016-07-08 08:13:45 -0400278 if (um->startup_config_filename)
279 {
280 unformat_input_t sub_input;
281 int fd;
282 struct stat s;
283 char *fn = (char *) um->startup_config_filename;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700284
Dave Barach9b8ffd92016-07-08 08:13:45 -0400285 fd = open (fn, O_RDONLY);
286 if (fd < 0)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700287 {
Dave Barach9b8ffd92016-07-08 08:13:45 -0400288 clib_warning ("failed to open `%s'", fn);
289 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700290 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700291
Dave Barach9b8ffd92016-07-08 08:13:45 -0400292 if (fstat (fd, &s) < 0)
293 {
294 clib_warning ("failed to stat `%s'", fn);
295 bail:
296 close (fd);
297 return 0;
298 }
299
300 if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
301 {
302 clib_warning ("not a regular file: `%s'", fn);
303 goto bail;
304 }
305
306 while (n > 0)
307 {
308 l = vec_len (buf);
309 vec_resize (buf, 4096);
310 n = read (fd, buf + l, 4096);
311 if (n > 0)
312 {
313 _vec_len (buf) = l + n;
314 if (n < 4096)
315 break;
316 }
317 else
318 break;
319 }
320 if (um->log_fd && vec_len (buf))
321 {
322 u8 *lv = 0;
323 lv = format (lv, "%U: ***** Startup Config *****\n%v",
324 format_timeval, 0 /* current bat-time */ ,
325 0 /* current bat-format */ ,
326 buf);
327 {
328 int rv __attribute__ ((unused)) =
329 write (um->log_fd, lv, vec_len (lv));
330 }
331 vec_reset_length (lv);
332 lv = format (lv, "%U: ***** End Startup Config *****\n",
333 format_timeval, 0 /* current bat-time */ ,
334 0 /* current bat-format */ );
335 {
336 int rv __attribute__ ((unused)) =
337 write (um->log_fd, lv, vec_len (lv));
338 }
339 vec_free (lv);
340 }
341
342 if (vec_len (buf))
343 {
344 unformat_init_vector (&sub_input, buf);
345 vlib_cli_input (vm, &sub_input, 0, 0);
346 /* frees buf for us */
347 unformat_free (&sub_input);
348 }
349 close (fd);
350 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700351 return 0;
352}
353
Dave Barach9b8ffd92016-07-08 08:13:45 -0400354/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700355VLIB_REGISTER_NODE (startup_config_node,static) = {
356 .function = startup_config_process,
357 .type = VLIB_NODE_TYPE_PROCESS,
358 .name = "startup-config-process",
359};
Dave Barach9b8ffd92016-07-08 08:13:45 -0400360/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700361
362static clib_error_t *
363unix_config (vlib_main_t * vm, unformat_input_t * input)
364{
Dave Barach9b8ffd92016-07-08 08:13:45 -0400365 unix_main_t *um = &unix_main;
366 clib_error_t *error = 0;
Damjan Mariona54230d2017-06-21 11:57:07 +0200367 gid_t gid;
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400368 int pidfd = -1;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700369
Chris Luke7afda3a2016-04-25 13:49:22 -0400370 /* Defaults */
371 um->cli_pager_buffer_limit = UNIX_CLI_DEFAULT_PAGER_LIMIT;
372 um->cli_history_limit = UNIX_CLI_DEFAULT_HISTORY;
373
Ed Warnickecb9cada2015-12-08 15:45:58 -0700374 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
375 {
Dave Barach9b8ffd92016-07-08 08:13:45 -0400376 char *cli_prompt;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700377 if (unformat (input, "interactive"))
378 um->flags |= UNIX_FLAG_INTERACTIVE;
379 else if (unformat (input, "nodaemon"))
Dave Barach9b8ffd92016-07-08 08:13:45 -0400380 um->flags |= UNIX_FLAG_NODAEMON;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700381 else if (unformat (input, "cli-prompt %s", &cli_prompt))
382 vlib_unix_cli_set_prompt (cli_prompt);
Dave Barach9b8ffd92016-07-08 08:13:45 -0400383 else
384 if (unformat (input, "cli-listen %s", &um->cli_listen_socket.config))
Ed Warnickecb9cada2015-12-08 15:45:58 -0700385 ;
Damjan Marion57d963f2017-07-20 19:17:06 +0200386 else if (unformat (input, "runtime-dir %s", &um->runtime_dir))
387 ;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700388 else if (unformat (input, "cli-line-mode"))
Dave Barach9b8ffd92016-07-08 08:13:45 -0400389 um->cli_line_mode = 1;
Chris Luke572d8122016-04-25 13:49:07 -0400390 else if (unformat (input, "cli-no-banner"))
Dave Barach9b8ffd92016-07-08 08:13:45 -0400391 um->cli_no_banner = 1;
Chris Luke7afda3a2016-04-25 13:49:22 -0400392 else if (unformat (input, "cli-no-pager"))
Dave Barach9b8ffd92016-07-08 08:13:45 -0400393 um->cli_no_pager = 1;
Dave Barach85aa4902018-06-14 18:52:46 -0400394 else if (unformat (input, "poll-sleep-usec %d", &um->poll_sleep_usec))
395 ;
Chris Luke7afda3a2016-04-25 13:49:22 -0400396 else if (unformat (input, "cli-pager-buffer-limit %d",
Dave Barach9b8ffd92016-07-08 08:13:45 -0400397 &um->cli_pager_buffer_limit))
398 ;
399 else
400 if (unformat (input, "cli-history-limit %d", &um->cli_history_limit))
401 ;
Klement Sekerac8c44eb2017-03-02 11:13:30 +0100402 else if (unformat (input, "coredump-size"))
403 {
404 uword coredump_size = 0;
405 if (unformat (input, "unlimited"))
406 {
407 coredump_size = RLIM_INFINITY;
408 }
409 else
410 if (!unformat (input, "%U", unformat_memory_size, &coredump_size))
411 {
412 return clib_error_return (0,
413 "invalid coredump-size parameter `%U'",
414 format_unformat_error, input);
415 }
416 const struct rlimit new_limit = { coredump_size, coredump_size };
417 if (0 != setrlimit (RLIMIT_CORE, &new_limit))
418 {
419 clib_unix_warning ("prlimit() failed");
420 }
421 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700422 else if (unformat (input, "full-coredump"))
Dave Barach9b8ffd92016-07-08 08:13:45 -0400423 {
424 int fd;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700425
Dave Barach9b8ffd92016-07-08 08:13:45 -0400426 fd = open ("/proc/self/coredump_filter", O_WRONLY);
Dave Barachb2a6e252016-07-27 10:00:58 -0400427 if (fd >= 0)
Dave Barach9b8ffd92016-07-08 08:13:45 -0400428 {
429 if (write (fd, "0x6f\n", 5) != 5)
430 clib_unix_warning ("coredump filter write failed!");
431 close (fd);
432 }
433 else
434 clib_unix_warning ("couldn't open /proc/self/coredump_filter");
435 }
436 else if (unformat (input, "startup-config %s",
437 &um->startup_config_filename))
438 ;
439 else if (unformat (input, "exec %s", &um->startup_config_filename))
440 ;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700441 else if (unformat (input, "log %s", &um->log_filename))
Dave Barach9b8ffd92016-07-08 08:13:45 -0400442 {
443 um->log_fd = open ((char *) um->log_filename,
444 O_CREAT | O_WRONLY | O_APPEND, 0644);
445 if (um->log_fd < 0)
446 {
447 clib_warning ("couldn't open log '%s'\n", um->log_filename);
448 um->log_fd = 0;
449 }
450 else
451 {
452 u8 *lv = 0;
453 lv = format (0, "%U: ***** Start: PID %d *****\n",
454 format_timeval, 0 /* current bat-time */ ,
455 0 /* current bat-format */ ,
456 getpid ());
Ed Warnickecb9cada2015-12-08 15:45:58 -0700457 {
Dave Barach9b8ffd92016-07-08 08:13:45 -0400458 int rv __attribute__ ((unused)) =
459 write (um->log_fd, lv, vec_len (lv));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700460 }
Dave Barach9b8ffd92016-07-08 08:13:45 -0400461 vec_free (lv);
462 }
463 }
Damjan Mariona54230d2017-06-21 11:57:07 +0200464 else if (unformat (input, "gid %U", unformat_unix_gid, &gid))
465 {
466 if (setegid (gid) == -1)
467 return clib_error_return_unix (0, "setegid");
468 }
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400469 else if (unformat (input, "pidfile %s", &um->pidfile))
470 ;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700471 else
472 return clib_error_return (0, "unknown input `%U'",
473 format_unformat_error, input);
474 }
475
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400476 if (um->runtime_dir == 0)
477 {
478 uid_t uid = geteuid ();
479 if (uid == 00)
480 um->runtime_dir = format (0, "/run/%s%c",
481 vlib_default_runtime_dir, 0);
482 else
483 um->runtime_dir = format (0, "/run/user/%u/%s%c", uid,
484 vlib_default_runtime_dir, 0);
485 }
486
Chris Lukeab7b8d92017-09-07 07:40:13 -0400487 error = setup_signal_handlers (um);
488 if (error)
489 return error;
490
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400491 if (um->pidfile)
492 {
493 if ((error = vlib_unix_validate_runtime_file (um,
494 (char *) um->pidfile,
495 &um->pidfile)))
496 return error;
497
498 if (((pidfd = open ((char *) um->pidfile,
499 O_CREAT | O_WRONLY | O_TRUNC, 0644)) < 0))
500 {
501 return clib_error_return_unix (0, "open");
502 }
503 }
504
Dave Barach9b8ffd92016-07-08 08:13:45 -0400505 if (!(um->flags & UNIX_FLAG_INTERACTIVE))
Ed Warnickecb9cada2015-12-08 15:45:58 -0700506 {
Ed Warnickecb9cada2015-12-08 15:45:58 -0700507 openlog (vm->name, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON);
508 clib_error_register_handler (unix_error_handler, um);
509
Dave Barach9b8ffd92016-07-08 08:13:45 -0400510 if (!(um->flags & UNIX_FLAG_NODAEMON) && daemon ( /* chdir to / */ 0,
511 /* stdin/stdout/stderr -> /dev/null */
512 0) < 0)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700513 clib_error_return (0, "daemon () fails");
514 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700515
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400516 if (pidfd >= 0)
Damjan Marionc67787b2017-08-30 17:12:25 +0200517 {
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400518 u8 *lv = format (0, "%d", getpid ());
519 if (write (pidfd, (char *) lv, vec_len (lv)) != vec_len (lv))
520 {
521 vec_free (lv);
522 close (pidfd);
523 return clib_error_return_unix (0, "write");
524 }
525 vec_free (lv);
526 close (pidfd);
Damjan Marionc67787b2017-08-30 17:12:25 +0200527 }
528
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400529 um->unix_config_complete = 1;
Damjan Marion57d963f2017-07-20 19:17:06 +0200530
Ed Warnickecb9cada2015-12-08 15:45:58 -0700531 return 0;
532}
533
534/* unix { ... } configuration. */
Chris Luke90f52bf2016-09-12 08:55:13 -0400535/*?
536 *
537 * @cfgcmd{interactive}
538 * Attach CLI to stdin/out and provide a debugging command line interface.
539 * Implies @c nodaemon.
540 *
541 * @cfgcmd{nodaemon}
542 * Do not fork or background the VPP process. Typically used when invoking
543 * VPP applications from a process monitor.
544 *
545 * @cfgcmd{exec, &lt;filename&gt;}
546 * @par <code>startup-config &lt;filename&gt;</code>
547 * Read startup operational configuration from @c filename.
548 * The contents of the file will be performed as though entered at the CLI.
549 * The two keywords are aliases for the same function; if both are specified,
550 * only the last will have an effect.
551 *
552 * @cfgcmd{log, &lt;filename&gt;}
553 * Logs the startup configuration and all subsequent CLI commands in
554 * @c filename.
555 * Very useful in situations where folks don't remember or can't be bothered
556 * to include CLI commands in bug reports.
557 *
Pierre Pfister9a244bb2017-07-27 22:57:34 -0400558 * @cfgcmd{pidfile, &lt;filename&gt;}
559 * Writes the pid of the main thread in @c filename.
560 *
Chris Luke90f52bf2016-09-12 08:55:13 -0400561 * @cfgcmd{full-coredump}
562 * Ask the Linux kernel to dump all memory-mapped address regions, instead
563 * of just text+data+bss.
564 *
Damjan Marion57d963f2017-07-20 19:17:06 +0200565 * @cfgcmd{runtime-dir}
566 * Define directory where VPP is going to store all runtime files.
Paul Vinciguerrad54815c2019-04-11 06:32:19 -0700567 * Default is /run/vpp when running as root, /run/user/<UID>/vpp if running as
568 * an unprivileged user.
Damjan Marion57d963f2017-07-20 19:17:06 +0200569 *
Chris Luke90f52bf2016-09-12 08:55:13 -0400570 * @cfgcmd{cli-listen, &lt;address:port&gt;}
Paul Vinciguerrad54815c2019-04-11 06:32:19 -0700571 * Bind the CLI to listen at the address and port given. @c localhost
Chris Luke90f52bf2016-09-12 08:55:13 -0400572 * on TCP port @c 5002, given as <tt>cli-listen localhost:5002</tt>,
573 * is typical.
574 *
575 * @cfgcmd{cli-line-mode}
576 * Disable character-by-character I/O on stdin. Useful when combined with,
577 * for example, <tt>emacs M-x gud-gdb</tt>.
578 *
579 * @cfgcmd{cli-prompt, &lt;string&gt;}
580 * Configure the CLI prompt to be @c string.
581 *
582 * @cfgcmd{cli-history-limit, &lt;nn&gt;}
Paul Vinciguerrad54815c2019-04-11 06:32:19 -0700583 * Limit command history to @c nn lines. A value of @c 0
Chris Luke90f52bf2016-09-12 08:55:13 -0400584 * disables command history. Default value: @c 50
585 *
586 * @cfgcmd{cli-no-banner}
587 * Disable the login banner on stdin and Telnet connections.
588 *
589 * @cfgcmd{cli-no-pager}
590 * Disable the output pager.
591 *
592 * @cfgcmd{cli-pager-buffer-limit, &lt;nn&gt;}
593 * Limit pager buffer to @c nn lines of output.
594 * A value of @c 0 disables the pager. Default value: @c 100000
Paul Vinciguerrad54815c2019-04-11 06:32:19 -0700595 *
596 * @cfgcmd{gid, &lt;nn&gt;}
597 * Set the effective gid under which the vpp process is to run.
598 *
599 * @cfgcmd{poll-sleep-usec, &lt;nn&gt;}
600 * Set a fixed poll sleep interval between main loop polls.
Chris Luke90f52bf2016-09-12 08:55:13 -0400601?*/
Damjan Marion57d963f2017-07-20 19:17:06 +0200602VLIB_EARLY_CONFIG_FUNCTION (unix_config, "unix");
Ed Warnickecb9cada2015-12-08 15:45:58 -0700603
604static clib_error_t *
605unix_exit (vlib_main_t * vm)
606{
607 /* Close syslog connection. */
608 closelog ();
609 return 0;
610}
611
612VLIB_MAIN_LOOP_EXIT_FUNCTION (unix_exit);
613
614u8 **vlib_thread_stacks;
615
Dave Barach9b8ffd92016-07-08 08:13:45 -0400616static uword
617thread0 (uword arg)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700618{
Dave Barach9b8ffd92016-07-08 08:13:45 -0400619 vlib_main_t *vm = (vlib_main_t *) arg;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700620 unformat_input_t input;
621 int i;
Dave Barach9b8ffd92016-07-08 08:13:45 -0400622
623 unformat_init_command_line (&input, (char **) vm->argv);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700624 i = vlib_main (vm, &input);
625 unformat_free (&input);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700626
Dave Barach9b8ffd92016-07-08 08:13:45 -0400627 return i;
628}
629
Damjan Marion586afd72017-04-05 19:18:20 +0200630u8 *
631vlib_thread_stack_init (uword thread_index)
632{
633 vec_validate (vlib_thread_stacks, thread_index);
634 vlib_thread_stacks[thread_index] = clib_mem_alloc_aligned
635 (VLIB_THREAD_STACK_SIZE, VLIB_THREAD_STACK_SIZE);
636
637 /*
638 * Disallow writes to the bottom page of the stack, to
639 * catch stack overflows.
640 */
641 if (mprotect (vlib_thread_stacks[thread_index],
642 clib_mem_get_page_size (), PROT_READ) < 0)
643 clib_unix_warning ("thread stack");
644 return vlib_thread_stacks[thread_index];
645}
646
Dave Barach9b8ffd92016-07-08 08:13:45 -0400647int
648vlib_unix_main (int argc, char *argv[])
Ed Warnickecb9cada2015-12-08 15:45:58 -0700649{
Dave Barach9b8ffd92016-07-08 08:13:45 -0400650 vlib_main_t *vm = &vlib_global_main; /* one and only time for this! */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700651 unformat_input_t input;
Dave Barach9b8ffd92016-07-08 08:13:45 -0400652 clib_error_t *e;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700653 int i;
654
Dave Barach9b8ffd92016-07-08 08:13:45 -0400655 vm->argv = (u8 **) argv;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700656 vm->name = argv[0];
657 vm->heap_base = clib_mem_get_heap ();
Dave Barach6a5adc32018-07-04 10:56:23 -0400658 vm->heap_aligned_base = (void *)
659 (((uword) vm->heap_base) & ~(VLIB_FRAME_ALIGN - 1));
Dave Barach9b8ffd92016-07-08 08:13:45 -0400660 ASSERT (vm->heap_base);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700661
Damjan Marion3b46cba2017-01-23 21:13:45 +0100662 unformat_init_command_line (&input, (char **) vm->argv);
663 if ((e = vlib_plugin_config (vm, &input)))
664 {
665 clib_error_report (e);
666 return 1;
667 }
668 unformat_free (&input);
669
Ed Warnickecb9cada2015-12-08 15:45:58 -0700670 i = vlib_plugin_early_init (vm);
671 if (i)
672 return i;
Dave Barach9b8ffd92016-07-08 08:13:45 -0400673
674 unformat_init_command_line (&input, (char **) vm->argv);
Dave Barach1f49ed62016-02-24 11:29:06 -0500675 if (vm->init_functions_called == 0)
Dave Barach9b8ffd92016-07-08 08:13:45 -0400676 vm->init_functions_called = hash_create (0, /* value bytes */ 0);
677 e = vlib_call_all_config_functions (vm, &input, 1 /* early */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -0700678 if (e != 0)
679 {
Dave Barach9b8ffd92016-07-08 08:13:45 -0400680 clib_error_report (e);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700681 return 1;
682 }
683 unformat_free (&input);
684
Kingwel Xie497deaf2018-06-15 04:56:24 -0400685 /* always load symbols, for signal handler and mheap memory get/put backtrace */
686 clib_elf_main_init (vm->name);
687
Damjan Marion586afd72017-04-05 19:18:20 +0200688 vlib_thread_stack_init (0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700689
Damjan Marionf55f9b82017-05-10 21:06:28 +0200690 __os_thread_index = 0;
Keith Burns (alagalah)0bda0f42017-10-20 13:55:18 -0700691 vm->thread_index = 0;
Dave Barach9b8ffd92016-07-08 08:13:45 -0400692
693 i = clib_calljmp (thread0, (uword) vm,
694 (void *) (vlib_thread_stacks[0] +
695 VLIB_THREAD_STACK_SIZE));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700696 return i;
697}
Dave Barach9b8ffd92016-07-08 08:13:45 -0400698
699/*
700 * fd.io coding-style-patch-verification: ON
701 *
702 * Local Variables:
703 * eval: (c-set-style "gnu")
704 * End:
705 */