]> 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
continue work with error messages, log_oom()
[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: %m");
172 else if (pid == 0) {
173 make_console_stdio();
174 execl("/bin/sh", "/bin/sh", NULL);
175
176 log_error("execl() failed: %m");
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 %m. Ignoring.");
354 } else {
355 *eq = 0;
356 r = setenv(cenv, eq + 1, 1);
357 if (r < 0)
358 log_warning("setenv failed %m. Ignoring.");
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 log_oom();
499
500 r = safe_atou(t, &cpu);
501 free(t);
502
503 if (!c)
504 if (!(c = cpu_set_malloc(&ncpus)))
505 return log_oom();
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 log_oom();
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 log_oom();
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 log_oom();
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 log_oom();
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 log_oom();
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 log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
734 goto finish;
735 }
736 }
737
738 r = 0;
739
740 finish:
741 free(line);
742 return r;
743 }
744
745 static int parse_argv(int argc, char *argv[]) {
746
747 enum {
748 ARG_LOG_LEVEL = 0x100,
749 ARG_LOG_TARGET,
750 ARG_LOG_COLOR,
751 ARG_LOG_LOCATION,
752 ARG_UNIT,
753 ARG_SYSTEM,
754 ARG_USER,
755 ARG_TEST,
756 ARG_VERSION,
757 ARG_DUMP_CONFIGURATION_ITEMS,
758 ARG_DUMP_CORE,
759 ARG_CRASH_SHELL,
760 ARG_CONFIRM_SPAWN,
761 ARG_SHOW_STATUS,
762 ARG_DESERIALIZE,
763 ARG_SWITCHED_ROOT,
764 ARG_INTROSPECT,
765 ARG_DEFAULT_STD_OUTPUT,
766 ARG_DEFAULT_STD_ERROR
767 };
768
769 static const struct option options[] = {
770 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
771 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
772 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
773 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
774 { "unit", required_argument, NULL, ARG_UNIT },
775 { "system", no_argument, NULL, ARG_SYSTEM },
776 { "user", no_argument, NULL, ARG_USER },
777 { "test", no_argument, NULL, ARG_TEST },
778 { "help", no_argument, NULL, 'h' },
779 { "version", no_argument, NULL, ARG_VERSION },
780 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
781 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
782 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
783 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
784 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
785 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
786 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
787 { "introspect", optional_argument, NULL, ARG_INTROSPECT },
788 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
789 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
790 { NULL, 0, NULL, 0 }
791 };
792
793 int c, r;
794
795 assert(argc >= 1);
796 assert(argv);
797
798 if (getpid() == 1)
799 opterr = 0;
800
801 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
802
803 switch (c) {
804
805 case ARG_LOG_LEVEL:
806 if ((r = log_set_max_level_from_string(optarg)) < 0) {
807 log_error("Failed to parse log level %s.", optarg);
808 return r;
809 }
810
811 break;
812
813 case ARG_LOG_TARGET:
814
815 if ((r = log_set_target_from_string(optarg)) < 0) {
816 log_error("Failed to parse log target %s.", optarg);
817 return r;
818 }
819
820 break;
821
822 case ARG_LOG_COLOR:
823
824 if (optarg) {
825 if ((r = log_show_color_from_string(optarg)) < 0) {
826 log_error("Failed to parse log color setting %s.", optarg);
827 return r;
828 }
829 } else
830 log_show_color(true);
831
832 break;
833
834 case ARG_LOG_LOCATION:
835
836 if (optarg) {
837 if ((r = log_show_location_from_string(optarg)) < 0) {
838 log_error("Failed to parse log location setting %s.", optarg);
839 return r;
840 }
841 } else
842 log_show_location(true);
843
844 break;
845
846 case ARG_DEFAULT_STD_OUTPUT:
847
848 if ((r = exec_output_from_string(optarg)) < 0) {
849 log_error("Failed to parse default standard output setting %s.", optarg);
850 return r;
851 } else
852 arg_default_std_output = r;
853 break;
854
855 case ARG_DEFAULT_STD_ERROR:
856
857 if ((r = exec_output_from_string(optarg)) < 0) {
858 log_error("Failed to parse default standard error output setting %s.", optarg);
859 return r;
860 } else
861 arg_default_std_error = r;
862 break;
863
864 case ARG_UNIT:
865
866 if ((r = set_default_unit(optarg)) < 0) {
867 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
868 return r;
869 }
870
871 break;
872
873 case ARG_SYSTEM:
874 arg_running_as = MANAGER_SYSTEM;
875 break;
876
877 case ARG_USER:
878 arg_running_as = MANAGER_USER;
879 break;
880
881 case ARG_TEST:
882 arg_action = ACTION_TEST;
883 break;
884
885 case ARG_VERSION:
886 arg_action = ACTION_VERSION;
887 break;
888
889 case ARG_DUMP_CONFIGURATION_ITEMS:
890 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
891 break;
892
893 case ARG_DUMP_CORE:
894 r = optarg ? parse_boolean(optarg) : 1;
895 if (r < 0) {
896 log_error("Failed to parse dump core boolean %s.", optarg);
897 return r;
898 }
899 arg_dump_core = r;
900 break;
901
902 case ARG_CRASH_SHELL:
903 r = optarg ? parse_boolean(optarg) : 1;
904 if (r < 0) {
905 log_error("Failed to parse crash shell boolean %s.", optarg);
906 return r;
907 }
908 arg_crash_shell = r;
909 break;
910
911 case ARG_CONFIRM_SPAWN:
912 r = optarg ? parse_boolean(optarg) : 1;
913 if (r < 0) {
914 log_error("Failed to parse confirm spawn boolean %s.", optarg);
915 return r;
916 }
917 arg_confirm_spawn = r;
918 break;
919
920 case ARG_SHOW_STATUS:
921 r = optarg ? parse_boolean(optarg) : 1;
922 if (r < 0) {
923 log_error("Failed to parse show status boolean %s.", optarg);
924 return r;
925 }
926 arg_show_status = r;
927 break;
928
929 case ARG_DESERIALIZE: {
930 int fd;
931 FILE *f;
932
933 if ((r = safe_atoi(optarg, &fd)) < 0 || fd < 0) {
934 log_error("Failed to parse deserialize option %s.", optarg);
935 return r;
936 }
937
938 if (!(f = fdopen(fd, "r"))) {
939 log_error("Failed to open serialization fd: %m");
940 return r;
941 }
942
943 if (serialization)
944 fclose(serialization);
945
946 serialization = f;
947
948 break;
949 }
950
951 case ARG_SWITCHED_ROOT:
952 arg_switched_root = true;
953 break;
954
955 case ARG_INTROSPECT: {
956 const char * const * i = NULL;
957
958 for (i = bus_interface_table; *i; i += 2)
959 if (!optarg || streq(i[0], optarg)) {
960 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
961 "<node>\n", stdout);
962 fputs(i[1], stdout);
963 fputs("</node>\n", stdout);
964
965 if (optarg)
966 break;
967 }
968
969 if (!i[0] && optarg)
970 log_error("Unknown interface %s.", optarg);
971
972 arg_action = ACTION_DONE;
973 break;
974 }
975
976 case 'h':
977 arg_action = ACTION_HELP;
978 break;
979
980 case 'D':
981 log_set_max_level(LOG_DEBUG);
982 break;
983
984 case 'b':
985 case 's':
986 case 'z':
987 /* Just to eat away the sysvinit kernel
988 * cmdline args without getopt() error
989 * messages that we'll parse in
990 * parse_proc_cmdline_word() or ignore. */
991
992 case '?':
993 default:
994 if (getpid() != 1) {
995 log_error("Unknown option code %c", c);
996 return -EINVAL;
997 }
998
999 break;
1000 }
1001
1002 if (optind < argc && getpid() != 1) {
1003 /* Hmm, when we aren't run as init system
1004 * let's complain about excess arguments */
1005
1006 log_error("Excess arguments.");
1007 return -EINVAL;
1008 }
1009
1010 if (detect_container(NULL) > 0) {
1011 char **a;
1012
1013 /* All /proc/cmdline arguments the kernel didn't
1014 * understand it passed to us. We're not really
1015 * interested in that usually since /proc/cmdline is
1016 * more interesting and complete. With one exception:
1017 * if we are run in a container /proc/cmdline is not
1018 * relevant for the container, hence we rely on argv[]
1019 * instead. */
1020
1021 for (a = argv; a < argv + argc; a++)
1022 if ((r = parse_proc_cmdline_word(*a)) < 0) {
1023 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
1024 return r;
1025 }
1026 }
1027
1028 return 0;
1029 }
1030
1031 static int help(void) {
1032
1033 printf("%s [OPTIONS...]\n\n"
1034 "Starts up and maintains the system or user services.\n\n"
1035 " -h --help Show this help\n"
1036 " --test Determine startup sequence, dump it and exit\n"
1037 " --dump-configuration-items Dump understood unit configuration items\n"
1038 " --introspect[=INTERFACE] Extract D-Bus interface data\n"
1039 " --unit=UNIT Set default unit\n"
1040 " --system Run a system instance, even if PID != 1\n"
1041 " --user Run a user instance\n"
1042 " --dump-core[=0|1] Dump core on crash\n"
1043 " --crash-shell[=0|1] Run shell on crash\n"
1044 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
1045 " --show-status[=0|1] Show status updates on the console during bootup\n"
1046 " --log-target=TARGET Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1047 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1048 " --log-color[=0|1] Highlight important log messages\n"
1049 " --log-location[=0|1] Include code location in log messages\n"
1050 " --default-standard-output= Set default standard output for services\n"
1051 " --default-standard-error= Set default standard error output for services\n",
1052 program_invocation_short_name);
1053
1054 return 0;
1055 }
1056
1057 static int version(void) {
1058 puts(PACKAGE_STRING);
1059 puts(DISTRIBUTION);
1060 puts(SYSTEMD_FEATURES);
1061
1062 return 0;
1063 }
1064
1065 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool serialize_jobs) {
1066 FILE *f = NULL;
1067 FDSet *fds = NULL;
1068 int r;
1069
1070 assert(m);
1071 assert(_f);
1072 assert(_fds);
1073
1074 /* Make sure nothing is really destructed when we shut down */
1075 m->n_reloading ++;
1076
1077 r = manager_open_serialization(m, &f);
1078 if (r < 0) {
1079 log_error("Failed to create serialization file: %s", strerror(-r));
1080 goto fail;
1081 }
1082
1083 fds = fdset_new();
1084 if (!fds) {
1085 r = -ENOMEM;
1086 log_error("Failed to allocate fd set: %s", strerror(-r));
1087 goto fail;
1088 }
1089
1090 r = manager_serialize(m, f, fds, serialize_jobs);
1091 if (r < 0) {
1092 log_error("Failed to serialize state: %s", strerror(-r));
1093 goto fail;
1094 }
1095
1096 if (fseeko(f, 0, SEEK_SET) < 0) {
1097 log_error("Failed to rewind serialization fd: %m");
1098 goto fail;
1099 }
1100
1101 r = fd_cloexec(fileno(f), false);
1102 if (r < 0) {
1103 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1104 goto fail;
1105 }
1106
1107 r = fdset_cloexec(fds, false);
1108 if (r < 0) {
1109 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1110 goto fail;
1111 }
1112
1113 *_f = f;
1114 *_fds = fds;
1115
1116 return 0;
1117
1118 fail:
1119 fdset_free(fds);
1120
1121 if (f)
1122 fclose(f);
1123
1124 return r;
1125 }
1126
1127 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1128 const char *e;
1129 unsigned long long a, b;
1130
1131 assert(t);
1132
1133 e = getenv("RD_TIMESTAMP");
1134 if (!e)
1135 return NULL;
1136
1137 if (sscanf(e, "%llu %llu", &a, &b) != 2)
1138 return NULL;
1139
1140 t->realtime = (usec_t) a;
1141 t->monotonic = (usec_t) b;
1142
1143 return t;
1144 }
1145
1146 static void test_mtab(void) {
1147 char *p;
1148
1149 /* Check that /etc/mtab is a symlink */
1150
1151 if (readlink_malloc("/etc/mtab", &p) >= 0) {
1152 bool b;
1153
1154 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1155 free(p);
1156
1157 if (b)
1158 return;
1159 }
1160
1161 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1162 "This is not supported anymore. "
1163 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1164 }
1165
1166 static void test_usr(void) {
1167
1168 /* Check that /usr is not a separate fs */
1169
1170 if (dir_is_empty("/usr") <= 0)
1171 return;
1172
1173 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1174 "Some things will probably break (sometimes even silently) in mysterious ways. "
1175 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1176 }
1177
1178 static void test_cgroups(void) {
1179
1180 if (access("/proc/cgroups", F_OK) >= 0)
1181 return;
1182
1183 log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1184 "Systems without control groups are not supported. "
1185 "We will now sleep for 10s, and then continue boot-up. "
1186 "Expect breakage and please do not file bugs. "
1187 "Instead fix your kernel and enable CONFIG_CGROUPS. "
1188 "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1189
1190 sleep(10);
1191 }
1192
1193 int main(int argc, char *argv[]) {
1194 Manager *m = NULL;
1195 int r, retval = EXIT_FAILURE;
1196 usec_t before_startup, after_startup;
1197 char timespan[FORMAT_TIMESPAN_MAX];
1198 FDSet *fds = NULL;
1199 bool reexecute = false;
1200 const char *shutdown_verb = NULL;
1201 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1202 static char systemd[] = "systemd";
1203 bool skip_setup = false;
1204 int j;
1205 bool loaded_policy = false;
1206 bool arm_reboot_watchdog = false;
1207 bool queue_default_job = false;
1208 char *switch_root_dir = NULL, *switch_root_init = NULL;
1209
1210 #ifdef HAVE_SYSV_COMPAT
1211 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1212 /* This is compatibility support for SysV, where
1213 * calling init as a user is identical to telinit. */
1214
1215 errno = -ENOENT;
1216 execv(SYSTEMCTL_BINARY_PATH, argv);
1217 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1218 return 1;
1219 }
1220 #endif
1221
1222 /* Determine if this is a reexecution or normal bootup. We do
1223 * the full command line parsing much later, so let's just
1224 * have a quick peek here. */
1225 for (j = 1; j < argc; j++)
1226 if (streq(argv[j], "--deserialize")) {
1227 skip_setup = true;
1228 break;
1229 }
1230
1231 /* If we have switched root, do all the special setup
1232 * things */
1233 for (j = 1; j < argc; j++)
1234 if (streq(argv[j], "--switched-root")) {
1235 skip_setup = false;
1236 break;
1237 }
1238
1239 /* If we get started via the /sbin/init symlink then we are
1240 called 'init'. After a subsequent reexecution we are then
1241 called 'systemd'. That is confusing, hence let's call us
1242 systemd right-away. */
1243 program_invocation_short_name = systemd;
1244 prctl(PR_SET_NAME, systemd);
1245
1246 saved_argv = argv;
1247 saved_argc = argc;
1248
1249 log_show_color(isatty(STDERR_FILENO) > 0);
1250 log_show_location(false);
1251 log_set_max_level(LOG_INFO);
1252
1253 if (getpid() == 1) {
1254 if (in_initrd()) {
1255 char *rd_timestamp = NULL;
1256
1257 dual_timestamp_get(&initrd_timestamp);
1258 asprintf(&rd_timestamp, "%llu %llu",
1259 (unsigned long long) initrd_timestamp.realtime,
1260 (unsigned long long) initrd_timestamp.monotonic);
1261 if (rd_timestamp) {
1262 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1263 free(rd_timestamp);
1264 }
1265 }
1266
1267 arg_running_as = MANAGER_SYSTEM;
1268 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
1269
1270 if (!skip_setup) {
1271 if (selinux_setup(&loaded_policy) < 0)
1272 goto finish;
1273 if (ima_setup() < 0)
1274 goto finish;
1275 }
1276
1277 log_open();
1278
1279 if (label_init(NULL) < 0)
1280 goto finish;
1281
1282 if (!skip_setup)
1283 if (hwclock_is_localtime() > 0) {
1284 int min;
1285
1286 r = hwclock_apply_localtime_delta(&min);
1287 if (r < 0)
1288 log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1289 else
1290 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1291 }
1292
1293 } else {
1294 arg_running_as = MANAGER_USER;
1295 log_set_target(LOG_TARGET_AUTO);
1296 log_open();
1297 }
1298
1299 /* Initialize default unit */
1300 if (r == set_default_unit(SPECIAL_DEFAULT_TARGET) < 0) {
1301 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1302 goto finish;
1303 }
1304
1305 /* By default, mount "cpu" and "cpuacct" together */
1306 arg_join_controllers = new(char**, 2);
1307 if (!arg_join_controllers)
1308 goto finish;
1309
1310 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1311 arg_join_controllers[1] = NULL;
1312
1313 if (!arg_join_controllers[0])
1314 goto finish;
1315
1316 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1317 * /proc/$PID/fd is available. */
1318 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1319 r = mount_setup(loaded_policy);
1320 if (r < 0)
1321 goto finish;
1322 }
1323
1324 /* Reset all signal handlers. */
1325 assert_se(reset_all_signal_handlers() == 0);
1326
1327 /* If we are init, we can block sigkill. Yay. */
1328 ignore_signals(SIGNALS_IGNORE, -1);
1329
1330 if (parse_config_file() < 0)
1331 goto finish;
1332
1333 if (arg_running_as == MANAGER_SYSTEM)
1334 if (parse_proc_cmdline() < 0)
1335 goto finish;
1336
1337 log_parse_environment();
1338
1339 if (parse_argv(argc, argv) < 0)
1340 goto finish;
1341
1342 if (arg_action == ACTION_TEST && geteuid() == 0) {
1343 log_error("Don't run test mode as root.");
1344 goto finish;
1345 }
1346
1347 if (arg_running_as == MANAGER_SYSTEM &&
1348 arg_action == ACTION_RUN &&
1349 running_in_chroot() > 0) {
1350 log_error("Cannot be run in a chroot() environment.");
1351 goto finish;
1352 }
1353
1354 if (arg_action == ACTION_HELP) {
1355 retval = help();
1356 goto finish;
1357 } else if (arg_action == ACTION_VERSION) {
1358 retval = version();
1359 goto finish;
1360 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1361 unit_dump_config_items(stdout);
1362 retval = EXIT_SUCCESS;
1363 goto finish;
1364 } else if (arg_action == ACTION_DONE) {
1365 retval = EXIT_SUCCESS;
1366 goto finish;
1367 }
1368
1369 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1370
1371 /* Close logging fds, in order not to confuse fdset below */
1372 log_close();
1373
1374 /* Remember open file descriptors for later deserialization */
1375 if (serialization) {
1376 r = fdset_new_fill(&fds);
1377 if (r < 0) {
1378 log_error("Failed to allocate fd set: %s", strerror(-r));
1379 goto finish;
1380 }
1381
1382 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1383 } else
1384 close_all_fds(NULL, 0);
1385
1386 /* Set up PATH unless it is already set */
1387 setenv("PATH",
1388 #ifdef HAVE_SPLIT_USR
1389 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1390 #else
1391 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1392 #endif
1393 arg_running_as == MANAGER_SYSTEM);
1394
1395 if (arg_running_as == MANAGER_SYSTEM) {
1396 /* Parse the data passed to us. We leave this
1397 * variables set, but the manager later on will not
1398 * pass them on to our children. */
1399 if (!in_initrd())
1400 parse_initrd_timestamp(&initrd_timestamp);
1401
1402 /* Unset some environment variables passed in from the
1403 * kernel that don't really make sense for us. */
1404 unsetenv("HOME");
1405 unsetenv("TERM");
1406
1407 /* When we are invoked by a shell, these might be set,
1408 * but make little sense to pass on */
1409 unsetenv("PWD");
1410 unsetenv("SHLVL");
1411 unsetenv("_");
1412
1413 /* When we are invoked by a chroot-like tool such as
1414 * nspawn, these might be set, but make little sense
1415 * to pass on */
1416 unsetenv("USER");
1417 unsetenv("LOGNAME");
1418
1419 /* All other variables are left as is, so that clients
1420 * can still read them via /proc/1/environ */
1421 }
1422
1423 /* Move out of the way, so that we won't block unmounts */
1424 assert_se(chdir("/") == 0);
1425
1426 if (arg_running_as == MANAGER_SYSTEM) {
1427 /* Become a session leader if we aren't one yet. */
1428 setsid();
1429
1430 /* Disable the umask logic */
1431 umask(0);
1432 }
1433
1434 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1435 dbus_connection_set_change_sigpipe(FALSE);
1436
1437 /* Reset the console, but only if this is really init and we
1438 * are freshly booted */
1439 if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1440 console_setup(getpid() == 1 && !skip_setup);
1441 make_null_stdio();
1442 }
1443
1444 /* Open the logging devices, if possible and necessary */
1445 log_open();
1446
1447 /* Make sure we leave a core dump without panicing the
1448 * kernel. */
1449 if (getpid() == 1)
1450 install_crash_handler();
1451
1452 if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1453 r = mount_cgroup_controllers(arg_join_controllers);
1454 if (r < 0)
1455 goto finish;
1456 }
1457
1458 if (arg_running_as == MANAGER_SYSTEM) {
1459 const char *virtualization = NULL;
1460
1461 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1462
1463 detect_virtualization(&virtualization);
1464 if (virtualization)
1465 log_info("Detected virtualization '%s'.", virtualization);
1466
1467 if (in_initrd())
1468 log_info("Running in initial RAM disk.");
1469
1470 } else
1471 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1472
1473 if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1474 locale_setup();
1475
1476 if (arg_show_status || plymouth_running())
1477 status_welcome();
1478
1479 kmod_setup();
1480 hostname_setup();
1481 machine_id_setup();
1482 loopback_setup();
1483
1484 test_mtab();
1485 test_usr();
1486 test_cgroups();
1487 }
1488
1489 if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1490 watchdog_set_timeout(&arg_runtime_watchdog);
1491
1492 if (arg_timer_slack_nsec != (nsec_t) -1)
1493 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1494 log_error("Failed to adjust timer slack: %m");
1495
1496 if (arg_capability_bounding_set_drop) {
1497 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1498 if (r < 0) {
1499 log_error("Failed to drop capability bounding set: %s", strerror(-r));
1500 goto finish;
1501 }
1502 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1503 if (r < 0) {
1504 log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1505 goto finish;
1506 }
1507 }
1508
1509 if (arg_running_as == MANAGER_USER) {
1510 /* Become reaper of our children */
1511 r = prctl(PR_SET_CHILD_SUBREAPER, 1);
1512 if (r < 0)
1513 log_error("Failed to prctl(PR_SET_CHILD_SUBREAPER): %s", strerror(-r));
1514 if (r == -EINVAL)
1515 log_error("Perhaps the kernel version is too old (< 3.4?)");
1516 }
1517
1518 r = manager_new(arg_running_as, &m);
1519 if (r < 0) {
1520 log_error("Failed to allocate manager object: %s", strerror(-r));
1521 goto finish;
1522 }
1523
1524 m->confirm_spawn = arg_confirm_spawn;
1525 m->default_std_output = arg_default_std_output;
1526 m->default_std_error = arg_default_std_error;
1527 m->runtime_watchdog = arg_runtime_watchdog;
1528 m->shutdown_watchdog = arg_shutdown_watchdog;
1529
1530 manager_set_default_rlimits(m, arg_default_rlimit);
1531
1532 if (dual_timestamp_is_set(&initrd_timestamp))
1533 m->initrd_timestamp = initrd_timestamp;
1534
1535 if (arg_default_controllers)
1536 manager_set_default_controllers(m, arg_default_controllers);
1537
1538 manager_set_show_status(m, arg_show_status);
1539
1540 /* Remember whether we should queue the default job */
1541 queue_default_job = !serialization || arg_switched_root;
1542
1543 before_startup = now(CLOCK_MONOTONIC);
1544
1545 r = manager_startup(m, serialization, fds);
1546 if (r < 0)
1547 log_error("Failed to fully start up daemon: %s", strerror(-r));
1548
1549 /* This will close all file descriptors that were opened, but
1550 * not claimed by any unit. */
1551 if (fds) {
1552 fdset_free(fds);
1553 fds = NULL;
1554 }
1555
1556 if (serialization) {
1557 fclose(serialization);
1558 serialization = NULL;
1559 }
1560
1561 if (queue_default_job) {
1562 DBusError error;
1563 Unit *target = NULL;
1564 Job *default_unit_job;
1565
1566 dbus_error_init(&error);
1567
1568 log_debug("Activating default unit: %s", arg_default_unit);
1569
1570 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1571 if (r < 0) {
1572 log_error("Failed to load default target: %s", bus_error(&error, r));
1573 dbus_error_free(&error);
1574 } else if (target->load_state == UNIT_ERROR)
1575 log_error("Failed to load default target: %s", strerror(-target->load_error));
1576 else if (target->load_state == UNIT_MASKED)
1577 log_error("Default target masked.");
1578
1579 if (!target || target->load_state != UNIT_LOADED) {
1580 log_info("Trying to load rescue target...");
1581
1582 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1583 if (r < 0) {
1584 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1585 dbus_error_free(&error);
1586 goto finish;
1587 } else if (target->load_state == UNIT_ERROR) {
1588 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1589 goto finish;
1590 } else if (target->load_state == UNIT_MASKED) {
1591 log_error("Rescue target masked.");
1592 goto finish;
1593 }
1594 }
1595
1596 assert(target->load_state == UNIT_LOADED);
1597
1598 if (arg_action == ACTION_TEST) {
1599 printf("-> By units:\n");
1600 manager_dump_units(m, stdout, "\t");
1601 }
1602
1603 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1604 if (r < 0) {
1605 log_error("Failed to start default target: %s", bus_error(&error, r));
1606 dbus_error_free(&error);
1607 goto finish;
1608 }
1609 m->default_unit_job_id = default_unit_job->id;
1610
1611 after_startup = now(CLOCK_MONOTONIC);
1612 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1613 "Loaded units and determined initial transaction in %s.",
1614 format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1615
1616 if (arg_action == ACTION_TEST) {
1617 printf("-> By jobs:\n");
1618 manager_dump_jobs(m, stdout, "\t");
1619 retval = EXIT_SUCCESS;
1620 goto finish;
1621 }
1622 }
1623
1624 for (;;) {
1625 r = manager_loop(m);
1626 if (r < 0) {
1627 log_error("Failed to run mainloop: %s", strerror(-r));
1628 goto finish;
1629 }
1630
1631 switch (m->exit_code) {
1632
1633 case MANAGER_EXIT:
1634 retval = EXIT_SUCCESS;
1635 log_debug("Exit.");
1636 goto finish;
1637
1638 case MANAGER_RELOAD:
1639 log_info("Reloading.");
1640 r = manager_reload(m);
1641 if (r < 0)
1642 log_error("Failed to reload: %s", strerror(-r));
1643 break;
1644
1645 case MANAGER_REEXECUTE:
1646
1647 if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1648 goto finish;
1649
1650 reexecute = true;
1651 log_notice("Reexecuting.");
1652 goto finish;
1653
1654 case MANAGER_SWITCH_ROOT:
1655 /* Steal the switch root parameters */
1656 switch_root_dir = m->switch_root;
1657 switch_root_init = m->switch_root_init;
1658 m->switch_root = m->switch_root_init = NULL;
1659
1660 if (!switch_root_init)
1661 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1662 goto finish;
1663
1664 reexecute = true;
1665 log_notice("Switching root.");
1666 goto finish;
1667
1668 case MANAGER_REBOOT:
1669 case MANAGER_POWEROFF:
1670 case MANAGER_HALT:
1671 case MANAGER_KEXEC: {
1672 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1673 [MANAGER_REBOOT] = "reboot",
1674 [MANAGER_POWEROFF] = "poweroff",
1675 [MANAGER_HALT] = "halt",
1676 [MANAGER_KEXEC] = "kexec"
1677 };
1678
1679 assert_se(shutdown_verb = table[m->exit_code]);
1680 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1681
1682 log_notice("Shutting down.");
1683 goto finish;
1684 }
1685
1686 default:
1687 assert_not_reached("Unknown exit code.");
1688 }
1689 }
1690
1691 finish:
1692 if (m)
1693 manager_free(m);
1694
1695 for (j = 0; j < RLIMIT_NLIMITS; j++)
1696 free (arg_default_rlimit[j]);
1697
1698 free(arg_default_unit);
1699 strv_free(arg_default_controllers);
1700 free_join_controllers();
1701
1702 dbus_shutdown();
1703 label_finish();
1704
1705 if (reexecute) {
1706 const char **args;
1707 unsigned i, args_size;
1708
1709 /* Close and disarm the watchdog, so that the new
1710 * instance can reinitialize it, but doesn't get
1711 * rebooted while we do that */
1712 watchdog_close(true);
1713
1714 if (switch_root_dir) {
1715 /* Kill all remaining processes from the
1716 * initrd, but don't wait for them, so that we
1717 * can handle the SIGCHLD for them after
1718 * deserializing. */
1719 broadcast_signal(SIGTERM, false);
1720
1721 /* And switch root */
1722 r = switch_root(switch_root_dir);
1723 if (r < 0)
1724 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1725 }
1726
1727 args_size = MAX(6, argc+1);
1728 args = newa(const char*, args_size);
1729
1730 if (!switch_root_init) {
1731 char sfd[16];
1732
1733 /* First try to spawn ourselves with the right
1734 * path, and with full serialization. We do
1735 * this only if the user didn't specify an
1736 * explicit init to spawn. */
1737
1738 assert(serialization);
1739 assert(fds);
1740
1741 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1742 char_array_0(sfd);
1743
1744 i = 0;
1745 args[i++] = SYSTEMD_BINARY_PATH;
1746 if (switch_root_dir)
1747 args[i++] = "--switched-root";
1748 args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1749 args[i++] = "--deserialize";
1750 args[i++] = sfd;
1751 args[i++] = NULL;
1752
1753 assert(i <= args_size);
1754 execv(args[0], (char* const*) args);
1755 }
1756
1757 /* Try the fallback, if there is any, without any
1758 * serialization. We pass the original argv[] and
1759 * envp[]. (Well, modulo the ordering changes due to
1760 * getopt() in argv[], and some cleanups in envp[],
1761 * but let's hope that doesn't matter.) */
1762
1763 if (serialization) {
1764 fclose(serialization);
1765 serialization = NULL;
1766 }
1767
1768 if (fds) {
1769 fdset_free(fds);
1770 fds = NULL;
1771 }
1772
1773 /* Reopen the console */
1774 make_console_stdio();
1775
1776 for (j = 1, i = 1; j < argc; j++)
1777 args[i++] = argv[j];
1778 args[i++] = NULL;
1779 assert(i <= args_size);
1780
1781 if (switch_root_init) {
1782 args[0] = switch_root_init;
1783 execv(args[0], (char* const*) args);
1784 log_warning("Failed to execute configured init, trying fallback: %m");
1785 }
1786
1787 args[0] = "/sbin/init";
1788 execv(args[0], (char* const*) args);
1789
1790 if (errno == ENOENT) {
1791 log_warning("No /sbin/init, trying fallback");
1792
1793 args[0] = "/bin/sh";
1794 args[1] = NULL;
1795 execv(args[0], (char* const*) args);
1796 log_error("Failed to execute /bin/sh, giving up: %m");
1797 } else
1798 log_warning("Failed to execute /sbin/init, giving up: %m");
1799 }
1800
1801 if (serialization)
1802 fclose(serialization);
1803
1804 if (fds)
1805 fdset_free(fds);
1806
1807 if (shutdown_verb) {
1808 const char * command_line[] = {
1809 SYSTEMD_SHUTDOWN_BINARY_PATH,
1810 shutdown_verb,
1811 NULL
1812 };
1813 char **env_block;
1814
1815 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1816 char e[32];
1817
1818 /* If we reboot let's set the shutdown
1819 * watchdog and tell the shutdown binary to
1820 * repeatedly ping it */
1821 watchdog_set_timeout(&arg_shutdown_watchdog);
1822 watchdog_close(false);
1823
1824 /* Tell the binary how often to ping */
1825 snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1826 char_array_0(e);
1827
1828 env_block = strv_append(environ, e);
1829 } else {
1830 env_block = strv_copy(environ);
1831 watchdog_close(true);
1832 }
1833
1834 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1835 free(env_block);
1836 log_error("Failed to execute shutdown binary, freezing: %m");
1837 }
1838
1839 if (getpid() == 1)
1840 freeze();
1841
1842 return retval;
1843 }
Unnamed repository; edit this file 'description' to name the repository.