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