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