]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/main.c
projects / thirdparty / systemd.git / blob
? search:


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