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