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