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