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