]> 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
util-lib: split out file attribute calls to chattr-util.[ch]
[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 49#include "conf-parser.h"
618234a5 50#include "cpu-set-util.h"
3dfc9763
LP		 51#include "dbus-manager.h"
52#include "def.h"
53#include "env-util.h"
3ffd4af2 54#include "fd-util.h"
3dfc9763 55#include "fdset.h"
718db961 56#include "fileio.h"
24882e06 57#include "formats-util.h"
3dfc9763
LP		 58#include "hostname-setup.h"
59#include "ima-setup.h"
60#include "killall.h"
61#include "kmod-setup.h"
d7b8eec7 62#include "load-fragment.h"
3dfc9763 63#include "log.h"
b6e66135 64#include "loopback-setup.h"
b6e66135 65#include "machine-id-setup.h"
3dfc9763
LP		 66#include "manager.h"
67#include "missing.h"
68#include "mount-setup.h"
69#include "pager.h"
6bedfcbb 70#include "parse-util.h"
3dfc9763 71#include "process-util.h"
78f22b97 72#include "rlimit-util.h"
b6e66135 73#include "selinux-setup.h"
3dfc9763
LP		 74#include "selinux-util.h"
75#include "signal-util.h"
ffbd2c4d 76#include "smack-setup.h"
3dfc9763
LP		 77#include "special.h"
78#include "strv.h"
79#include "switch-root.h"
80#include "terminal-util.h"
b1d4f8e1 81#include "user-util.h"
3dfc9763
LP		 82#include "virt.h"
83#include "watchdog.h"
b6e66135 84
f170852a
LP		 85static enum {
86 ACTION_RUN,
e965d56d 87 ACTION_HELP,
9ba0bc4e 88 ACTION_VERSION,
e537352b 89 ACTION_TEST,
4288f619
LP		 90 ACTION_DUMP_CONFIGURATION_ITEMS,
91 ACTION_DONE
fa0f4d8a 92} arg_action = ACTION_RUN;
fa0f4d8a 93static char *arg_default_unit = NULL;
b2c23da8 94static ManagerRunningAs arg_running_as = _MANAGER_RUNNING_AS_INVALID;
fa0f4d8a 95static bool arg_dump_core = true;
fa0f4d8a 96static int arg_crash_chvt = -1;
b9e74c39
LP		 97static bool arg_crash_shell = false;
98static bool arg_crash_reboot = false;
fa0f4d8a 99static bool arg_confirm_spawn = false;
b6e2f329 100static ShowStatus arg_show_status = _SHOW_STATUS_UNSET;
bf4df7c3 101static bool arg_switched_root = false;
b87c2aa6 102static int arg_no_pager = -1;
0c85a4f3 103static char ***arg_join_controllers = NULL;
706343f4 104static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
0a494f1f 105static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
1f19a534
OS		 106static usec_t arg_default_restart_usec = DEFAULT_RESTART_USEC;
107static usec_t arg_default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
108static usec_t arg_default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
3f41e1e5
LN		 109static usec_t arg_default_start_limit_interval = DEFAULT_START_LIMIT_INTERVAL;
110static unsigned arg_default_start_limit_burst = DEFAULT_START_LIMIT_BURST;
e96d6be7
LP		 111static usec_t arg_runtime_watchdog = 0;
112static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
97d0e5f8 113static char **arg_default_environment = NULL;
517d56b1 114static struct rlimit *arg_default_rlimit[_RLIMIT_MAX] = {};
ec8927ca 115static uint64_t arg_capability_bounding_set_drop = 0;
3a43da28 116static nsec_t arg_timer_slack_nsec = NSEC_INFINITY;
bd8f585b 117static usec_t arg_default_timer_accuracy_usec = 1 * USEC_PER_MINUTE;
d3b1c508
LP		 118static Set* arg_syscall_archs = NULL;
119static FILE* arg_serialization = NULL;
085afe36
LP		 120static bool arg_default_cpu_accounting = false;
121static bool arg_default_blockio_accounting = false;
122static bool arg_default_memory_accounting = false;
03a7b521 123static bool arg_default_tasks_accounting = false;
4fc935ca 124
b87c2aa6
ZJS		 125static void pager_open_if_enabled(void) {
126
127 if (arg_no_pager <= 0)
128 return;
129
130 pager_open(false);
131}
132
b9e74c39
LP		 133noreturn static void freeze_or_reboot(void) {
134
135 if (arg_crash_reboot) {
136 log_notice("Rebooting in 10s...");
137 (void) sleep(10);
138
139 log_notice("Rebooting now...");
140 (void) reboot(RB_AUTOBOOT);
141 log_emergency_errno(errno, "Failed to reboot: %m");
142 }
143
144 log_emergency("Freezing execution.");
145 freeze();
146}
147
919ce0b7 148noreturn static void crash(int sig) {
7d06dad9
MS		 149 struct sigaction sa;
150 pid_t pid;
97c4f35c 151
abb26902
LP		 152 if (getpid() != 1)
153 /* Pass this on immediately, if this is not PID 1 */
92ca4cac 154 (void) raise(sig);
abb26902 155 else if (!arg_dump_core)
4104970e 156 log_emergency("Caught <%s>, not dumping core.", signal_to_string(sig));
97c4f35c 157 else {
7d06dad9 158 sa = (struct sigaction) {
189d5bac 159 .sa_handler = nop_signal_handler,
b92bea5d
ZJS		 160 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
161 };
97c4f35c 162
6f5e3f35 163 /* We want to wait for the core process, hence let's enable SIGCHLD */
92ca4cac 164 (void) sigaction(SIGCHLD, &sa, NULL);
6f5e3f35 165
ee05e779 166 pid = raw_clone(SIGCHLD, NULL);
e62d8c39 167 if (pid < 0)
56f64d95 168 log_emergency_errno(errno, "Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
97c4f35c 169 else if (pid == 0) {
92ca4cac
LP		 170 struct rlimit rl = {
171 .rlim_cur = RLIM_INFINITY,
172 .rlim_max = RLIM_INFINITY,
173 };
97c4f35c
LP		 174
175 /* Enable default signal handler for core dump */
92ca4cac
LP		 176 sa = (struct sigaction) {
177 .sa_handler = SIG_DFL,
178 };
179 (void) sigaction(sig, &sa, NULL);
97c4f35c
LP		 180
181 /* Don't limit the core dump size */
92ca4cac 182 (void) setrlimit(RLIMIT_CORE, &rl);
97c4f35c
LP		 183
184 /* Just to be sure... */
e62d9b81 185 (void) chdir("/");
97c4f35c
LP		 186
187 /* Raise the signal again */
ee05e779 188 pid = raw_getpid();
92ca4cac 189 (void) kill(pid, sig); /* raise() would kill the parent */
97c4f35c
LP		 190
191 assert_not_reached("We shouldn't be here...");
92ca4cac 192 _exit(EXIT_FAILURE);
4fc935ca 193 } else {
8e12a6ae
LP		 194 siginfo_t status;
195 int r;
4fc935ca
LP		 196
197 /* Order things nicely. */
e62d8c39
ZJS		 198 r = wait_for_terminate(pid, &status);
199 if (r < 0)
da927ba9 200 log_emergency_errno(r, "Caught <%s>, waitpid() failed: %m", signal_to_string(sig));
8e12a6ae 201 else if (status.si_code != CLD_DUMPED)
ee05e779
ZJS		 202 log_emergency("Caught <%s>, core dump failed (child "PID_FMT", code=%s, status=%i/%s).",
203 signal_to_string(sig),
204 pid, sigchld_code_to_string(status.si_code),
205 status.si_status,
206 strna(status.si_code == CLD_EXITED
207 ? exit_status_to_string(status.si_status, EXIT_STATUS_FULL)
208 : signal_to_string(status.si_status)));
4fc935ca 209 else
4104970e 210 log_emergency("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
97c4f35c
LP		 211 }
212 }
213
b9e74c39 214 if (arg_crash_chvt >= 0)
92ca4cac 215 (void) chvt(arg_crash_chvt);
601f6a1e 216
7d06dad9
MS		 217 sa = (struct sigaction) {
218 .sa_handler = SIG_IGN,
219 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
220 };
221
222 /* Let the kernel reap children for us */
223 (void) sigaction(SIGCHLD, &sa, NULL);
8c43883a 224
7d06dad9 225 if (arg_crash_shell) {
b9e74c39 226 log_notice("Executing crash shell in 10s...");
92ca4cac 227 (void) sleep(10);
4fc935ca 228
ee05e779 229 pid = raw_clone(SIGCHLD, NULL);
cd3bd60a 230 if (pid < 0)
56f64d95 231 log_emergency_errno(errno, "Failed to fork off crash shell: %m");
6f5e3f35 232 else if (pid == 0) {
b9e74c39 233 (void) setsid();
92ca4cac
LP		 234 (void) make_console_stdio();
235 (void) execle("/bin/sh", "/bin/sh", NULL, environ);
6f5e3f35 236
ee05e779 237 log_emergency_errno(errno, "execle() failed: %m");
92ca4cac 238 _exit(EXIT_FAILURE);
b9e74c39
LP		 239 } else {
240 log_info("Spawned crash shell as PID "PID_FMT".", pid);
4cf0b03b 241 (void) wait_for_terminate(pid, NULL);
b9e74c39 242 }
4fc935ca
LP		 243 }
244
b9e74c39 245 freeze_or_reboot();
97c4f35c
LP		 246}
247
248static void install_crash_handler(void) {
297d563d 249 static const struct sigaction sa = {
b92bea5d 250 .sa_handler = crash,
297d563d 251 .sa_flags = SA_NODEFER, /* So that we can raise the signal again from the signal handler */
b92bea5d 252 };
297d563d 253 int r;
97c4f35c 254
297d563d
LP		 255 /* We ignore the return value here, since, we don't mind if we
256 * cannot set up a crash handler */
257 r = sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
258 if (r < 0)
259 log_debug_errno(r, "I had trouble setting up the crash handler, ignoring: %m");
97c4f35c 260}
f170852a 261
56d96fc0
LP		 262static int console_setup(void) {
263 _cleanup_close_ int tty_fd = -1;
264 int r;
80876c20 265
512947d4 266 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
23bbb0de
MS		 267 if (tty_fd < 0)
268 return log_error_errno(tty_fd, "Failed to open /dev/console: %m");
80876c20 269
56d96fc0
LP		 270 /* We don't want to force text mode. plymouth may be showing
271 * pictures already from initrd. */
512947d4 272 r = reset_terminal_fd(tty_fd, false);
23bbb0de
MS		 273 if (r < 0)
274 return log_error_errno(r, "Failed to reset /dev/console: %m");
843d2643 275
56d96fc0 276 return 0;
80876c20
LP		 277}
278
b9e74c39
LP		 279static int parse_crash_chvt(const char *value) {
280 int b;
281
282 if (safe_atoi(value, &arg_crash_chvt) >= 0)
283 return 0;
284
285 b = parse_boolean(value);
286 if (b < 0)
287 return b;
288
289 if (b > 0)
290 arg_crash_chvt = 0; /* switch to where kmsg goes */
291 else
292 arg_crash_chvt = -1; /* turn off switching */
293
294 return 0;
295}
296
059cb385 297static int parse_proc_cmdline_item(const char *key, const char *value) {
f170852a
LP		 298
299 static const char * const rlmap[] = {
ed370f5d 300 "emergency", SPECIAL_EMERGENCY_TARGET,
099663ff 301 "-b", SPECIAL_EMERGENCY_TARGET,
5329ab10 302 "rescue", SPECIAL_RESCUE_TARGET,
ed370f5d
LP		 303 "single", SPECIAL_RESCUE_TARGET,
304 "-s", SPECIAL_RESCUE_TARGET,
305 "s", SPECIAL_RESCUE_TARGET,
306 "S", SPECIAL_RESCUE_TARGET,
307 "1", SPECIAL_RESCUE_TARGET,
d5d8429a
LP		 308 "2", SPECIAL_MULTI_USER_TARGET,
309 "3", SPECIAL_MULTI_USER_TARGET,
310 "4", SPECIAL_MULTI_USER_TARGET,
311 "5", SPECIAL_GRAPHICAL_TARGET,
f170852a 312 };
059cb385 313 int r;
f170852a 314
059cb385 315 assert(key);
5192bd19 316
059cb385 317 if (streq(key, "systemd.unit") && value) {
bf4df7c3
LP		 318
319 if (!in_initrd())
e6e242ad 320 return free_and_strdup(&arg_default_unit, value);
bf4df7c3 321
059cb385 322 } else if (streq(key, "rd.systemd.unit") && value) {
bf4df7c3 323
ca05941b 324 if (in_initrd())
e6e242ad 325 return free_and_strdup(&arg_default_unit, value);
f170852a 326
059cb385 327 } else if (streq(key, "systemd.dump_core") && value) {
4fc935ca 328
059cb385 329 r = parse_boolean(value);
fb472900 330 if (r < 0)
059cb385 331 log_warning("Failed to parse dump core switch %s. Ignoring.", value);
4fc935ca 332 else
fa0f4d8a 333 arg_dump_core = r;
4fc935ca 334
b9e74c39
LP		 335 } else if (streq(key, "systemd.crash_chvt") && value) {
336
337 if (parse_crash_chvt(value) < 0)
338 log_warning("Failed to parse crash chvt switch %s. Ignoring.", value);
339
059cb385 340 } else if (streq(key, "systemd.crash_shell") && value) {
4fc935ca 341
059cb385 342 r = parse_boolean(value);
fb472900 343 if (r < 0)
059cb385 344 log_warning("Failed to parse crash shell switch %s. Ignoring.", value);
4fc935ca 345 else
fa0f4d8a 346 arg_crash_shell = r;
5e7ee61c 347
b9e74c39 348 } else if (streq(key, "systemd.crash_reboot") && value) {
5e7ee61c 349
b9e74c39
LP		 350 r = parse_boolean(value);
351 if (r < 0)
352 log_warning("Failed to parse crash reboot switch %s. Ignoring.", value);
5e7ee61c 353 else
b9e74c39 354 arg_crash_reboot = r;
5e7ee61c 355
059cb385 356 } else if (streq(key, "systemd.confirm_spawn") && value) {
601f6a1e 357
059cb385
LP		 358 r = parse_boolean(value);
359 if (r < 0)
360 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", value);
601f6a1e 361 else
059cb385 362 arg_confirm_spawn = r;
601f6a1e 363
059cb385 364 } else if (streq(key, "systemd.show_status") && value) {
9e58ff9c 365
059cb385 366 r = parse_show_status(value, &arg_show_status);
d450b6f2 367 if (r < 0)
059cb385
LP		 368 log_warning("Failed to parse show status switch %s. Ignoring.", value);
369
370 } else if (streq(key, "systemd.default_standard_output") && value) {
0a494f1f 371
059cb385 372 r = exec_output_from_string(value);
fb472900 373 if (r < 0)
059cb385 374 log_warning("Failed to parse default standard output switch %s. Ignoring.", value);
0a494f1f
LP		 375 else
376 arg_default_std_output = r;
0a494f1f 377
059cb385
LP		 378 } else if (streq(key, "systemd.default_standard_error") && value) {
379
380 r = exec_output_from_string(value);
fb472900 381 if (r < 0)
059cb385 382 log_warning("Failed to parse default standard error switch %s. Ignoring.", value);
0a494f1f
LP		 383 else
384 arg_default_std_error = r;
9e7c5357 385
059cb385
LP		 386 } else if (streq(key, "systemd.setenv") && value) {
387
388 if (env_assignment_is_valid(value)) {
e21fea24
KS		 389 char **env;
390
059cb385 391 env = strv_env_set(arg_default_environment, value);
e21fea24
KS		 392 if (env)
393 arg_default_environment = env;
394 else
279d3c9c 395 log_warning_errno(ENOMEM, "Setting environment variable '%s' failed, ignoring: %m", value);
e21fea24 396 } else
059cb385 397 log_warning("Environment variable name '%s' is not valid. Ignoring.", value);
9e58ff9c 398
059cb385 399 } else if (streq(key, "quiet") && !value) {
d7b15e0a 400
b6e2f329 401 if (arg_show_status == _SHOW_STATUS_UNSET)
d450b6f2 402 arg_show_status = SHOW_STATUS_AUTO;
059cb385
LP		 403
404 } else if (streq(key, "debug") && !value) {
d7b15e0a 405
1de1c9c3
LP		 406 /* Note that log_parse_environment() handles 'debug'
407 * too, and sets the log level to LOG_DEBUG. */
d7b15e0a 408
75f86906 409 if (detect_container() > 0)
b2103dcc 410 log_set_target(LOG_TARGET_CONSOLE);
059cb385
LP		 411
412 } else if (!in_initrd() && !value) {
f170852a
LP		 413 unsigned i;
414
415 /* SysV compatibility */
f170852a 416 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
059cb385 417 if (streq(key, rlmap[i]))
e6e242ad 418 return free_and_strdup(&arg_default_unit, rlmap[i+1]);
f170852a
LP		 419 }
420
421 return 0;
422}
423
e8e581bf
ZJS		 424#define DEFINE_SETTER(name, func, descr) \
425 static int name(const char *unit, \
426 const char *filename, \
427 unsigned line, \
428 const char *section, \
71a61510 429 unsigned section_line, \
e8e581bf
ZJS		 430 const char *lvalue, \
431 int ltype, \
432 const char *rvalue, \
433 void *data, \
434 void *userdata) { \
435 \
436 int r; \
437 \
438 assert(filename); \
439 assert(lvalue); \
440 assert(rvalue); \
441 \
442 r = func(rvalue); \
443 if (r < 0) \
d1cefe0a
LP		 444 log_syntax(unit, LOG_ERR, filename, line, r, \
445 "Invalid " descr "'%s': %m", \
446 rvalue); \
e8e581bf
ZJS		 447 \
448 return 0; \
449 }
487393e9 450
e8e581bf
ZJS		 451DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
452DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
453DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
454DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
487393e9 455
4d7213b2
LP		 456static int config_parse_cpu_affinity2(
457 const char *unit,
458 const char *filename,
459 unsigned line,
460 const char *section,
461 unsigned section_line,
462 const char *lvalue,
463 int ltype,
464 const char *rvalue,
465 void *data,
466 void *userdata) {
487393e9 467
4b40bc38 468 _cleanup_cpu_free_ cpu_set_t *c = NULL;
f5c72b73 469 int ncpus;
487393e9 470
765d143b 471 ncpus = parse_cpu_set_and_warn(rvalue, &c, unit, filename, line, lvalue);
f5c72b73
FB		 472 if (ncpus < 0)
473 return ncpus;
487393e9 474
f5c72b73
FB		 475 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
476 log_warning("Failed to set CPU affinity: %m");
487393e9 477
487393e9
LP		 478 return 0;
479}
480
4d7213b2
LP		 481static int config_parse_show_status(
482 const char* unit,
483 const char *filename,
484 unsigned line,
485 const char *section,
486 unsigned section_line,
487 const char *lvalue,
488 int ltype,
489 const char *rvalue,
490 void *data,
491 void *userdata) {
492
493 int k;
494 ShowStatus *b = data;
495
496 assert(filename);
497 assert(lvalue);
498 assert(rvalue);
499 assert(data);
500
501 k = parse_show_status(rvalue, b);
502 if (k < 0) {
12ca818f 503 log_syntax(unit, LOG_ERR, filename, line, k, "Failed to parse show status setting, ignoring: %s", rvalue);
4d7213b2
LP		 504 return 0;
505 }
506
507 return 0;
508}
509
b9e74c39
LP		 510static int config_parse_crash_chvt(
511 const char* unit,
512 const char *filename,
513 unsigned line,
514 const char *section,
515 unsigned section_line,
516 const char *lvalue,
517 int ltype,
518 const char *rvalue,
519 void *data,
520 void *userdata) {
521
522 int r;
523
524 assert(filename);
525 assert(lvalue);
526 assert(rvalue);
b9e74c39
LP		 527
528 r = parse_crash_chvt(rvalue);
529 if (r < 0) {
530 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CrashChangeVT= setting, ignoring: %s", rvalue);
531 return 0;
532 }
533
534 return 0;
535}
536
e8e581bf
ZJS		 537static int config_parse_join_controllers(const char *unit,
538 const char *filename,
539 unsigned line,
540 const char *section,
71a61510 541 unsigned section_line,
e8e581bf
ZJS		 542 const char *lvalue,
543 int ltype,
544 const char *rvalue,
545 void *data,
546 void *userdata) {
0c85a4f3 547
3875c85b 548 const char *whole_rvalue = rvalue;
0c85a4f3 549 unsigned n = 0;
0c85a4f3
LP		 550
551 assert(filename);
552 assert(lvalue);
553 assert(rvalue);
554
fe382237 555 arg_join_controllers = strv_free_free(arg_join_controllers);
0c85a4f3 556
d4ebeb4f
FB		 557 for (;;) {
558 _cleanup_free_ char *word = NULL;
559 char **l;
560 int r;
0c85a4f3 561
d4ebeb4f 562 r = extract_first_word(&rvalue, &word, WHITESPACE, EXTRACT_QUOTES);
3875c85b
FB		 563 if (r < 0) {
564 log_syntax(unit, LOG_ERR, filename, line, r, "Invalid value for %s: %s", lvalue, whole_rvalue);
d4ebeb4f 565 return r;
3875c85b 566 }
d4ebeb4f
FB		 567 if (r == 0)
568 break;
0c85a4f3 569
d4ebeb4f 570 l = strv_split(word, ",");
1592ec21 571 if (!l)
aa8aeac0 572 return log_oom();
0c85a4f3
LP		 573 strv_uniq(l);
574
575 if (strv_length(l) <= 1) {
576 strv_free(l);
577 continue;
578 }
579
580 if (!arg_join_controllers) {
581 arg_join_controllers = new(char**, 2);
582 if (!arg_join_controllers) {
583 strv_free(l);
14212119 584 return log_oom();
0c85a4f3
LP		 585 }
586
587 arg_join_controllers[0] = l;
588 arg_join_controllers[1] = NULL;
589
590 n = 1;
591 } else {
592 char ***a;
593 char ***t;
594
595 t = new0(char**, n+2);
596 if (!t) {
597 strv_free(l);
14212119 598 return log_oom();
0c85a4f3
LP		 599 }
600
601 n = 0;
602
603 for (a = arg_join_controllers; *a; a++) {
604
605 if (strv_overlap(*a, l)) {
e287086b 606 if (strv_extend_strv(&l, *a, false) < 0) {
0c85a4f3
LP		 607 strv_free(l);
608 strv_free_free(t);
14212119 609 return log_oom();
0c85a4f3
LP		 610 }
611
0c85a4f3
LP		 612 } else {
613 char **c;
614
615 c = strv_copy(*a);
616 if (!c) {
617 strv_free(l);
618 strv_free_free(t);
14212119 619 return log_oom();
0c85a4f3
LP		 620 }
621
622 t[n++] = c;
623 }
624 }
625
626 t[n++] = strv_uniq(l);
627
628 strv_free_free(arg_join_controllers);
629 arg_join_controllers = t;
630 }
631 }
d4ebeb4f 632 if (!isempty(rvalue))
12ca818f 633 log_syntax(unit, LOG_ERR, filename, line, 0, "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. "
f7cd3d5f 1134 "Please replace /etc/mtab with a symlink to /proc/self/mounts.");
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.