]> 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
resolved: avoid possible dereference of null pointer
[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 '?':
f170852a 955 default:
099663ff
LP		 956 if (getpid() != 1) {
957 log_error("Unknown option code %c", c);
958 return -EINVAL;
959 }
960
961 break;
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"
4cfa2c99 1021 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-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);
bbe63281 1331
90dc8c2e
MG		 1332 /* Disable the umask logic */
1333 if (getpid() == 1)
1334 umask(0);
1335
a866073d 1336 if (getpid() == 1 && detect_container(NULL) <= 0) {
4f8d551f 1337
a866073d 1338 /* Running outside of a container as PID 1 */
67445f4e 1339 arg_running_as = SYSTEMD_SYSTEM;
a866073d
LP		 1340 make_null_stdio();
1341 log_set_target(LOG_TARGET_KMSG);
1342 log_open();
1343
21bf2ab0 1344 if (in_initrd())
c3a170f3 1345 initrd_timestamp = userspace_timestamp;
c3ba6250 1346
2660882b 1347 if (!skip_setup) {
8f838d8a 1348 mount_setup_early();
c2e0d600 1349 dual_timestamp_get(&security_start_timestamp);
0b3325e7
LP		 1350 if (selinux_setup(&loaded_policy) < 0)
1351 goto finish;
81611586
RS		 1352 if (ima_setup() < 0)
1353 goto finish;
e49d3c01 1354 if (smack_setup(&loaded_policy) < 0)
ffbd2c4d 1355 goto finish;
c2e0d600 1356 dual_timestamp_get(&security_finish_timestamp);
81611586 1357 }
0b3325e7 1358
e9a5ef7c 1359 if (label_init(NULL) < 0)
0ff4cdd9 1360 goto finish;
7948c4df 1361
72edcff5 1362 if (!skip_setup) {
24efb112 1363 if (clock_is_localtime() > 0) {
0b3325e7 1364 int min;
7948c4df 1365
c264aeab
KS		 1366 /*
1367 * The very first call of settimeofday() also does a time warp in the kernel.
1368 *
1369 * In the rtc-in-local time mode, we set the kernel's timezone, and rely on
1370 * external tools to take care of maintaining the RTC and do all adjustments.
1371 * This matches the behavior of Windows, which leaves the RTC alone if the
1372 * registry tells that the RTC runs in UTC.
1373 */
24efb112 1374 r = clock_set_timezone(&min);
0b3325e7
LP		 1375 if (r < 0)
1376 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1377 else
1378 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
19e65613
KS		 1379 } else if (!in_initrd()) {
1380 /*
c264aeab 1381 * Do a dummy very first call to seal the kernel's time warp magic.
19e65613
KS		 1382 *
1383 * Do not call this this from inside the initrd. The initrd might not
1384 * carry /etc/adjtime with LOCAL, but the real system could be set up
1385 * that way. In such case, we need to delay the time-warp or the sealing
1386 * until we reach the real system.
c264aeab
KS		 1387 *
1388 * Do no set the kernel's timezone. The concept of local time cannot
1389 * be supported reliably, the time will jump or be incorrect at every daylight
1390 * saving time change. All kernel local time concepts will be treated
1391 * as UTC that way.
19e65613 1392 */
c264aeab 1393 clock_reset_timewarp();
72edcff5
KS		 1394 }
1395 }
a866073d
LP		 1396
1397 /* Set the default for later on, but don't actually
1398 * open the logs like this for now. Note that if we
1399 * are transitioning from the initrd there might still
1400 * be journal fd open, and we shouldn't attempt
1401 * opening that before we parsed /proc/cmdline which
1402 * might redirect output elsewhere. */
1403 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1404
1405 } else if (getpid() == 1) {
a866073d 1406 /* Running inside a container, as PID 1 */
67445f4e 1407 arg_running_as = SYSTEMD_SYSTEM;
a866073d 1408 log_set_target(LOG_TARGET_CONSOLE);
99f09825 1409 log_close_console(); /* force reopen of /dev/console */
a866073d
LP		 1410 log_open();
1411
1412 /* For the later on, see above... */
1413 log_set_target(LOG_TARGET_JOURNAL);
1414
c3a170f3
HH		 1415 /* clear the kernel timestamp,
1416 * because we are in a container */
1417 kernel_timestamp.monotonic = 0ULL;
1418 kernel_timestamp.realtime = 0ULL;
a866073d 1419
c3a170f3 1420 } else {
a866073d 1421 /* Running as user instance */
67445f4e 1422 arg_running_as = SYSTEMD_USER;
eeecf6e6 1423 log_set_target(LOG_TARGET_AUTO);
871e5809 1424 log_open();
c3a170f3
HH		 1425
1426 /* clear the kernel timestamp,
1427 * because we are not PID 1 */
1428 kernel_timestamp.monotonic = 0ULL;
1429 kernel_timestamp.realtime = 0ULL;
bbe63281 1430 }
a5dab5ce 1431
0c85a4f3 1432 /* Initialize default unit */
6afa301b
LP		 1433 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1434 if (r < 0) {
14212119 1435 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
f170852a 1436 goto finish;
14212119 1437 }
60918275 1438
a07fdfa3
LP		 1439 r = initialize_join_controllers();
1440 if (r < 0)
0c85a4f3
LP		 1441 goto finish;
1442
f170852a
LP		 1443 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1444 * /proc/$PID/fd is available. */
c1dae1b3 1445 if (getpid() == 1) {
0c85a4f3
LP		 1446 r = mount_setup(loaded_policy);
1447 if (r < 0)
8efe3c01 1448 goto finish;
0c85a4f3 1449 }
4ade7963
LP		 1450
1451 /* Reset all signal handlers. */
1452 assert_se(reset_all_signal_handlers() == 0);
1453
9a34ec5f 1454 ignore_signals(SIGNALS_IGNORE, -1);
078e4539 1455
487393e9
LP		 1456 if (parse_config_file() < 0)
1457 goto finish;
1458
67445f4e 1459 if (arg_running_as == SYSTEMD_SYSTEM)
059cb385 1460 if (parse_proc_cmdline(parse_proc_cmdline_item) < 0)
a5dab5ce 1461 goto finish;
f170852a
LP		 1462
1463 log_parse_environment();
1464
1465 if (parse_argv(argc, argv) < 0)
1466 goto finish;
1467
6bae23a0
TB		 1468 if (arg_action == ACTION_TEST &&
1469 geteuid() == 0) {
b5c6cf87
LP		 1470 log_error("Don't run test mode as root.");
1471 goto finish;
1472 }
1473
6bae23a0
TB		 1474 if (arg_running_as == SYSTEMD_USER &&
1475 arg_action == ACTION_RUN &&
1476 sd_booted() <= 0) {
1477 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1478 goto finish;
1479 }
1480
67445f4e 1481 if (arg_running_as == SYSTEMD_SYSTEM &&
fe783b03
LP		 1482 arg_action == ACTION_RUN &&
1483 running_in_chroot() > 0) {
1484 log_error("Cannot be run in a chroot() environment.");
1485 goto finish;
1486 }
1487
0d8c31ff
ZJS		 1488 if (arg_action == ACTION_TEST)
1489 skip_setup = true;
1490
b87c2aa6
ZJS		 1491 pager_open_if_enabled();
1492
fa0f4d8a 1493 if (arg_action == ACTION_HELP) {
f170852a
LP		 1494 retval = help();
1495 goto finish;
9ba0bc4e
ZJS		 1496 } else if (arg_action == ACTION_VERSION) {
1497 retval = version();
1498 goto finish;
fa0f4d8a 1499 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
e537352b 1500 unit_dump_config_items(stdout);
22f4096c 1501 retval = EXIT_SUCCESS;
e537352b 1502 goto finish;
fa0f4d8a 1503 } else if (arg_action == ACTION_DONE) {
22f4096c 1504 retval = EXIT_SUCCESS;
4288f619 1505 goto finish;
f170852a
LP		 1506 }
1507
8be28fb1
KS		 1508 if (arg_running_as == SYSTEMD_USER &&
1509 !getenv("XDG_RUNTIME_DIR")) {
1510 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1511 goto finish;
1512 }
1513
fa0f4d8a 1514 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
f170852a 1515
871e5809
LP		 1516 /* Close logging fds, in order not to confuse fdset below */
1517 log_close();
1518
a16e1123 1519 /* Remember open file descriptors for later deserialization */
01e10de3
LP		 1520 r = fdset_new_fill(&fds);
1521 if (r < 0) {
1522 log_error("Failed to allocate fd set: %s", strerror(-r));
1523 goto finish;
1524 } else
1525 fdset_cloexec(fds, true);
a16e1123 1526
d3b1c508
LP		 1527 if (arg_serialization)
1528 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
a16e1123 1529
90dc8c2e 1530 if (arg_running_as == SYSTEMD_SYSTEM)
80876c20
LP		 1531 /* Become a session leader if we aren't one yet. */
1532 setsid();
4ade7963 1533
befb5b6a
LP		 1534 /* Move out of the way, so that we won't block unmounts */
1535 assert_se(chdir("/") == 0);
1536
2146621b
LP		 1537 /* Reset the console, but only if this is really init and we
1538 * are freshly booted */
67445f4e 1539 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
2660882b 1540 console_setup(getpid() == 1 && !skip_setup);
4ade7963 1541
18149b9f 1542 /* Open the logging devices, if possible and necessary */
843d2643 1543 log_open();
4ade7963 1544
b6e2f329
LP		 1545 if (arg_show_status == _SHOW_STATUS_UNSET)
1546 arg_show_status = SHOW_STATUS_YES;
1547
5373d602
LP		 1548 /* Make sure we leave a core dump without panicing the
1549 * kernel. */
ab422445 1550 if (getpid() == 1) {
4fc935ca 1551 install_crash_handler();
97c4f35c 1552
0c85a4f3
LP		 1553 r = mount_cgroup_controllers(arg_join_controllers);
1554 if (r < 0)
1555 goto finish;
1556 }
1557
67445f4e 1558 if (arg_running_as == SYSTEMD_SYSTEM) {
c20f5ac7
LP		 1559 const char *virtualization = NULL;
1560
0d8c31ff
ZJS		 1561 log_info(PACKAGE_STRING " running in %ssystem mode. (" SYSTEMD_FEATURES ")",
1562 arg_action == ACTION_TEST ? "test " : "" );
c20f5ac7
LP		 1563
1564 detect_virtualization(&virtualization);
1565 if (virtualization)
1566 log_info("Detected virtualization '%s'.", virtualization);
1567
fdd25311
LP		 1568 write_container_id();
1569
d9d93745
LP		 1570 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1571
26a1efdf
LP		 1572 if (in_initrd())
1573 log_info("Running in initial RAM disk.");
1574
3408ba01
LP		 1575 /* Let's check whether /etc is already populated. We
1576 * don't actually really check for that, but use
1577 * /etc/machine-id as flag file. This allows container
1578 * managers and installers to provision a couple of
1579 * files already. If the container manager wants to
1580 * provision the machine ID itself it should pass
1581 * $container_uuid to PID 1.*/
1582
baa1bdf7 1583 empty_etc = access("/etc/machine-id", F_OK) < 0;
5f5c2f38
LP		 1584 if (empty_etc)
1585 log_info("Running with unpopulated /etc.");
d8160f21 1586 } else {
1f97091d
LP		 1587 _cleanup_free_ char *t;
1588
1589 t = uid_to_name(getuid());
0d8c31ff
ZJS		 1590 log_debug(PACKAGE_STRING " running in %suser mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1591 arg_action == ACTION_TEST ? " test" : "", getuid(), t);
d8160f21 1592 }
a5dab5ce 1593
67445f4e 1594 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
d450b6f2 1595 if (arg_show_status > 0 || plymouth_running())
888c6216
LP		 1596 status_welcome();
1597
e3043162 1598#ifdef HAVE_KMOD
c47fc1f0 1599 kmod_setup();
e3043162 1600#endif
888c6216 1601 hostname_setup();
489388fb 1602 machine_id_setup(NULL);
888c6216 1603 loopback_setup();
490aed58 1604
6ee5bbf8 1605 test_mtab();
80758717 1606 test_usr();
af5bc85d 1607 }
302e8c4c 1608
67445f4e 1609 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
e96d6be7
LP		 1610 watchdog_set_timeout(&arg_runtime_watchdog);
1611
3a43da28 1612 if (arg_timer_slack_nsec != NSEC_INFINITY)
aa0f64ac
LP		 1613 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1614 log_error("Failed to adjust timer slack: %m");
1615
ec8927ca 1616 if (arg_capability_bounding_set_drop) {
31c885e9 1617 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
ec8927ca 1618 if (r < 0) {
31c885e9 1619 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
ec8927ca
LP		 1620 goto finish;
1621 }
31c885e9 1622 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
939b8f14 1623 if (r < 0) {
31c885e9 1624 log_error("Failed to drop capability bounding set: %s", strerror(-r));
939b8f14
LP		 1625 goto finish;
1626 }
ec8927ca
LP		 1627 }
1628
d3b1c508
LP		 1629 if (arg_syscall_archs) {
1630 r = enforce_syscall_archs(arg_syscall_archs);
1631 if (r < 0)
1632 goto finish;
1633 }
1634
67445f4e 1635 if (arg_running_as == SYSTEMD_USER) {
d4447f4d 1636 /* Become reaper of our children */
8b8ffe68
LP		 1637 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1638 log_warning("Failed to make us a subreaper: %m");
1639 if (errno == EINVAL)
ddfa5101 1640 log_info("Perhaps the kernel version is too old (< 3.4?)");
8b8ffe68 1641 }
d4447f4d
AK		 1642 }
1643
5f5c2f38 1644 if (arg_running_as == SYSTEMD_SYSTEM) {
4096d6f5
LP		 1645 bump_rlimit_nofile(&saved_rlimit_nofile);
1646
5f5c2f38
LP		 1647 if (empty_etc) {
1648 r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1649 if (r < 0)
1650 log_warning("Failed to populate /etc with preset unit settings, ignoring: %s", strerror(-r));
1651 else
1652 log_info("Populated /etc with preset unit settings.");
1653 }
1654 }
1655
0d8c31ff 1656 r = manager_new(arg_running_as, arg_action == ACTION_TEST, &m);
e96d6be7 1657 if (r < 0) {
8e274523 1658 log_error("Failed to allocate manager object: %s", strerror(-r));
60918275
LP		 1659 goto finish;
1660 }
1661
9e58ff9c 1662 m->confirm_spawn = arg_confirm_spawn;
bd8f585b 1663 m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
0a494f1f
LP		 1664 m->default_std_output = arg_default_std_output;
1665 m->default_std_error = arg_default_std_error;
1f19a534
OS		 1666 m->default_restart_usec = arg_default_restart_usec;
1667 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1668 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
3f41e1e5
LN		 1669 m->default_start_limit_interval = arg_default_start_limit_interval;
1670 m->default_start_limit_burst = arg_default_start_limit_burst;
085afe36
LP		 1671 m->default_cpu_accounting = arg_default_cpu_accounting;
1672 m->default_blockio_accounting = arg_default_blockio_accounting;
1673 m->default_memory_accounting = arg_default_memory_accounting;
e96d6be7
LP		 1674 m->runtime_watchdog = arg_runtime_watchdog;
1675 m->shutdown_watchdog = arg_shutdown_watchdog;
c3a170f3
HH		 1676 m->userspace_timestamp = userspace_timestamp;
1677 m->kernel_timestamp = kernel_timestamp;
c3a170f3 1678 m->initrd_timestamp = initrd_timestamp;
c2e0d600
TA		 1679 m->security_start_timestamp = security_start_timestamp;
1680 m->security_finish_timestamp = security_finish_timestamp;
9e58ff9c 1681
c93ff2e9 1682 manager_set_default_rlimits(m, arg_default_rlimit);
b6e2f329 1683 manager_environment_add(m, NULL, arg_default_environment);
27d340c7 1684 manager_set_show_status(m, arg_show_status);
e2680723 1685 manager_set_first_boot(m, empty_etc);
27d340c7 1686
bf4df7c3 1687 /* Remember whether we should queue the default job */
d3b1c508 1688 queue_default_job = !arg_serialization || arg_switched_root;
bf4df7c3 1689
9d76d730
LP		 1690 before_startup = now(CLOCK_MONOTONIC);
1691
d3b1c508 1692 r = manager_startup(m, arg_serialization, fds);
e96d6be7 1693 if (r < 0)
6e2ef85b 1694 log_error("Failed to fully start up daemon: %s", strerror(-r));
a16e1123 1695
bf4df7c3
LP		 1696 /* This will close all file descriptors that were opened, but
1697 * not claimed by any unit. */
01e10de3 1698 fdset_free(fds);
6c081276 1699 fds = NULL;
f50e0a01 1700
d3b1c508
LP		 1701 if (arg_serialization) {
1702 fclose(arg_serialization);
1703 arg_serialization = NULL;
bf4df7c3
LP		 1704 }
1705
1706 if (queue_default_job) {
718db961 1707 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1c27d3f3 1708 Unit *target = NULL;
bacbccb7 1709 Job *default_unit_job;
398ef8ba 1710
fa0f4d8a 1711 log_debug("Activating default unit: %s", arg_default_unit);
a16e1123 1712
e96d6be7 1713 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
718db961
LP		 1714 if (r < 0)
1715 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1716 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
ac155bb8
MS		 1717 log_error("Failed to load default target: %s", strerror(-target->load_error));
1718 else if (target->load_state == UNIT_MASKED)
6daf4f90 1719 log_error("Default target masked.");
27b14a22 1720
ac155bb8 1721 if (!target || target->load_state != UNIT_LOADED) {
a16e1123 1722 log_info("Trying to load rescue target...");
1c27d3f3 1723
e96d6be7
LP		 1724 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1725 if (r < 0) {
718db961 1726 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
a16e1123 1727 goto finish;
11ddb6f4 1728 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
ac155bb8 1729 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1c27d3f3 1730 goto finish;
ac155bb8 1731 } else if (target->load_state == UNIT_MASKED) {
6daf4f90 1732 log_error("Rescue target masked.");
00dc5d76 1733 goto finish;
a16e1123
LP		 1734 }
1735 }
37d88da7 1736
ac155bb8 1737 assert(target->load_state == UNIT_LOADED);
00dc5d76 1738
fa0f4d8a 1739 if (arg_action == ACTION_TEST) {
40d50879 1740 printf("-> By units:\n");
a16e1123
LP		 1741 manager_dump_units(m, stdout, "\t");
1742 }
1743
95f1b47d 1744 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
ab17a050 1745 if (r == -EPERM) {
718db961 1746 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
ab17a050
LP		 1747
1748 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1749 if (r < 0) {
718db961 1750 log_error("Failed to start default target: %s", bus_error_message(&error, r));
ab17a050
LP		 1751 goto finish;
1752 }
1753 } else if (r < 0) {
718db961 1754 log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
37d88da7
LP		 1755 goto finish;
1756 }
ab17a050 1757
bacbccb7 1758 m->default_unit_job_id = default_unit_job->id;
60918275 1759
07672f49
LP		 1760 after_startup = now(CLOCK_MONOTONIC);
1761 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1762 "Loaded units and determined initial transaction in %s.",
2fa4092c 1763 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
07672f49 1764
fa0f4d8a 1765 if (arg_action == ACTION_TEST) {
40d50879 1766 printf("-> By jobs:\n");
a16e1123 1767 manager_dump_jobs(m, stdout, "\t");
22f4096c 1768 retval = EXIT_SUCCESS;
a16e1123
LP		 1769 goto finish;
1770 }
e965d56d 1771 }
d46de8a1 1772
a16e1123 1773 for (;;) {
e96d6be7
LP		 1774 r = manager_loop(m);
1775 if (r < 0) {
a16e1123
LP		 1776 log_error("Failed to run mainloop: %s", strerror(-r));
1777 goto finish;
1778 }
11dd41ce 1779
a16e1123 1780 switch (m->exit_code) {
e965d56d 1781
a16e1123 1782 case MANAGER_EXIT:
22f4096c 1783 retval = EXIT_SUCCESS;
a16e1123
LP		 1784 log_debug("Exit.");
1785 goto finish;
e965d56d 1786
a16e1123 1787 case MANAGER_RELOAD:
e015090f 1788 log_info("Reloading.");
e96d6be7
LP		 1789 r = manager_reload(m);
1790 if (r < 0)
a16e1123
LP		 1791 log_error("Failed to reload: %s", strerror(-r));
1792 break;
cea8e32e 1793
a16e1123 1794 case MANAGER_REEXECUTE:
664f88a7 1795
d3b1c508 1796 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
a16e1123 1797 goto finish;
60918275 1798
a16e1123 1799 reexecute = true;
e015090f 1800 log_notice("Reexecuting.");
a16e1123
LP		 1801 goto finish;
1802
664f88a7
LP		 1803 case MANAGER_SWITCH_ROOT:
1804 /* Steal the switch root parameters */
41669317 1805 switch_root_dir = m->switch_root;
664f88a7
LP		 1806 switch_root_init = m->switch_root_init;
1807 m->switch_root = m->switch_root_init = NULL;
1808
1809 if (!switch_root_init)
d3b1c508 1810 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
664f88a7
LP		 1811 goto finish;
1812
1813 reexecute = true;
1814 log_notice("Switching root.");
1815 goto finish;
1816
b9080b03
FF		 1817 case MANAGER_REBOOT:
1818 case MANAGER_POWEROFF:
1819 case MANAGER_HALT:
1820 case MANAGER_KEXEC: {
1821 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1822 [MANAGER_REBOOT] = "reboot",
1823 [MANAGER_POWEROFF] = "poweroff",
1824 [MANAGER_HALT] = "halt",
1825 [MANAGER_KEXEC] = "kexec"
1826 };
1827
1828 assert_se(shutdown_verb = table[m->exit_code]);
e96d6be7 1829 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
b9080b03
FF		 1830
1831 log_notice("Shutting down.");
1832 goto finish;
1833 }
1834
a16e1123
LP		 1835 default:
1836 assert_not_reached("Unknown exit code.");
1837 }
1838 }
f170852a 1839
60918275 1840finish:
b87c2aa6
ZJS		 1841 pager_close();
1842
d3b1c508 1843 if (m) {
60918275 1844 manager_free(m);
d3b1c508
LP		 1845 m = NULL;
1846 }
60918275 1847
d3b1c508 1848 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
4096d6f5 1849 free(arg_default_rlimit[j]);
d3b1c508
LP		 1850 arg_default_rlimit[j] = NULL;
1851 }
c93ff2e9 1852
fa0f4d8a 1853 free(arg_default_unit);
d3b1c508
LP		 1854 arg_default_unit = NULL;
1855
0c85a4f3 1856 free_join_controllers();
b9cd2ec1 1857
d3b1c508
LP		 1858 strv_free(arg_default_environment);
1859 arg_default_environment = NULL;
1860
1861 set_free(arg_syscall_archs);
1862 arg_syscall_archs = NULL;
1863
b2bb3dbe
LP		 1864 label_finish();
1865
a16e1123 1866 if (reexecute) {
664f88a7 1867 const char **args;
e564a982 1868 unsigned i, args_size;
9bfcda95 1869 sigset_t ss;
a16e1123 1870
664f88a7
LP		 1871 /* Close and disarm the watchdog, so that the new
1872 * instance can reinitialize it, but doesn't get
1873 * rebooted while we do that */
1874 watchdog_close(true);
a16e1123 1875
4096d6f5
LP		 1876 /* Reset the RLIMIT_NOFILE to the kernel default, so
1877 * that the new systemd can pass the kernel default to
1878 * its child processes */
1879 if (saved_rlimit_nofile.rlim_cur > 0)
1880 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1881
41669317 1882 if (switch_root_dir) {
cee530bb
LP		 1883 /* Kill all remaining processes from the
1884 * initrd, but don't wait for them, so that we
1885 * can handle the SIGCHLD for them after
1886 * deserializing. */
0bee65f0 1887 broadcast_signal(SIGTERM, false, true);
bd3fa1d2
LP		 1888
1889 /* And switch root */
41669317
LP		 1890 r = switch_root(switch_root_dir);
1891 if (r < 0)
1892 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1893 }
a16e1123 1894
d03bc1b8 1895 args_size = MAX(6, argc+1);
e564a982 1896 args = newa(const char*, args_size);
a16e1123 1897
664f88a7
LP		 1898 if (!switch_root_init) {
1899 char sfd[16];
a16e1123 1900
664f88a7
LP		 1901 /* First try to spawn ourselves with the right
1902 * path, and with full serialization. We do
1903 * this only if the user didn't specify an
1904 * explicit init to spawn. */
edb9aaa8 1905
d3b1c508 1906 assert(arg_serialization);
664f88a7 1907 assert(fds);
edb9aaa8 1908
d3b1c508 1909 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
664f88a7 1910 char_array_0(sfd);
edb9aaa8 1911
664f88a7
LP		 1912 i = 0;
1913 args[i++] = SYSTEMD_BINARY_PATH;
41669317 1914 if (switch_root_dir)
2660882b 1915 args[i++] = "--switched-root";
67445f4e 1916 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
664f88a7
LP		 1917 args[i++] = "--deserialize";
1918 args[i++] = sfd;
1919 args[i++] = NULL;
edb9aaa8 1920
ce8aba56
KS		 1921 /* do not pass along the environment we inherit from the kernel or initrd */
1922 if (switch_root_dir)
1923 clearenv();
1924
e564a982 1925 assert(i <= args_size);
664f88a7
LP		 1926 execv(args[0], (char* const*) args);
1927 }
6e98720f 1928
664f88a7
LP		 1929 /* Try the fallback, if there is any, without any
1930 * serialization. We pass the original argv[] and
1931 * envp[]. (Well, modulo the ordering changes due to
1932 * getopt() in argv[], and some cleanups in envp[],
1933 * but let's hope that doesn't matter.) */
a16e1123 1934
d3b1c508
LP		 1935 if (arg_serialization) {
1936 fclose(arg_serialization);
1937 arg_serialization = NULL;
b8f83232 1938 }
a16e1123 1939
b8f83232 1940 if (fds) {
664f88a7 1941 fdset_free(fds);
b8f83232
LP		 1942 fds = NULL;
1943 }
a16e1123 1944
a504223d
HH		 1945 /* Reopen the console */
1946 make_console_stdio();
1947
d3b1c508 1948 for (j = 1, i = 1; j < (unsigned) argc; j++)
664f88a7 1949 args[i++] = argv[j];
a16e1123 1950 args[i++] = NULL;
e564a982 1951 assert(i <= args_size);
b8f83232 1952
5a85ca1c
RO		 1953 /* reenable any blocked signals, especially important
1954 * if we switch from initial ramdisk to init=... */
9bfcda95
LP		 1955 reset_all_signal_handlers();
1956
1957 assert_se(sigemptyset(&ss) == 0);
1958 assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);
5a85ca1c 1959
b8f83232
LP		 1960 if (switch_root_init) {
1961 args[0] = switch_root_init;
1962 execv(args[0], (char* const*) args);
1963 log_warning("Failed to execute configured init, trying fallback: %m");
1964 }
1965
1966 args[0] = "/sbin/init";
a16e1123
LP		 1967 execv(args[0], (char* const*) args);
1968
745e2fb7
KS		 1969 if (errno == ENOENT) {
1970 log_warning("No /sbin/init, trying fallback");
b8f83232 1971
745e2fb7
KS		 1972 args[0] = "/bin/sh";
1973 args[1] = NULL;
1974 execv(args[0], (char* const*) args);
1975 log_error("Failed to execute /bin/sh, giving up: %m");
1976 } else
1977 log_warning("Failed to execute /sbin/init, giving up: %m");
a16e1123
LP		 1978 }
1979
d3b1c508
LP		 1980 if (arg_serialization) {
1981 fclose(arg_serialization);
1982 arg_serialization = NULL;
1983 }
a16e1123 1984
d3b1c508 1985 if (fds) {
a16e1123 1986 fdset_free(fds);
d3b1c508
LP		 1987 fds = NULL;
1988 }
a16e1123 1989
54b434b1
LP		 1990#ifdef HAVE_VALGRIND_VALGRIND_H
1991 /* If we are PID 1 and running under valgrind, then let's exit
1992 * here explicitly. valgrind will only generate nice output on
1993 * exit(), not on exec(), hence let's do the former not the
1994 * latter here. */
1995 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1996 return 0;
1997#endif
1998
b9080b03 1999 if (shutdown_verb) {
b1e90ec5
ZJS		 2000 char log_level[DECIMAL_STR_MAX(int) + 1];
2001 const char* command_line[9] = {
b9080b03
FF		 2002 SYSTEMD_SHUTDOWN_BINARY_PATH,
2003 shutdown_verb,
b1e90ec5
ZJS		 2004 "--log-level", log_level,
2005 "--log-target",
b9080b03 2006 };
b1e90ec5 2007 unsigned pos = 5;
e3e45d4f 2008 _cleanup_strv_free_ char **env_block = NULL;
15bd5aee
LP		 2009
2010 assert(command_line[pos] == NULL);
e3e45d4f 2011 env_block = strv_copy(environ);
b9080b03 2012
b1e90ec5
ZJS		 2013 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
2014
2015 switch (log_get_target()) {
2016 case LOG_TARGET_KMSG:
2017 case LOG_TARGET_JOURNAL_OR_KMSG:
2018 case LOG_TARGET_SYSLOG_OR_KMSG:
2019 command_line[pos++] = "kmsg";
2020 break;
2021
2022 case LOG_TARGET_CONSOLE:
2023 default:
2024 command_line[pos++] = "console";
2025 break;
2026 };
2027
2028 if (log_get_show_color())
2029 command_line[pos++] = "--log-color";
2030
2031 if (log_get_show_location())
2032 command_line[pos++] = "--log-location";
2033
26abdc73 2034 assert(pos < ELEMENTSOF(command_line));
b1e90ec5 2035
e96d6be7 2036 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
e3e45d4f 2037 char *e;
d18f337c 2038
e96d6be7
LP		 2039 /* If we reboot let's set the shutdown
2040 * watchdog and tell the shutdown binary to
2041 * repeatedly ping it */
2042 watchdog_set_timeout(&arg_shutdown_watchdog);
2043 watchdog_close(false);
2044
e3e45d4f
SP		 2045 /* Tell the binary how often to ping, ignore failure */
2046 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2047 strv_push(&env_block, e);
2048 } else
e96d6be7
LP		 2049 watchdog_close(true);
2050
66713f77
LP		 2051 /* Avoid the creation of new processes forked by the
2052 * kernel; at this point, we will not listen to the
2053 * signals anyway */
2054 if (detect_container(NULL) <= 0)
2055 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
ad929bcc 2056
d18f337c 2057 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
b1e90ec5
ZJS		 2058 log_error("Failed to execute shutdown binary, %s: %m",
2059 getpid() == 1 ? "freezing" : "quitting");
b9080b03
FF		 2060 }
2061
c3b3c274
LP		 2062 if (getpid() == 1)
2063 freeze();
2064
60918275
LP		 2065 return retval;
2066}
Unnamed repository; edit this file 'description' to name the repository.