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