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