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