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