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