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