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