]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/main.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NEWS: correct NTP implementation data
[thirdparty/systemd.git] / src / core / main.c
CommitLineData
d6c9574f 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
60918275 2
a7334b09
LP		 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
5430f7f2
LP		 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
a7334b09
LP		 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
5430f7f2 16 Lesser General Public License for more details.
a7334b09 17
5430f7f2 18 You should have received a copy of the GNU Lesser General Public License
a7334b09
LP		 19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
ea430986
LP		 22#include <dbus/dbus.h>
23
60918275
LP		 24#include <stdio.h>
25#include <errno.h>
26#include <string.h>
16354eff 27#include <unistd.h>
4ade7963
LP		 28#include <sys/types.h>
29#include <sys/stat.h>
f170852a 30#include <getopt.h>
97c4f35c 31#include <signal.h>
4fc935ca 32#include <sys/wait.h>
80876c20 33#include <fcntl.h>
f3b6a3ed 34#include <sys/prctl.h>
664f88a7 35#include <sys/mount.h>
60918275
LP		 36
37#include "manager.h"
16354eff 38#include "log.h"
302e8c4c 39#include "load-fragment.h"
a16e1123 40#include "fdset.h"
514f4ef5 41#include "special.h"
487393e9 42#include "conf-parser.h"
398ef8ba 43#include "bus-errors.h"
ad780f19 44#include "missing.h"
e51bc1a2 45#include "label.h"
302e27c8 46#include "build.h"
06d4c99a 47#include "strv.h"
f6a6225e 48#include "def.h"
b52aae1d 49#include "virt.h"
e96d6be7 50#include "watchdog.h"
664f88a7 51#include "path-util.h"
41669317 52#include "switch-root.h"
ec8927ca 53#include "capability.h"
bd3fa1d2 54#include "killall.h"
60918275 55
b6e66135
LP		 56#include "mount-setup.h"
57#include "loopback-setup.h"
58#include "kmod-setup.h"
59#include "hostname-setup.h"
60#include "machine-id-setup.h"
61#include "locale-setup.h"
bbc98d32 62#include "hwclock.h"
b6e66135
LP		 63#include "selinux-setup.h"
64#include "ima-setup.h"
65
f170852a
LP		 66static enum {
67 ACTION_RUN,
e965d56d 68 ACTION_HELP,
9ba0bc4e 69 ACTION_VERSION,
e537352b 70 ACTION_TEST,
4288f619
LP		 71 ACTION_DUMP_CONFIGURATION_ITEMS,
72 ACTION_DONE
fa0f4d8a 73} arg_action = ACTION_RUN;
f170852a 74
fa0f4d8a
LP		 75static char *arg_default_unit = NULL;
76static ManagerRunningAs arg_running_as = _MANAGER_RUNNING_AS_INVALID;
77
78static bool arg_dump_core = true;
79static bool arg_crash_shell = false;
80static int arg_crash_chvt = -1;
81static bool arg_confirm_spawn = false;
9e58ff9c 82static bool arg_show_status = true;
bf4df7c3 83static bool arg_switched_root = false;
06d4c99a 84static char **arg_default_controllers = NULL;
0c85a4f3 85static char ***arg_join_controllers = NULL;
706343f4 86static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
0a494f1f 87static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
e96d6be7
LP		 88static usec_t arg_runtime_watchdog = 0;
89static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
c93ff2e9 90static struct rlimit *arg_default_rlimit[RLIMIT_NLIMITS] = {};
ec8927ca 91static uint64_t arg_capability_bounding_set_drop = 0;
aa0f64ac 92static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
4fc935ca 93
a16e1123 94static FILE* serialization = NULL;
80876c20 95
6f5e3f35
LP		 96static void nop_handler(int sig) {
97}
98
93a46b0b 99_noreturn_ static void crash(int sig) {
97c4f35c 100
fa0f4d8a 101 if (!arg_dump_core)
582a507f 102 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
97c4f35c 103 else {
6f5e3f35 104 struct sigaction sa;
97c4f35c
LP		 105 pid_t pid;
106
6f5e3f35
LP		 107 /* We want to wait for the core process, hence let's enable SIGCHLD */
108 zero(sa);
109 sa.sa_handler = nop_handler;
110 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
111 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
112
97c4f35c 113 if ((pid = fork()) < 0)
582a507f 114 log_error("Caught <%s>, cannot fork for core dump: %s", signal_to_string(sig), strerror(errno));
97c4f35c
LP		 115
116 else if (pid == 0) {
97c4f35c
LP		 117 struct rlimit rl;
118
119 /* Enable default signal handler for core dump */
120 zero(sa);
121 sa.sa_handler = SIG_DFL;
122 assert_se(sigaction(sig, &sa, NULL) == 0);
123
124 /* Don't limit the core dump size */
125 zero(rl);
126 rl.rlim_cur = RLIM_INFINITY;
127 rl.rlim_max = RLIM_INFINITY;
128 setrlimit(RLIMIT_CORE, &rl);
129
130 /* Just to be sure... */
131 assert_se(chdir("/") == 0);
132
133 /* Raise the signal again */
134 raise(sig);
135
136 assert_not_reached("We shouldn't be here...");
137 _exit(1);
4fc935ca
LP		 138
139 } else {
8e12a6ae
LP		 140 siginfo_t status;
141 int r;
4fc935ca
LP		 142
143 /* Order things nicely. */
8e12a6ae
LP		 144 if ((r = wait_for_terminate(pid, &status)) < 0)
145 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
146 else if (status.si_code != CLD_DUMPED)
582a507f 147 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
4fc935ca 148 else
582a507f 149 log_error("Caught <%s>, dumped core as pid %lu.", signal_to_string(sig), (unsigned long) pid);
97c4f35c
LP		 150 }
151 }
152
fa0f4d8a
LP		 153 if (arg_crash_chvt)
154 chvt(arg_crash_chvt);
601f6a1e 155
fa0f4d8a 156 if (arg_crash_shell) {
6f5e3f35
LP		 157 struct sigaction sa;
158 pid_t pid;
8c43883a 159
4fc935ca
LP		 160 log_info("Executing crash shell in 10s...");
161 sleep(10);
162
6f5e3f35
LP		 163 /* Let the kernel reap children for us */
164 zero(sa);
165 sa.sa_handler = SIG_IGN;
166 sa.sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART;
167 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
8c43883a 168
cd3bd60a
LP		 169 pid = fork();
170 if (pid < 0)
6f5e3f35
LP		 171 log_error("Failed to fork off crash shell: %s", strerror(errno));
172 else if (pid == 0) {
cd3bd60a 173 make_console_stdio();
6f5e3f35
LP		 174 execl("/bin/sh", "/bin/sh", NULL);
175
176 log_error("execl() failed: %s", strerror(errno));
177 _exit(1);
178 }
c99b188e 179
f8e08a77 180 log_info("Successfully spawned crash shell as pid %lu.", (unsigned long) pid);
4fc935ca
LP		 181 }
182
183 log_info("Freezing execution.");
97c4f35c
LP		 184 freeze();
185}
186
187static void install_crash_handler(void) {
188 struct sigaction sa;
189
190 zero(sa);
191
192 sa.sa_handler = crash;
193 sa.sa_flags = SA_NODEFER;
194
1b91d3e8 195 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
97c4f35c 196}
f170852a 197
843d2643
LP		 198static int console_setup(bool do_reset) {
199 int tty_fd, r;
80876c20 200
843d2643
LP		 201 /* If we are init, we connect stdin/stdout/stderr to /dev/null
202 * and make sure we don't have a controlling tty. */
80876c20 203
843d2643
LP		 204 release_terminal();
205
206 if (!do_reset)
207 return 0;
80876c20 208
512947d4
MS		 209 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
210 if (tty_fd < 0) {
843d2643
LP		 211 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
212 return -tty_fd;
213 }
80876c20 214
512947d4
MS		 215 /* We don't want to force text mode.
216 * plymouth may be showing pictures already from initrd. */
217 r = reset_terminal_fd(tty_fd, false);
218 if (r < 0)
843d2643
LP		 219 log_error("Failed to reset /dev/console: %s", strerror(-r));
220
221 close_nointr_nofail(tty_fd);
80876c20
LP		 222 return r;
223}
224
f170852a
LP		 225static int set_default_unit(const char *u) {
226 char *c;
227
228 assert(u);
229
bf4df7c3
LP		 230 c = strdup(u);
231 if (!c)
f170852a
LP		 232 return -ENOMEM;
233
fa0f4d8a
LP		 234 free(arg_default_unit);
235 arg_default_unit = c;
bf4df7c3 236
f170852a
LP		 237 return 0;
238}
239
240static int parse_proc_cmdline_word(const char *word) {
241
242 static const char * const rlmap[] = {
ed370f5d 243 "emergency", SPECIAL_EMERGENCY_TARGET,
099663ff 244 "-b", SPECIAL_EMERGENCY_TARGET,
ed370f5d
LP		 245 "single", SPECIAL_RESCUE_TARGET,
246 "-s", SPECIAL_RESCUE_TARGET,
247 "s", SPECIAL_RESCUE_TARGET,
248 "S", SPECIAL_RESCUE_TARGET,
249 "1", SPECIAL_RESCUE_TARGET,
250 "2", SPECIAL_RUNLEVEL2_TARGET,
251 "3", SPECIAL_RUNLEVEL3_TARGET,
252 "4", SPECIAL_RUNLEVEL4_TARGET,
253 "5", SPECIAL_RUNLEVEL5_TARGET,
f170852a
LP		 254 };
255
5192bd19
LP		 256 assert(word);
257
bf4df7c3
LP		 258 if (startswith(word, "systemd.unit=")) {
259
260 if (!in_initrd())
261 return set_default_unit(word + 13);
262
263 } else if (startswith(word, "rd.systemd.unit=")) {
264
265 if (in_initrd())
266 return set_default_unit(word + 16);
f170852a 267
bf4df7c3 268 } else if (startswith(word, "systemd.log_target=")) {
f170852a
LP		 269
270 if (log_set_target_from_string(word + 19) < 0)
271 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
272
273 } else if (startswith(word, "systemd.log_level=")) {
274
275 if (log_set_max_level_from_string(word + 18) < 0)
276 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
277
bbe63281
LP		 278 } else if (startswith(word, "systemd.log_color=")) {
279
280 if (log_show_color_from_string(word + 18) < 0)
281 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
282
283 } else if (startswith(word, "systemd.log_location=")) {
284
285 if (log_show_location_from_string(word + 21) < 0)
286 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
287
4fc935ca
LP		 288 } else if (startswith(word, "systemd.dump_core=")) {
289 int r;
290
291 if ((r = parse_boolean(word + 18)) < 0)
509b6efb 292 log_warning("Failed to parse dump core switch %s. Ignoring.", word + 18);
4fc935ca 293 else
fa0f4d8a 294 arg_dump_core = r;
4fc935ca
LP		 295
296 } else if (startswith(word, "systemd.crash_shell=")) {
297 int r;
298
299 if ((r = parse_boolean(word + 20)) < 0)
509b6efb 300 log_warning("Failed to parse crash shell switch %s. Ignoring.", word + 20);
4fc935ca 301 else
fa0f4d8a 302 arg_crash_shell = r;
5e7ee61c
LP		 303
304 } else if (startswith(word, "systemd.confirm_spawn=")) {
305 int r;
306
307 if ((r = parse_boolean(word + 22)) < 0)
509b6efb 308 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", word + 22);
5e7ee61c 309 else
fa0f4d8a 310 arg_confirm_spawn = r;
5e7ee61c 311
601f6a1e
LP		 312 } else if (startswith(word, "systemd.crash_chvt=")) {
313 int k;
314
315 if (safe_atoi(word + 19, &k) < 0)
509b6efb 316 log_warning("Failed to parse crash chvt switch %s. Ignoring.", word + 19);
601f6a1e 317 else
fa0f4d8a 318 arg_crash_chvt = k;
601f6a1e 319
9e58ff9c
LP		 320 } else if (startswith(word, "systemd.show_status=")) {
321 int r;
322
323 if ((r = parse_boolean(word + 20)) < 0)
509b6efb 324 log_warning("Failed to parse show status switch %s. Ignoring.", word + 20);
6e98720f 325 else
9e58ff9c 326 arg_show_status = r;
0a494f1f
LP		 327 } else if (startswith(word, "systemd.default_standard_output=")) {
328 int r;
329
330 if ((r = exec_output_from_string(word + 32)) < 0)
509b6efb 331 log_warning("Failed to parse default standard output switch %s. Ignoring.", word + 32);
0a494f1f
LP		 332 else
333 arg_default_std_output = r;
334 } else if (startswith(word, "systemd.default_standard_error=")) {
335 int r;
336
337 if ((r = exec_output_from_string(word + 31)) < 0)
509b6efb 338 log_warning("Failed to parse default standard error switch %s. Ignoring.", word + 31);
0a494f1f
LP		 339 else
340 arg_default_std_error = r;
9e7c5357
WD		 341 } else if (startswith(word, "systemd.setenv=")) {
342 char *cenv, *eq;
343 int r;
344
345 cenv = strdup(word + 15);
346 if (!cenv)
347 return -ENOMEM;
348
349 eq = strchr(cenv, '=');
350 if (!eq) {
351 r = unsetenv(cenv);
352 if (r < 0)
353 log_warning("unsetenv failed %s. Ignoring.", strerror(errno));
354 } else {
355 *eq = 0;
356 r = setenv(cenv, eq + 1, 1);
357 if (r < 0)
358 log_warning("setenv failed %s. Ignoring.", strerror(errno));
359 }
360 free(cenv);
9e58ff9c 361
66a78c2b
LP		 362 } else if (startswith(word, "systemd.") ||
363 (in_initrd() && startswith(word, "rd.systemd."))) {
4fc935ca
LP		 364
365 log_warning("Unknown kernel switch %s. Ignoring.", word);
366
bbe63281
LP		 367 log_info("Supported kernel switches:\n"
368 "systemd.unit=UNIT Default unit to start\n"
bf4df7c3 369 "rd.systemd.unit=UNIT Default unit to start when run in initrd\n"
bbe63281 370 "systemd.dump_core=0|1 Dump core on crash\n"
9e58ff9c 371 "systemd.crash_shell=0|1 Run shell on crash\n"
bbe63281 372 "systemd.crash_chvt=N Change to VT #N on crash\n"
9e58ff9c 373 "systemd.confirm_spawn=0|1 Confirm every process spawn\n"
6e98720f 374 "systemd.show_status=0|1 Show status updates on the console during bootup\n"
4cfa2c99 375 "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
6e98720f
LP		 376 " Log target\n"
377 "systemd.log_level=LEVEL Log level\n"
378 "systemd.log_color=0|1 Highlight important log messages\n"
0a494f1f 379 "systemd.log_location=0|1 Include code location in log messages\n"
706343f4 380 "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
0a494f1f 381 " Set default log output for services\n"
706343f4 382 "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
c66e7bc7
LP		 383 " Set default log error output for services\n"
384 "systemd.setenv=ASSIGNMENT Set an environment variable for all spawned processes\n");
4fc935ca 385
d081dffb 386 } else if (streq(word, "quiet"))
6e98720f 387 arg_show_status = false;
d081dffb 388 else if (!in_initrd()) {
f170852a
LP		 389 unsigned i;
390
391 /* SysV compatibility */
f170852a
LP		 392 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
393 if (streq(word, rlmap[i]))
394 return set_default_unit(rlmap[i+1]);
395 }
396
397 return 0;
398}
399
f975e971 400static int config_parse_level2(
487393e9
LP		 401 const char *filename,
402 unsigned line,
403 const char *section,
404 const char *lvalue,
3731f1ea 405 int ltype,
487393e9
LP		 406 const char *rvalue,
407 void *data,
408 void *userdata) {
409
410 assert(filename);
411 assert(lvalue);
412 assert(rvalue);
413
414 log_set_max_level_from_string(rvalue);
415 return 0;
416}
417
418static int config_parse_target(
419 const char *filename,
420 unsigned line,
421 const char *section,
422 const char *lvalue,
3731f1ea 423 int ltype,
487393e9
LP		 424 const char *rvalue,
425 void *data,
426 void *userdata) {
427
428 assert(filename);
429 assert(lvalue);
430 assert(rvalue);
431
432 log_set_target_from_string(rvalue);
433 return 0;
434}
435
436static int config_parse_color(
437 const char *filename,
438 unsigned line,
439 const char *section,
440 const char *lvalue,
3731f1ea 441 int ltype,
487393e9
LP		 442 const char *rvalue,
443 void *data,
444 void *userdata) {
445
446 assert(filename);
447 assert(lvalue);
448 assert(rvalue);
449
450 log_show_color_from_string(rvalue);
451 return 0;
452}
453
454static int config_parse_location(
455 const char *filename,
456 unsigned line,
457 const char *section,
458 const char *lvalue,
3731f1ea 459 int ltype,
487393e9
LP		 460 const char *rvalue,
461 void *data,
462 void *userdata) {
463
464 assert(filename);
465 assert(lvalue);
466 assert(rvalue);
467
468 log_show_location_from_string(rvalue);
469 return 0;
470}
471
f975e971 472static int config_parse_cpu_affinity2(
487393e9
LP		 473 const char *filename,
474 unsigned line,
475 const char *section,
476 const char *lvalue,
3731f1ea 477 int ltype,
487393e9
LP		 478 const char *rvalue,
479 void *data,
480 void *userdata) {
481
482 char *w;
483 size_t l;
484 char *state;
485 cpu_set_t *c = NULL;
486 unsigned ncpus = 0;
487
488 assert(filename);
489 assert(lvalue);
490 assert(rvalue);
491
f60f22df 492 FOREACH_WORD_QUOTED(w, l, rvalue, state) {
487393e9
LP		 493 char *t;
494 int r;
495 unsigned cpu;
496
497 if (!(t = strndup(w, l)))
498 return -ENOMEM;
499
500 r = safe_atou(t, &cpu);
501 free(t);
502
503 if (!c)
504 if (!(c = cpu_set_malloc(&ncpus)))
505 return -ENOMEM;
506
507 if (r < 0 || cpu >= ncpus) {
508 log_error("[%s:%u] Failed to parse CPU affinity: %s", filename, line, rvalue);
509 CPU_FREE(c);
510 return -EBADMSG;
511 }
512
513 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
514 }
515
516 if (c) {
517 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
518 log_warning("Failed to set CPU affinity: %m");
519
520 CPU_FREE(c);
521 }
522
523 return 0;
524}
525
0c85a4f3
LP		 526static void strv_free_free(char ***l) {
527 char ***i;
528
529 if (!l)
530 return;
531
532 for (i = l; *i; i++)
533 strv_free(*i);
534
535 free(l);
536}
537
538static void free_join_controllers(void) {
539 if (!arg_join_controllers)
540 return;
541
542 strv_free_free(arg_join_controllers);
543 arg_join_controllers = NULL;
544}
545
546static int config_parse_join_controllers(
547 const char *filename,
548 unsigned line,
549 const char *section,
550 const char *lvalue,
551 int ltype,
552 const char *rvalue,
553 void *data,
554 void *userdata) {
555
556 unsigned n = 0;
557 char *state, *w;
558 size_t length;
559
560 assert(filename);
561 assert(lvalue);
562 assert(rvalue);
563
564 free_join_controllers();
565
566 FOREACH_WORD_QUOTED(w, length, rvalue, state) {
567 char *s, **l;
568
569 s = strndup(w, length);
570 if (!s)
571 return -ENOMEM;
572
573 l = strv_split(s, ",");
574 free(s);
575
576 strv_uniq(l);
577
578 if (strv_length(l) <= 1) {
579 strv_free(l);
580 continue;
581 }
582
583 if (!arg_join_controllers) {
584 arg_join_controllers = new(char**, 2);
585 if (!arg_join_controllers) {
586 strv_free(l);
587 return -ENOMEM;
588 }
589
590 arg_join_controllers[0] = l;
591 arg_join_controllers[1] = NULL;
592
593 n = 1;
594 } else {
595 char ***a;
596 char ***t;
597
598 t = new0(char**, n+2);
599 if (!t) {
600 strv_free(l);
601 return -ENOMEM;
602 }
603
604 n = 0;
605
606 for (a = arg_join_controllers; *a; a++) {
607
608 if (strv_overlap(*a, l)) {
609 char **c;
610
611 c = strv_merge(*a, l);
612 if (!c) {
613 strv_free(l);
614 strv_free_free(t);
615 return -ENOMEM;
616 }
617
618 strv_free(l);
619 l = c;
620 } else {
621 char **c;
622
623 c = strv_copy(*a);
624 if (!c) {
625 strv_free(l);
626 strv_free_free(t);
627 return -ENOMEM;
628 }
629
630 t[n++] = c;
631 }
632 }
633
634 t[n++] = strv_uniq(l);
635
636 strv_free_free(arg_join_controllers);
637 arg_join_controllers = t;
638 }
639 }
640
641 return 0;
642}
643
487393e9
LP		 644static int parse_config_file(void) {
645
f975e971
LP		 646 const ConfigTableItem items[] = {
647 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
648 { "Manager", "LogTarget", config_parse_target, 0, NULL },
649 { "Manager", "LogColor", config_parse_color, 0, NULL },
650 { "Manager", "LogLocation", config_parse_location, 0, NULL },
651 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
652 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
653 { "Manager", "ShowStatus", config_parse_bool, 0, &arg_show_status },
f975e971
LP		 654 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
655 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
f975e971
LP		 656 { "Manager", "DefaultControllers", config_parse_strv, 0, &arg_default_controllers },
657 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
658 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
0c85a4f3 659 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
e96d6be7
LP		 660 { "Manager", "RuntimeWatchdogSec", config_parse_usec, 0, &arg_runtime_watchdog },
661 { "Manager", "ShutdownWatchdogSec", config_parse_usec, 0, &arg_shutdown_watchdog },
ec8927ca 662 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
aa0f64ac 663 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
c93ff2e9
FC		 664 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU]},
665 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE]},
666 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA]},
667 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK]},
668 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE]},
669 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS]},
670 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE]},
671 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS]},
672 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC]},
673 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK]},
674 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS]},
675 { "Manager", "DefaultLimitSIGPENDING",config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING]},
676 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE]},
677 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE]},
678 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO]},
679 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME]},
f975e971 680 { NULL, NULL, NULL, 0, NULL }
487393e9
LP		 681 };
682
683 FILE *f;
684 const char *fn;
685 int r;
686
af2d49f7 687 fn = arg_running_as == MANAGER_SYSTEM ? SYSTEM_CONFIG_FILE : USER_CONFIG_FILE;
f975e971
LP		 688 f = fopen(fn, "re");
689 if (!f) {
487393e9
LP		 690 if (errno == ENOENT)
691 return 0;
692
693 log_warning("Failed to open configuration file '%s': %m", fn);
694 return 0;
695 }
696
f975e971
LP		 697 r = config_parse(fn, f, "Manager\0", config_item_table_lookup, (void*) items, false, NULL);
698 if (r < 0)
487393e9
LP		 699 log_warning("Failed to parse configuration file: %s", strerror(-r));
700
701 fclose(f);
702
703 return 0;
704}
705
f170852a 706static int parse_proc_cmdline(void) {
52661efd 707 char *line, *w, *state;
f170852a 708 int r;
f170852a 709 size_t l;
f170852a 710
b770165a
LP		 711 /* Don't read /proc/cmdline if we are in a container, since
712 * that is only relevant for the host system */
713 if (detect_container(NULL) > 0)
714 return 0;
715
f170852a 716 if ((r = read_one_line_file("/proc/cmdline", &line)) < 0) {
e364ad06 717 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
f170852a
LP		 718 return 0;
719 }
720
721 FOREACH_WORD_QUOTED(w, l, line, state) {
722 char *word;
723
724 if (!(word = strndup(w, l))) {
725 r = -ENOMEM;
726 goto finish;
727 }
728
729 r = parse_proc_cmdline_word(word);
730 free(word);
731
732 if (r < 0)
733 goto finish;
734 }
735
736 r = 0;
737
738finish:
739 free(line);
740 return r;
741}
742
743static int parse_argv(int argc, char *argv[]) {
744
745 enum {
746 ARG_LOG_LEVEL = 0x100,
747 ARG_LOG_TARGET,
bbe63281
LP		 748 ARG_LOG_COLOR,
749 ARG_LOG_LOCATION,
2f198e2f 750 ARG_UNIT,
edb9aaa8 751 ARG_SYSTEM,
af2d49f7 752 ARG_USER,
e537352b 753 ARG_TEST,
9ba0bc4e 754 ARG_VERSION,
80876c20 755 ARG_DUMP_CONFIGURATION_ITEMS,
9e58ff9c
LP		 756 ARG_DUMP_CORE,
757 ARG_CRASH_SHELL,
a16e1123 758 ARG_CONFIRM_SPAWN,
9e58ff9c 759 ARG_SHOW_STATUS,
4288f619 760 ARG_DESERIALIZE,
2660882b 761 ARG_SWITCHED_ROOT,
0a494f1f
LP		 762 ARG_INTROSPECT,
763 ARG_DEFAULT_STD_OUTPUT,
764 ARG_DEFAULT_STD_ERROR
f170852a
LP		 765 };
766
767 static const struct option options[] = {
a16e1123
LP		 768 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
769 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
bbe63281
LP		 770 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
771 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
2f198e2f 772 { "unit", required_argument, NULL, ARG_UNIT },
edb9aaa8 773 { "system", no_argument, NULL, ARG_SYSTEM },
af2d49f7 774 { "user", no_argument, NULL, ARG_USER },
a16e1123
LP		 775 { "test", no_argument, NULL, ARG_TEST },
776 { "help", no_argument, NULL, 'h' },
9ba0bc4e 777 { "version", no_argument, NULL, ARG_VERSION },
a16e1123 778 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
a5d87bf0
LP		 779 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
780 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
781 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
6e98720f 782 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
a16e1123 783 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
2660882b 784 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
4288f619 785 { "introspect", optional_argument, NULL, ARG_INTROSPECT },
0a494f1f
LP		 786 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
787 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
a16e1123 788 { NULL, 0, NULL, 0 }
f170852a
LP		 789 };
790
791 int c, r;
792
793 assert(argc >= 1);
794 assert(argv);
795
b770165a
LP		 796 if (getpid() == 1)
797 opterr = 0;
798
099663ff 799 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
f170852a
LP		 800
801 switch (c) {
802
803 case ARG_LOG_LEVEL:
804 if ((r = log_set_max_level_from_string(optarg)) < 0) {
805 log_error("Failed to parse log level %s.", optarg);
806 return r;
807 }
808
809 break;
810
811 case ARG_LOG_TARGET:
812
813 if ((r = log_set_target_from_string(optarg)) < 0) {
814 log_error("Failed to parse log target %s.", optarg);
815 return r;
816 }
817
818 break;
819
bbe63281
LP		 820 case ARG_LOG_COLOR:
821
d0b170c8
LP		 822 if (optarg) {
823 if ((r = log_show_color_from_string(optarg)) < 0) {
824 log_error("Failed to parse log color setting %s.", optarg);
825 return r;
826 }
827 } else
828 log_show_color(true);
bbe63281
LP		 829
830 break;
831
832 case ARG_LOG_LOCATION:
833
d0b170c8
LP		 834 if (optarg) {
835 if ((r = log_show_location_from_string(optarg)) < 0) {
836 log_error("Failed to parse log location setting %s.", optarg);
837 return r;
838 }
839 } else
840 log_show_location(true);
bbe63281
LP		 841
842 break;
843
0a494f1f
LP		 844 case ARG_DEFAULT_STD_OUTPUT:
845
846 if ((r = exec_output_from_string(optarg)) < 0) {
847 log_error("Failed to parse default standard output setting %s.", optarg);
848 return r;
849 } else
850 arg_default_std_output = r;
851 break;
852
853 case ARG_DEFAULT_STD_ERROR:
854
855 if ((r = exec_output_from_string(optarg)) < 0) {
856 log_error("Failed to parse default standard error output setting %s.", optarg);
857 return r;
858 } else
859 arg_default_std_error = r;
860 break;
861
2f198e2f 862 case ARG_UNIT:
f170852a
LP		 863
864 if ((r = set_default_unit(optarg)) < 0) {
865 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
866 return r;
867 }
868
869 break;
870
edb9aaa8
LP		 871 case ARG_SYSTEM:
872 arg_running_as = MANAGER_SYSTEM;
873 break;
a5dab5ce 874
af2d49f7
LP		 875 case ARG_USER:
876 arg_running_as = MANAGER_USER;
a5dab5ce 877 break;
a5dab5ce 878
e965d56d 879 case ARG_TEST:
fa0f4d8a 880 arg_action = ACTION_TEST;
e965d56d
LP		 881 break;
882
9ba0bc4e
ZJS		 883 case ARG_VERSION:
884 arg_action = ACTION_VERSION;
885 break;
886
e537352b 887 case ARG_DUMP_CONFIGURATION_ITEMS:
fa0f4d8a 888 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
e537352b
LP		 889 break;
890
9e58ff9c 891 case ARG_DUMP_CORE:
a5d87bf0
LP		 892 r = optarg ? parse_boolean(optarg) : 1;
893 if (r < 0) {
894 log_error("Failed to parse dump core boolean %s.", optarg);
895 return r;
896 }
897 arg_dump_core = r;
9e58ff9c
LP		 898 break;
899
900 case ARG_CRASH_SHELL:
a5d87bf0
LP		 901 r = optarg ? parse_boolean(optarg) : 1;
902 if (r < 0) {
903 log_error("Failed to parse crash shell boolean %s.", optarg);
904 return r;
905 }
906 arg_crash_shell = r;
9e58ff9c
LP		 907 break;
908
80876c20 909 case ARG_CONFIRM_SPAWN:
a5d87bf0
LP		 910 r = optarg ? parse_boolean(optarg) : 1;
911 if (r < 0) {
912 log_error("Failed to parse confirm spawn boolean %s.", optarg);
913 return r;
914 }
915 arg_confirm_spawn = r;
80876c20
LP		 916 break;
917
9e58ff9c 918 case ARG_SHOW_STATUS:
a5d87bf0
LP		 919 r = optarg ? parse_boolean(optarg) : 1;
920 if (r < 0) {
921 log_error("Failed to parse show status boolean %s.", optarg);
922 return r;
923 }
924 arg_show_status = r;
6e98720f 925 break;
a5d87bf0 926
a16e1123
LP		 927 case ARG_DESERIALIZE: {
928 int fd;
929 FILE *f;
930
931 if ((r = safe_atoi(optarg, &fd)) < 0 || fd < 0) {
932 log_error("Failed to parse deserialize option %s.", optarg);
933 return r;
934 }
935
936 if (!(f = fdopen(fd, "r"))) {
937 log_error("Failed to open serialization fd: %m");
938 return r;
939 }
940
941 if (serialization)
942 fclose(serialization);
943
944 serialization = f;
945
946 break;
947 }
948
2660882b 949 case ARG_SWITCHED_ROOT:
bf4df7c3 950 arg_switched_root = true;
d03bc1b8
HH		 951 break;
952
4288f619
LP		 953 case ARG_INTROSPECT: {
954 const char * const * i = NULL;
955
956 for (i = bus_interface_table; *i; i += 2)
957 if (!optarg || streq(i[0], optarg)) {
958 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
959 "<node>\n", stdout);
960 fputs(i[1], stdout);
961 fputs("</node>\n", stdout);
962
963 if (optarg)
964 break;
965 }
966
967 if (!i[0] && optarg)
968 log_error("Unknown interface %s.", optarg);
969
fa0f4d8a 970 arg_action = ACTION_DONE;
4288f619
LP		 971 break;
972 }
973
f170852a 974 case 'h':
fa0f4d8a 975 arg_action = ACTION_HELP;
f170852a
LP		 976 break;
977
1d2e23ab
LP		 978 case 'D':
979 log_set_max_level(LOG_DEBUG);
980 break;
981
099663ff
LP		 982 case 'b':
983 case 's':
984 case 'z':
985 /* Just to eat away the sysvinit kernel
986 * cmdline args without getopt() error
987 * messages that we'll parse in
988 * parse_proc_cmdline_word() or ignore. */
f170852a 989
099663ff 990 case '?':
f170852a 991 default:
099663ff
LP		 992 if (getpid() != 1) {
993 log_error("Unknown option code %c", c);
994 return -EINVAL;
995 }
996
997 break;
f170852a
LP		 998 }
999
d821e6d6
LP		 1000 if (optind < argc && getpid() != 1) {
1001 /* Hmm, when we aren't run as init system
1002 * let's complain about excess arguments */
1003
1004 log_error("Excess arguments.");
1005 return -EINVAL;
1006 }
1007
1008 if (detect_container(NULL) > 0) {
1009 char **a;
1010
1011 /* All /proc/cmdline arguments the kernel didn't
1012 * understand it passed to us. We're not really
1013 * interested in that usually since /proc/cmdline is
1014 * more interesting and complete. With one exception:
1015 * if we are run in a container /proc/cmdline is not
1016 * relevant for the container, hence we rely on argv[]
1017 * instead. */
1018
1019 for (a = argv; a < argv + argc; a++)
1020 if ((r = parse_proc_cmdline_word(*a)) < 0)
1021 return r;
51f0e189
LP		 1022 }
1023
f170852a
LP		 1024 return 0;
1025}
1026
1027static int help(void) {
1028
2e33c433 1029 printf("%s [OPTIONS...]\n\n"
af2d49f7 1030 "Starts up and maintains the system or user services.\n\n"
e537352b 1031 " -h --help Show this help\n"
e537352b 1032 " --test Determine startup sequence, dump it and exit\n"
80876c20 1033 " --dump-configuration-items Dump understood unit configuration items\n"
bbe63281 1034 " --introspect[=INTERFACE] Extract D-Bus interface data\n"
9e58ff9c 1035 " --unit=UNIT Set default unit\n"
edb9aaa8 1036 " --system Run a system instance, even if PID != 1\n"
af2d49f7 1037 " --user Run a user instance\n"
a5d87bf0
LP		 1038 " --dump-core[=0|1] Dump core on crash\n"
1039 " --crash-shell[=0|1] Run shell on crash\n"
1040 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
6e98720f 1041 " --show-status[=0|1] Show status updates on the console during bootup\n"
4cfa2c99 1042 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
9e58ff9c 1043 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
2218198b 1044 " --log-color[=0|1] Highlight important log messages\n"
0a494f1f
LP		 1045 " --log-location[=0|1] Include code location in log messages\n"
1046 " --default-standard-output= Set default standard output for services\n"
1047 " --default-standard-error= Set default standard error output for services\n",
5b6319dc 1048 program_invocation_short_name);
f170852a
LP		 1049
1050 return 0;
1051}
1052
9ba0bc4e
ZJS		 1053static int version(void) {
1054 puts(PACKAGE_STRING);
1055 puts(DISTRIBUTION);
1056 puts(SYSTEMD_FEATURES);
1057
1058 return 0;
1059}
1060
a16e1123
LP		 1061static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds) {
1062 FILE *f = NULL;
1063 FDSet *fds = NULL;
1064 int r;
1065
1066 assert(m);
1067 assert(_f);
1068 assert(_fds);
1069
a7556052
LP		 1070 /* Make sure nothing is really destructed when we shut down */
1071 m->n_reloading ++;
1072
d8d5ab98 1073 if ((r = manager_open_serialization(m, &f)) < 0) {
35b8ca3a 1074 log_error("Failed to create serialization file: %s", strerror(-r));
a16e1123
LP		 1075 goto fail;
1076 }
1077
1078 if (!(fds = fdset_new())) {
1079 r = -ENOMEM;
1080 log_error("Failed to allocate fd set: %s", strerror(-r));
1081 goto fail;
1082 }
1083
1084 if ((r = manager_serialize(m, f, fds)) < 0) {
1085 log_error("Failed to serialize state: %s", strerror(-r));
1086 goto fail;
1087 }
1088
1089 if (fseeko(f, 0, SEEK_SET) < 0) {
1090 log_error("Failed to rewind serialization fd: %m");
1091 goto fail;
1092 }
1093
1094 if ((r = fd_cloexec(fileno(f), false)) < 0) {
1095 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1096 goto fail;
1097 }
1098
1099 if ((r = fdset_cloexec(fds, false)) < 0) {
1100 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1101 goto fail;
1102 }
1103
1104 *_f = f;
1105 *_fds = fds;
1106
1107 return 0;
1108
1109fail:
1110 fdset_free(fds);
1111
1112 if (f)
1113 fclose(f);
1114
1115 return r;
1116}
1117
e9ddabc2
LP		 1118static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1119 const char *e;
1120 unsigned long long a, b;
1121
1122 assert(t);
1123
966a5d37
LP		 1124 e = getenv("RD_TIMESTAMP");
1125 if (!e)
e9ddabc2
LP		 1126 return NULL;
1127
1128 if (sscanf(e, "%llu %llu", &a, &b) != 2)
1129 return NULL;
1130
1131 t->realtime = (usec_t) a;
1132 t->monotonic = (usec_t) b;
1133
1134 return t;
1135}
1136
6ee5bbf8
LP		 1137static void test_mtab(void) {
1138 char *p;
1139
80758717
LP		 1140 /* Check that /etc/mtab is a symlink */
1141
6ee5bbf8
LP		 1142 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1143 bool b;
1144
ed86ebc4 1145 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
6ee5bbf8
LP		 1146 free(p);
1147
1148 if (b)
1149 return;
1150 }
1151
80758717
LP		 1152 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1153 "This is not supported anymore. "
1154 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1155}
1156
1157static void test_usr(void) {
80758717 1158
ed1c99fc 1159 /* Check that /usr is not a separate fs */
80758717 1160
871c44a7
LP		 1161 if (dir_is_empty("/usr") <= 0)
1162 return;
1163
2376ce13 1164 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
871c44a7
LP		 1165 "Some things will probably break (sometimes even silently) in mysterious ways. "
1166 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1167}
1168
1169static void test_cgroups(void) {
1170
1171 if (access("/proc/cgroups", F_OK) >= 0)
1172 return;
1173
1174 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1175 "Systems without control groups are not supported. "
1176 "We will now sleep for 10s, and then continue boot-up. "
1177 "Expect breakage and please do not file bugs. "
966a5d37
LP		 1178 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1179 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
871c44a7
LP		 1180
1181 sleep(10);
6ee5bbf8
LP		 1182}
1183
60918275
LP		 1184int main(int argc, char *argv[]) {
1185 Manager *m = NULL;
22f4096c 1186 int r, retval = EXIT_FAILURE;
9d76d730
LP		 1187 usec_t before_startup, after_startup;
1188 char timespan[FORMAT_TIMESPAN_MAX];
a16e1123
LP		 1189 FDSet *fds = NULL;
1190 bool reexecute = false;
b9080b03 1191 const char *shutdown_verb = NULL;
e9ddabc2 1192 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
5d6b1584 1193 static char systemd[] = "systemd";
2660882b 1194 bool skip_setup = false;
0b3325e7
LP		 1195 int j;
1196 bool loaded_policy = false;
e96d6be7 1197 bool arm_reboot_watchdog = false;
bf4df7c3 1198 bool queue_default_job = false;
41669317 1199 char *switch_root_dir = NULL, *switch_root_init = NULL;
27b14a22 1200
058dc6f3 1201#ifdef HAVE_SYSV_COMPAT
2cb1a60d 1202 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
35b8ca3a 1203 /* This is compatibility support for SysV, where
2cb1a60d
LP		 1204 * calling init as a user is identical to telinit. */
1205
1206 errno = -ENOENT;
1207 execv(SYSTEMCTL_BINARY_PATH, argv);
1208 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1209 return 1;
1210 }
058dc6f3 1211#endif
2cb1a60d 1212
0b3325e7
LP		 1213 /* Determine if this is a reexecution or normal bootup. We do
1214 * the full command line parsing much later, so let's just
1215 * have a quick peek here. */
0b3325e7
LP		 1216 for (j = 1; j < argc; j++)
1217 if (streq(argv[j], "--deserialize")) {
2660882b 1218 skip_setup = true;
7aaa27f2 1219 break;
0b3325e7
LP		 1220 }
1221
2660882b
LP		 1222 /* If we have switched root, do all the special setup
1223 * things */
d03bc1b8 1224 for (j = 1; j < argc; j++)
2660882b
LP		 1225 if (streq(argv[j], "--switched-root")) {
1226 skip_setup = false;
d03bc1b8
HH		 1227 break;
1228 }
1229
f3b6a3ed
LP		 1230 /* If we get started via the /sbin/init symlink then we are
1231 called 'init'. After a subsequent reexecution we are then
1232 called 'systemd'. That is confusing, hence let's call us
1233 systemd right-away. */
f3b6a3ed
LP		 1234 program_invocation_short_name = systemd;
1235 prctl(PR_SET_NAME, systemd);
5d6b1584 1236
9a0e6896
LP		 1237 saved_argv = argv;
1238 saved_argc = argc;
f3b6a3ed 1239
2cc59dbf 1240 log_show_color(isatty(STDERR_FILENO) > 0);
bbe63281 1241 log_show_location(false);
7c706717 1242 log_set_max_level(LOG_INFO);
bbe63281 1243
843d2643 1244 if (getpid() == 1) {
c3ba6250
HH		 1245 if (in_initrd()) {
1246 char *rd_timestamp = NULL;
1247
1248 dual_timestamp_get(&initrd_timestamp);
1249 asprintf(&rd_timestamp, "%llu %llu",
1250 (unsigned long long) initrd_timestamp.realtime,
1251 (unsigned long long) initrd_timestamp.monotonic);
1252 if (rd_timestamp) {
1253 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1254 free(rd_timestamp);
1255 }
1256 }
1257
fa0f4d8a 1258 arg_running_as = MANAGER_SYSTEM;
a0a38448 1259 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
0ff4cdd9 1260
2660882b 1261 if (!skip_setup) {
0b3325e7
LP		 1262 if (selinux_setup(&loaded_policy) < 0)
1263 goto finish;
81611586
RS		 1264 if (ima_setup() < 0)
1265 goto finish;
1266 }
0b3325e7
LP		 1267
1268 log_open();
c4dcdb9f 1269
e9a5ef7c 1270 if (label_init(NULL) < 0)
0ff4cdd9 1271 goto finish;
7948c4df 1272
2660882b 1273 if (!skip_setup)
0b3325e7
LP		 1274 if (hwclock_is_localtime() > 0) {
1275 int min;
7948c4df 1276
0b3325e7
LP		 1277 r = hwclock_apply_localtime_delta(&min);
1278 if (r < 0)
1279 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1280 else
1281 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1282 }
871e5809 1283
bbe63281 1284 } else {
af2d49f7 1285 arg_running_as = MANAGER_USER;
eeecf6e6 1286 log_set_target(LOG_TARGET_AUTO);
871e5809 1287 log_open();
bbe63281 1288 }
a5dab5ce 1289
0c85a4f3 1290 /* Initialize default unit */
f170852a
LP		 1291 if (set_default_unit(SPECIAL_DEFAULT_TARGET) < 0)
1292 goto finish;
60918275 1293
0c85a4f3
LP		 1294 /* By default, mount "cpu" and "cpuacct" together */
1295 arg_join_controllers = new(char**, 2);
1296 if (!arg_join_controllers)
1297 goto finish;
1298
1299 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1300 arg_join_controllers[1] = NULL;
1301
1302 if (!arg_join_controllers[0])
1303 goto finish;
1304
f170852a
LP		 1305 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1306 * /proc/$PID/fd is available. */
0c85a4f3
LP		 1307 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1308 r = mount_setup(loaded_policy);
1309 if (r < 0)
8efe3c01 1310 goto finish;
0c85a4f3 1311 }
4ade7963
LP		 1312
1313 /* Reset all signal handlers. */
1314 assert_se(reset_all_signal_handlers() == 0);
1315
078e4539 1316 /* If we are init, we can block sigkill. Yay. */
9a34ec5f 1317 ignore_signals(SIGNALS_IGNORE, -1);
078e4539 1318
487393e9
LP		 1319 if (parse_config_file() < 0)
1320 goto finish;
1321
fa0f4d8a 1322 if (arg_running_as == MANAGER_SYSTEM)
a5dab5ce
LP		 1323 if (parse_proc_cmdline() < 0)
1324 goto finish;
f170852a
LP		 1325
1326 log_parse_environment();
1327
1328 if (parse_argv(argc, argv) < 0)
1329 goto finish;
1330
b5c6cf87
LP		 1331 if (arg_action == ACTION_TEST && geteuid() == 0) {
1332 log_error("Don't run test mode as root.");
1333 goto finish;
1334 }
1335
fe783b03
LP		 1336 if (arg_running_as == MANAGER_SYSTEM &&
1337 arg_action == ACTION_RUN &&
1338 running_in_chroot() > 0) {
1339 log_error("Cannot be run in a chroot() environment.");
1340 goto finish;
1341 }
1342
fa0f4d8a 1343 if (arg_action == ACTION_HELP) {
f170852a
LP		 1344 retval = help();
1345 goto finish;
9ba0bc4e
ZJS		 1346 } else if (arg_action == ACTION_VERSION) {
1347 retval = version();
1348 goto finish;
fa0f4d8a 1349 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
e537352b 1350 unit_dump_config_items(stdout);
22f4096c 1351 retval = EXIT_SUCCESS;
e537352b 1352 goto finish;
fa0f4d8a 1353 } else if (arg_action == ACTION_DONE) {
22f4096c 1354 retval = EXIT_SUCCESS;
4288f619 1355 goto finish;
f170852a
LP		 1356 }
1357
fa0f4d8a 1358 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
f170852a 1359
871e5809
LP		 1360 /* Close logging fds, in order not to confuse fdset below */
1361 log_close();
1362
a16e1123
LP		 1363 /* Remember open file descriptors for later deserialization */
1364 if (serialization) {
966a5d37
LP		 1365 r = fdset_new_fill(&fds);
1366 if (r < 0) {
a16e1123
LP		 1367 log_error("Failed to allocate fd set: %s", strerror(-r));
1368 goto finish;
1369 }
1370
1371 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1372 } else
1373 close_all_fds(NULL, 0);
1374
09082a94 1375 /* Set up PATH unless it is already set */
e537352b 1376 setenv("PATH",
2c6db6fb 1377#ifdef HAVE_SPLIT_USR
e537352b 1378 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
2c6db6fb
LP		 1379#else
1380 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1381#endif
fa0f4d8a 1382 arg_running_as == MANAGER_SYSTEM);
09082a94 1383
39439087 1384 if (arg_running_as == MANAGER_SYSTEM) {
71ecc858
LP		 1385 /* Parse the data passed to us. We leave this
1386 * variables set, but the manager later on will not
1387 * pass them on to our children. */
2660882b 1388 if (!in_initrd())
c3ba6250 1389 parse_initrd_timestamp(&initrd_timestamp);
e9ddabc2
LP		 1390
1391 /* Unset some environment variables passed in from the
1392 * kernel that don't really make sense for us. */
39439087
LP		 1393 unsetenv("HOME");
1394 unsetenv("TERM");
b770165a 1395
9543ad16
LP		 1396 /* When we are invoked by a shell, these might be set,
1397 * but make little sense to pass on */
1398 unsetenv("PWD");
1399 unsetenv("SHLVL");
1400 unsetenv("_");
1401
2660882b 1402 /* When we are invoked by a chroot-like tool such as
9f28b98e
LP		 1403 * nspawn, these might be set, but make little sense
1404 * to pass on */
1405 unsetenv("USER");
1406 unsetenv("LOGNAME");
1407
b770165a
LP		 1408 /* All other variables are left as is, so that clients
1409 * can still read them via /proc/1/environ */
39439087 1410 }
1104f3c1 1411
f170852a
LP		 1412 /* Move out of the way, so that we won't block unmounts */
1413 assert_se(chdir("/") == 0);
1414
fa0f4d8a 1415 if (arg_running_as == MANAGER_SYSTEM) {
80876c20
LP		 1416 /* Become a session leader if we aren't one yet. */
1417 setsid();
4ade7963 1418
80876c20
LP		 1419 /* Disable the umask logic */
1420 umask(0);
1421 }
1422
843d2643
LP		 1423 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1424 dbus_connection_set_change_sigpipe(FALSE);
1425
2146621b
LP		 1426 /* Reset the console, but only if this is really init and we
1427 * are freshly booted */
fa0f4d8a 1428 if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
2660882b 1429 console_setup(getpid() == 1 && !skip_setup);
843d2643
LP		 1430 make_null_stdio();
1431 }
4ade7963 1432
18149b9f 1433 /* Open the logging devices, if possible and necessary */
843d2643 1434 log_open();
4ade7963 1435
5373d602
LP		 1436 /* Make sure we leave a core dump without panicing the
1437 * kernel. */
4fc935ca
LP		 1438 if (getpid() == 1)
1439 install_crash_handler();
97c4f35c 1440
0c85a4f3
LP		 1441 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1442 r = mount_cgroup_controllers(arg_join_controllers);
1443 if (r < 0)
1444 goto finish;
1445 }
1446
c20f5ac7
LP		 1447 if (arg_running_as == MANAGER_SYSTEM) {
1448 const char *virtualization = NULL;
1449
1450 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1451
1452 detect_virtualization(&virtualization);
1453 if (virtualization)
1454 log_info("Detected virtualization '%s'.", virtualization);
1455
26a1efdf
LP		 1456 if (in_initrd())
1457 log_info("Running in initial RAM disk.");
1458
c20f5ac7
LP		 1459 } else
1460 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
a5dab5ce 1461
2660882b 1462 if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
72bca11b
LP		 1463 locale_setup();
1464
6faa1114 1465 if (arg_show_status || plymouth_running())
888c6216
LP		 1466 status_welcome();
1467
888c6216
LP		 1468 kmod_setup();
1469 hostname_setup();
d7ccca2e 1470 machine_id_setup();
888c6216 1471 loopback_setup();
490aed58 1472
6ee5bbf8 1473 test_mtab();
80758717 1474 test_usr();
871c44a7 1475 test_cgroups();
af5bc85d 1476 }
302e8c4c 1477
e96d6be7
LP		 1478 if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1479 watchdog_set_timeout(&arg_runtime_watchdog);
1480
aa0f64ac
LP		 1481 if (arg_timer_slack_nsec != (nsec_t) -1)
1482 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1483 log_error("Failed to adjust timer slack: %m");
1484
ec8927ca
LP		 1485 if (arg_capability_bounding_set_drop) {
1486 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1487 if (r < 0) {
1488 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1489 goto finish;
1490 }
939b8f14
LP		 1491 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1492 if (r < 0) {
1493 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1494 goto finish;
1495 }
ec8927ca
LP		 1496 }
1497
e96d6be7
LP		 1498 r = manager_new(arg_running_as, &m);
1499 if (r < 0) {
8e274523 1500 log_error("Failed to allocate manager object: %s", strerror(-r));
60918275
LP		 1501 goto finish;
1502 }
1503
9e58ff9c 1504 m->confirm_spawn = arg_confirm_spawn;
0a494f1f
LP		 1505 m->default_std_output = arg_default_std_output;
1506 m->default_std_error = arg_default_std_error;
e96d6be7
LP		 1507 m->runtime_watchdog = arg_runtime_watchdog;
1508 m->shutdown_watchdog = arg_shutdown_watchdog;
9e58ff9c 1509
c93ff2e9
FC		 1510 manager_set_default_rlimits(m, arg_default_rlimit);
1511
e9ddabc2
LP		 1512 if (dual_timestamp_is_set(&initrd_timestamp))
1513 m->initrd_timestamp = initrd_timestamp;
1514
06d4c99a
LP		 1515 if (arg_default_controllers)
1516 manager_set_default_controllers(m, arg_default_controllers);
1517
27d340c7
LP		 1518 manager_set_show_status(m, arg_show_status);
1519
bf4df7c3
LP		 1520 /* Remember whether we should queue the default job */
1521 queue_default_job = !serialization || arg_switched_root;
1522
9d76d730
LP		 1523 before_startup = now(CLOCK_MONOTONIC);
1524
e96d6be7
LP		 1525 r = manager_startup(m, serialization, fds);
1526 if (r < 0)
6e2ef85b 1527 log_error("Failed to fully start up daemon: %s", strerror(-r));
a16e1123 1528
bf4df7c3
LP		 1529 /* This will close all file descriptors that were opened, but
1530 * not claimed by any unit. */
a16e1123 1531 if (fds) {
a16e1123
LP		 1532 fdset_free(fds);
1533 fds = NULL;
f50e0a01
LP		 1534 }
1535
a16e1123
LP		 1536 if (serialization) {
1537 fclose(serialization);
1538 serialization = NULL;
bf4df7c3
LP		 1539 }
1540
1541 if (queue_default_job) {
398ef8ba 1542 DBusError error;
1c27d3f3 1543 Unit *target = NULL;
bacbccb7 1544 Job *default_unit_job;
398ef8ba
LP		 1545
1546 dbus_error_init(&error);
1547
fa0f4d8a 1548 log_debug("Activating default unit: %s", arg_default_unit);
a16e1123 1549
e96d6be7
LP		 1550 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1551 if (r < 0) {
398ef8ba
LP		 1552 log_error("Failed to load default target: %s", bus_error(&error, r));
1553 dbus_error_free(&error);
ac155bb8
MS		 1554 } else if (target->load_state == UNIT_ERROR)
1555 log_error("Failed to load default target: %s", strerror(-target->load_error));
1556 else if (target->load_state == UNIT_MASKED)
6daf4f90 1557 log_error("Default target masked.");
27b14a22 1558
ac155bb8 1559 if (!target || target->load_state != UNIT_LOADED) {
a16e1123 1560 log_info("Trying to load rescue target...");
1c27d3f3 1561
e96d6be7
LP		 1562 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1563 if (r < 0) {
398ef8ba
LP		 1564 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1565 dbus_error_free(&error);
a16e1123 1566 goto finish;
ac155bb8
MS		 1567 } else if (target->load_state == UNIT_ERROR) {
1568 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1c27d3f3 1569 goto finish;
ac155bb8 1570 } else if (target->load_state == UNIT_MASKED) {
6daf4f90 1571 log_error("Rescue target masked.");
00dc5d76 1572 goto finish;
a16e1123
LP		 1573 }
1574 }
37d88da7 1575
ac155bb8 1576 assert(target->load_state == UNIT_LOADED);
00dc5d76 1577
fa0f4d8a 1578 if (arg_action == ACTION_TEST) {
40d50879 1579 printf("-> By units:\n");
a16e1123
LP		 1580 manager_dump_units(m, stdout, "\t");
1581 }
1582
bacbccb7
MS		 1583 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1584 if (r < 0) {
398ef8ba
LP		 1585 log_error("Failed to start default target: %s", bus_error(&error, r));
1586 dbus_error_free(&error);
37d88da7
LP		 1587 goto finish;
1588 }
bacbccb7 1589 m->default_unit_job_id = default_unit_job->id;
60918275 1590
07672f49
LP		 1591 after_startup = now(CLOCK_MONOTONIC);
1592 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1593 "Loaded units and determined initial transaction in %s.",
1594 format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1595
fa0f4d8a 1596 if (arg_action == ACTION_TEST) {
40d50879 1597 printf("-> By jobs:\n");
a16e1123 1598 manager_dump_jobs(m, stdout, "\t");
22f4096c 1599 retval = EXIT_SUCCESS;
a16e1123
LP		 1600 goto finish;
1601 }
e965d56d 1602 }
d46de8a1 1603
a16e1123 1604 for (;;) {
e96d6be7
LP		 1605 r = manager_loop(m);
1606 if (r < 0) {
a16e1123
LP		 1607 log_error("Failed to run mainloop: %s", strerror(-r));
1608 goto finish;
1609 }
11dd41ce 1610
a16e1123 1611 switch (m->exit_code) {
e965d56d 1612
a16e1123 1613 case MANAGER_EXIT:
22f4096c 1614 retval = EXIT_SUCCESS;
a16e1123
LP		 1615 log_debug("Exit.");
1616 goto finish;
e965d56d 1617
a16e1123 1618 case MANAGER_RELOAD:
e015090f 1619 log_info("Reloading.");
e96d6be7
LP		 1620 r = manager_reload(m);
1621 if (r < 0)
a16e1123
LP		 1622 log_error("Failed to reload: %s", strerror(-r));
1623 break;
cea8e32e 1624
a16e1123 1625 case MANAGER_REEXECUTE:
664f88a7 1626
a16e1123
LP		 1627 if (prepare_reexecute(m, &serialization, &fds) < 0)
1628 goto finish;
60918275 1629
a16e1123 1630 reexecute = true;
e015090f 1631 log_notice("Reexecuting.");
a16e1123
LP		 1632 goto finish;
1633
664f88a7
LP		 1634 case MANAGER_SWITCH_ROOT:
1635 /* Steal the switch root parameters */
41669317 1636 switch_root_dir = m->switch_root;
664f88a7
LP		 1637 switch_root_init = m->switch_root_init;
1638 m->switch_root = m->switch_root_init = NULL;
1639
1640 if (!switch_root_init)
1641 if (prepare_reexecute(m, &serialization, &fds) < 0)
1642 goto finish;
1643
1644 reexecute = true;
1645 log_notice("Switching root.");
1646 goto finish;
1647
b9080b03
FF		 1648 case MANAGER_REBOOT:
1649 case MANAGER_POWEROFF:
1650 case MANAGER_HALT:
1651 case MANAGER_KEXEC: {
1652 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1653 [MANAGER_REBOOT] = "reboot",
1654 [MANAGER_POWEROFF] = "poweroff",
1655 [MANAGER_HALT] = "halt",
1656 [MANAGER_KEXEC] = "kexec"
1657 };
1658
1659 assert_se(shutdown_verb = table[m->exit_code]);
e96d6be7 1660 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
b9080b03
FF		 1661
1662 log_notice("Shutting down.");
1663 goto finish;
1664 }
1665
a16e1123
LP		 1666 default:
1667 assert_not_reached("Unknown exit code.");
1668 }
1669 }
f170852a 1670
60918275
LP		 1671finish:
1672 if (m)
1673 manager_free(m);
1674
c93ff2e9
FC		 1675 for (j = 0; j < RLIMIT_NLIMITS; j++)
1676 free (arg_default_rlimit[j]);
1677
fa0f4d8a 1678 free(arg_default_unit);
06d4c99a 1679 strv_free(arg_default_controllers);
0c85a4f3 1680 free_join_controllers();
b9cd2ec1 1681
ea430986 1682 dbus_shutdown();
b2bb3dbe
LP		 1683 label_finish();
1684
a16e1123 1685 if (reexecute) {
664f88a7 1686 const char **args;
e564a982 1687 unsigned i, args_size;
a16e1123 1688
664f88a7
LP		 1689 /* Close and disarm the watchdog, so that the new
1690 * instance can reinitialize it, but doesn't get
1691 * rebooted while we do that */
1692 watchdog_close(true);
a16e1123 1693
41669317 1694 if (switch_root_dir) {
cee530bb
LP		 1695 /* Kill all remaining processes from the
1696 * initrd, but don't wait for them, so that we
1697 * can handle the SIGCHLD for them after
1698 * deserializing. */
1699 broadcast_signal(SIGTERM, false);
bd3fa1d2
LP		 1700
1701 /* And switch root */
41669317
LP		 1702 r = switch_root(switch_root_dir);
1703 if (r < 0)
1704 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1705 }
a16e1123 1706
d03bc1b8 1707 args_size = MAX(6, argc+1);
e564a982 1708 args = newa(const char*, args_size);
a16e1123 1709
664f88a7
LP		 1710 if (!switch_root_init) {
1711 char sfd[16];
a16e1123 1712
664f88a7
LP		 1713 /* First try to spawn ourselves with the right
1714 * path, and with full serialization. We do
1715 * this only if the user didn't specify an
1716 * explicit init to spawn. */
edb9aaa8 1717
664f88a7
LP		 1718 assert(serialization);
1719 assert(fds);
edb9aaa8 1720
664f88a7
LP		 1721 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1722 char_array_0(sfd);
edb9aaa8 1723
664f88a7
LP		 1724 i = 0;
1725 args[i++] = SYSTEMD_BINARY_PATH;
41669317 1726 if (switch_root_dir)
2660882b 1727 args[i++] = "--switched-root";
664f88a7
LP		 1728 args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1729 args[i++] = "--deserialize";
1730 args[i++] = sfd;
1731 args[i++] = NULL;
edb9aaa8 1732
e564a982 1733 assert(i <= args_size);
664f88a7
LP		 1734 execv(args[0], (char* const*) args);
1735 }
6e98720f 1736
664f88a7
LP		 1737 /* Try the fallback, if there is any, without any
1738 * serialization. We pass the original argv[] and
1739 * envp[]. (Well, modulo the ordering changes due to
1740 * getopt() in argv[], and some cleanups in envp[],
1741 * but let's hope that doesn't matter.) */
a16e1123 1742
b8f83232 1743 if (serialization) {
664f88a7 1744 fclose(serialization);
b8f83232
LP		 1745 serialization = NULL;
1746 }
a16e1123 1747
b8f83232 1748 if (fds) {
664f88a7 1749 fdset_free(fds);
b8f83232
LP		 1750 fds = NULL;
1751 }
a16e1123 1752
a504223d
HH		 1753 /* Reopen the console */
1754 make_console_stdio();
1755
b8f83232 1756 for (j = 1, i = 1; j < argc; j++)
664f88a7 1757 args[i++] = argv[j];
a16e1123 1758 args[i++] = NULL;
e564a982 1759 assert(i <= args_size);
b8f83232
LP		 1760
1761 if (switch_root_init) {
1762 args[0] = switch_root_init;
1763 execv(args[0], (char* const*) args);
1764 log_warning("Failed to execute configured init, trying fallback: %m");
1765 }
1766
1767 args[0] = "/sbin/init";
a16e1123
LP		 1768 execv(args[0], (char* const*) args);
1769
745e2fb7
KS		 1770 if (errno == ENOENT) {
1771 log_warning("No /sbin/init, trying fallback");
b8f83232 1772
745e2fb7
KS		 1773 args[0] = "/bin/sh";
1774 args[1] = NULL;
1775 execv(args[0], (char* const*) args);
1776 log_error("Failed to execute /bin/sh, giving up: %m");
1777 } else
1778 log_warning("Failed to execute /sbin/init, giving up: %m");
a16e1123
LP		 1779 }
1780
1781 if (serialization)
1782 fclose(serialization);
1783
1784 if (fds)
1785 fdset_free(fds);
1786
b9080b03
FF		 1787 if (shutdown_verb) {
1788 const char * command_line[] = {
1789 SYSTEMD_SHUTDOWN_BINARY_PATH,
1790 shutdown_verb,
1791 NULL
1792 };
d18f337c 1793 char **env_block;
b9080b03 1794
e96d6be7 1795 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
d18f337c
LP		 1796 char e[32];
1797
e96d6be7
LP		 1798 /* If we reboot let's set the shutdown
1799 * watchdog and tell the shutdown binary to
1800 * repeatedly ping it */
1801 watchdog_set_timeout(&arg_shutdown_watchdog);
1802 watchdog_close(false);
1803
1804 /* Tell the binary how often to ping */
1805 snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1806 char_array_0(e);
d18f337c
LP		 1807
1808 env_block = strv_append(environ, e);
1809 } else {
1810 env_block = strv_copy(environ);
e96d6be7 1811 watchdog_close(true);
d18f337c 1812 }
e96d6be7 1813
d18f337c
LP		 1814 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1815 free(env_block);
b9080b03
FF		 1816 log_error("Failed to execute shutdown binary, freezing: %m");
1817 }
1818
c3b3c274
LP		 1819 if (getpid() == 1)
1820 freeze();
1821
60918275
LP		 1822 return retval;
1823}
Unnamed repository; edit this file 'description' to name the repository.