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