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