]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/main.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1761 from ssahani/word
[thirdparty/systemd.git] / src / core / main.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <getopt.h>
25 #include <signal.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <sys/mount.h>
29 #include <sys/prctl.h>
30 #include <sys/reboot.h>
31 #include <sys/stat.h>
32 #include <unistd.h>
33 #ifdef HAVE_SECCOMP
34 #include <seccomp.h>
35 #endif
36 #ifdef HAVE_VALGRIND_VALGRIND_H
37 #include <valgrind/valgrind.h>
38 #endif
39
40 #include "sd-daemon.h"
41 #include "sd-bus.h"
42
43 #include "alloc-util.h"
44 #include "architecture.h"
45 #include "build.h"
46 #include "bus-error.h"
47 #include "bus-util.h"
48 #include "capability-util.h"
49 #include "clock-util.h"
50 #include "conf-parser.h"
51 #include "cpu-set-util.h"
52 #include "dbus-manager.h"
53 #include "def.h"
54 #include "env-util.h"
55 #include "fd-util.h"
56 #include "fdset.h"
57 #include "fileio.h"
58 #include "formats-util.h"
59 #include "fs-util.h"
60 #include "hostname-setup.h"
61 #include "ima-setup.h"
62 #include "killall.h"
63 #include "kmod-setup.h"
64 #include "load-fragment.h"
65 #include "log.h"
66 #include "loopback-setup.h"
67 #include "machine-id-setup.h"
68 #include "manager.h"
69 #include "missing.h"
70 #include "mount-setup.h"
71 #include "pager.h"
72 #include "parse-util.h"
73 #include "proc-cmdline.h"
74 #include "process-util.h"
75 #include "rlimit-util.h"
76 #include "selinux-setup.h"
77 #include "selinux-util.h"
78 #include "signal-util.h"
79 #include "smack-setup.h"
80 #include "special.h"
81 #include "stat-util.h"
82 #include "stdio-util.h"
83 #include "strv.h"
84 #include "switch-root.h"
85 #include "terminal-util.h"
86 #include "user-util.h"
87 #include "virt.h"
88 #include "watchdog.h"
89
90 static enum {
91 ACTION_RUN,
92 ACTION_HELP,
93 ACTION_VERSION,
94 ACTION_TEST,
95 ACTION_DUMP_CONFIGURATION_ITEMS,
96 ACTION_DONE
97 } arg_action = ACTION_RUN;
98 static char *arg_default_unit = NULL;
99 static ManagerRunningAs arg_running_as = _MANAGER_RUNNING_AS_INVALID;
100 static bool arg_dump_core = true;
101 static int arg_crash_chvt = -1;
102 static bool arg_crash_shell = false;
103 static bool arg_crash_reboot = false;
104 static bool arg_confirm_spawn = false;
105 static ShowStatus arg_show_status = _SHOW_STATUS_UNSET;
106 static bool arg_switched_root = false;
107 static int arg_no_pager = -1;
108 static char ***arg_join_controllers = NULL;
109 static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
110 static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
111 static usec_t arg_default_restart_usec = DEFAULT_RESTART_USEC;
112 static usec_t arg_default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
113 static usec_t arg_default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
114 static usec_t arg_default_start_limit_interval = DEFAULT_START_LIMIT_INTERVAL;
115 static unsigned arg_default_start_limit_burst = DEFAULT_START_LIMIT_BURST;
116 static usec_t arg_runtime_watchdog = 0;
117 static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
118 static char **arg_default_environment = NULL;
119 static struct rlimit *arg_default_rlimit[_RLIMIT_MAX] = {};
120 static uint64_t arg_capability_bounding_set_drop = 0;
121 static nsec_t arg_timer_slack_nsec = NSEC_INFINITY;
122 static usec_t arg_default_timer_accuracy_usec = 1 * USEC_PER_MINUTE;
123 static Set* arg_syscall_archs = NULL;
124 static FILE* arg_serialization = NULL;
125 static bool arg_default_cpu_accounting = false;
126 static bool arg_default_blockio_accounting = false;
127 static bool arg_default_memory_accounting = false;
128 static bool arg_default_tasks_accounting = false;
129
130 static void pager_open_if_enabled(void) {
131
132 if (arg_no_pager <= 0)
133 return;
134
135 pager_open(false);
136 }
137
138 noreturn static void freeze_or_reboot(void) {
139
140 if (arg_crash_reboot) {
141 log_notice("Rebooting in 10s...");
142 (void) sleep(10);
143
144 log_notice("Rebooting now...");
145 (void) reboot(RB_AUTOBOOT);
146 log_emergency_errno(errno, "Failed to reboot: %m");
147 }
148
149 log_emergency("Freezing execution.");
150 freeze();
151 }
152
153 noreturn static void crash(int sig) {
154 struct sigaction sa;
155 pid_t pid;
156
157 if (getpid() != 1)
158 /* Pass this on immediately, if this is not PID 1 */
159 (void) raise(sig);
160 else if (!arg_dump_core)
161 log_emergency("Caught <%s>, not dumping core.", signal_to_string(sig));
162 else {
163 sa = (struct sigaction) {
164 .sa_handler = nop_signal_handler,
165 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
166 };
167
168 /* We want to wait for the core process, hence let's enable SIGCHLD */
169 (void) sigaction(SIGCHLD, &sa, NULL);
170
171 pid = raw_clone(SIGCHLD, NULL);
172 if (pid < 0)
173 log_emergency_errno(errno, "Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
174 else if (pid == 0) {
175 struct rlimit rl = {
176 .rlim_cur = RLIM_INFINITY,
177 .rlim_max = RLIM_INFINITY,
178 };
179
180 /* Enable default signal handler for core dump */
181 sa = (struct sigaction) {
182 .sa_handler = SIG_DFL,
183 };
184 (void) sigaction(sig, &sa, NULL);
185
186 /* Don't limit the core dump size */
187 (void) setrlimit(RLIMIT_CORE, &rl);
188
189 /* Just to be sure... */
190 (void) chdir("/");
191
192 /* Raise the signal again */
193 pid = raw_getpid();
194 (void) kill(pid, sig); /* raise() would kill the parent */
195
196 assert_not_reached("We shouldn't be here...");
197 _exit(EXIT_FAILURE);
198 } else {
199 siginfo_t status;
200 int r;
201
202 /* Order things nicely. */
203 r = wait_for_terminate(pid, &status);
204 if (r < 0)
205 log_emergency_errno(r, "Caught <%s>, waitpid() failed: %m", signal_to_string(sig));
206 else if (status.si_code != CLD_DUMPED)
207 log_emergency("Caught <%s>, core dump failed (child "PID_FMT", code=%s, status=%i/%s).",
208 signal_to_string(sig),
209 pid, sigchld_code_to_string(status.si_code),
210 status.si_status,
211 strna(status.si_code == CLD_EXITED
212 ? exit_status_to_string(status.si_status, EXIT_STATUS_FULL)
213 : signal_to_string(status.si_status)));
214 else
215 log_emergency("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
216 }
217 }
218
219 if (arg_crash_chvt >= 0)
220 (void) chvt(arg_crash_chvt);
221
222 sa = (struct sigaction) {
223 .sa_handler = SIG_IGN,
224 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
225 };
226
227 /* Let the kernel reap children for us */
228 (void) sigaction(SIGCHLD, &sa, NULL);
229
230 if (arg_crash_shell) {
231 log_notice("Executing crash shell in 10s...");
232 (void) sleep(10);
233
234 pid = raw_clone(SIGCHLD, NULL);
235 if (pid < 0)
236 log_emergency_errno(errno, "Failed to fork off crash shell: %m");
237 else if (pid == 0) {
238 (void) setsid();
239 (void) make_console_stdio();
240 (void) execle("/bin/sh", "/bin/sh", NULL, environ);
241
242 log_emergency_errno(errno, "execle() failed: %m");
243 _exit(EXIT_FAILURE);
244 } else {
245 log_info("Spawned crash shell as PID "PID_FMT".", pid);
246 (void) wait_for_terminate(pid, NULL);
247 }
248 }
249
250 freeze_or_reboot();
251 }
252
253 static void install_crash_handler(void) {
254 static const struct sigaction sa = {
255 .sa_handler = crash,
256 .sa_flags = SA_NODEFER, /* So that we can raise the signal again from the signal handler */
257 };
258 int r;
259
260 /* We ignore the return value here, since, we don't mind if we
261 * cannot set up a crash handler */
262 r = sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
263 if (r < 0)
264 log_debug_errno(r, "I had trouble setting up the crash handler, ignoring: %m");
265 }
266
267 static int console_setup(void) {
268 _cleanup_close_ int tty_fd = -1;
269 int r;
270
271 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
272 if (tty_fd < 0)
273 return log_error_errno(tty_fd, "Failed to open /dev/console: %m");
274
275 /* We don't want to force text mode. plymouth may be showing
276 * pictures already from initrd. */
277 r = reset_terminal_fd(tty_fd, false);
278 if (r < 0)
279 return log_error_errno(r, "Failed to reset /dev/console: %m");
280
281 return 0;
282 }
283
284 static int parse_crash_chvt(const char *value) {
285 int b;
286
287 if (safe_atoi(value, &arg_crash_chvt) >= 0)
288 return 0;
289
290 b = parse_boolean(value);
291 if (b < 0)
292 return b;
293
294 if (b > 0)
295 arg_crash_chvt = 0; /* switch to where kmsg goes */
296 else
297 arg_crash_chvt = -1; /* turn off switching */
298
299 return 0;
300 }
301
302 static int parse_proc_cmdline_item(const char *key, const char *value) {
303
304 int r;
305
306 assert(key);
307
308 if (streq(key, "systemd.unit") && value) {
309
310 if (!in_initrd())
311 return free_and_strdup(&arg_default_unit, value);
312
313 } else if (streq(key, "rd.systemd.unit") && value) {
314
315 if (in_initrd())
316 return free_and_strdup(&arg_default_unit, value);
317
318 } else if (streq(key, "systemd.dump_core") && value) {
319
320 r = parse_boolean(value);
321 if (r < 0)
322 log_warning("Failed to parse dump core switch %s. Ignoring.", value);
323 else
324 arg_dump_core = r;
325
326 } else if (streq(key, "systemd.crash_chvt") && value) {
327
328 if (parse_crash_chvt(value) < 0)
329 log_warning("Failed to parse crash chvt switch %s. Ignoring.", value);
330
331 } else if (streq(key, "systemd.crash_shell") && value) {
332
333 r = parse_boolean(value);
334 if (r < 0)
335 log_warning("Failed to parse crash shell switch %s. Ignoring.", value);
336 else
337 arg_crash_shell = r;
338
339 } else if (streq(key, "systemd.crash_reboot") && value) {
340
341 r = parse_boolean(value);
342 if (r < 0)
343 log_warning("Failed to parse crash reboot switch %s. Ignoring.", value);
344 else
345 arg_crash_reboot = r;
346
347 } else if (streq(key, "systemd.confirm_spawn") && value) {
348
349 r = parse_boolean(value);
350 if (r < 0)
351 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", value);
352 else
353 arg_confirm_spawn = r;
354
355 } else if (streq(key, "systemd.show_status") && value) {
356
357 r = parse_show_status(value, &arg_show_status);
358 if (r < 0)
359 log_warning("Failed to parse show status switch %s. Ignoring.", value);
360
361 } else if (streq(key, "systemd.default_standard_output") && value) {
362
363 r = exec_output_from_string(value);
364 if (r < 0)
365 log_warning("Failed to parse default standard output switch %s. Ignoring.", value);
366 else
367 arg_default_std_output = r;
368
369 } else if (streq(key, "systemd.default_standard_error") && value) {
370
371 r = exec_output_from_string(value);
372 if (r < 0)
373 log_warning("Failed to parse default standard error switch %s. Ignoring.", value);
374 else
375 arg_default_std_error = r;
376
377 } else if (streq(key, "systemd.setenv") && value) {
378
379 if (env_assignment_is_valid(value)) {
380 char **env;
381
382 env = strv_env_set(arg_default_environment, value);
383 if (env)
384 arg_default_environment = env;
385 else
386 log_warning_errno(ENOMEM, "Setting environment variable '%s' failed, ignoring: %m", value);
387 } else
388 log_warning("Environment variable name '%s' is not valid. Ignoring.", value);
389
390 } else if (streq(key, "quiet") && !value) {
391
392 if (arg_show_status == _SHOW_STATUS_UNSET)
393 arg_show_status = SHOW_STATUS_AUTO;
394
395 } else if (streq(key, "debug") && !value) {
396
397 /* Note that log_parse_environment() handles 'debug'
398 * too, and sets the log level to LOG_DEBUG. */
399
400 if (detect_container() > 0)
401 log_set_target(LOG_TARGET_CONSOLE);
402
403 } else if (!in_initrd() && !value) {
404 const char *target;
405
406 /* SysV compatibility */
407 target = runlevel_to_target(key);
408 if (target)
409 return free_and_strdup(&arg_default_unit, target);
410 }
411
412 return 0;
413 }
414
415 #define DEFINE_SETTER(name, func, descr) \
416 static int name(const char *unit, \
417 const char *filename, \
418 unsigned line, \
419 const char *section, \
420 unsigned section_line, \
421 const char *lvalue, \
422 int ltype, \
423 const char *rvalue, \
424 void *data, \
425 void *userdata) { \
426 \
427 int r; \
428 \
429 assert(filename); \
430 assert(lvalue); \
431 assert(rvalue); \
432 \
433 r = func(rvalue); \
434 if (r < 0) \
435 log_syntax(unit, LOG_ERR, filename, line, r, \
436 "Invalid " descr "'%s': %m", \
437 rvalue); \
438 \
439 return 0; \
440 }
441
442 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
443 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
444 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
445 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
446
447 static int config_parse_cpu_affinity2(
448 const char *unit,
449 const char *filename,
450 unsigned line,
451 const char *section,
452 unsigned section_line,
453 const char *lvalue,
454 int ltype,
455 const char *rvalue,
456 void *data,
457 void *userdata) {
458
459 _cleanup_cpu_free_ cpu_set_t *c = NULL;
460 int ncpus;
461
462 ncpus = parse_cpu_set_and_warn(rvalue, &c, unit, filename, line, lvalue);
463 if (ncpus < 0)
464 return ncpus;
465
466 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
467 log_warning("Failed to set CPU affinity: %m");
468
469 return 0;
470 }
471
472 static int config_parse_show_status(
473 const char* unit,
474 const char *filename,
475 unsigned line,
476 const char *section,
477 unsigned section_line,
478 const char *lvalue,
479 int ltype,
480 const char *rvalue,
481 void *data,
482 void *userdata) {
483
484 int k;
485 ShowStatus *b = data;
486
487 assert(filename);
488 assert(lvalue);
489 assert(rvalue);
490 assert(data);
491
492 k = parse_show_status(rvalue, b);
493 if (k < 0) {
494 log_syntax(unit, LOG_ERR, filename, line, k, "Failed to parse show status setting, ignoring: %s", rvalue);
495 return 0;
496 }
497
498 return 0;
499 }
500
501 static int config_parse_crash_chvt(
502 const char* unit,
503 const char *filename,
504 unsigned line,
505 const char *section,
506 unsigned section_line,
507 const char *lvalue,
508 int ltype,
509 const char *rvalue,
510 void *data,
511 void *userdata) {
512
513 int r;
514
515 assert(filename);
516 assert(lvalue);
517 assert(rvalue);
518
519 r = parse_crash_chvt(rvalue);
520 if (r < 0) {
521 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CrashChangeVT= setting, ignoring: %s", rvalue);
522 return 0;
523 }
524
525 return 0;
526 }
527
528 static int config_parse_join_controllers(const char *unit,
529 const char *filename,
530 unsigned line,
531 const char *section,
532 unsigned section_line,
533 const char *lvalue,
534 int ltype,
535 const char *rvalue,
536 void *data,
537 void *userdata) {
538
539 const char *whole_rvalue = rvalue;
540 unsigned n = 0;
541
542 assert(filename);
543 assert(lvalue);
544 assert(rvalue);
545
546 arg_join_controllers = strv_free_free(arg_join_controllers);
547
548 for (;;) {
549 _cleanup_free_ char *word = NULL;
550 char **l;
551 int r;
552
553 r = extract_first_word(&rvalue, &word, WHITESPACE, EXTRACT_QUOTES);
554 if (r < 0) {
555 log_syntax(unit, LOG_ERR, filename, line, r, "Invalid value for %s: %s", lvalue, whole_rvalue);
556 return r;
557 }
558 if (r == 0)
559 break;
560
561 l = strv_split(word, ",");
562 if (!l)
563 return log_oom();
564 strv_uniq(l);
565
566 if (strv_length(l) <= 1) {
567 strv_free(l);
568 continue;
569 }
570
571 if (!arg_join_controllers) {
572 arg_join_controllers = new(char**, 2);
573 if (!arg_join_controllers) {
574 strv_free(l);
575 return log_oom();
576 }
577
578 arg_join_controllers[0] = l;
579 arg_join_controllers[1] = NULL;
580
581 n = 1;
582 } else {
583 char ***a;
584 char ***t;
585
586 t = new0(char**, n+2);
587 if (!t) {
588 strv_free(l);
589 return log_oom();
590 }
591
592 n = 0;
593
594 for (a = arg_join_controllers; *a; a++) {
595
596 if (strv_overlap(*a, l)) {
597 if (strv_extend_strv(&l, *a, false) < 0) {
598 strv_free(l);
599 strv_free_free(t);
600 return log_oom();
601 }
602
603 } else {
604 char **c;
605
606 c = strv_copy(*a);
607 if (!c) {
608 strv_free(l);
609 strv_free_free(t);
610 return log_oom();
611 }
612
613 t[n++] = c;
614 }
615 }
616
617 t[n++] = strv_uniq(l);
618
619 strv_free_free(arg_join_controllers);
620 arg_join_controllers = t;
621 }
622 }
623 if (!isempty(rvalue))
624 log_syntax(unit, LOG_ERR, filename, line, 0, "Trailing garbage, ignoring.");
625
626 return 0;
627 }
628
629 static int parse_config_file(void) {
630
631 const ConfigTableItem items[] = {
632 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
633 { "Manager", "LogTarget", config_parse_target, 0, NULL },
634 { "Manager", "LogColor", config_parse_color, 0, NULL },
635 { "Manager", "LogLocation", config_parse_location, 0, NULL },
636 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
637 { "Manager", "CrashChVT", /* legacy */ config_parse_crash_chvt, 0, NULL },
638 { "Manager", "CrashChangeVT", config_parse_crash_chvt, 0, NULL },
639 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
640 { "Manager", "CrashReboot", config_parse_bool, 0, &arg_crash_reboot },
641 { "Manager", "ShowStatus", config_parse_show_status, 0, &arg_show_status },
642 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
643 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
644 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
645 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
646 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
647 #ifdef HAVE_SECCOMP
648 { "Manager", "SystemCallArchitectures", config_parse_syscall_archs, 0, &arg_syscall_archs },
649 #endif
650 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
651 { "Manager", "DefaultTimerAccuracySec", config_parse_sec, 0, &arg_default_timer_accuracy_usec },
652 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
653 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
654 { "Manager", "DefaultTimeoutStartSec", config_parse_sec, 0, &arg_default_timeout_start_usec },
655 { "Manager", "DefaultTimeoutStopSec", config_parse_sec, 0, &arg_default_timeout_stop_usec },
656 { "Manager", "DefaultRestartSec", config_parse_sec, 0, &arg_default_restart_usec },
657 { "Manager", "DefaultStartLimitInterval", config_parse_sec, 0, &arg_default_start_limit_interval },
658 { "Manager", "DefaultStartLimitBurst", config_parse_unsigned, 0, &arg_default_start_limit_burst },
659 { "Manager", "DefaultEnvironment", config_parse_environ, 0, &arg_default_environment },
660 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU] },
661 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE] },
662 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA] },
663 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK] },
664 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE] },
665 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS] },
666 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE] },
667 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS] },
668 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC] },
669 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK] },
670 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS] },
671 { "Manager", "DefaultLimitSIGPENDING", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING] },
672 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE] },
673 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE] },
674 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO] },
675 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME] },
676 { "Manager", "DefaultCPUAccounting", config_parse_bool, 0, &arg_default_cpu_accounting },
677 { "Manager", "DefaultBlockIOAccounting", config_parse_bool, 0, &arg_default_blockio_accounting },
678 { "Manager", "DefaultMemoryAccounting", config_parse_bool, 0, &arg_default_memory_accounting },
679 { "Manager", "DefaultTasksAccounting", config_parse_bool, 0, &arg_default_tasks_accounting },
680 {}
681 };
682
683 const char *fn, *conf_dirs_nulstr;
684
685 fn = arg_running_as == MANAGER_SYSTEM ? PKGSYSCONFDIR "/system.conf" : PKGSYSCONFDIR "/user.conf";
686 conf_dirs_nulstr = arg_running_as == MANAGER_SYSTEM ? CONF_DIRS_NULSTR("systemd/system.conf") : CONF_DIRS_NULSTR("systemd/user.conf");
687 config_parse_many(fn, conf_dirs_nulstr, "Manager\0",
688 config_item_table_lookup, items, false, NULL);
689
690 return 0;
691 }
692
693 static void manager_set_defaults(Manager *m) {
694
695 assert(m);
696
697 m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
698 m->default_std_output = arg_default_std_output;
699 m->default_std_error = arg_default_std_error;
700 m->default_timeout_start_usec = arg_default_timeout_start_usec;
701 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
702 m->default_restart_usec = arg_default_restart_usec;
703 m->default_start_limit_interval = arg_default_start_limit_interval;
704 m->default_start_limit_burst = arg_default_start_limit_burst;
705 m->default_cpu_accounting = arg_default_cpu_accounting;
706 m->default_blockio_accounting = arg_default_blockio_accounting;
707 m->default_memory_accounting = arg_default_memory_accounting;
708 m->default_tasks_accounting = arg_default_tasks_accounting;
709
710 manager_set_default_rlimits(m, arg_default_rlimit);
711 manager_environment_add(m, NULL, arg_default_environment);
712 }
713
714 static int parse_argv(int argc, char *argv[]) {
715
716 enum {
717 ARG_LOG_LEVEL = 0x100,
718 ARG_LOG_TARGET,
719 ARG_LOG_COLOR,
720 ARG_LOG_LOCATION,
721 ARG_UNIT,
722 ARG_SYSTEM,
723 ARG_USER,
724 ARG_TEST,
725 ARG_NO_PAGER,
726 ARG_VERSION,
727 ARG_DUMP_CONFIGURATION_ITEMS,
728 ARG_DUMP_CORE,
729 ARG_CRASH_CHVT,
730 ARG_CRASH_SHELL,
731 ARG_CRASH_REBOOT,
732 ARG_CONFIRM_SPAWN,
733 ARG_SHOW_STATUS,
734 ARG_DESERIALIZE,
735 ARG_SWITCHED_ROOT,
736 ARG_DEFAULT_STD_OUTPUT,
737 ARG_DEFAULT_STD_ERROR
738 };
739
740 static const struct option options[] = {
741 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
742 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
743 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
744 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
745 { "unit", required_argument, NULL, ARG_UNIT },
746 { "system", no_argument, NULL, ARG_SYSTEM },
747 { "user", no_argument, NULL, ARG_USER },
748 { "test", no_argument, NULL, ARG_TEST },
749 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
750 { "help", no_argument, NULL, 'h' },
751 { "version", no_argument, NULL, ARG_VERSION },
752 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
753 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
754 { "crash-chvt", required_argument, NULL, ARG_CRASH_CHVT },
755 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
756 { "crash-reboot", optional_argument, NULL, ARG_CRASH_REBOOT },
757 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
758 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
759 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
760 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
761 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
762 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
763 {}
764 };
765
766 int c, r;
767
768 assert(argc >= 1);
769 assert(argv);
770
771 if (getpid() == 1)
772 opterr = 0;
773
774 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
775
776 switch (c) {
777
778 case ARG_LOG_LEVEL:
779 r = log_set_max_level_from_string(optarg);
780 if (r < 0) {
781 log_error("Failed to parse log level %s.", optarg);
782 return r;
783 }
784
785 break;
786
787 case ARG_LOG_TARGET:
788 r = log_set_target_from_string(optarg);
789 if (r < 0) {
790 log_error("Failed to parse log target %s.", optarg);
791 return r;
792 }
793
794 break;
795
796 case ARG_LOG_COLOR:
797
798 if (optarg) {
799 r = log_show_color_from_string(optarg);
800 if (r < 0) {
801 log_error("Failed to parse log color setting %s.", optarg);
802 return r;
803 }
804 } else
805 log_show_color(true);
806
807 break;
808
809 case ARG_LOG_LOCATION:
810 if (optarg) {
811 r = log_show_location_from_string(optarg);
812 if (r < 0) {
813 log_error("Failed to parse log location setting %s.", optarg);
814 return r;
815 }
816 } else
817 log_show_location(true);
818
819 break;
820
821 case ARG_DEFAULT_STD_OUTPUT:
822 r = exec_output_from_string(optarg);
823 if (r < 0) {
824 log_error("Failed to parse default standard output setting %s.", optarg);
825 return r;
826 } else
827 arg_default_std_output = r;
828 break;
829
830 case ARG_DEFAULT_STD_ERROR:
831 r = exec_output_from_string(optarg);
832 if (r < 0) {
833 log_error("Failed to parse default standard error output setting %s.", optarg);
834 return r;
835 } else
836 arg_default_std_error = r;
837 break;
838
839 case ARG_UNIT:
840
841 r = free_and_strdup(&arg_default_unit, optarg);
842 if (r < 0)
843 return log_error_errno(r, "Failed to set default unit %s: %m", optarg);
844
845 break;
846
847 case ARG_SYSTEM:
848 arg_running_as = MANAGER_SYSTEM;
849 break;
850
851 case ARG_USER:
852 arg_running_as = MANAGER_USER;
853 break;
854
855 case ARG_TEST:
856 arg_action = ACTION_TEST;
857 if (arg_no_pager < 0)
858 arg_no_pager = true;
859 break;
860
861 case ARG_NO_PAGER:
862 arg_no_pager = true;
863 break;
864
865 case ARG_VERSION:
866 arg_action = ACTION_VERSION;
867 break;
868
869 case ARG_DUMP_CONFIGURATION_ITEMS:
870 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
871 break;
872
873 case ARG_DUMP_CORE:
874 if (!optarg)
875 arg_dump_core = true;
876 else {
877 r = parse_boolean(optarg);
878 if (r < 0)
879 return log_error_errno(r, "Failed to parse dump core boolean: %s", optarg);
880 arg_dump_core = r;
881 }
882 break;
883
884 case ARG_CRASH_CHVT:
885 r = parse_crash_chvt(optarg);
886 if (r < 0)
887 return log_error_errno(r, "Failed to parse crash virtual terminal index: %s", optarg);
888 break;
889
890 case ARG_CRASH_SHELL:
891 if (!optarg)
892 arg_crash_shell = true;
893 else {
894 r = parse_boolean(optarg);
895 if (r < 0)
896 return log_error_errno(r, "Failed to parse crash shell boolean: %s", optarg);
897 arg_crash_shell = r;
898 }
899 break;
900
901 case ARG_CRASH_REBOOT:
902 if (!optarg)
903 arg_crash_reboot = true;
904 else {
905 r = parse_boolean(optarg);
906 if (r < 0)
907 return log_error_errno(r, "Failed to parse crash shell boolean: %s", optarg);
908 arg_crash_reboot = r;
909 }
910 break;
911
912 case ARG_CONFIRM_SPAWN:
913 r = optarg ? parse_boolean(optarg) : 1;
914 if (r < 0) {
915 log_error("Failed to parse confirm spawn boolean %s.", optarg);
916 return r;
917 }
918 arg_confirm_spawn = r;
919 break;
920
921 case ARG_SHOW_STATUS:
922 if (optarg) {
923 r = parse_show_status(optarg, &arg_show_status);
924 if (r < 0) {
925 log_error("Failed to parse show status boolean %s.", optarg);
926 return r;
927 }
928 } else
929 arg_show_status = SHOW_STATUS_YES;
930 break;
931
932 case ARG_DESERIALIZE: {
933 int fd;
934 FILE *f;
935
936 r = safe_atoi(optarg, &fd);
937 if (r < 0 || fd < 0) {
938 log_error("Failed to parse deserialize option %s.", optarg);
939 return -EINVAL;
940 }
941
942 (void) fd_cloexec(fd, true);
943
944 f = fdopen(fd, "r");
945 if (!f)
946 return log_error_errno(errno, "Failed to open serialization fd: %m");
947
948 safe_fclose(arg_serialization);
949 arg_serialization = f;
950
951 break;
952 }
953
954 case ARG_SWITCHED_ROOT:
955 arg_switched_root = true;
956 break;
957
958 case 'h':
959 arg_action = ACTION_HELP;
960 if (arg_no_pager < 0)
961 arg_no_pager = true;
962 break;
963
964 case 'D':
965 log_set_max_level(LOG_DEBUG);
966 break;
967
968 case 'b':
969 case 's':
970 case 'z':
971 /* Just to eat away the sysvinit kernel
972 * cmdline args without getopt() error
973 * messages that we'll parse in
974 * parse_proc_cmdline_word() or ignore. */
975
976 case '?':
977 if (getpid() != 1)
978 return -EINVAL;
979 else
980 return 0;
981
982 default:
983 assert_not_reached("Unhandled option code.");
984 }
985
986 if (optind < argc && getpid() != 1) {
987 /* Hmm, when we aren't run as init system
988 * let's complain about excess arguments */
989
990 log_error("Excess arguments.");
991 return -EINVAL;
992 }
993
994 return 0;
995 }
996
997 static int help(void) {
998
999 printf("%s [OPTIONS...]\n\n"
1000 "Starts up and maintains the system or user services.\n\n"
1001 " -h --help Show this help\n"
1002 " --test Determine startup sequence, dump it and exit\n"
1003 " --no-pager Do not pipe output into a pager\n"
1004 " --dump-configuration-items Dump understood unit configuration items\n"
1005 " --unit=UNIT Set default unit\n"
1006 " --system Run a system instance, even if PID != 1\n"
1007 " --user Run a user instance\n"
1008 " --dump-core[=BOOL] Dump core on crash\n"
1009 " --crash-vt=NR Change to specified VT on crash\n"
1010 " --crash-reboot[=BOOL] Reboot on crash\n"
1011 " --crash-shell[=BOOL] Run shell on crash\n"
1012 " --confirm-spawn[=BOOL] Ask for confirmation when spawning processes\n"
1013 " --show-status[=BOOL] Show status updates on the console during bootup\n"
1014 " --log-target=TARGET Set log target (console, journal, kmsg, journal-or-kmsg, null)\n"
1015 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1016 " --log-color[=BOOL] Highlight important log messages\n"
1017 " --log-location[=BOOL] Include code location in log messages\n"
1018 " --default-standard-output= Set default standard output for services\n"
1019 " --default-standard-error= Set default standard error output for services\n",
1020 program_invocation_short_name);
1021
1022 return 0;
1023 }
1024
1025 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
1026 _cleanup_fdset_free_ FDSet *fds = NULL;
1027 _cleanup_fclose_ FILE *f = NULL;
1028 int r;
1029
1030 assert(m);
1031 assert(_f);
1032 assert(_fds);
1033
1034 r = manager_open_serialization(m, &f);
1035 if (r < 0)
1036 return log_error_errno(r, "Failed to create serialization file: %m");
1037
1038 /* Make sure nothing is really destructed when we shut down */
1039 m->n_reloading ++;
1040 bus_manager_send_reloading(m, true);
1041
1042 fds = fdset_new();
1043 if (!fds)
1044 return log_oom();
1045
1046 r = manager_serialize(m, f, fds, switching_root);
1047 if (r < 0)
1048 return log_error_errno(r, "Failed to serialize state: %m");
1049
1050 if (fseeko(f, 0, SEEK_SET) == (off_t) -1)
1051 return log_error_errno(errno, "Failed to rewind serialization fd: %m");
1052
1053 r = fd_cloexec(fileno(f), false);
1054 if (r < 0)
1055 return log_error_errno(r, "Failed to disable O_CLOEXEC for serialization: %m");
1056
1057 r = fdset_cloexec(fds, false);
1058 if (r < 0)
1059 return log_error_errno(r, "Failed to disable O_CLOEXEC for serialization fds: %m");
1060
1061 *_f = f;
1062 *_fds = fds;
1063
1064 f = NULL;
1065 fds = NULL;
1066
1067 return 0;
1068 }
1069
1070 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1071 struct rlimit nl;
1072 int r;
1073
1074 assert(saved_rlimit);
1075
1076 /* Save the original RLIMIT_NOFILE so that we can reset it
1077 * later when transitioning from the initrd to the main
1078 * systemd or suchlike. */
1079 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0)
1080 return log_error_errno(errno, "Reading RLIMIT_NOFILE failed: %m");
1081
1082 /* Make sure forked processes get the default kernel setting */
1083 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1084 struct rlimit *rl;
1085
1086 rl = newdup(struct rlimit, saved_rlimit, 1);
1087 if (!rl)
1088 return log_oom();
1089
1090 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1091 }
1092
1093 /* Bump up the resource limit for ourselves substantially */
1094 nl.rlim_cur = nl.rlim_max = 64*1024;
1095 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1096 if (r < 0)
1097 return log_error_errno(r, "Setting RLIMIT_NOFILE failed: %m");
1098
1099 return 0;
1100 }
1101
1102 static void test_usr(void) {
1103
1104 /* Check that /usr is not a separate fs */
1105
1106 if (dir_is_empty("/usr") <= 0)
1107 return;
1108
1109 log_warning("/usr appears to be on its own filesystem and is not already mounted. This is not a supported setup. "
1110 "Some things will probably break (sometimes even silently) in mysterious ways. "
1111 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1112 }
1113
1114 static int initialize_join_controllers(void) {
1115 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1116 * + "net_prio". We'd like to add "cpuset" to the mix, but
1117 * "cpuset" doesn't really work for groups with no initialized
1118 * attributes. */
1119
1120 arg_join_controllers = new(char**, 3);
1121 if (!arg_join_controllers)
1122 return -ENOMEM;
1123
1124 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1125 if (!arg_join_controllers[0])
1126 goto oom;
1127
1128 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1129 if (!arg_join_controllers[1])
1130 goto oom;
1131
1132 arg_join_controllers[2] = NULL;
1133 return 0;
1134
1135 oom:
1136 arg_join_controllers = strv_free_free(arg_join_controllers);
1137 return -ENOMEM;
1138 }
1139
1140 static int enforce_syscall_archs(Set *archs) {
1141 #ifdef HAVE_SECCOMP
1142 scmp_filter_ctx *seccomp;
1143 Iterator i;
1144 void *id;
1145 int r;
1146
1147 seccomp = seccomp_init(SCMP_ACT_ALLOW);
1148 if (!seccomp)
1149 return log_oom();
1150
1151 SET_FOREACH(id, arg_syscall_archs, i) {
1152 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1153 if (r == -EEXIST)
1154 continue;
1155 if (r < 0) {
1156 log_error_errno(r, "Failed to add architecture to seccomp: %m");
1157 goto finish;
1158 }
1159 }
1160
1161 r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1162 if (r < 0) {
1163 log_error_errno(r, "Failed to unset NO_NEW_PRIVS: %m");
1164 goto finish;
1165 }
1166
1167 r = seccomp_load(seccomp);
1168 if (r < 0)
1169 log_error_errno(r, "Failed to add install architecture seccomp: %m");
1170
1171 finish:
1172 seccomp_release(seccomp);
1173 return r;
1174 #else
1175 return 0;
1176 #endif
1177 }
1178
1179 static int status_welcome(void) {
1180 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1181 int r;
1182
1183 r = parse_env_file("/etc/os-release", NEWLINE,
1184 "PRETTY_NAME", &pretty_name,
1185 "ANSI_COLOR", &ansi_color,
1186 NULL);
1187 if (r == -ENOENT)
1188 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1189 "PRETTY_NAME", &pretty_name,
1190 "ANSI_COLOR", &ansi_color,
1191 NULL);
1192
1193 if (r < 0 && r != -ENOENT)
1194 log_warning_errno(r, "Failed to read os-release file: %m");
1195
1196 return status_printf(NULL, false, false,
1197 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1198 isempty(ansi_color) ? "1" : ansi_color,
1199 isempty(pretty_name) ? "Linux" : pretty_name);
1200 }
1201
1202 static int write_container_id(void) {
1203 const char *c;
1204 int r;
1205
1206 c = getenv("container");
1207 if (isempty(c))
1208 return 0;
1209
1210 r = write_string_file("/run/systemd/container", c, WRITE_STRING_FILE_CREATE);
1211 if (r < 0)
1212 return log_warning_errno(r, "Failed to write /run/systemd/container, ignoring: %m");
1213
1214 return 1;
1215 }
1216
1217 static int bump_unix_max_dgram_qlen(void) {
1218 _cleanup_free_ char *qlen = NULL;
1219 unsigned long v;
1220 int r;
1221
1222 /* Let's bump the net.unix.max_dgram_qlen sysctl. The kernel
1223 * default of 16 is simply too low. We set the value really
1224 * really early during boot, so that it is actually applied to
1225 * all our sockets, including the $NOTIFY_SOCKET one. */
1226
1227 r = read_one_line_file("/proc/sys/net/unix/max_dgram_qlen", &qlen);
1228 if (r < 0)
1229 return log_warning_errno(r, "Failed to read AF_UNIX datagram queue length, ignoring: %m");
1230
1231 r = safe_atolu(qlen, &v);
1232 if (r < 0)
1233 return log_warning_errno(r, "Failed to parse AF_UNIX datagram queue length, ignoring: %m");
1234
1235 if (v >= DEFAULT_UNIX_MAX_DGRAM_QLEN)
1236 return 0;
1237
1238 qlen = mfree(qlen);
1239 if (asprintf(&qlen, "%lu\n", DEFAULT_UNIX_MAX_DGRAM_QLEN) < 0)
1240 return log_oom();
1241
1242 r = write_string_file("/proc/sys/net/unix/max_dgram_qlen", qlen, 0);
1243 if (r < 0)
1244 return log_full_errno(IN_SET(r, -EROFS, -EPERM, -EACCES) ? LOG_DEBUG : LOG_WARNING, r,
1245 "Failed to bump AF_UNIX datagram queue length, ignoring: %m");
1246
1247 return 1;
1248 }
1249
1250 int main(int argc, char *argv[]) {
1251 Manager *m = NULL;
1252 int r, retval = EXIT_FAILURE;
1253 usec_t before_startup, after_startup;
1254 char timespan[FORMAT_TIMESPAN_MAX];
1255 FDSet *fds = NULL;
1256 bool reexecute = false;
1257 const char *shutdown_verb = NULL;
1258 dual_timestamp initrd_timestamp = DUAL_TIMESTAMP_NULL;
1259 dual_timestamp userspace_timestamp = DUAL_TIMESTAMP_NULL;
1260 dual_timestamp kernel_timestamp = DUAL_TIMESTAMP_NULL;
1261 dual_timestamp security_start_timestamp = DUAL_TIMESTAMP_NULL;
1262 dual_timestamp security_finish_timestamp = DUAL_TIMESTAMP_NULL;
1263 static char systemd[] = "systemd";
1264 bool skip_setup = false;
1265 unsigned j;
1266 bool loaded_policy = false;
1267 bool arm_reboot_watchdog = false;
1268 bool queue_default_job = false;
1269 bool empty_etc = false;
1270 char *switch_root_dir = NULL, *switch_root_init = NULL;
1271 struct rlimit saved_rlimit_nofile = RLIMIT_MAKE_CONST(0);
1272 const char *error_message = NULL;
1273
1274 #ifdef HAVE_SYSV_COMPAT
1275 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1276 /* This is compatibility support for SysV, where
1277 * calling init as a user is identical to telinit. */
1278
1279 errno = -ENOENT;
1280 execv(SYSTEMCTL_BINARY_PATH, argv);
1281 log_error_errno(errno, "Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1282 return 1;
1283 }
1284 #endif
1285
1286 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1287 dual_timestamp_get(&userspace_timestamp);
1288
1289 /* Determine if this is a reexecution or normal bootup. We do
1290 * the full command line parsing much later, so let's just
1291 * have a quick peek here. */
1292 if (strv_find(argv+1, "--deserialize"))
1293 skip_setup = true;
1294
1295 /* If we have switched root, do all the special setup
1296 * things */
1297 if (strv_find(argv+1, "--switched-root"))
1298 skip_setup = false;
1299
1300 /* If we get started via the /sbin/init symlink then we are
1301 called 'init'. After a subsequent reexecution we are then
1302 called 'systemd'. That is confusing, hence let's call us
1303 systemd right-away. */
1304 program_invocation_short_name = systemd;
1305 prctl(PR_SET_NAME, systemd);
1306
1307 saved_argv = argv;
1308 saved_argc = argc;
1309
1310 log_show_color(isatty(STDERR_FILENO) > 0);
1311 log_set_upgrade_syslog_to_journal(true);
1312
1313 /* Disable the umask logic */
1314 if (getpid() == 1)
1315 umask(0);
1316
1317 if (getpid() == 1 && detect_container() <= 0) {
1318
1319 /* Running outside of a container as PID 1 */
1320 arg_running_as = MANAGER_SYSTEM;
1321 make_null_stdio();
1322 log_set_target(LOG_TARGET_KMSG);
1323 log_open();
1324
1325 if (in_initrd())
1326 initrd_timestamp = userspace_timestamp;
1327
1328 if (!skip_setup) {
1329 mount_setup_early();
1330 dual_timestamp_get(&security_start_timestamp);
1331 if (mac_selinux_setup(&loaded_policy) < 0) {
1332 error_message = "Failed to load SELinux policy";
1333 goto finish;
1334 } else if (ima_setup() < 0) {
1335 error_message = "Failed to load IMA policy";
1336 goto finish;
1337 } else if (mac_smack_setup(&loaded_policy) < 0) {
1338 error_message = "Failed to load SMACK policy";
1339 goto finish;
1340 }
1341 dual_timestamp_get(&security_finish_timestamp);
1342 }
1343
1344 if (mac_selinux_init(NULL) < 0) {
1345 error_message = "Failed to initialize SELinux policy";
1346 goto finish;
1347 }
1348
1349 if (!skip_setup) {
1350 if (clock_is_localtime() > 0) {
1351 int min;
1352
1353 /*
1354 * The very first call of settimeofday() also does a time warp in the kernel.
1355 *
1356 * In the rtc-in-local time mode, we set the kernel's timezone, and rely on
1357 * external tools to take care of maintaining the RTC and do all adjustments.
1358 * This matches the behavior of Windows, which leaves the RTC alone if the
1359 * registry tells that the RTC runs in UTC.
1360 */
1361 r = clock_set_timezone(&min);
1362 if (r < 0)
1363 log_error_errno(r, "Failed to apply local time delta, ignoring: %m");
1364 else
1365 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1366 } else if (!in_initrd()) {
1367 /*
1368 * Do a dummy very first call to seal the kernel's time warp magic.
1369 *
1370 * Do not call this this from inside the initrd. The initrd might not
1371 * carry /etc/adjtime with LOCAL, but the real system could be set up
1372 * that way. In such case, we need to delay the time-warp or the sealing
1373 * until we reach the real system.
1374 *
1375 * Do no set the kernel's timezone. The concept of local time cannot
1376 * be supported reliably, the time will jump or be incorrect at every daylight
1377 * saving time change. All kernel local time concepts will be treated
1378 * as UTC that way.
1379 */
1380 clock_reset_timewarp();
1381 }
1382 }
1383
1384 /* Set the default for later on, but don't actually
1385 * open the logs like this for now. Note that if we
1386 * are transitioning from the initrd there might still
1387 * be journal fd open, and we shouldn't attempt
1388 * opening that before we parsed /proc/cmdline which
1389 * might redirect output elsewhere. */
1390 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1391
1392 } else if (getpid() == 1) {
1393 /* Running inside a container, as PID 1 */
1394 arg_running_as = MANAGER_SYSTEM;
1395 log_set_target(LOG_TARGET_CONSOLE);
1396 log_close_console(); /* force reopen of /dev/console */
1397 log_open();
1398
1399 /* For the later on, see above... */
1400 log_set_target(LOG_TARGET_JOURNAL);
1401
1402 /* clear the kernel timestamp,
1403 * because we are in a container */
1404 kernel_timestamp.monotonic = 0ULL;
1405 kernel_timestamp.realtime = 0ULL;
1406
1407 } else {
1408 /* Running as user instance */
1409 arg_running_as = MANAGER_USER;
1410 log_set_target(LOG_TARGET_AUTO);
1411 log_open();
1412
1413 /* clear the kernel timestamp,
1414 * because we are not PID 1 */
1415 kernel_timestamp = DUAL_TIMESTAMP_NULL;
1416 }
1417
1418 /* Initialize default unit */
1419 r = free_and_strdup(&arg_default_unit, SPECIAL_DEFAULT_TARGET);
1420 if (r < 0) {
1421 log_emergency_errno(r, "Failed to set default unit %s: %m", SPECIAL_DEFAULT_TARGET);
1422 error_message = "Failed to set default unit";
1423 goto finish;
1424 }
1425
1426 r = initialize_join_controllers();
1427 if (r < 0) {
1428 error_message = "Failed to initialize cgroup controllers";
1429 goto finish;
1430 }
1431
1432 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1433 * /proc/$PID/fd is available. */
1434 if (getpid() == 1) {
1435
1436 /* Load the kernel modules early, so that we kdbus.ko is loaded before kdbusfs shall be mounted */
1437 if (!skip_setup)
1438 kmod_setup();
1439
1440 r = mount_setup(loaded_policy);
1441 if (r < 0) {
1442 error_message = "Failed to mount API filesystems";
1443 goto finish;
1444 }
1445 }
1446
1447 /* Reset all signal handlers. */
1448 (void) reset_all_signal_handlers();
1449 (void) ignore_signals(SIGNALS_IGNORE, -1);
1450
1451 if (parse_config_file() < 0) {
1452 error_message = "Failed to parse config file";
1453 goto finish;
1454 }
1455
1456 if (arg_running_as == MANAGER_SYSTEM) {
1457 r = parse_proc_cmdline(parse_proc_cmdline_item);
1458 if (r < 0)
1459 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
1460 }
1461
1462 /* Note that this also parses bits from the kernel command
1463 * line, including "debug". */
1464 log_parse_environment();
1465
1466 if (parse_argv(argc, argv) < 0) {
1467 error_message = "Failed to parse commandline arguments";
1468 goto finish;
1469 }
1470
1471 if (arg_action == ACTION_TEST &&
1472 geteuid() == 0) {
1473 log_error("Don't run test mode as root.");
1474 goto finish;
1475 }
1476
1477 if (arg_running_as == MANAGER_USER &&
1478 arg_action == ACTION_RUN &&
1479 sd_booted() <= 0) {
1480 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1481 goto finish;
1482 }
1483
1484 if (arg_running_as == MANAGER_SYSTEM &&
1485 arg_action == ACTION_RUN &&
1486 running_in_chroot() > 0) {
1487 log_error("Cannot be run in a chroot() environment.");
1488 goto finish;
1489 }
1490
1491 if (arg_action == ACTION_TEST)
1492 skip_setup = true;
1493
1494 pager_open_if_enabled();
1495
1496 if (arg_action == ACTION_HELP) {
1497 retval = help();
1498 goto finish;
1499 } else if (arg_action == ACTION_VERSION) {
1500 retval = version();
1501 goto finish;
1502 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1503 unit_dump_config_items(stdout);
1504 retval = EXIT_SUCCESS;
1505 goto finish;
1506 } else if (arg_action == ACTION_DONE) {
1507 retval = EXIT_SUCCESS;
1508 goto finish;
1509 }
1510
1511 if (arg_running_as == MANAGER_USER &&
1512 !getenv("XDG_RUNTIME_DIR")) {
1513 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1514 goto finish;
1515 }
1516
1517 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1518
1519 /* Close logging fds, in order not to confuse fdset below */
1520 log_close();
1521
1522 /* Remember open file descriptors for later deserialization */
1523 r = fdset_new_fill(&fds);
1524 if (r < 0) {
1525 log_emergency_errno(r, "Failed to allocate fd set: %m");
1526 error_message = "Failed to allocate fd set";
1527 goto finish;
1528 } else
1529 fdset_cloexec(fds, true);
1530
1531 if (arg_serialization)
1532 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1533
1534 if (arg_running_as == MANAGER_SYSTEM)
1535 /* Become a session leader if we aren't one yet. */
1536 setsid();
1537
1538 /* Move out of the way, so that we won't block unmounts */
1539 assert_se(chdir("/") == 0);
1540
1541 /* Reset the console, but only if this is really init and we
1542 * are freshly booted */
1543 if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1544
1545 /* If we are init, we connect stdin/stdout/stderr to
1546 * /dev/null and make sure we don't have a controlling
1547 * tty. */
1548 release_terminal();
1549
1550 if (getpid() == 1 && !skip_setup)
1551 console_setup();
1552 }
1553
1554 /* Open the logging devices, if possible and necessary */
1555 log_open();
1556
1557 if (arg_show_status == _SHOW_STATUS_UNSET)
1558 arg_show_status = SHOW_STATUS_YES;
1559
1560 /* Make sure we leave a core dump without panicing the
1561 * kernel. */
1562 if (getpid() == 1) {
1563 install_crash_handler();
1564
1565 r = mount_cgroup_controllers(arg_join_controllers);
1566 if (r < 0)
1567 goto finish;
1568 }
1569
1570 if (arg_running_as == MANAGER_SYSTEM) {
1571 int v;
1572
1573 log_info(PACKAGE_STRING " running in %ssystem mode. (" SYSTEMD_FEATURES ")",
1574 arg_action == ACTION_TEST ? "test " : "" );
1575
1576 v = detect_virtualization();
1577 if (v > 0)
1578 log_info("Detected virtualization %s.", virtualization_to_string(v));
1579
1580 write_container_id();
1581
1582 log_info("Detected architecture %s.", architecture_to_string(uname_architecture()));
1583
1584 if (in_initrd())
1585 log_info("Running in initial RAM disk.");
1586
1587 /* Let's check whether /etc is already populated. We
1588 * don't actually really check for that, but use
1589 * /etc/machine-id as flag file. This allows container
1590 * managers and installers to provision a couple of
1591 * files already. If the container manager wants to
1592 * provision the machine ID itself it should pass
1593 * $container_uuid to PID 1. */
1594
1595 empty_etc = access("/etc/machine-id", F_OK) < 0;
1596 if (empty_etc)
1597 log_info("Running with unpopulated /etc.");
1598 } else {
1599 _cleanup_free_ char *t;
1600
1601 t = uid_to_name(getuid());
1602 log_debug(PACKAGE_STRING " running in %suser mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1603 arg_action == ACTION_TEST ? " test" : "", getuid(), t);
1604 }
1605
1606 if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1607 if (arg_show_status > 0)
1608 status_welcome();
1609
1610 hostname_setup();
1611 machine_id_setup(NULL);
1612 loopback_setup();
1613 bump_unix_max_dgram_qlen();
1614
1615 test_usr();
1616 }
1617
1618 if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1619 watchdog_set_timeout(&arg_runtime_watchdog);
1620
1621 if (arg_timer_slack_nsec != NSEC_INFINITY)
1622 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1623 log_error_errno(errno, "Failed to adjust timer slack: %m");
1624
1625 if (arg_capability_bounding_set_drop) {
1626 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1627 if (r < 0) {
1628 log_emergency_errno(r, "Failed to drop capability bounding set of usermode helpers: %m");
1629 error_message = "Failed to drop capability bounding set of usermode helpers";
1630 goto finish;
1631 }
1632 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1633 if (r < 0) {
1634 log_emergency_errno(r, "Failed to drop capability bounding set: %m");
1635 error_message = "Failed to drop capability bounding set";
1636 goto finish;
1637 }
1638 }
1639
1640 if (arg_syscall_archs) {
1641 r = enforce_syscall_archs(arg_syscall_archs);
1642 if (r < 0) {
1643 error_message = "Failed to set syscall architectures";
1644 goto finish;
1645 }
1646 }
1647
1648 if (arg_running_as == MANAGER_USER)
1649 /* Become reaper of our children */
1650 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0)
1651 log_warning_errno(errno, "Failed to make us a subreaper: %m");
1652
1653 if (arg_running_as == MANAGER_SYSTEM) {
1654 bump_rlimit_nofile(&saved_rlimit_nofile);
1655
1656 if (empty_etc) {
1657 r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_ENABLE_ONLY, false, NULL, 0);
1658 if (r < 0)
1659 log_warning_errno(r, "Failed to populate /etc with preset unit settings, ignoring: %m");
1660 else
1661 log_info("Populated /etc with preset unit settings.");
1662 }
1663 }
1664
1665 r = manager_new(arg_running_as, arg_action == ACTION_TEST, &m);
1666 if (r < 0) {
1667 log_emergency_errno(r, "Failed to allocate manager object: %m");
1668 error_message = "Failed to allocate manager object";
1669 goto finish;
1670 }
1671
1672 m->confirm_spawn = arg_confirm_spawn;
1673 m->runtime_watchdog = arg_runtime_watchdog;
1674 m->shutdown_watchdog = arg_shutdown_watchdog;
1675 m->userspace_timestamp = userspace_timestamp;
1676 m->kernel_timestamp = kernel_timestamp;
1677 m->initrd_timestamp = initrd_timestamp;
1678 m->security_start_timestamp = security_start_timestamp;
1679 m->security_finish_timestamp = security_finish_timestamp;
1680
1681 manager_set_defaults(m);
1682 manager_set_show_status(m, arg_show_status);
1683 manager_set_first_boot(m, empty_etc);
1684
1685 /* Remember whether we should queue the default job */
1686 queue_default_job = !arg_serialization || arg_switched_root;
1687
1688 before_startup = now(CLOCK_MONOTONIC);
1689
1690 r = manager_startup(m, arg_serialization, fds);
1691 if (r < 0)
1692 log_error_errno(r, "Failed to fully start up daemon: %m");
1693
1694 /* This will close all file descriptors that were opened, but
1695 * not claimed by any unit. */
1696 fds = fdset_free(fds);
1697
1698 arg_serialization = safe_fclose(arg_serialization);
1699
1700 if (queue_default_job) {
1701 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1702 Unit *target = NULL;
1703 Job *default_unit_job;
1704
1705 log_debug("Activating default unit: %s", arg_default_unit);
1706
1707 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1708 if (r < 0)
1709 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1710 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1711 log_error_errno(target->load_error, "Failed to load default target: %m");
1712 else if (target->load_state == UNIT_MASKED)
1713 log_error("Default target masked.");
1714
1715 if (!target || target->load_state != UNIT_LOADED) {
1716 log_info("Trying to load rescue target...");
1717
1718 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1719 if (r < 0) {
1720 log_emergency("Failed to load rescue target: %s", bus_error_message(&error, r));
1721 error_message = "Failed to load rescue target";
1722 goto finish;
1723 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1724 log_emergency_errno(target->load_error, "Failed to load rescue target: %m");
1725 error_message = "Failed to load rescue target";
1726 goto finish;
1727 } else if (target->load_state == UNIT_MASKED) {
1728 log_emergency("Rescue target masked.");
1729 error_message = "Rescue target masked";
1730 goto finish;
1731 }
1732 }
1733
1734 assert(target->load_state == UNIT_LOADED);
1735
1736 if (arg_action == ACTION_TEST) {
1737 printf("-> By units:\n");
1738 manager_dump_units(m, stdout, "\t");
1739 }
1740
1741 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1742 if (r == -EPERM) {
1743 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1744
1745 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1746 if (r < 0) {
1747 log_emergency("Failed to start default target: %s", bus_error_message(&error, r));
1748 error_message = "Failed to start default target";
1749 goto finish;
1750 }
1751 } else if (r < 0) {
1752 log_emergency("Failed to isolate default target: %s", bus_error_message(&error, r));
1753 error_message = "Failed to isolate default target";
1754 goto finish;
1755 }
1756
1757 m->default_unit_job_id = default_unit_job->id;
1758
1759 after_startup = now(CLOCK_MONOTONIC);
1760 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1761 "Loaded units and determined initial transaction in %s.",
1762 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 100 * USEC_PER_MSEC));
1763
1764 if (arg_action == ACTION_TEST) {
1765 printf("-> By jobs:\n");
1766 manager_dump_jobs(m, stdout, "\t");
1767 retval = EXIT_SUCCESS;
1768 goto finish;
1769 }
1770 }
1771
1772 for (;;) {
1773 r = manager_loop(m);
1774 if (r < 0) {
1775 log_emergency_errno(r, "Failed to run main loop: %m");
1776 error_message = "Failed to run main loop";
1777 goto finish;
1778 }
1779
1780 switch (m->exit_code) {
1781
1782 case MANAGER_RELOAD:
1783 log_info("Reloading.");
1784
1785 r = parse_config_file();
1786 if (r < 0)
1787 log_error("Failed to parse config file.");
1788
1789 manager_set_defaults(m);
1790
1791 r = manager_reload(m);
1792 if (r < 0)
1793 log_error_errno(r, "Failed to reload: %m");
1794 break;
1795
1796 case MANAGER_REEXECUTE:
1797
1798 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0) {
1799 error_message = "Failed to prepare for reexecution";
1800 goto finish;
1801 }
1802
1803 reexecute = true;
1804 log_notice("Reexecuting.");
1805 goto finish;
1806
1807 case MANAGER_SWITCH_ROOT:
1808 /* Steal the switch root parameters */
1809 switch_root_dir = m->switch_root;
1810 switch_root_init = m->switch_root_init;
1811 m->switch_root = m->switch_root_init = NULL;
1812
1813 if (!switch_root_init)
1814 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0) {
1815 error_message = "Failed to prepare for reexecution";
1816 goto finish;
1817 }
1818
1819 reexecute = true;
1820 log_notice("Switching root.");
1821 goto finish;
1822
1823 case MANAGER_EXIT:
1824 retval = m->return_value;
1825
1826 if (m->running_as == MANAGER_USER) {
1827 log_debug("Exit.");
1828 goto finish;
1829 }
1830
1831 /* fallthrough */
1832 case MANAGER_REBOOT:
1833 case MANAGER_POWEROFF:
1834 case MANAGER_HALT:
1835 case MANAGER_KEXEC: {
1836 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1837 [MANAGER_EXIT] = "exit",
1838 [MANAGER_REBOOT] = "reboot",
1839 [MANAGER_POWEROFF] = "poweroff",
1840 [MANAGER_HALT] = "halt",
1841 [MANAGER_KEXEC] = "kexec"
1842 };
1843
1844 assert_se(shutdown_verb = table[m->exit_code]);
1845 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1846
1847 log_notice("Shutting down.");
1848 goto finish;
1849 }
1850
1851 default:
1852 assert_not_reached("Unknown exit code.");
1853 }
1854 }
1855
1856 finish:
1857 pager_close();
1858
1859 if (m)
1860 arg_shutdown_watchdog = m->shutdown_watchdog;
1861
1862 m = manager_free(m);
1863
1864 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++)
1865 arg_default_rlimit[j] = mfree(arg_default_rlimit[j]);
1866
1867 arg_default_unit = mfree(arg_default_unit);
1868 arg_join_controllers = strv_free_free(arg_join_controllers);
1869 arg_default_environment = strv_free(arg_default_environment);
1870 arg_syscall_archs = set_free(arg_syscall_archs);
1871
1872 mac_selinux_finish();
1873
1874 if (reexecute) {
1875 const char **args;
1876 unsigned i, args_size;
1877
1878 /* Close and disarm the watchdog, so that the new
1879 * instance can reinitialize it, but doesn't get
1880 * rebooted while we do that */
1881 watchdog_close(true);
1882
1883 /* Reset the RLIMIT_NOFILE to the kernel default, so
1884 * that the new systemd can pass the kernel default to
1885 * its child processes */
1886 if (saved_rlimit_nofile.rlim_cur > 0)
1887 (void) setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1888
1889 if (switch_root_dir) {
1890 /* Kill all remaining processes from the
1891 * initrd, but don't wait for them, so that we
1892 * can handle the SIGCHLD for them after
1893 * deserializing. */
1894 broadcast_signal(SIGTERM, false, true);
1895
1896 /* And switch root with MS_MOVE, because we remove the old directory afterwards and detach it. */
1897 r = switch_root(switch_root_dir, "/mnt", true, MS_MOVE);
1898 if (r < 0)
1899 log_error_errno(r, "Failed to switch root, trying to continue: %m");
1900 }
1901
1902 args_size = MAX(6, argc+1);
1903 args = newa(const char*, args_size);
1904
1905 if (!switch_root_init) {
1906 char sfd[DECIMAL_STR_MAX(int) + 1];
1907
1908 /* First try to spawn ourselves with the right
1909 * path, and with full serialization. We do
1910 * this only if the user didn't specify an
1911 * explicit init to spawn. */
1912
1913 assert(arg_serialization);
1914 assert(fds);
1915
1916 xsprintf(sfd, "%i", fileno(arg_serialization));
1917
1918 i = 0;
1919 args[i++] = SYSTEMD_BINARY_PATH;
1920 if (switch_root_dir)
1921 args[i++] = "--switched-root";
1922 args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1923 args[i++] = "--deserialize";
1924 args[i++] = sfd;
1925 args[i++] = NULL;
1926
1927 /* do not pass along the environment we inherit from the kernel or initrd */
1928 if (switch_root_dir)
1929 (void) clearenv();
1930
1931 assert(i <= args_size);
1932 (void) execv(args[0], (char* const*) args);
1933 }
1934
1935 /* Try the fallback, if there is any, without any
1936 * serialization. We pass the original argv[] and
1937 * envp[]. (Well, modulo the ordering changes due to
1938 * getopt() in argv[], and some cleanups in envp[],
1939 * but let's hope that doesn't matter.) */
1940
1941 arg_serialization = safe_fclose(arg_serialization);
1942 fds = fdset_free(fds);
1943
1944 /* Reopen the console */
1945 (void) make_console_stdio();
1946
1947 for (j = 1, i = 1; j < (unsigned) argc; j++)
1948 args[i++] = argv[j];
1949 args[i++] = NULL;
1950 assert(i <= args_size);
1951
1952 /* Reenable any blocked signals, especially important
1953 * if we switch from initial ramdisk to init=... */
1954 (void) reset_all_signal_handlers();
1955 (void) reset_signal_mask();
1956
1957 if (switch_root_init) {
1958 args[0] = switch_root_init;
1959 (void) execv(args[0], (char* const*) args);
1960 log_warning_errno(errno, "Failed to execute configured init, trying fallback: %m");
1961 }
1962
1963 args[0] = "/sbin/init";
1964 (void) execv(args[0], (char* const*) args);
1965
1966 if (errno == ENOENT) {
1967 log_warning("No /sbin/init, trying fallback");
1968
1969 args[0] = "/bin/sh";
1970 args[1] = NULL;
1971 (void) execv(args[0], (char* const*) args);
1972 log_error_errno(errno, "Failed to execute /bin/sh, giving up: %m");
1973 } else
1974 log_warning_errno(errno, "Failed to execute /sbin/init, giving up: %m");
1975 }
1976
1977 arg_serialization = safe_fclose(arg_serialization);
1978 fds = fdset_free(fds);
1979
1980 #ifdef HAVE_VALGRIND_VALGRIND_H
1981 /* If we are PID 1 and running under valgrind, then let's exit
1982 * here explicitly. valgrind will only generate nice output on
1983 * exit(), not on exec(), hence let's do the former not the
1984 * latter here. */
1985 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1986 return 0;
1987 #endif
1988
1989 if (shutdown_verb) {
1990 char log_level[DECIMAL_STR_MAX(int) + 1];
1991 char exit_code[DECIMAL_STR_MAX(uint8_t) + 1];
1992 const char* command_line[11] = {
1993 SYSTEMD_SHUTDOWN_BINARY_PATH,
1994 shutdown_verb,
1995 "--log-level", log_level,
1996 "--log-target",
1997 };
1998 unsigned pos = 5;
1999 _cleanup_strv_free_ char **env_block = NULL;
2000
2001 assert(command_line[pos] == NULL);
2002 env_block = strv_copy(environ);
2003
2004 xsprintf(log_level, "%d", log_get_max_level());
2005
2006 switch (log_get_target()) {
2007
2008 case LOG_TARGET_KMSG:
2009 case LOG_TARGET_JOURNAL_OR_KMSG:
2010 case LOG_TARGET_SYSLOG_OR_KMSG:
2011 command_line[pos++] = "kmsg";
2012 break;
2013
2014 case LOG_TARGET_NULL:
2015 command_line[pos++] = "null";
2016 break;
2017
2018 case LOG_TARGET_CONSOLE:
2019 default:
2020 command_line[pos++] = "console";
2021 break;
2022 };
2023
2024 if (log_get_show_color())
2025 command_line[pos++] = "--log-color";
2026
2027 if (log_get_show_location())
2028 command_line[pos++] = "--log-location";
2029
2030 if (streq(shutdown_verb, "exit")) {
2031 command_line[pos++] = "--exit-code";
2032 command_line[pos++] = exit_code;
2033 xsprintf(exit_code, "%d", retval);
2034 }
2035
2036 assert(pos < ELEMENTSOF(command_line));
2037
2038 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
2039 char *e;
2040
2041 /* If we reboot let's set the shutdown
2042 * watchdog and tell the shutdown binary to
2043 * repeatedly ping it */
2044 r = watchdog_set_timeout(&arg_shutdown_watchdog);
2045 watchdog_close(r < 0);
2046
2047 /* Tell the binary how often to ping, ignore failure */
2048 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2049 (void) strv_push(&env_block, e);
2050 } else
2051 watchdog_close(true);
2052
2053 /* Avoid the creation of new processes forked by the
2054 * kernel; at this point, we will not listen to the
2055 * signals anyway */
2056 if (detect_container() <= 0)
2057 (void) cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2058
2059 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2060 log_error_errno(errno, "Failed to execute shutdown binary, %s: %m",
2061 getpid() == 1 ? "freezing" : "quitting");
2062 }
2063
2064 if (getpid() == 1) {
2065 if (error_message)
2066 manager_status_printf(NULL, STATUS_TYPE_EMERGENCY,
2067 ANSI_HIGHLIGHT_RED "!!!!!!" ANSI_NORMAL,
2068 "%s, freezing.", error_message);
2069 freeze_or_reboot();
2070 }
2071
2072 return retval;
2073 }
Unnamed repository; edit this file 'description' to name the repository.