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