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