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