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