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