]> 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
man: Factor out a common snippet for .d directories and precedence
[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");
4a62c710
MS		 887 if (!f)
888 return log_error_errno(errno, "Failed to open serialization fd: %m");
a16e1123 889
d3b1c508
LP		 890 if (arg_serialization)
891 fclose(arg_serialization);
a16e1123 892
d3b1c508 893 arg_serialization = f;
a16e1123
LP		 894
895 break;
896 }
897
2660882b 898 case ARG_SWITCHED_ROOT:
bf4df7c3 899 arg_switched_root = true;
d03bc1b8
HH		 900 break;
901
f170852a 902 case 'h':
fa0f4d8a 903 arg_action = ACTION_HELP;
b87c2aa6
ZJS		 904 if (arg_no_pager < 0)
905 arg_no_pager = true;
f170852a
LP		 906 break;
907
1d2e23ab
LP		 908 case 'D':
909 log_set_max_level(LOG_DEBUG);
910 break;
911
099663ff
LP		 912 case 'b':
913 case 's':
914 case 'z':
915 /* Just to eat away the sysvinit kernel
916 * cmdline args without getopt() error
917 * messages that we'll parse in
918 * parse_proc_cmdline_word() or ignore. */
f170852a 919
099663ff 920 case '?':
601185b4 921 if (getpid() != 1)
099663ff 922 return -EINVAL;
601185b4
ZJS		 923 else
924 return 0;
099663ff 925
601185b4
ZJS		 926 default:
927 assert_not_reached("Unhandled option code.");
f170852a
LP		 928 }
929
d821e6d6
LP		 930 if (optind < argc && getpid() != 1) {
931 /* Hmm, when we aren't run as init system
932 * let's complain about excess arguments */
933
934 log_error("Excess arguments.");
935 return -EINVAL;
936 }
937
f170852a
LP		 938 return 0;
939}
940
941static int help(void) {
942
2e33c433 943 printf("%s [OPTIONS...]\n\n"
af2d49f7 944 "Starts up and maintains the system or user services.\n\n"
e537352b 945 " -h --help Show this help\n"
e537352b 946 " --test Determine startup sequence, dump it and exit\n"
b87c2aa6 947 " --no-pager Do not pipe output into a pager\n"
80876c20 948 " --dump-configuration-items Dump understood unit configuration items\n"
9e58ff9c 949 " --unit=UNIT Set default unit\n"
edb9aaa8 950 " --system Run a system instance, even if PID != 1\n"
af2d49f7 951 " --user Run a user instance\n"
a5d87bf0
LP		 952 " --dump-core[=0|1] Dump core on crash\n"
953 " --crash-shell[=0|1] Run shell on crash\n"
954 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
6e98720f 955 " --show-status[=0|1] Show status updates on the console during bootup\n"
c1dc6153 956 " --log-target=TARGET Set log target (console, journal, kmsg, journal-or-kmsg, null)\n"
9e58ff9c 957 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
2218198b 958 " --log-color[=0|1] Highlight important log messages\n"
0a494f1f
LP		 959 " --log-location[=0|1] Include code location in log messages\n"
960 " --default-standard-output= Set default standard output for services\n"
961 " --default-standard-error= Set default standard error output for services\n",
5b6319dc 962 program_invocation_short_name);
f170852a
LP		 963
964 return 0;
965}
966
9ba0bc4e
ZJS		 967static int version(void) {
968 puts(PACKAGE_STRING);
9ba0bc4e
ZJS		 969 puts(SYSTEMD_FEATURES);
970
971 return 0;
972}
973
b3680f49 974static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
a16e1123
LP		 975 FILE *f = NULL;
976 FDSet *fds = NULL;
977 int r;
978
979 assert(m);
980 assert(_f);
981 assert(_fds);
982
6b78f9b4
LP		 983 r = manager_open_serialization(m, &f);
984 if (r < 0) {
da927ba9 985 log_error_errno(r, "Failed to create serialization file: %m");
a16e1123
LP		 986 goto fail;
987 }
988
71445ae7
LP		 989 /* Make sure nothing is really destructed when we shut down */
990 m->n_reloading ++;
718db961 991 bus_manager_send_reloading(m, true);
71445ae7 992
6b78f9b4
LP		 993 fds = fdset_new();
994 if (!fds) {
a16e1123 995 r = -ENOMEM;
da927ba9 996 log_error_errno(r, "Failed to allocate fd set: %m");
a16e1123
LP		 997 goto fail;
998 }
999
b3680f49 1000 r = manager_serialize(m, f, fds, switching_root);
6b78f9b4 1001 if (r < 0) {
da927ba9 1002 log_error_errno(r, "Failed to serialize state: %m");
a16e1123
LP		 1003 goto fail;
1004 }
1005
1006 if (fseeko(f, 0, SEEK_SET) < 0) {
56f64d95 1007 log_error_errno(errno, "Failed to rewind serialization fd: %m");
a16e1123
LP		 1008 goto fail;
1009 }
1010
6b78f9b4
LP		 1011 r = fd_cloexec(fileno(f), false);
1012 if (r < 0) {
da927ba9 1013 log_error_errno(r, "Failed to disable O_CLOEXEC for serialization: %m");
a16e1123
LP		 1014 goto fail;
1015 }
1016
6b78f9b4
LP		 1017 r = fdset_cloexec(fds, false);
1018 if (r < 0) {
da927ba9 1019 log_error_errno(r, "Failed to disable O_CLOEXEC for serialization fds: %m");
a16e1123
LP		 1020 goto fail;
1021 }
1022
1023 *_f = f;
1024 *_fds = fds;
1025
1026 return 0;
1027
1028fail:
1029 fdset_free(fds);
1030
1031 if (f)
1032 fclose(f);
1033
1034 return r;
1035}
1036
4096d6f5
LP		 1037static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1038 struct rlimit nl;
1039 int r;
1040
1041 assert(saved_rlimit);
1042
1043 /* Save the original RLIMIT_NOFILE so that we can reset it
1044 * later when transitioning from the initrd to the main
1045 * systemd or suchlike. */
4a62c710
MS		 1046 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0)
1047 return log_error_errno(errno, "Reading RLIMIT_NOFILE failed: %m");
4096d6f5
LP		 1048
1049 /* Make sure forked processes get the default kernel setting */
1050 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1051 struct rlimit *rl;
1052
1053 rl = newdup(struct rlimit, saved_rlimit, 1);
1054 if (!rl)
1055 return log_oom();
1056
1057 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1058 }
1059
1060 /* Bump up the resource limit for ourselves substantially */
1061 nl.rlim_cur = nl.rlim_max = 64*1024;
1062 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
23bbb0de
MS		 1063 if (r < 0)
1064 return log_error_errno(r, "Setting RLIMIT_NOFILE failed: %m");
4096d6f5
LP		 1065
1066 return 0;
1067}
1068
6ee5bbf8 1069static void test_mtab(void) {
6ee5bbf8 1070
5b4c0131
LP		 1071 static const char ok[] =
1072 "/proc/self/mounts\0"
1073 "/proc/mounts\0"
1074 "../proc/self/mounts\0"
1075 "../proc/mounts\0";
80758717 1076
5b4c0131
LP		 1077 _cleanup_free_ char *p = NULL;
1078 int r;
6ee5bbf8 1079
5b4c0131
LP		 1080 /* Check that /etc/mtab is a symlink to the right place or
1081 * non-existing. But certainly not a file, or a symlink to
1082 * some weird place... */
6ee5bbf8 1083
5b4c0131
LP		 1084 r = readlink_malloc("/etc/mtab", &p);
1085 if (r == -ENOENT)
1086 return;
1087 if (r >= 0 && nulstr_contains(ok, p))
1088 return;
6ee5bbf8 1089
80758717
LP		 1090 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1091 "This is not supported anymore. "
1092 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1093}
1094
1095static void test_usr(void) {
80758717 1096
ed1c99fc 1097 /* Check that /usr is not a separate fs */
80758717 1098
871c44a7
LP		 1099 if (dir_is_empty("/usr") <= 0)
1100 return;
1101
2376ce13 1102 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
871c44a7
LP		 1103 "Some things will probably break (sometimes even silently) in mysterious ways. "
1104 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1105}
1106
a07fdfa3
LP		 1107static int initialize_join_controllers(void) {
1108 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1109 * + "net_prio". We'd like to add "cpuset" to the mix, but
1110 * "cpuset" does't really work for groups with no initialized
1111 * attributes. */
1112
1113 arg_join_controllers = new(char**, 3);
1114 if (!arg_join_controllers)
1115 return -ENOMEM;
1116
1117 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
a07fdfa3 1118 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
a6b26d90
ZJS		 1119 arg_join_controllers[2] = NULL;
1120
1121 if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1122 free_join_controllers();
a07fdfa3 1123 return -ENOMEM;
a6b26d90 1124 }
a07fdfa3 1125
a07fdfa3
LP		 1126 return 0;
1127}
1128
d3b1c508
LP		 1129static int enforce_syscall_archs(Set *archs) {
1130#ifdef HAVE_SECCOMP
1131 scmp_filter_ctx *seccomp;
1132 Iterator i;
1133 void *id;
1134 int r;
1135
1136 seccomp = seccomp_init(SCMP_ACT_ALLOW);
1137 if (!seccomp)
1138 return log_oom();
1139
1140 SET_FOREACH(id, arg_syscall_archs, i) {
1141 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1142 if (r == -EEXIST)
1143 continue;
1144 if (r < 0) {
da927ba9 1145 log_error_errno(r, "Failed to add architecture to seccomp: %m");
d3b1c508
LP		 1146 goto finish;
1147 }
1148 }
1149
8a8bf3c0
LP		 1150 r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1151 if (r < 0) {
da927ba9 1152 log_error_errno(r, "Failed to unset NO_NEW_PRIVS: %m");
8a8bf3c0
LP		 1153 goto finish;
1154 }
1155
d3b1c508
LP		 1156 r = seccomp_load(seccomp);
1157 if (r < 0)
da927ba9 1158 log_error_errno(r, "Failed to add install architecture seccomp: %m");
d3b1c508
LP		 1159
1160finish:
1161 seccomp_release(seccomp);
1162 return r;
1163#else
1164 return 0;
1165#endif
1166}
1167
b6e2f329
LP		 1168static int status_welcome(void) {
1169 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1170 int r;
1171
1172 r = parse_env_file("/etc/os-release", NEWLINE,
1173 "PRETTY_NAME", &pretty_name,
1174 "ANSI_COLOR", &ansi_color,
1175 NULL);
5ae4d543
LP		 1176 if (r == -ENOENT) {
1177 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1178 "PRETTY_NAME", &pretty_name,
1179 "ANSI_COLOR", &ansi_color,
1180 NULL);
1181 }
b6e2f329
LP		 1182
1183 if (r < 0 && r != -ENOENT)
da927ba9 1184 log_warning_errno(r, "Failed to read os-release file: %m");
b6e2f329
LP		 1185
1186 return status_printf(NULL, false, false,
1187 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1188 isempty(ansi_color) ? "1" : ansi_color,
1189 isempty(pretty_name) ? "Linux" : pretty_name);
1190}
1191
fdd25311
LP		 1192static int write_container_id(void) {
1193 const char *c;
1194
1195 c = getenv("container");
1196 if (isempty(c))
1197 return 0;
1198
1199 return write_string_file("/run/systemd/container", c);
1200}
1201
60918275
LP		 1202int main(int argc, char *argv[]) {
1203 Manager *m = NULL;
22f4096c 1204 int r, retval = EXIT_FAILURE;
9d76d730
LP		 1205 usec_t before_startup, after_startup;
1206 char timespan[FORMAT_TIMESPAN_MAX];
a16e1123
LP		 1207 FDSet *fds = NULL;
1208 bool reexecute = false;
b9080b03 1209 const char *shutdown_verb = NULL;
e9ddabc2 1210 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
c3a170f3
HH		 1211 dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1212 dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
c2e0d600
TA		 1213 dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1214 dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
5d6b1584 1215 static char systemd[] = "systemd";
2660882b 1216 bool skip_setup = false;
d3b1c508 1217 unsigned j;
0b3325e7 1218 bool loaded_policy = false;
e96d6be7 1219 bool arm_reboot_watchdog = false;
bf4df7c3 1220 bool queue_default_job = false;
5f5c2f38 1221 bool empty_etc = false;
41669317 1222 char *switch_root_dir = NULL, *switch_root_init = NULL;
4096d6f5 1223 static struct rlimit saved_rlimit_nofile = { 0, 0 };
cb6531be 1224 const char *error_message = NULL;
27b14a22 1225
058dc6f3 1226#ifdef HAVE_SYSV_COMPAT
2cb1a60d 1227 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
35b8ca3a 1228 /* This is compatibility support for SysV, where
2cb1a60d
LP		 1229 * calling init as a user is identical to telinit. */
1230
1231 errno = -ENOENT;
1232 execv(SYSTEMCTL_BINARY_PATH, argv);
56f64d95 1233 log_error_errno(errno, "Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
2cb1a60d
LP		 1234 return 1;
1235 }
058dc6f3 1236#endif
2cb1a60d 1237
c3a170f3
HH		 1238 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1239 dual_timestamp_get(&userspace_timestamp);
1240
0b3325e7
LP		 1241 /* Determine if this is a reexecution or normal bootup. We do
1242 * the full command line parsing much later, so let's just
1243 * have a quick peek here. */
db813c2a
LP		 1244 if (strv_find(argv+1, "--deserialize"))
1245 skip_setup = true;
0b3325e7 1246
2660882b
LP		 1247 /* If we have switched root, do all the special setup
1248 * things */
db813c2a
LP		 1249 if (strv_find(argv+1, "--switched-root"))
1250 skip_setup = false;
d03bc1b8 1251
f3b6a3ed
LP		 1252 /* If we get started via the /sbin/init symlink then we are
1253 called 'init'. After a subsequent reexecution we are then
1254 called 'systemd'. That is confusing, hence let's call us
1255 systemd right-away. */
f3b6a3ed
LP		 1256 program_invocation_short_name = systemd;
1257 prctl(PR_SET_NAME, systemd);
5d6b1584 1258
9a0e6896
LP		 1259 saved_argv = argv;
1260 saved_argc = argc;
f3b6a3ed 1261
2cc59dbf 1262 log_show_color(isatty(STDERR_FILENO) > 0);
c1dc6153 1263 log_set_upgrade_syslog_to_journal(true);
bbe63281 1264
90dc8c2e
MG		 1265 /* Disable the umask logic */
1266 if (getpid() == 1)
1267 umask(0);
1268
a866073d 1269 if (getpid() == 1 && detect_container(NULL) <= 0) {
4f8d551f 1270
a866073d 1271 /* Running outside of a container as PID 1 */
67445f4e 1272 arg_running_as = SYSTEMD_SYSTEM;
a866073d
LP		 1273 make_null_stdio();
1274 log_set_target(LOG_TARGET_KMSG);
1275 log_open();
1276
21bf2ab0 1277 if (in_initrd())
c3a170f3 1278 initrd_timestamp = userspace_timestamp;
c3ba6250 1279
2660882b 1280 if (!skip_setup) {
8f838d8a 1281 mount_setup_early();
c2e0d600 1282 dual_timestamp_get(&security_start_timestamp);
cb6531be
ZJS		 1283 if (mac_selinux_setup(&loaded_policy) < 0) {
1284 error_message = "Failed to load SELinux policy";
0b3325e7 1285 goto finish;
cb6531be
ZJS		 1286 } else if (ima_setup() < 0) {
1287 error_message = "Failed to load IMA policy";
81611586 1288 goto finish;
cb6531be
ZJS		 1289 } else if (mac_smack_setup(&loaded_policy) < 0) {
1290 error_message = "Failed to load SMACK policy";
ffbd2c4d 1291 goto finish;
cb6531be 1292 }
c2e0d600 1293 dual_timestamp_get(&security_finish_timestamp);
81611586 1294 }
0b3325e7 1295
cb6531be
ZJS		 1296 if (mac_selinux_init(NULL) < 0) {
1297 error_message = "Failed to initialize SELinux policy";
0ff4cdd9 1298 goto finish;
cb6531be 1299 }
7948c4df 1300
72edcff5 1301 if (!skip_setup) {
24efb112 1302 if (clock_is_localtime() > 0) {
0b3325e7 1303 int min;
7948c4df 1304
c264aeab
KS		 1305 /*
1306 * The very first call of settimeofday() also does a time warp in the kernel.
1307 *
1308 * In the rtc-in-local time mode, we set the kernel's timezone, and rely on
1309 * external tools to take care of maintaining the RTC and do all adjustments.
1310 * This matches the behavior of Windows, which leaves the RTC alone if the
1311 * registry tells that the RTC runs in UTC.
1312 */
24efb112 1313 r = clock_set_timezone(&min);
0b3325e7 1314 if (r < 0)
da927ba9 1315 log_error_errno(r, "Failed to apply local time delta, ignoring: %m");
0b3325e7
LP		 1316 else
1317 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
19e65613
KS		 1318 } else if (!in_initrd()) {
1319 /*
c264aeab 1320 * Do a dummy very first call to seal the kernel's time warp magic.
19e65613
KS		 1321 *
1322 * Do not call this this from inside the initrd. The initrd might not
1323 * carry /etc/adjtime with LOCAL, but the real system could be set up
1324 * that way. In such case, we need to delay the time-warp or the sealing
1325 * until we reach the real system.
c264aeab
KS		 1326 *
1327 * Do no set the kernel's timezone. The concept of local time cannot
1328 * be supported reliably, the time will jump or be incorrect at every daylight
1329 * saving time change. All kernel local time concepts will be treated
1330 * as UTC that way.
19e65613 1331 */
c264aeab 1332 clock_reset_timewarp();
72edcff5
KS		 1333 }
1334 }
a866073d
LP		 1335
1336 /* Set the default for later on, but don't actually
1337 * open the logs like this for now. Note that if we
1338 * are transitioning from the initrd there might still
1339 * be journal fd open, and we shouldn't attempt
1340 * opening that before we parsed /proc/cmdline which
1341 * might redirect output elsewhere. */
1342 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1343
1344 } else if (getpid() == 1) {
a866073d 1345 /* Running inside a container, as PID 1 */
67445f4e 1346 arg_running_as = SYSTEMD_SYSTEM;
a866073d 1347 log_set_target(LOG_TARGET_CONSOLE);
99f09825 1348 log_close_console(); /* force reopen of /dev/console */
a866073d
LP		 1349 log_open();
1350
1351 /* For the later on, see above... */
1352 log_set_target(LOG_TARGET_JOURNAL);
1353
c3a170f3
HH		 1354 /* clear the kernel timestamp,
1355 * because we are in a container */
1356 kernel_timestamp.monotonic = 0ULL;
1357 kernel_timestamp.realtime = 0ULL;
a866073d 1358
c3a170f3 1359 } else {
a866073d 1360 /* Running as user instance */
67445f4e 1361 arg_running_as = SYSTEMD_USER;
eeecf6e6 1362 log_set_target(LOG_TARGET_AUTO);
871e5809 1363 log_open();
c3a170f3
HH		 1364
1365 /* clear the kernel timestamp,
1366 * because we are not PID 1 */
1367 kernel_timestamp.monotonic = 0ULL;
1368 kernel_timestamp.realtime = 0ULL;
bbe63281 1369 }
a5dab5ce 1370
0c85a4f3 1371 /* Initialize default unit */
6afa301b
LP		 1372 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1373 if (r < 0) {
da927ba9 1374 log_emergency_errno(r, "Failed to set default unit %s: %m", SPECIAL_DEFAULT_TARGET);
cb6531be 1375 error_message = "Failed to set default unit";
f170852a 1376 goto finish;
14212119 1377 }
60918275 1378
a07fdfa3 1379 r = initialize_join_controllers();
cb6531be
ZJS		 1380 if (r < 0) {
1381 error_message = "Failed to initalize cgroup controllers";
0c85a4f3 1382 goto finish;
cb6531be 1383 }
0c85a4f3 1384
f170852a
LP		 1385 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1386 * /proc/$PID/fd is available. */
c1dae1b3 1387 if (getpid() == 1) {
f84f9974
LP		 1388
1389 /* Load the kernel modules early, so that we kdbus.ko is loaded before kdbusfs shall be mounted */
2e75e2a8
DM		 1390 if (!skip_setup)
1391 kmod_setup();
2e75e2a8 1392
0c85a4f3 1393 r = mount_setup(loaded_policy);
cb6531be
ZJS		 1394 if (r < 0) {
1395 error_message = "Failed to mount API filesystems";
8efe3c01 1396 goto finish;
cb6531be 1397 }
0c85a4f3 1398 }
4ade7963
LP		 1399
1400 /* Reset all signal handlers. */
1401 assert_se(reset_all_signal_handlers() == 0);
1402
9a34ec5f 1403 ignore_signals(SIGNALS_IGNORE, -1);
078e4539 1404
cb6531be
ZJS		 1405 if (parse_config_file() < 0) {
1406 error_message = "Failed to parse config file";
487393e9 1407 goto finish;
cb6531be 1408 }
487393e9 1409
b5884878
LP		 1410 if (arg_running_as == SYSTEMD_SYSTEM) {
1411 r = parse_proc_cmdline(parse_proc_cmdline_item);
1412 if (r < 0)
da927ba9 1413 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
b5884878 1414 }
f170852a 1415
1de1c9c3
LP		 1416 /* Note that this also parses bits from the kernel command
1417 * line, including "debug". */
f170852a
LP		 1418 log_parse_environment();
1419
cb6531be
ZJS		 1420 if (parse_argv(argc, argv) < 0) {
1421 error_message = "Failed to parse commandline arguments";
f170852a 1422 goto finish;
cb6531be 1423 }
f170852a 1424
6bae23a0
TB		 1425 if (arg_action == ACTION_TEST &&
1426 geteuid() == 0) {
b5c6cf87
LP		 1427 log_error("Don't run test mode as root.");
1428 goto finish;
1429 }
1430
6bae23a0
TB		 1431 if (arg_running_as == SYSTEMD_USER &&
1432 arg_action == ACTION_RUN &&
1433 sd_booted() <= 0) {
1434 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1435 goto finish;
1436 }
1437
67445f4e 1438 if (arg_running_as == SYSTEMD_SYSTEM &&
fe783b03
LP		 1439 arg_action == ACTION_RUN &&
1440 running_in_chroot() > 0) {
1441 log_error("Cannot be run in a chroot() environment.");
1442 goto finish;
1443 }
1444
0d8c31ff
ZJS		 1445 if (arg_action == ACTION_TEST)
1446 skip_setup = true;
1447
b87c2aa6
ZJS		 1448 pager_open_if_enabled();
1449
fa0f4d8a 1450 if (arg_action == ACTION_HELP) {
f170852a
LP		 1451 retval = help();
1452 goto finish;
9ba0bc4e
ZJS		 1453 } else if (arg_action == ACTION_VERSION) {
1454 retval = version();
1455 goto finish;
fa0f4d8a 1456 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
e537352b 1457 unit_dump_config_items(stdout);
22f4096c 1458 retval = EXIT_SUCCESS;
e537352b 1459 goto finish;
fa0f4d8a 1460 } else if (arg_action == ACTION_DONE) {
22f4096c 1461 retval = EXIT_SUCCESS;
4288f619 1462 goto finish;
f170852a
LP		 1463 }
1464
8be28fb1
KS		 1465 if (arg_running_as == SYSTEMD_USER &&
1466 !getenv("XDG_RUNTIME_DIR")) {
1467 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1468 goto finish;
1469 }
1470
fa0f4d8a 1471 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
f170852a 1472
871e5809
LP		 1473 /* Close logging fds, in order not to confuse fdset below */
1474 log_close();
1475
a16e1123 1476 /* Remember open file descriptors for later deserialization */
01e10de3
LP		 1477 r = fdset_new_fill(&fds);
1478 if (r < 0) {
da927ba9 1479 log_emergency_errno(r, "Failed to allocate fd set: %m");
cb6531be 1480 error_message = "Failed to allocate fd set";
01e10de3
LP		 1481 goto finish;
1482 } else
1483 fdset_cloexec(fds, true);
a16e1123 1484
d3b1c508
LP		 1485 if (arg_serialization)
1486 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
a16e1123 1487
90dc8c2e 1488 if (arg_running_as == SYSTEMD_SYSTEM)
80876c20
LP		 1489 /* Become a session leader if we aren't one yet. */
1490 setsid();
4ade7963 1491
befb5b6a
LP		 1492 /* Move out of the way, so that we won't block unmounts */
1493 assert_se(chdir("/") == 0);
1494
2146621b
LP		 1495 /* Reset the console, but only if this is really init and we
1496 * are freshly booted */
56d96fc0
LP		 1497 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN) {
1498
1499 /* If we are init, we connect stdin/stdout/stderr to
1500 * /dev/null and make sure we don't have a controlling
1501 * tty. */
1502 release_terminal();
1503
1504 if (getpid() == 1 && !skip_setup)
1505 console_setup();
1506 }
4ade7963 1507
18149b9f 1508 /* Open the logging devices, if possible and necessary */
843d2643 1509 log_open();
4ade7963 1510
b6e2f329
LP		 1511 if (arg_show_status == _SHOW_STATUS_UNSET)
1512 arg_show_status = SHOW_STATUS_YES;
1513
5373d602
LP		 1514 /* Make sure we leave a core dump without panicing the
1515 * kernel. */
ab422445 1516 if (getpid() == 1) {
4fc935ca 1517 install_crash_handler();
97c4f35c 1518
0c85a4f3
LP		 1519 r = mount_cgroup_controllers(arg_join_controllers);
1520 if (r < 0)
1521 goto finish;
1522 }
1523
67445f4e 1524 if (arg_running_as == SYSTEMD_SYSTEM) {
c20f5ac7
LP		 1525 const char *virtualization = NULL;
1526
0d8c31ff
ZJS		 1527 log_info(PACKAGE_STRING " running in %ssystem mode. (" SYSTEMD_FEATURES ")",
1528 arg_action == ACTION_TEST ? "test " : "" );
c20f5ac7
LP		 1529
1530 detect_virtualization(&virtualization);
1531 if (virtualization)
1532 log_info("Detected virtualization '%s'.", virtualization);
1533
fdd25311
LP		 1534 write_container_id();
1535
d9d93745
LP		 1536 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1537
26a1efdf
LP		 1538 if (in_initrd())
1539 log_info("Running in initial RAM disk.");
1540
3408ba01
LP		 1541 /* Let's check whether /etc is already populated. We
1542 * don't actually really check for that, but use
1543 * /etc/machine-id as flag file. This allows container
1544 * managers and installers to provision a couple of
1545 * files already. If the container manager wants to
1546 * provision the machine ID itself it should pass
1547 * $container_uuid to PID 1.*/
1548
baa1bdf7 1549 empty_etc = access("/etc/machine-id", F_OK) < 0;
5f5c2f38
LP		 1550 if (empty_etc)
1551 log_info("Running with unpopulated /etc.");
d8160f21 1552 } else {
1f97091d
LP		 1553 _cleanup_free_ char *t;
1554
1555 t = uid_to_name(getuid());
0d8c31ff
ZJS		 1556 log_debug(PACKAGE_STRING " running in %suser mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1557 arg_action == ACTION_TEST ? " test" : "", getuid(), t);
d8160f21 1558 }
a5dab5ce 1559
67445f4e 1560 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
d450b6f2 1561 if (arg_show_status > 0 || plymouth_running())
888c6216
LP		 1562 status_welcome();
1563
888c6216 1564 hostname_setup();
489388fb 1565 machine_id_setup(NULL);
888c6216 1566 loopback_setup();
490aed58 1567
6ee5bbf8 1568 test_mtab();
80758717 1569 test_usr();
af5bc85d 1570 }
302e8c4c 1571
67445f4e 1572 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
e96d6be7
LP		 1573 watchdog_set_timeout(&arg_runtime_watchdog);
1574
3a43da28 1575 if (arg_timer_slack_nsec != NSEC_INFINITY)
aa0f64ac 1576 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
56f64d95 1577 log_error_errno(errno, "Failed to adjust timer slack: %m");
aa0f64ac 1578
ec8927ca 1579 if (arg_capability_bounding_set_drop) {
31c885e9 1580 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
ec8927ca 1581 if (r < 0) {
da927ba9 1582 log_emergency_errno(r, "Failed to drop capability bounding set of usermode helpers: %m");
cb6531be 1583 error_message = "Failed to drop capability bounding set of usermode helpers";
ec8927ca
LP		 1584 goto finish;
1585 }
31c885e9 1586 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
939b8f14 1587 if (r < 0) {
da927ba9 1588 log_emergency_errno(r, "Failed to drop capability bounding set: %m");
cb6531be 1589 error_message = "Failed to drop capability bounding set";
939b8f14
LP		 1590 goto finish;
1591 }
ec8927ca
LP		 1592 }
1593
d3b1c508
LP		 1594 if (arg_syscall_archs) {
1595 r = enforce_syscall_archs(arg_syscall_archs);
cb6531be
ZJS		 1596 if (r < 0) {
1597 error_message = "Failed to set syscall architectures";
d3b1c508 1598 goto finish;
cb6531be 1599 }
d3b1c508
LP		 1600 }
1601
67445f4e 1602 if (arg_running_as == SYSTEMD_USER) {
d4447f4d 1603 /* Become reaper of our children */
8b8ffe68 1604 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
56f64d95 1605 log_warning_errno(errno, "Failed to make us a subreaper: %m");
8b8ffe68 1606 if (errno == EINVAL)
ddfa5101 1607 log_info("Perhaps the kernel version is too old (< 3.4?)");
8b8ffe68 1608 }
d4447f4d
AK		 1609 }
1610
5f5c2f38 1611 if (arg_running_as == SYSTEMD_SYSTEM) {
4096d6f5
LP		 1612 bump_rlimit_nofile(&saved_rlimit_nofile);
1613
5f5c2f38
LP		 1614 if (empty_etc) {
1615 r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1616 if (r < 0)
da927ba9 1617 log_warning_errno(r, "Failed to populate /etc with preset unit settings, ignoring: %m");
5f5c2f38
LP		 1618 else
1619 log_info("Populated /etc with preset unit settings.");
1620 }
1621 }
1622
0d8c31ff 1623 r = manager_new(arg_running_as, arg_action == ACTION_TEST, &m);
e96d6be7 1624 if (r < 0) {
da927ba9 1625 log_emergency_errno(r, "Failed to allocate manager object: %m");
cb6531be 1626 error_message = "Failed to allocate manager object";
60918275
LP		 1627 goto finish;
1628 }
1629
9e58ff9c 1630 m->confirm_spawn = arg_confirm_spawn;
bd8f585b 1631 m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
0a494f1f
LP		 1632 m->default_std_output = arg_default_std_output;
1633 m->default_std_error = arg_default_std_error;
1f19a534
OS		 1634 m->default_restart_usec = arg_default_restart_usec;
1635 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1636 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
3f41e1e5
LN		 1637 m->default_start_limit_interval = arg_default_start_limit_interval;
1638 m->default_start_limit_burst = arg_default_start_limit_burst;
085afe36
LP		 1639 m->default_cpu_accounting = arg_default_cpu_accounting;
1640 m->default_blockio_accounting = arg_default_blockio_accounting;
1641 m->default_memory_accounting = arg_default_memory_accounting;
e96d6be7
LP		 1642 m->runtime_watchdog = arg_runtime_watchdog;
1643 m->shutdown_watchdog = arg_shutdown_watchdog;
2928b0a8 1644
c3a170f3
HH		 1645 m->userspace_timestamp = userspace_timestamp;
1646 m->kernel_timestamp = kernel_timestamp;
c3a170f3 1647 m->initrd_timestamp = initrd_timestamp;
c2e0d600
TA		 1648 m->security_start_timestamp = security_start_timestamp;
1649 m->security_finish_timestamp = security_finish_timestamp;
9e58ff9c 1650
c93ff2e9 1651 manager_set_default_rlimits(m, arg_default_rlimit);
b6e2f329 1652 manager_environment_add(m, NULL, arg_default_environment);
27d340c7 1653 manager_set_show_status(m, arg_show_status);
e2680723 1654 manager_set_first_boot(m, empty_etc);
27d340c7 1655
bf4df7c3 1656 /* Remember whether we should queue the default job */
d3b1c508 1657 queue_default_job = !arg_serialization || arg_switched_root;
bf4df7c3 1658
9d76d730
LP		 1659 before_startup = now(CLOCK_MONOTONIC);
1660
d3b1c508 1661 r = manager_startup(m, arg_serialization, fds);
e96d6be7 1662 if (r < 0)
da927ba9 1663 log_error_errno(r, "Failed to fully start up daemon: %m");
a16e1123 1664
bf4df7c3
LP		 1665 /* This will close all file descriptors that were opened, but
1666 * not claimed by any unit. */
01e10de3 1667 fdset_free(fds);
6c081276 1668 fds = NULL;
f50e0a01 1669
d3b1c508
LP		 1670 if (arg_serialization) {
1671 fclose(arg_serialization);
1672 arg_serialization = NULL;
bf4df7c3
LP		 1673 }
1674
1675 if (queue_default_job) {
718db961 1676 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1c27d3f3 1677 Unit *target = NULL;
bacbccb7 1678 Job *default_unit_job;
398ef8ba 1679
fa0f4d8a 1680 log_debug("Activating default unit: %s", arg_default_unit);
a16e1123 1681
e96d6be7 1682 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
718db961
LP		 1683 if (r < 0)
1684 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1685 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
c33b3297 1686 log_error_errno(target->load_error, "Failed to load default target: %m");
ac155bb8 1687 else if (target->load_state == UNIT_MASKED)
6daf4f90 1688 log_error("Default target masked.");
27b14a22 1689
ac155bb8 1690 if (!target || target->load_state != UNIT_LOADED) {
a16e1123 1691 log_info("Trying to load rescue target...");
1c27d3f3 1692
e96d6be7
LP		 1693 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1694 if (r < 0) {
4104970e 1695 log_emergency("Failed to load rescue target: %s", bus_error_message(&error, r));
cb6531be 1696 error_message = "Failed to load rescue target";
a16e1123 1697 goto finish;
11ddb6f4 1698 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
c33b3297 1699 log_emergency_errno(target->load_error, "Failed to load rescue target: %m");
cb6531be 1700 error_message = "Failed to load rescue target";
1c27d3f3 1701 goto finish;
ac155bb8 1702 } else if (target->load_state == UNIT_MASKED) {
4104970e 1703 log_emergency("Rescue target masked.");
cb6531be 1704 error_message = "Rescue target masked";
00dc5d76 1705 goto finish;
a16e1123
LP		 1706 }
1707 }
37d88da7 1708
ac155bb8 1709 assert(target->load_state == UNIT_LOADED);
00dc5d76 1710
fa0f4d8a 1711 if (arg_action == ACTION_TEST) {
40d50879 1712 printf("-> By units:\n");
a16e1123
LP		 1713 manager_dump_units(m, stdout, "\t");
1714 }
1715
95f1b47d 1716 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
ab17a050 1717 if (r == -EPERM) {
718db961 1718 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
ab17a050
LP		 1719
1720 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1721 if (r < 0) {
4104970e 1722 log_emergency("Failed to start default target: %s", bus_error_message(&error, r));
cb6531be 1723 error_message = "Failed to start default target";
ab17a050
LP		 1724 goto finish;
1725 }
1726 } else if (r < 0) {
4104970e 1727 log_emergency("Failed to isolate default target: %s", bus_error_message(&error, r));
cb6531be 1728 error_message = "Failed to isolate default target";
37d88da7
LP		 1729 goto finish;
1730 }
ab17a050 1731
bacbccb7 1732 m->default_unit_job_id = default_unit_job->id;
60918275 1733
07672f49
LP		 1734 after_startup = now(CLOCK_MONOTONIC);
1735 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1736 "Loaded units and determined initial transaction in %s.",
fdb14b7e 1737 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 100 * USEC_PER_MSEC));
07672f49 1738
fa0f4d8a 1739 if (arg_action == ACTION_TEST) {
40d50879 1740 printf("-> By jobs:\n");
a16e1123 1741 manager_dump_jobs(m, stdout, "\t");
22f4096c 1742 retval = EXIT_SUCCESS;
a16e1123
LP		 1743 goto finish;
1744 }
e965d56d 1745 }
d46de8a1 1746
a16e1123 1747 for (;;) {
e96d6be7
LP		 1748 r = manager_loop(m);
1749 if (r < 0) {
da927ba9 1750 log_emergency_errno(r, "Failed to run main loop: %m");
cb6531be 1751 error_message = "Failed to run main loop";
a16e1123
LP		 1752 goto finish;
1753 }
11dd41ce 1754
a16e1123 1755 switch (m->exit_code) {
e965d56d 1756
a16e1123 1757 case MANAGER_EXIT:
22f4096c 1758 retval = EXIT_SUCCESS;
a16e1123
LP		 1759 log_debug("Exit.");
1760 goto finish;
e965d56d 1761
a16e1123 1762 case MANAGER_RELOAD:
e015090f 1763 log_info("Reloading.");
e96d6be7
LP		 1764 r = manager_reload(m);
1765 if (r < 0)
da927ba9 1766 log_error_errno(r, "Failed to reload: %m");
a16e1123 1767 break;
cea8e32e 1768
a16e1123 1769 case MANAGER_REEXECUTE:
664f88a7 1770
cb6531be
ZJS		 1771 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0) {
1772 error_message = "Failed to prepare for reexection";
a16e1123 1773 goto finish;
cb6531be 1774 }
60918275 1775
a16e1123 1776 reexecute = true;
e015090f 1777 log_notice("Reexecuting.");
a16e1123
LP		 1778 goto finish;
1779
664f88a7
LP		 1780 case MANAGER_SWITCH_ROOT:
1781 /* Steal the switch root parameters */
41669317 1782 switch_root_dir = m->switch_root;
664f88a7
LP		 1783 switch_root_init = m->switch_root_init;
1784 m->switch_root = m->switch_root_init = NULL;
1785
1786 if (!switch_root_init)
cb6531be
ZJS		 1787 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0) {
1788 error_message = "Failed to prepare for reexection";
664f88a7 1789 goto finish;
cb6531be 1790 }
664f88a7
LP		 1791
1792 reexecute = true;
1793 log_notice("Switching root.");
1794 goto finish;
1795
b9080b03
FF		 1796 case MANAGER_REBOOT:
1797 case MANAGER_POWEROFF:
1798 case MANAGER_HALT:
1799 case MANAGER_KEXEC: {
1800 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1801 [MANAGER_REBOOT] = "reboot",
1802 [MANAGER_POWEROFF] = "poweroff",
1803 [MANAGER_HALT] = "halt",
1804 [MANAGER_KEXEC] = "kexec"
1805 };
1806
1807 assert_se(shutdown_verb = table[m->exit_code]);
e96d6be7 1808 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
b9080b03
FF		 1809
1810 log_notice("Shutting down.");
1811 goto finish;
1812 }
1813
a16e1123
LP		 1814 default:
1815 assert_not_reached("Unknown exit code.");
1816 }
1817 }
f170852a 1818
60918275 1819finish:
b87c2aa6
ZJS		 1820 pager_close();
1821
06d8d842 1822 m = manager_free(m);
60918275 1823
d3b1c508 1824 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
4096d6f5 1825 free(arg_default_rlimit[j]);
d3b1c508
LP		 1826 arg_default_rlimit[j] = NULL;
1827 }
c93ff2e9 1828
fa0f4d8a 1829 free(arg_default_unit);
d3b1c508
LP		 1830 arg_default_unit = NULL;
1831
0c85a4f3 1832 free_join_controllers();
b9cd2ec1 1833
d3b1c508
LP		 1834 strv_free(arg_default_environment);
1835 arg_default_environment = NULL;
1836
1837 set_free(arg_syscall_archs);
1838 arg_syscall_archs = NULL;
1839
cc56fafe 1840 mac_selinux_finish();
b2bb3dbe 1841
a16e1123 1842 if (reexecute) {
664f88a7 1843 const char **args;
e564a982 1844 unsigned i, args_size;
a16e1123 1845
664f88a7
LP		 1846 /* Close and disarm the watchdog, so that the new
1847 * instance can reinitialize it, but doesn't get
1848 * rebooted while we do that */
1849 watchdog_close(true);
a16e1123 1850
4096d6f5
LP		 1851 /* Reset the RLIMIT_NOFILE to the kernel default, so
1852 * that the new systemd can pass the kernel default to
1853 * its child processes */
1854 if (saved_rlimit_nofile.rlim_cur > 0)
1855 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1856
41669317 1857 if (switch_root_dir) {
cee530bb
LP		 1858 /* Kill all remaining processes from the
1859 * initrd, but don't wait for them, so that we
1860 * can handle the SIGCHLD for them after
1861 * deserializing. */
0bee65f0 1862 broadcast_signal(SIGTERM, false, true);
bd3fa1d2 1863
5a4bf02f
HH		 1864 /* And switch root with MS_MOVE, because we remove the old directory afterwards and detach it. */
1865 r = switch_root(switch_root_dir, "/mnt", true, MS_MOVE);
41669317 1866 if (r < 0)
da927ba9 1867 log_error_errno(r, "Failed to switch root, trying to continue: %m");
41669317 1868 }
a16e1123 1869
d03bc1b8 1870 args_size = MAX(6, argc+1);
e564a982 1871 args = newa(const char*, args_size);
a16e1123 1872
664f88a7
LP		 1873 if (!switch_root_init) {
1874 char sfd[16];
a16e1123 1875
664f88a7
LP		 1876 /* First try to spawn ourselves with the right
1877 * path, and with full serialization. We do
1878 * this only if the user didn't specify an
1879 * explicit init to spawn. */
edb9aaa8 1880
d3b1c508 1881 assert(arg_serialization);
664f88a7 1882 assert(fds);
edb9aaa8 1883
d3b1c508 1884 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
664f88a7 1885 char_array_0(sfd);
edb9aaa8 1886
664f88a7
LP		 1887 i = 0;
1888 args[i++] = SYSTEMD_BINARY_PATH;
41669317 1889 if (switch_root_dir)
2660882b 1890 args[i++] = "--switched-root";
67445f4e 1891 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
664f88a7
LP		 1892 args[i++] = "--deserialize";
1893 args[i++] = sfd;
1894 args[i++] = NULL;
edb9aaa8 1895
ce8aba56
KS		 1896 /* do not pass along the environment we inherit from the kernel or initrd */
1897 if (switch_root_dir)
1898 clearenv();
1899
e564a982 1900 assert(i <= args_size);
664f88a7
LP		 1901 execv(args[0], (char* const*) args);
1902 }
6e98720f 1903
664f88a7
LP		 1904 /* Try the fallback, if there is any, without any
1905 * serialization. We pass the original argv[] and
1906 * envp[]. (Well, modulo the ordering changes due to
1907 * getopt() in argv[], and some cleanups in envp[],
1908 * but let's hope that doesn't matter.) */
a16e1123 1909
d3b1c508
LP		 1910 if (arg_serialization) {
1911 fclose(arg_serialization);
1912 arg_serialization = NULL;
b8f83232 1913 }
a16e1123 1914
b8f83232 1915 if (fds) {
664f88a7 1916 fdset_free(fds);
b8f83232
LP		 1917 fds = NULL;
1918 }
a16e1123 1919
a504223d
HH		 1920 /* Reopen the console */
1921 make_console_stdio();
1922
d3b1c508 1923 for (j = 1, i = 1; j < (unsigned) argc; j++)
664f88a7 1924 args[i++] = argv[j];
a16e1123 1925 args[i++] = NULL;
e564a982 1926 assert(i <= args_size);
b8f83232 1927
1b6d7fa7 1928 /* Reenable any blocked signals, especially important
5a85ca1c 1929 * if we switch from initial ramdisk to init=... */
9bfcda95 1930 reset_all_signal_handlers();
1b6d7fa7 1931 reset_signal_mask();
5a85ca1c 1932
b8f83232
LP		 1933 if (switch_root_init) {
1934 args[0] = switch_root_init;
1935 execv(args[0], (char* const*) args);
56f64d95 1936 log_warning_errno(errno, "Failed to execute configured init, trying fallback: %m");
b8f83232
LP		 1937 }
1938
1939 args[0] = "/sbin/init";
a16e1123
LP		 1940 execv(args[0], (char* const*) args);
1941
745e2fb7
KS		 1942 if (errno == ENOENT) {
1943 log_warning("No /sbin/init, trying fallback");
b8f83232 1944
745e2fb7
KS		 1945 args[0] = "/bin/sh";
1946 args[1] = NULL;
1947 execv(args[0], (char* const*) args);
56f64d95 1948 log_error_errno(errno, "Failed to execute /bin/sh, giving up: %m");
745e2fb7 1949 } else
56f64d95 1950 log_warning_errno(errno, "Failed to execute /sbin/init, giving up: %m");
a16e1123
LP		 1951 }
1952
d3b1c508
LP		 1953 if (arg_serialization) {
1954 fclose(arg_serialization);
1955 arg_serialization = NULL;
1956 }
a16e1123 1957
d3b1c508 1958 if (fds) {
a16e1123 1959 fdset_free(fds);
d3b1c508
LP		 1960 fds = NULL;
1961 }
a16e1123 1962
54b434b1
LP		 1963#ifdef HAVE_VALGRIND_VALGRIND_H
1964 /* If we are PID 1 and running under valgrind, then let's exit
1965 * here explicitly. valgrind will only generate nice output on
1966 * exit(), not on exec(), hence let's do the former not the
1967 * latter here. */
1968 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1969 return 0;
1970#endif
1971
b9080b03 1972 if (shutdown_verb) {
b1e90ec5
ZJS		 1973 char log_level[DECIMAL_STR_MAX(int) + 1];
1974 const char* command_line[9] = {
b9080b03
FF		 1975 SYSTEMD_SHUTDOWN_BINARY_PATH,
1976 shutdown_verb,
b1e90ec5
ZJS		 1977 "--log-level", log_level,
1978 "--log-target",
b9080b03 1979 };
b1e90ec5 1980 unsigned pos = 5;
e3e45d4f 1981 _cleanup_strv_free_ char **env_block = NULL;
15bd5aee
LP		 1982
1983 assert(command_line[pos] == NULL);
e3e45d4f 1984 env_block = strv_copy(environ);
b9080b03 1985
b1e90ec5
ZJS		 1986 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1987
1988 switch (log_get_target()) {
1989 case LOG_TARGET_KMSG:
1990 case LOG_TARGET_JOURNAL_OR_KMSG:
1991 case LOG_TARGET_SYSLOG_OR_KMSG:
1992 command_line[pos++] = "kmsg";
1993 break;
1994
1995 case LOG_TARGET_CONSOLE:
1996 default:
1997 command_line[pos++] = "console";
1998 break;
1999 };
2000
2001 if (log_get_show_color())
2002 command_line[pos++] = "--log-color";
2003
2004 if (log_get_show_location())
2005 command_line[pos++] = "--log-location";
2006
26abdc73 2007 assert(pos < ELEMENTSOF(command_line));
b1e90ec5 2008
e96d6be7 2009 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
e3e45d4f 2010 char *e;
d18f337c 2011
e96d6be7
LP		 2012 /* If we reboot let's set the shutdown
2013 * watchdog and tell the shutdown binary to
2014 * repeatedly ping it */
2015 watchdog_set_timeout(&arg_shutdown_watchdog);
2016 watchdog_close(false);
2017
e3e45d4f
SP		 2018 /* Tell the binary how often to ping, ignore failure */
2019 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2020 strv_push(&env_block, e);
2021 } else
e96d6be7
LP		 2022 watchdog_close(true);
2023
66713f77
LP		 2024 /* Avoid the creation of new processes forked by the
2025 * kernel; at this point, we will not listen to the
2026 * signals anyway */
2027 if (detect_container(NULL) <= 0)
2028 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
ad929bcc 2029
d18f337c 2030 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
56f64d95 2031 log_error_errno(errno, "Failed to execute shutdown binary, %s: %m",
b1e90ec5 2032 getpid() == 1 ? "freezing" : "quitting");
b9080b03
FF		 2033 }
2034
cb6531be
ZJS		 2035 if (getpid() == 1) {
2036 if (error_message)
2037 manager_status_printf(NULL, STATUS_TYPE_EMERGENCY,
2038 ANSI_HIGHLIGHT_RED_ON "!!!!!!" ANSI_HIGHLIGHT_OFF,
2039 "%s, freezing.", error_message);
c3b3c274 2040 freeze();
cb6531be 2041 }
c3b3c274 2042
60918275
LP		 2043 return retval;
2044}
Unnamed repository; edit this file 'description' to name the repository.