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