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