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