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