]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/main.c
projects / thirdparty / systemd.git / blob
? search:


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