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