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