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