chiark / gitweb /
7b5c86161fe512525c5e947faf34c936b5c954d1
[elogind.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**, 3);
1309         if (!arg_join_controllers)
1310                 goto finish;
1311
1312         arg_join_controllers[0] = strv_new("cpu", "cpuacct", "cpuset", NULL);
1313         arg_join_controllers[1] = strv_new("net_cls", "netprio", NULL);
1314         arg_join_controllers[2] = NULL;
1315
1316         if (!arg_join_controllers[0])
1317                 goto finish;
1318
1319         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1320          * /proc/$PID/fd is available. */
1321         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1322                 r = mount_setup(loaded_policy);
1323                 if (r < 0)
1324                         goto finish;
1325         }
1326
1327         /* Reset all signal handlers. */
1328         assert_se(reset_all_signal_handlers() == 0);
1329
1330         /* If we are init, we can block sigkill. Yay. */
1331         ignore_signals(SIGNALS_IGNORE, -1);
1332
1333         if (parse_config_file() < 0)
1334                 goto finish;
1335
1336         if (arg_running_as == MANAGER_SYSTEM)
1337                 if (parse_proc_cmdline() < 0)
1338                         goto finish;
1339
1340         log_parse_environment();
1341
1342         if (parse_argv(argc, argv) < 0)
1343                 goto finish;
1344
1345         if (arg_action == ACTION_TEST && geteuid() == 0) {
1346                 log_error("Don't run test mode as root.");
1347                 goto finish;
1348         }
1349
1350         if (arg_running_as == MANAGER_SYSTEM &&
1351             arg_action == ACTION_RUN &&
1352             running_in_chroot() > 0) {
1353                 log_error("Cannot be run in a chroot() environment.");
1354                 goto finish;
1355         }
1356
1357         if (arg_action == ACTION_HELP) {
1358                 retval = help();
1359                 goto finish;
1360         } else if (arg_action == ACTION_VERSION) {
1361                 retval = version();
1362                 goto finish;
1363         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1364                 unit_dump_config_items(stdout);
1365                 retval = EXIT_SUCCESS;
1366                 goto finish;
1367         } else if (arg_action == ACTION_DONE) {
1368                 retval = EXIT_SUCCESS;
1369                 goto finish;
1370         }
1371
1372         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1373
1374         /* Close logging fds, in order not to confuse fdset below */
1375         log_close();
1376
1377         /* Remember open file descriptors for later deserialization */
1378         if (serialization) {
1379                 r = fdset_new_fill(&fds);
1380                 if (r < 0) {
1381                         log_error("Failed to allocate fd set: %s", strerror(-r));
1382                         goto finish;
1383                 }
1384
1385                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1386         } else
1387                 close_all_fds(NULL, 0);
1388
1389         /* Set up PATH unless it is already set */
1390         setenv("PATH",
1391 #ifdef HAVE_SPLIT_USR
1392                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1393 #else
1394                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1395 #endif
1396                arg_running_as == MANAGER_SYSTEM);
1397
1398         if (arg_running_as == MANAGER_SYSTEM) {
1399                 /* Parse the data passed to us. We leave this
1400                  * variables set, but the manager later on will not
1401                  * pass them on to our children. */
1402                 if (!in_initrd())
1403                         parse_initrd_timestamp(&initrd_timestamp);
1404
1405                 /* Unset some environment variables passed in from the
1406                  * kernel that don't really make sense for us. */
1407                 unsetenv("HOME");
1408                 unsetenv("TERM");
1409
1410                 /* When we are invoked by a shell, these might be set,
1411                  * but make little sense to pass on */
1412                 unsetenv("PWD");
1413                 unsetenv("SHLVL");
1414                 unsetenv("_");
1415
1416                 /* When we are invoked by a chroot-like tool such as
1417                  * nspawn, these might be set, but make little sense
1418                  * to pass on */
1419                 unsetenv("USER");
1420                 unsetenv("LOGNAME");
1421
1422                 /* All other variables are left as is, so that clients
1423                  * can still read them via /proc/1/environ */
1424         }
1425
1426         /* Move out of the way, so that we won't block unmounts */
1427         assert_se(chdir("/")  == 0);
1428
1429         if (arg_running_as == MANAGER_SYSTEM) {
1430                 /* Become a session leader if we aren't one yet. */
1431                 setsid();
1432
1433                 /* Disable the umask logic */
1434                 umask(0);
1435         }
1436
1437         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1438         dbus_connection_set_change_sigpipe(FALSE);
1439
1440         /* Reset the console, but only if this is really init and we
1441          * are freshly booted */
1442         if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1443                 console_setup(getpid() == 1 && !skip_setup);
1444                 make_null_stdio();
1445         }
1446
1447         /* Open the logging devices, if possible and necessary */
1448         log_open();
1449
1450         /* Make sure we leave a core dump without panicing the
1451          * kernel. */
1452         if (getpid() == 1)
1453                 install_crash_handler();
1454
1455         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1456                 r = mount_cgroup_controllers(arg_join_controllers);
1457                 if (r < 0)
1458                         goto finish;
1459         }
1460
1461         if (arg_running_as == MANAGER_SYSTEM) {
1462                 const char *virtualization = NULL;
1463
1464                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1465
1466                 detect_virtualization(&virtualization);
1467                 if (virtualization)
1468                         log_info("Detected virtualization '%s'.", virtualization);
1469
1470                 if (in_initrd())
1471                         log_info("Running in initial RAM disk.");
1472
1473         } else
1474                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1475
1476         if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1477                 locale_setup();
1478
1479                 if (arg_show_status || plymouth_running())
1480                         status_welcome();
1481
1482                 kmod_setup();
1483                 hostname_setup();
1484                 machine_id_setup();
1485                 loopback_setup();
1486
1487                 test_mtab();
1488                 test_usr();
1489                 test_cgroups();
1490         }
1491
1492         if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1493                 watchdog_set_timeout(&arg_runtime_watchdog);
1494
1495         if (arg_timer_slack_nsec != (nsec_t) -1)
1496                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1497                         log_error("Failed to adjust timer slack: %m");
1498
1499         if (arg_capability_bounding_set_drop) {
1500                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1501                 if (r < 0) {
1502                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1503                         goto finish;
1504                 }
1505                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1506                 if (r < 0) {
1507                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1508                         goto finish;
1509                 }
1510         }
1511
1512         if (arg_running_as == MANAGER_USER) {
1513                 /* Become reaper of our children */
1514                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1515                         log_warning("Failed to make us a subreaper: %m");
1516                         if (errno == EINVAL)
1517                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1518                 }
1519         }
1520
1521         r = manager_new(arg_running_as, &m);
1522         if (r < 0) {
1523                 log_error("Failed to allocate manager object: %s", strerror(-r));
1524                 goto finish;
1525         }
1526
1527         m->confirm_spawn = arg_confirm_spawn;
1528         m->default_std_output = arg_default_std_output;
1529         m->default_std_error = arg_default_std_error;
1530         m->runtime_watchdog = arg_runtime_watchdog;
1531         m->shutdown_watchdog = arg_shutdown_watchdog;
1532
1533         manager_set_default_rlimits(m, arg_default_rlimit);
1534
1535         if (dual_timestamp_is_set(&initrd_timestamp))
1536                 m->initrd_timestamp = initrd_timestamp;
1537
1538         if (arg_default_controllers)
1539                 manager_set_default_controllers(m, arg_default_controllers);
1540
1541         manager_set_show_status(m, arg_show_status);
1542
1543         /* Remember whether we should queue the default job */
1544         queue_default_job = !serialization || arg_switched_root;
1545
1546         before_startup = now(CLOCK_MONOTONIC);
1547
1548         r = manager_startup(m, serialization, fds);
1549         if (r < 0)
1550                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1551
1552         /* This will close all file descriptors that were opened, but
1553          * not claimed by any unit. */
1554         if (fds) {
1555                 fdset_free(fds);
1556                 fds = NULL;
1557         }
1558
1559         if (serialization) {
1560                 fclose(serialization);
1561                 serialization = NULL;
1562         }
1563
1564         if (queue_default_job) {
1565                 DBusError error;
1566                 Unit *target = NULL;
1567                 Job *default_unit_job;
1568
1569                 dbus_error_init(&error);
1570
1571                 log_debug("Activating default unit: %s", arg_default_unit);
1572
1573                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1574                 if (r < 0) {
1575                         log_error("Failed to load default target: %s", bus_error(&error, r));
1576                         dbus_error_free(&error);
1577                 } else if (target->load_state == UNIT_ERROR)
1578                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1579                 else if (target->load_state == UNIT_MASKED)
1580                         log_error("Default target masked.");
1581
1582                 if (!target || target->load_state != UNIT_LOADED) {
1583                         log_info("Trying to load rescue target...");
1584
1585                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1586                         if (r < 0) {
1587                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1588                                 dbus_error_free(&error);
1589                                 goto finish;
1590                         } else if (target->load_state == UNIT_ERROR) {
1591                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1592                                 goto finish;
1593                         } else if (target->load_state == UNIT_MASKED) {
1594                                 log_error("Rescue target masked.");
1595                                 goto finish;
1596                         }
1597                 }
1598
1599                 assert(target->load_state == UNIT_LOADED);
1600
1601                 if (arg_action == ACTION_TEST) {
1602                         printf("-> By units:\n");
1603                         manager_dump_units(m, stdout, "\t");
1604                 }
1605
1606                 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1607                 if (r < 0) {
1608                         log_error("Failed to start default target: %s", bus_error(&error, r));
1609                         dbus_error_free(&error);
1610                         goto finish;
1611                 }
1612                 m->default_unit_job_id = default_unit_job->id;
1613
1614                 after_startup = now(CLOCK_MONOTONIC);
1615                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1616                          "Loaded units and determined initial transaction in %s.",
1617                           format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1618
1619                 if (arg_action == ACTION_TEST) {
1620                         printf("-> By jobs:\n");
1621                         manager_dump_jobs(m, stdout, "\t");
1622                         retval = EXIT_SUCCESS;
1623                         goto finish;
1624                 }
1625         }
1626
1627         for (;;) {
1628                 r = manager_loop(m);
1629                 if (r < 0) {
1630                         log_error("Failed to run mainloop: %s", strerror(-r));
1631                         goto finish;
1632                 }
1633
1634                 switch (m->exit_code) {
1635
1636                 case MANAGER_EXIT:
1637                         retval = EXIT_SUCCESS;
1638                         log_debug("Exit.");
1639                         goto finish;
1640
1641                 case MANAGER_RELOAD:
1642                         log_info("Reloading.");
1643                         r = manager_reload(m);
1644                         if (r < 0)
1645                                 log_error("Failed to reload: %s", strerror(-r));
1646                         break;
1647
1648                 case MANAGER_REEXECUTE:
1649
1650                         if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1651                                 goto finish;
1652
1653                         reexecute = true;
1654                         log_notice("Reexecuting.");
1655                         goto finish;
1656
1657                 case MANAGER_SWITCH_ROOT:
1658                         /* Steal the switch root parameters */
1659                         switch_root_dir = m->switch_root;
1660                         switch_root_init = m->switch_root_init;
1661                         m->switch_root = m->switch_root_init = NULL;
1662
1663                         if (!switch_root_init)
1664                                 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1665                                         goto finish;
1666
1667                         reexecute = true;
1668                         log_notice("Switching root.");
1669                         goto finish;
1670
1671                 case MANAGER_REBOOT:
1672                 case MANAGER_POWEROFF:
1673                 case MANAGER_HALT:
1674                 case MANAGER_KEXEC: {
1675                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1676                                 [MANAGER_REBOOT] = "reboot",
1677                                 [MANAGER_POWEROFF] = "poweroff",
1678                                 [MANAGER_HALT] = "halt",
1679                                 [MANAGER_KEXEC] = "kexec"
1680                         };
1681
1682                         assert_se(shutdown_verb = table[m->exit_code]);
1683                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1684
1685                         log_notice("Shutting down.");
1686                         goto finish;
1687                 }
1688
1689                 default:
1690                         assert_not_reached("Unknown exit code.");
1691                 }
1692         }
1693
1694 finish:
1695         if (m)
1696                 manager_free(m);
1697
1698         for (j = 0; j < RLIMIT_NLIMITS; j++)
1699                 free (arg_default_rlimit[j]);
1700
1701         free(arg_default_unit);
1702         strv_free(arg_default_controllers);
1703         free_join_controllers();
1704
1705         dbus_shutdown();
1706         label_finish();
1707
1708         if (reexecute) {
1709                 const char **args;
1710                 unsigned i, args_size;
1711
1712                 /* Close and disarm the watchdog, so that the new
1713                  * instance can reinitialize it, but doesn't get
1714                  * rebooted while we do that */
1715                 watchdog_close(true);
1716
1717                 if (switch_root_dir) {
1718                         /* Kill all remaining processes from the
1719                          * initrd, but don't wait for them, so that we
1720                          * can handle the SIGCHLD for them after
1721                          * deserializing. */
1722                         broadcast_signal(SIGTERM, false);
1723
1724                         /* And switch root */
1725                         r = switch_root(switch_root_dir);
1726                         if (r < 0)
1727                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1728                 }
1729
1730                 args_size = MAX(6, argc+1);
1731                 args = newa(const char*, args_size);
1732
1733                 if (!switch_root_init) {
1734                         char sfd[16];
1735
1736                         /* First try to spawn ourselves with the right
1737                          * path, and with full serialization. We do
1738                          * this only if the user didn't specify an
1739                          * explicit init to spawn. */
1740
1741                         assert(serialization);
1742                         assert(fds);
1743
1744                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1745                         char_array_0(sfd);
1746
1747                         i = 0;
1748                         args[i++] = SYSTEMD_BINARY_PATH;
1749                         if (switch_root_dir)
1750                                 args[i++] = "--switched-root";
1751                         args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1752                         args[i++] = "--deserialize";
1753                         args[i++] = sfd;
1754                         args[i++] = NULL;
1755
1756                         assert(i <= args_size);
1757                         execv(args[0], (char* const*) args);
1758                 }
1759
1760                 /* Try the fallback, if there is any, without any
1761                  * serialization. We pass the original argv[] and
1762                  * envp[]. (Well, modulo the ordering changes due to
1763                  * getopt() in argv[], and some cleanups in envp[],
1764                  * but let's hope that doesn't matter.) */
1765
1766                 if (serialization) {
1767                         fclose(serialization);
1768                         serialization = NULL;
1769                 }
1770
1771                 if (fds) {
1772                         fdset_free(fds);
1773                         fds = NULL;
1774                 }
1775
1776                 /* Reopen the console */
1777                 make_console_stdio();
1778
1779                 for (j = 1, i = 1; j < argc; j++)
1780                         args[i++] = argv[j];
1781                 args[i++] = NULL;
1782                 assert(i <= args_size);
1783
1784                 if (switch_root_init) {
1785                         args[0] = switch_root_init;
1786                         execv(args[0], (char* const*) args);
1787                         log_warning("Failed to execute configured init, trying fallback: %m");
1788                 }
1789
1790                 args[0] = "/sbin/init";
1791                 execv(args[0], (char* const*) args);
1792
1793                 if (errno == ENOENT) {
1794                         log_warning("No /sbin/init, trying fallback");
1795
1796                         args[0] = "/bin/sh";
1797                         args[1] = NULL;
1798                         execv(args[0], (char* const*) args);
1799                         log_error("Failed to execute /bin/sh, giving up: %m");
1800                 } else
1801                         log_warning("Failed to execute /sbin/init, giving up: %m");
1802         }
1803
1804         if (serialization)
1805                 fclose(serialization);
1806
1807         if (fds)
1808                 fdset_free(fds);
1809
1810         if (shutdown_verb) {
1811                 const char * command_line[] = {
1812                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1813                         shutdown_verb,
1814                         NULL
1815                 };
1816                 char **env_block;
1817
1818                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1819                         char e[32];
1820
1821                         /* If we reboot let's set the shutdown
1822                          * watchdog and tell the shutdown binary to
1823                          * repeatedly ping it */
1824                         watchdog_set_timeout(&arg_shutdown_watchdog);
1825                         watchdog_close(false);
1826
1827                         /* Tell the binary how often to ping */
1828                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1829                         char_array_0(e);
1830
1831                         env_block = strv_append(environ, e);
1832                 } else {
1833                         env_block = strv_copy(environ);
1834                         watchdog_close(true);
1835                 }
1836
1837                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1838                 free(env_block);
1839                 log_error("Failed to execute shutdown binary, freezing: %m");
1840         }
1841
1842         if (getpid() == 1)
1843                 freeze();
1844
1845         return retval;
1846 }