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