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