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