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 "clock-util.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_MAX] = {};
 109 static uint64_t arg_capability_bounding_set_drop = 0;
 110 static nsec_t arg_timer_slack_nsec = (nsec_t) -1;
 111 static usec_t arg_default_timer_accuracy_usec = 1 * USEC_PER_MINUTE;
 112 static Set* arg_syscall_archs = NULL;
 113 static FILE* arg_serialization = NULL;
 114 static bool arg_default_cpu_accounting = false;
 115 static bool arg_default_blockio_accounting = false;
 116 static bool arg_default_memory_accounting = false;
 117
 118 static void nop_handler(int sig) {}
 119
 120 noreturn static void crash(int sig) {
 121
 122         if (getpid() != 1)
 123                 /* Pass this on immediately, if this is not PID 1 */
 124                 raise(sig);
 125         else if (!arg_dump_core)
 126                 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
 127         else {
 128                 struct sigaction sa = {
 129                         .sa_handler = nop_handler,
 130                         .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 131                 };
 132                 pid_t pid;
 133
 134                 /* We want to wait for the core process, hence let's enable SIGCHLD */
 135                 sigaction(SIGCHLD, &sa, NULL);
 136
 137                 pid = fork();
 138                 if (pid < 0)
 139                         log_error("Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
 140
 141                 else if (pid == 0) {
 142                         struct rlimit rl = {};
 143
 144                         /* Enable default signal handler for core dump */
 145                         zero(sa);
 146                         sa.sa_handler = SIG_DFL;
 147                         sigaction(sig, &sa, NULL);
 148
 149                         /* Don't limit the core dump size */
 150                         rl.rlim_cur = RLIM_INFINITY;
 151                         rl.rlim_max = RLIM_INFINITY;
 152                         setrlimit(RLIMIT_CORE, &rl);
 153
 154                         /* Just to be sure... */
 155                         chdir("/");
 156
 157                         /* Raise the signal again */
 158                         raise(sig);
 159
 160                         assert_not_reached("We shouldn't be here...");
 161                         _exit(1);
 162
 163                 } else {
 164                         siginfo_t status;
 165                         int r;
 166
 167                         /* Order things nicely. */
 168                         r = wait_for_terminate(pid, &status);
 169                         if (r < 0)
 170                                 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
 171                         else if (status.si_code != CLD_DUMPED)
 172                                 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
 173                         else
 174                                 log_error("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
 175                 }
 176         }
 177
 178         if (arg_crash_chvt)
 179                 chvt(arg_crash_chvt);
 180
 181         if (arg_crash_shell) {
 182                 struct sigaction sa = {
 183                         .sa_handler = SIG_IGN,
 184                         .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
 185                 };
 186                 pid_t pid;
 187
 188                 log_info("Executing crash shell in 10s...");
 189                 sleep(10);
 190
 191                 /* Let the kernel reap children for us */
 192                 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 193
 194                 pid = fork();
 195                 if (pid < 0)
 196                         log_error("Failed to fork off crash shell: %m");
 197                 else if (pid == 0) {
 198                         make_console_stdio();
 199                         execl("/bin/sh", "/bin/sh", NULL);
 200
 201                         log_error("execl() failed: %m");
 202                         _exit(1);
 203                 }
 204
 205                 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
 206         }
 207
 208         log_info("Freezing execution.");
 209         freeze();
 210 }
 211
 212 static void install_crash_handler(void) {
 213         struct sigaction sa = {
 214                 .sa_handler = crash,
 215                 .sa_flags = SA_NODEFER,
 216         };
 217
 218         sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
 219 }
 220
 221 static int console_setup(bool do_reset) {
 222         int tty_fd, r;
 223
 224         /* If we are init, we connect stdin/stdout/stderr to /dev/null
 225          * and make sure we don't have a controlling tty. */
 226
 227         release_terminal();
 228
 229         if (!do_reset)
 230                 return 0;
 231
 232         tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
 233         if (tty_fd < 0) {
 234                 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
 235                 return -tty_fd;
 236         }
 237
 238         /* We don't want to force text mode.
 239          * plymouth may be showing pictures already from initrd. */
 240         r = reset_terminal_fd(tty_fd, false);
 241         if (r < 0)
 242                 log_error("Failed to reset /dev/console: %s", strerror(-r));
 243
 244         safe_close(tty_fd);
 245         return r;
 246 }
 247
 248 static int set_default_unit(const char *u) {
 249         char *c;
 250
 251         assert(u);
 252
 253         c = strdup(u);
 254         if (!c)
 255                 return -ENOMEM;
 256
 257         free(arg_default_unit);
 258         arg_default_unit = c;
 259
 260         return 0;
 261 }
 262
 263 static int parse_proc_cmdline_item(const char *key, const char *value) {
 264
 265         static const char * const rlmap[] = {
 266                 "emergency", SPECIAL_EMERGENCY_TARGET,
 267                 "-b",        SPECIAL_EMERGENCY_TARGET,
 268                 "single",    SPECIAL_RESCUE_TARGET,
 269                 "-s",        SPECIAL_RESCUE_TARGET,
 270                 "s",         SPECIAL_RESCUE_TARGET,
 271                 "S",         SPECIAL_RESCUE_TARGET,
 272                 "1",         SPECIAL_RESCUE_TARGET,
 273                 "2",         SPECIAL_RUNLEVEL2_TARGET,
 274                 "3",         SPECIAL_RUNLEVEL3_TARGET,
 275                 "4",         SPECIAL_RUNLEVEL4_TARGET,
 276                 "5",         SPECIAL_RUNLEVEL5_TARGET,
 277         };
 278         int r;
 279
 280         assert(key);
 281
 282         if (streq(key, "systemd.unit") && value) {
 283
 284                 if (!in_initrd())
 285                         return set_default_unit(value);
 286
 287         } else if (streq(key, "rd.systemd.unit") && value) {
 288
 289                 if (in_initrd())
 290                         return set_default_unit(value);
 291
 292         } else if (streq(key, "systemd.log_target") && value) {
 293
 294                 if (log_set_target_from_string(value) < 0)
 295                         log_warning("Failed to parse log target %s. Ignoring.", value);
 296
 297         } else if (streq(key, "systemd.log_level") && value) {
 298
 299                 if (log_set_max_level_from_string(value) < 0)
 300                         log_warning("Failed to parse log level %s. Ignoring.", value);
 301
 302         } else if (streq(key, "systemd.log_color") && value) {
 303
 304                 if (log_show_color_from_string(value) < 0)
 305                         log_warning("Failed to parse log color setting %s. Ignoring.", value);
 306
 307         } else if (streq(key, "systemd.log_location") && value) {
 308
 309                 if (log_show_location_from_string(value) < 0)
 310                         log_warning("Failed to parse log location setting %s. Ignoring.", value);
 311
 312         } else if (streq(key, "systemd.dump_core") && value) {
 313
 314                 r = parse_boolean(value);
 315                 if (r < 0)
 316                         log_warning("Failed to parse dump core switch %s. Ignoring.", value);
 317                 else
 318                         arg_dump_core = r;
 319
 320         } else if (streq(key, "systemd.crash_shell") && value) {
 321
 322                 r = parse_boolean(value);
 323                 if (r < 0)
 324                         log_warning("Failed to parse crash shell switch %s. Ignoring.", value);
 325                 else
 326                         arg_crash_shell = r;
 327
 328         } else if (streq(key, "systemd.crash_chvt") && value) {
 329
 330                 if (safe_atoi(value, &r) < 0)
 331                         log_warning("Failed to parse crash chvt switch %s. Ignoring.", value);
 332                 else
 333                         arg_crash_chvt = r;
 334
 335         } else if (streq(key, "systemd.confirm_spawn") && value) {
 336
 337                 r = parse_boolean(value);
 338                 if (r < 0)
 339                         log_warning("Failed to parse confirm spawn switch %s. Ignoring.", value);
 340                 else
 341                         arg_confirm_spawn = r;
 342
 343         } else if (streq(key, "systemd.show_status") && value) {
 344
 345                 r = parse_show_status(value, &arg_show_status);
 346                 if (r < 0)
 347                         log_warning("Failed to parse show status switch %s. Ignoring.", value);
 348
 349         } else if (streq(key, "systemd.default_standard_output") && value) {
 350
 351                 r = exec_output_from_string(value);
 352                 if (r < 0)
 353                         log_warning("Failed to parse default standard output switch %s. Ignoring.", value);
 354                 else
 355                         arg_default_std_output = r;
 356
 357         } else if (streq(key, "systemd.default_standard_error") && value) {
 358
 359                 r = exec_output_from_string(value);
 360                 if (r < 0)
 361                         log_warning("Failed to parse default standard error switch %s. Ignoring.", value);
 362                 else
 363                         arg_default_std_error = r;
 364
 365         } else if (streq(key, "systemd.setenv") && value) {
 366
 367                 if (env_assignment_is_valid(value)) {
 368                         char **env;
 369
 370                         env = strv_env_set(arg_default_environment, value);
 371                         if (env)
 372                                 arg_default_environment = env;
 373                         else
 374                                 log_warning("Setting environment variable '%s' failed, ignoring: %s", value, strerror(ENOMEM));
 375                 } else
 376                         log_warning("Environment variable name '%s' is not valid. Ignoring.", value);
 377
 378         } else if (streq(key, "quiet") && !value) {
 379
 380                 log_set_max_level(LOG_NOTICE);
 381
 382                 if (arg_show_status == _SHOW_STATUS_UNSET)
 383                         arg_show_status = SHOW_STATUS_AUTO;
 384
 385         } else if (streq(key, "debug") && !value) {
 386
 387                 log_set_max_level(LOG_DEBUG);
 388
 389                 if (detect_container(NULL) > 0)
 390                         log_set_target(LOG_TARGET_CONSOLE);
 391
 392         } else if (!in_initrd() && !value) {
 393                 unsigned i;
 394
 395                 /* SysV compatibility */
 396                 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
 397                         if (streq(key, rlmap[i]))
 398                                 return set_default_unit(rlmap[i+1]);
 399         }
 400
 401         return 0;
 402 }
 403
 404 #define DEFINE_SETTER(name, func, descr)                              \
 405         static int name(const char *unit,                             \
 406                         const char *filename,                         \
 407                         unsigned line,                                \
 408                         const char *section,                          \
 409                         unsigned section_line,                        \
 410                         const char *lvalue,                           \
 411                         int ltype,                                    \
 412                         const char *rvalue,                           \
 413                         void *data,                                   \
 414                         void *userdata) {                             \
 415                                                                       \
 416                 int r;                                                \
 417                                                                       \
 418                 assert(filename);                                     \
 419                 assert(lvalue);                                       \
 420                 assert(rvalue);                                       \
 421                                                                       \
 422                 r = func(rvalue);                                     \
 423                 if (r < 0)                                            \
 424                         log_syntax(unit, LOG_ERR, filename, line, -r, \
 425                                    "Invalid " descr "'%s': %s",       \
 426                                    rvalue, strerror(-r));             \
 427                                                                       \
 428                 return 0;                                             \
 429         }
 430
 431 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
 432 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
 433 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
 434 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
 435
 436 static int config_parse_cpu_affinity2(
 437                 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         char *w;
 449         size_t l;
 450         char *state;
 451         cpu_set_t *c = NULL;
 452         unsigned ncpus = 0;
 453
 454         assert(filename);
 455         assert(lvalue);
 456         assert(rvalue);
 457
 458         FOREACH_WORD_QUOTED(w, l, rvalue, state) {
 459                 char *t;
 460                 int r;
 461                 unsigned cpu;
 462
 463                 if (!(t = strndup(w, l)))
 464                         return log_oom();
 465
 466                 r = safe_atou(t, &cpu);
 467                 free(t);
 468
 469                 if (!c)
 470                         if (!(c = cpu_set_malloc(&ncpus)))
 471                                 return log_oom();
 472
 473                 if (r < 0 || cpu >= ncpus) {
 474                         log_syntax(unit, LOG_ERR, filename, line, -r,
 475                                    "Failed to parse CPU affinity '%s'", rvalue);
 476                         CPU_FREE(c);
 477                         return -EBADMSG;
 478                 }
 479
 480                 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
 481         }
 482
 483         if (c) {
 484                 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
 485                         log_warning_unit(unit, "Failed to set CPU affinity: %m");
 486
 487                 CPU_FREE(c);
 488         }
 489
 490         return 0;
 491 }
 492
 493 static int config_parse_show_status(
 494                 const char* unit,
 495                 const char *filename,
 496                 unsigned line,
 497                 const char *section,
 498                 unsigned section_line,
 499                 const char *lvalue,
 500                 int ltype,
 501                 const char *rvalue,
 502                 void *data,
 503                 void *userdata) {
 504
 505         int k;
 506         ShowStatus *b = data;
 507
 508         assert(filename);
 509         assert(lvalue);
 510         assert(rvalue);
 511         assert(data);
 512
 513         k = parse_show_status(rvalue, b);
 514         if (k < 0) {
 515                 log_syntax(unit, LOG_ERR, filename, line, -k,
 516                            "Failed to parse show status setting, ignoring: %s", rvalue);
 517                 return 0;
 518         }
 519
 520         return 0;
 521 }
 522
 523 static void strv_free_free(char ***l) {
 524         char ***i;
 525
 526         if (!l)
 527                 return;
 528
 529         for (i = l; *i; i++)
 530                 strv_free(*i);
 531
 532         free(l);
 533 }
 534
 535 static void free_join_controllers(void) {
 536         strv_free_free(arg_join_controllers);
 537         arg_join_controllers = NULL;
 538 }
 539
 540 static int config_parse_join_controllers(const char *unit,
 541                                          const char *filename,
 542                                          unsigned line,
 543                                          const char *section,
 544                                          unsigned section_line,
 545                                          const char *lvalue,
 546                                          int ltype,
 547                                          const char *rvalue,
 548                                          void *data,
 549                                          void *userdata) {
 550
 551         unsigned n = 0;
 552         char *state, *w;
 553         size_t length;
 554
 555         assert(filename);
 556         assert(lvalue);
 557         assert(rvalue);
 558
 559         free_join_controllers();
 560
 561         FOREACH_WORD_QUOTED(w, length, rvalue, state) {
 562                 char *s, **l;
 563
 564                 s = strndup(w, length);
 565                 if (!s)
 566                         return log_oom();
 567
 568                 l = strv_split(s, ",");
 569                 free(s);
 570
 571                 strv_uniq(l);
 572
 573                 if (strv_length(l) <= 1) {
 574                         strv_free(l);
 575                         continue;
 576                 }
 577
 578                 if (!arg_join_controllers) {
 579                         arg_join_controllers = new(char**, 2);
 580                         if (!arg_join_controllers) {
 581                                 strv_free(l);
 582                                 return log_oom();
 583                         }
 584
 585                         arg_join_controllers[0] = l;
 586                         arg_join_controllers[1] = NULL;
 587
 588                         n = 1;
 589                 } else {
 590                         char ***a;
 591                         char ***t;
 592
 593                         t = new0(char**, n+2);
 594                         if (!t) {
 595                                 strv_free(l);
 596                                 return log_oom();
 597                         }
 598
 599                         n = 0;
 600
 601                         for (a = arg_join_controllers; *a; a++) {
 602
 603                                 if (strv_overlap(*a, l)) {
 604                                         if (strv_extend_strv(&l, *a) < 0) {
 605                                                 strv_free(l);
 606                                                 strv_free_free(t);
 607                                                 return log_oom();
 608                                         }
 609
 610                                 } else {
 611                                         char **c;
 612
 613                                         c = strv_copy(*a);
 614                                         if (!c) {
 615                                                 strv_free(l);
 616                                                 strv_free_free(t);
 617                                                 return log_oom();
 618                                         }
 619
 620                                         t[n++] = c;
 621                                 }
 622                         }
 623
 624                         t[n++] = strv_uniq(l);
 625
 626                         strv_free_free(arg_join_controllers);
 627                         arg_join_controllers = t;
 628                 }
 629         }
 630
 631         return 0;
 632 }
 633
 634 static int parse_config_file(void) {
 635
 636         const ConfigTableItem items[] = {
 637                 { "Manager", "LogLevel",                  config_parse_level2,           0, NULL                                   },
 638                 { "Manager", "LogTarget",                 config_parse_target,           0, NULL                                   },
 639                 { "Manager", "LogColor",                  config_parse_color,            0, NULL                                   },
 640                 { "Manager", "LogLocation",               config_parse_location,         0, NULL                                   },
 641                 { "Manager", "DumpCore",                  config_parse_bool,             0, &arg_dump_core                         },
 642                 { "Manager", "CrashShell",                config_parse_bool,             0, &arg_crash_shell                       },
 643                 { "Manager", "ShowStatus",                config_parse_show_status,      0, &arg_show_status                       },
 644                 { "Manager", "CrashChVT",                 config_parse_int,              0, &arg_crash_chvt                        },
 645                 { "Manager", "CPUAffinity",               config_parse_cpu_affinity2,    0, NULL                                   },
 646                 { "Manager", "JoinControllers",           config_parse_join_controllers, 0, &arg_join_controllers                  },
 647                 { "Manager", "RuntimeWatchdogSec",        config_parse_sec,              0, &arg_runtime_watchdog                  },
 648                 { "Manager", "ShutdownWatchdogSec",       config_parse_sec,              0, &arg_shutdown_watchdog                 },
 649                 { "Manager", "CapabilityBoundingSet",     config_parse_bounding_set,     0, &arg_capability_bounding_set_drop      },
 650 #ifdef HAVE_SECCOMP
 651                 { "Manager", "SystemCallArchitectures",   config_parse_syscall_archs,    0, &arg_syscall_archs                     },
 652 #endif
 653                 { "Manager", "TimerSlackNSec",            config_parse_nsec,             0, &arg_timer_slack_nsec                  },
 654                 { "Manager", "DefaultTimerAccuracySec",   config_parse_sec,              0, &arg_default_timer_accuracy_usec       },
 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                         _cleanup_free_ char *w;
 970                         char *value;
 971
 972                         w = strdup(*a);
 973                         if (!w)
 974                                 return log_oom();
 975
 976                         value = strchr(w, '=');
 977                         if (value)
 978                                 *(value++) = 0;
 979
 980                         r = parse_proc_cmdline_item(w, value);
 981                         if (r < 0) {
 982                                 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
 983                                 return r;
 984                         }
 985                 }
 986         }
 987
 988         return 0;
 989 }
 990
 991 static int help(void) {
 992
 993         printf("%s [OPTIONS...]\n\n"
 994                "Starts up and maintains the system or user services.\n\n"
 995                "  -h --help                      Show this help\n"
 996                "     --test                      Determine startup sequence, dump it and exit\n"
 997                "     --dump-configuration-items  Dump understood unit configuration items\n"
 998                "     --unit=UNIT                 Set default unit\n"
 999                "     --system                    Run a system instance, even if PID != 1\n"
1000                "     --user                      Run a user instance\n"
1001                "     --dump-core[=0|1]           Dump core on crash\n"
1002                "     --crash-shell[=0|1]         Run shell on crash\n"
1003                "     --confirm-spawn[=0|1]       Ask for confirmation when spawning processes\n"
1004                "     --show-status[=0|1]         Show status updates on the console during bootup\n"
1005                "     --log-target=TARGET         Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1006                "     --log-level=LEVEL           Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1007                "     --log-color[=0|1]           Highlight important log messages\n"
1008                "     --log-location[=0|1]        Include code location in log messages\n"
1009                "     --default-standard-output=  Set default standard output for services\n"
1010                "     --default-standard-error=   Set default standard error output for services\n",
1011                program_invocation_short_name);
1012
1013         return 0;
1014 }
1015
1016 static int version(void) {
1017         puts(PACKAGE_STRING);
1018         puts(SYSTEMD_FEATURES);
1019
1020         return 0;
1021 }
1022
1023 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
1024         FILE *f = NULL;
1025         FDSet *fds = NULL;
1026         int r;
1027
1028         assert(m);
1029         assert(_f);
1030         assert(_fds);
1031
1032         r = manager_open_serialization(m, &f);
1033         if (r < 0) {
1034                 log_error("Failed to create serialization file: %s", strerror(-r));
1035                 goto fail;
1036         }
1037
1038         /* Make sure nothing is really destructed when we shut down */
1039         m->n_reloading ++;
1040         bus_manager_send_reloading(m, true);
1041
1042         fds = fdset_new();
1043         if (!fds) {
1044                 r = -ENOMEM;
1045                 log_error("Failed to allocate fd set: %s", strerror(-r));
1046                 goto fail;
1047         }
1048
1049         r = manager_serialize(m, f, fds, switching_root);
1050         if (r < 0) {
1051                 log_error("Failed to serialize state: %s", strerror(-r));
1052                 goto fail;
1053         }
1054
1055         if (fseeko(f, 0, SEEK_SET) < 0) {
1056                 log_error("Failed to rewind serialization fd: %m");
1057                 goto fail;
1058         }
1059
1060         r = fd_cloexec(fileno(f), false);
1061         if (r < 0) {
1062                 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1063                 goto fail;
1064         }
1065
1066         r = fdset_cloexec(fds, false);
1067         if (r < 0) {
1068                 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1069                 goto fail;
1070         }
1071
1072         *_f = f;
1073         *_fds = fds;
1074
1075         return 0;
1076
1077 fail:
1078         fdset_free(fds);
1079
1080         if (f)
1081                 fclose(f);
1082
1083         return r;
1084 }
1085
1086 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1087         struct rlimit nl;
1088         int r;
1089
1090         assert(saved_rlimit);
1091
1092         /* Save the original RLIMIT_NOFILE so that we can reset it
1093          * later when transitioning from the initrd to the main
1094          * systemd or suchlike. */
1095         if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1096                 log_error("Reading RLIMIT_NOFILE failed: %m");
1097                 return -errno;
1098         }
1099
1100         /* Make sure forked processes get the default kernel setting */
1101         if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1102                 struct rlimit *rl;
1103
1104                 rl = newdup(struct rlimit, saved_rlimit, 1);
1105                 if (!rl)
1106                         return log_oom();
1107
1108                 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1109         }
1110
1111         /* Bump up the resource limit for ourselves substantially */
1112         nl.rlim_cur = nl.rlim_max = 64*1024;
1113         r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1114         if (r < 0) {
1115                 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1116                 return r;
1117         }
1118
1119         return 0;
1120 }
1121
1122 static void test_mtab(void) {
1123
1124         static const char ok[] =
1125                 "/proc/self/mounts\0"
1126                 "/proc/mounts\0"
1127                 "../proc/self/mounts\0"
1128                 "../proc/mounts\0";
1129
1130         _cleanup_free_ char *p = NULL;
1131         int r;
1132
1133         /* Check that /etc/mtab is a symlink to the right place or
1134          * non-existing. But certainly not a file, or a symlink to
1135          * some weird place... */
1136
1137         r = readlink_malloc("/etc/mtab", &p);
1138         if (r == -ENOENT)
1139                 return;
1140         if (r >= 0 && nulstr_contains(ok, p))
1141                 return;
1142
1143         log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1144                     "This is not supported anymore. "
1145                     "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1146 }
1147
1148 static void test_usr(void) {
1149
1150         /* Check that /usr is not a separate fs */
1151
1152         if (dir_is_empty("/usr") <= 0)
1153                 return;
1154
1155         log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1156                     "Some things will probably break (sometimes even silently) in mysterious ways. "
1157                     "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1158 }
1159
1160 static int initialize_join_controllers(void) {
1161         /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1162          * + "net_prio". We'd like to add "cpuset" to the mix, but
1163          * "cpuset" does't really work for groups with no initialized
1164          * attributes. */
1165
1166         arg_join_controllers = new(char**, 3);
1167         if (!arg_join_controllers)
1168                 return -ENOMEM;
1169
1170         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1171         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1172         arg_join_controllers[2] = NULL;
1173
1174         if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1175                 free_join_controllers();
1176                 return -ENOMEM;
1177         }
1178
1179         return 0;
1180 }
1181
1182 static int enforce_syscall_archs(Set *archs) {
1183 #ifdef HAVE_SECCOMP
1184         scmp_filter_ctx *seccomp;
1185         Iterator i;
1186         void *id;
1187         int r;
1188
1189         seccomp = seccomp_init(SCMP_ACT_ALLOW);
1190         if (!seccomp)
1191                 return log_oom();
1192
1193         SET_FOREACH(id, arg_syscall_archs, i) {
1194                 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1195                 if (r == -EEXIST)
1196                         continue;
1197                 if (r < 0) {
1198                         log_error("Failed to add architecture to seccomp: %s", strerror(-r));
1199                         goto finish;
1200                 }
1201         }
1202
1203         r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1204         if (r < 0) {
1205                 log_error("Failed to unset NO_NEW_PRIVS: %s", strerror(-r));
1206                 goto finish;
1207         }
1208
1209         r = seccomp_load(seccomp);
1210         if (r < 0)
1211                 log_error("Failed to add install architecture seccomp: %s", strerror(-r));
1212
1213 finish:
1214         seccomp_release(seccomp);
1215         return r;
1216 #else
1217         return 0;
1218 #endif
1219 }
1220
1221 static int status_welcome(void) {
1222         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1223         int r;
1224
1225         r = parse_env_file("/etc/os-release", NEWLINE,
1226                            "PRETTY_NAME", &pretty_name,
1227                            "ANSI_COLOR", &ansi_color,
1228                            NULL);
1229         if (r == -ENOENT) {
1230                 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1231                                    "PRETTY_NAME", &pretty_name,
1232                                    "ANSI_COLOR", &ansi_color,
1233                                    NULL);
1234         }
1235
1236         if (r < 0 && r != -ENOENT)
1237                 log_warning("Failed to read os-release file: %s", strerror(-r));
1238
1239         return status_printf(NULL, false, false,
1240                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1241                              isempty(ansi_color) ? "1" : ansi_color,
1242                              isempty(pretty_name) ? "Linux" : pretty_name);
1243 }
1244
1245 static int write_container_id(void) {
1246         const char *c;
1247
1248         c = getenv("container");
1249         if (isempty(c))
1250                 return 0;
1251
1252         return write_string_file("/run/systemd/container", c);
1253 }
1254
1255 int main(int argc, char *argv[]) {
1256         Manager *m = NULL;
1257         int r, retval = EXIT_FAILURE;
1258         usec_t before_startup, after_startup;
1259         char timespan[FORMAT_TIMESPAN_MAX];
1260         FDSet *fds = NULL;
1261         bool reexecute = false;
1262         const char *shutdown_verb = NULL;
1263         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1264         dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1265         dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1266         dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1267         dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1268         static char systemd[] = "systemd";
1269         bool skip_setup = false;
1270         unsigned j;
1271         bool loaded_policy = false;
1272         bool arm_reboot_watchdog = false;
1273         bool queue_default_job = false;
1274         bool empty_etc = false;
1275         char *switch_root_dir = NULL, *switch_root_init = NULL;
1276         static struct rlimit saved_rlimit_nofile = { 0, 0 };
1277
1278 #ifdef HAVE_SYSV_COMPAT
1279         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1280                 /* This is compatibility support for SysV, where
1281                  * calling init as a user is identical to telinit. */
1282
1283                 errno = -ENOENT;
1284                 execv(SYSTEMCTL_BINARY_PATH, argv);
1285                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1286                 return 1;
1287         }
1288 #endif
1289
1290         dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1291         dual_timestamp_get(&userspace_timestamp);
1292
1293         /* Determine if this is a reexecution or normal bootup. We do
1294          * the full command line parsing much later, so let's just
1295          * have a quick peek here. */
1296         if (strv_find(argv+1, "--deserialize"))
1297                 skip_setup = true;
1298
1299         /* If we have switched root, do all the special setup
1300          * things */
1301         if (strv_find(argv+1, "--switched-root"))
1302                 skip_setup = false;
1303
1304         /* If we get started via the /sbin/init symlink then we are
1305            called 'init'. After a subsequent reexecution we are then
1306            called 'systemd'. That is confusing, hence let's call us
1307            systemd right-away. */
1308         program_invocation_short_name = systemd;
1309         prctl(PR_SET_NAME, systemd);
1310
1311         saved_argv = argv;
1312         saved_argc = argc;
1313
1314         log_show_color(isatty(STDERR_FILENO) > 0);
1315
1316         /* Disable the umask logic */
1317         if (getpid() == 1)
1318                 umask(0);
1319
1320         if (getpid() == 1 && detect_container(NULL) <= 0) {
1321
1322                 /* Running outside of a container as PID 1 */
1323                 arg_running_as = SYSTEMD_SYSTEM;
1324                 make_null_stdio();
1325                 log_set_target(LOG_TARGET_KMSG);
1326                 log_open();
1327
1328                 if (in_initrd())
1329                         initrd_timestamp = userspace_timestamp;
1330
1331                 if (!skip_setup) {
1332                         mount_setup_early();
1333                         dual_timestamp_get(&security_start_timestamp);
1334                         if (selinux_setup(&loaded_policy) < 0)
1335                                 goto finish;
1336                         if (ima_setup() < 0)
1337                                 goto finish;
1338                         if (smack_setup(&loaded_policy) < 0)
1339                                 goto finish;
1340                         dual_timestamp_get(&security_finish_timestamp);
1341                 }
1342
1343                 if (label_init(NULL) < 0)
1344                         goto finish;
1345
1346                 if (!skip_setup) {
1347                         if (clock_is_localtime() > 0) {
1348                                 int min;
1349
1350                                 /* The first-time call to settimeofday() does a time warp in the kernel */
1351                                 r = clock_set_timezone(&min);
1352                                 if (r < 0)
1353                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1354                                 else
1355                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1356                         } else if (!in_initrd()) {
1357                                 /*
1358                                  * Do dummy first-time call to seal the kernel's time warp magic
1359                                  *
1360                                  * Do not call this this from inside the initrd. The initrd might not
1361                                  * carry /etc/adjtime with LOCAL, but the real system could be set up
1362                                  * that way. In such case, we need to delay the time-warp or the sealing
1363                                  * until we reach the real system.
1364                                  */
1365                                 clock_reset_timezone();
1366
1367                                 /* Tell the kernel our timezone */
1368                                 r = clock_set_timezone(NULL);
1369                                 if (r < 0)
1370                                         log_error("Failed to set the kernel's timezone, ignoring: %s", strerror(-r));
1371                         }
1372                 }
1373
1374                 /* Set the default for later on, but don't actually
1375                  * open the logs like this for now. Note that if we
1376                  * are transitioning from the initrd there might still
1377                  * be journal fd open, and we shouldn't attempt
1378                  * opening that before we parsed /proc/cmdline which
1379                  * might redirect output elsewhere. */
1380                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1381
1382         } else if (getpid() == 1) {
1383                 /* Running inside a container, as PID 1 */
1384                 arg_running_as = SYSTEMD_SYSTEM;
1385                 log_set_target(LOG_TARGET_CONSOLE);
1386                 log_close_console(); /* force reopen of /dev/console */
1387                 log_open();
1388
1389                 /* For the later on, see above... */
1390                 log_set_target(LOG_TARGET_JOURNAL);
1391
1392                 /* clear the kernel timestamp,
1393                  * because we are in a container */
1394                 kernel_timestamp.monotonic = 0ULL;
1395                 kernel_timestamp.realtime = 0ULL;
1396
1397         } else {
1398                 /* Running as user instance */
1399                 arg_running_as = SYSTEMD_USER;
1400                 log_set_target(LOG_TARGET_AUTO);
1401                 log_open();
1402
1403                 /* clear the kernel timestamp,
1404                  * because we are not PID 1 */
1405                 kernel_timestamp.monotonic = 0ULL;
1406                 kernel_timestamp.realtime = 0ULL;
1407         }
1408
1409         /* Initialize default unit */
1410         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1411         if (r < 0) {
1412                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1413                 goto finish;
1414         }
1415
1416         r = initialize_join_controllers();
1417         if (r < 0)
1418                 goto finish;
1419
1420         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1421          * /proc/$PID/fd is available. */
1422         if (getpid() == 1) {
1423                 r = mount_setup(loaded_policy);
1424                 if (r < 0)
1425                         goto finish;
1426         }
1427
1428         /* Reset all signal handlers. */
1429         assert_se(reset_all_signal_handlers() == 0);
1430
1431         ignore_signals(SIGNALS_IGNORE, -1);
1432
1433         if (parse_config_file() < 0)
1434                 goto finish;
1435
1436         if (arg_running_as == SYSTEMD_SYSTEM)
1437                 if (parse_proc_cmdline(parse_proc_cmdline_item) < 0)
1438                         goto finish;
1439
1440         log_parse_environment();
1441
1442         if (parse_argv(argc, argv) < 0)
1443                 goto finish;
1444
1445         if (arg_action == ACTION_TEST &&
1446             geteuid() == 0) {
1447                 log_error("Don't run test mode as root.");
1448                 goto finish;
1449         }
1450
1451         if (arg_running_as == SYSTEMD_USER &&
1452             arg_action == ACTION_RUN &&
1453             sd_booted() <= 0) {
1454                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1455                 goto finish;
1456         }
1457
1458         if (arg_running_as == SYSTEMD_SYSTEM &&
1459             arg_action == ACTION_RUN &&
1460             running_in_chroot() > 0) {
1461                 log_error("Cannot be run in a chroot() environment.");
1462                 goto finish;
1463         }
1464
1465         if (arg_action == ACTION_HELP) {
1466                 retval = help();
1467                 goto finish;
1468         } else if (arg_action == ACTION_VERSION) {
1469                 retval = version();
1470                 goto finish;
1471         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1472                 unit_dump_config_items(stdout);
1473                 retval = EXIT_SUCCESS;
1474                 goto finish;
1475         } else if (arg_action == ACTION_DONE) {
1476                 retval = EXIT_SUCCESS;
1477                 goto finish;
1478         }
1479
1480         if (arg_running_as == SYSTEMD_USER &&
1481             !getenv("XDG_RUNTIME_DIR")) {
1482                 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1483                 goto finish;
1484         }
1485
1486         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1487
1488         /* Close logging fds, in order not to confuse fdset below */
1489         log_close();
1490
1491         /* Remember open file descriptors for later deserialization */
1492         r = fdset_new_fill(&fds);
1493         if (r < 0) {
1494                 log_error("Failed to allocate fd set: %s", strerror(-r));
1495                 goto finish;
1496         } else
1497                 fdset_cloexec(fds, true);
1498
1499         if (arg_serialization)
1500                 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1501
1502         if (arg_running_as == SYSTEMD_SYSTEM)
1503                 /* Become a session leader if we aren't one yet. */
1504                 setsid();
1505
1506         /* Move out of the way, so that we won't block unmounts */
1507         assert_se(chdir("/")  == 0);
1508
1509         /* Reset the console, but only if this is really init and we
1510          * are freshly booted */
1511         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1512                 console_setup(getpid() == 1 && !skip_setup);
1513
1514         /* Open the logging devices, if possible and necessary */
1515         log_open();
1516
1517         if (arg_show_status == _SHOW_STATUS_UNSET)
1518                 arg_show_status = SHOW_STATUS_YES;
1519
1520         /* Make sure we leave a core dump without panicing the
1521          * kernel. */
1522         if (getpid() == 1) {
1523                 install_crash_handler();
1524
1525                 r = mount_cgroup_controllers(arg_join_controllers);
1526                 if (r < 0)
1527                         goto finish;
1528         }
1529
1530         if (arg_running_as == SYSTEMD_SYSTEM) {
1531                 const char *virtualization = NULL;
1532
1533                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1534
1535                 detect_virtualization(&virtualization);
1536                 if (virtualization)
1537                         log_info("Detected virtualization '%s'.", virtualization);
1538
1539                 write_container_id();
1540
1541                 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1542
1543                 if (in_initrd())
1544                         log_info("Running in initial RAM disk.");
1545
1546                 empty_etc = dir_is_empty("/etc") > 0;
1547                 if (empty_etc)
1548                         log_info("Running with unpopulated /etc.");
1549         } else {
1550                 _cleanup_free_ char *t = uid_to_name(getuid());
1551                 log_debug(PACKAGE_STRING " running in user mode for user "PID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1552                           getuid(), t);
1553         }
1554
1555         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1556                 if (arg_show_status > 0 || plymouth_running())
1557                         status_welcome();
1558
1559 #ifdef HAVE_KMOD
1560                 kmod_setup();
1561 #endif
1562                 hostname_setup();
1563                 machine_id_setup(NULL);
1564                 loopback_setup();
1565
1566                 test_mtab();
1567                 test_usr();
1568         }
1569
1570         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1571                 watchdog_set_timeout(&arg_runtime_watchdog);
1572
1573         if (arg_timer_slack_nsec != (nsec_t) -1)
1574                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1575                         log_error("Failed to adjust timer slack: %m");
1576
1577         if (arg_capability_bounding_set_drop) {
1578                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1579                 if (r < 0) {
1580                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1581                         goto finish;
1582                 }
1583                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1584                 if (r < 0) {
1585                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1586                         goto finish;
1587                 }
1588         }
1589
1590         if (arg_syscall_archs) {
1591                 r = enforce_syscall_archs(arg_syscall_archs);
1592                 if (r < 0)
1593                         goto finish;
1594         }
1595
1596         if (arg_running_as == SYSTEMD_USER) {
1597                 /* Become reaper of our children */
1598                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1599                         log_warning("Failed to make us a subreaper: %m");
1600                         if (errno == EINVAL)
1601                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1602                 }
1603         }
1604
1605         if (arg_running_as == SYSTEMD_SYSTEM) {
1606                 bump_rlimit_nofile(&saved_rlimit_nofile);
1607
1608                 if (empty_etc) {
1609                         r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1610                         if (r < 0)
1611                                 log_warning("Failed to populate /etc with preset unit settings, ignoring: %s", strerror(-r));
1612                         else
1613                                 log_info("Populated /etc with preset unit settings.");
1614                 }
1615         }
1616
1617         r = manager_new(arg_running_as, &m);
1618         if (r < 0) {
1619                 log_error("Failed to allocate manager object: %s", strerror(-r));
1620                 goto finish;
1621         }
1622
1623         m->confirm_spawn = arg_confirm_spawn;
1624         m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1625         m->default_std_output = arg_default_std_output;
1626         m->default_std_error = arg_default_std_error;
1627         m->default_restart_usec = arg_default_restart_usec;
1628         m->default_timeout_start_usec = arg_default_timeout_start_usec;
1629         m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1630         m->default_start_limit_interval = arg_default_start_limit_interval;
1631         m->default_start_limit_burst = arg_default_start_limit_burst;
1632         m->default_cpu_accounting = arg_default_cpu_accounting;
1633         m->default_blockio_accounting = arg_default_blockio_accounting;
1634         m->default_memory_accounting = arg_default_memory_accounting;
1635         m->runtime_watchdog = arg_runtime_watchdog;
1636         m->shutdown_watchdog = arg_shutdown_watchdog;
1637         m->userspace_timestamp = userspace_timestamp;
1638         m->kernel_timestamp = kernel_timestamp;
1639         m->initrd_timestamp = initrd_timestamp;
1640         m->security_start_timestamp = security_start_timestamp;
1641         m->security_finish_timestamp = security_finish_timestamp;
1642
1643         manager_set_default_rlimits(m, arg_default_rlimit);
1644         manager_environment_add(m, NULL, arg_default_environment);
1645         manager_set_show_status(m, arg_show_status);
1646
1647         /* Remember whether we should queue the default job */
1648         queue_default_job = !arg_serialization || arg_switched_root;
1649
1650         before_startup = now(CLOCK_MONOTONIC);
1651
1652         r = manager_startup(m, arg_serialization, fds);
1653         if (r < 0)
1654                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1655
1656         /* This will close all file descriptors that were opened, but
1657          * not claimed by any unit. */
1658         fdset_free(fds);
1659         fds = NULL;
1660
1661         if (arg_serialization) {
1662                 fclose(arg_serialization);
1663                 arg_serialization = NULL;
1664         }
1665
1666         if (queue_default_job) {
1667                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1668                 Unit *target = NULL;
1669                 Job *default_unit_job;
1670
1671                 log_debug("Activating default unit: %s", arg_default_unit);
1672
1673                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1674                 if (r < 0)
1675                         log_error("Failed to load default target: %s", bus_error_message(&error, r));
1676                 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1677                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1678                 else if (target->load_state == UNIT_MASKED)
1679                         log_error("Default target masked.");
1680
1681                 if (!target || target->load_state != UNIT_LOADED) {
1682                         log_info("Trying to load rescue target...");
1683
1684                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1685                         if (r < 0) {
1686                                 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1687                                 goto finish;
1688                         } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1689                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1690                                 goto finish;
1691                         } else if (target->load_state == UNIT_MASKED) {
1692                                 log_error("Rescue target masked.");
1693                                 goto finish;
1694                         }
1695                 }
1696
1697                 assert(target->load_state == UNIT_LOADED);
1698
1699                 if (arg_action == ACTION_TEST) {
1700                         printf("-> By units:\n");
1701                         manager_dump_units(m, stdout, "\t");
1702                 }
1703
1704                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1705                 if (r == -EPERM) {
1706                         log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1707
1708                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1709                         if (r < 0) {
1710                                 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1711                                 goto finish;
1712                         }
1713                 } else if (r < 0) {
1714                         log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1715                         goto finish;
1716                 }
1717
1718                 m->default_unit_job_id = default_unit_job->id;
1719
1720                 after_startup = now(CLOCK_MONOTONIC);
1721                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1722                          "Loaded units and determined initial transaction in %s.",
1723                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1724
1725                 if (arg_action == ACTION_TEST) {
1726                         printf("-> By jobs:\n");
1727                         manager_dump_jobs(m, stdout, "\t");
1728                         retval = EXIT_SUCCESS;
1729                         goto finish;
1730                 }
1731         }
1732
1733         for (;;) {
1734                 r = manager_loop(m);
1735                 if (r < 0) {
1736                         log_error("Failed to run mainloop: %s", strerror(-r));
1737                         goto finish;
1738                 }
1739
1740                 switch (m->exit_code) {
1741
1742                 case MANAGER_EXIT:
1743                         retval = EXIT_SUCCESS;
1744                         log_debug("Exit.");
1745                         goto finish;
1746
1747                 case MANAGER_RELOAD:
1748                         log_info("Reloading.");
1749                         r = manager_reload(m);
1750                         if (r < 0)
1751                                 log_error("Failed to reload: %s", strerror(-r));
1752                         break;
1753
1754                 case MANAGER_REEXECUTE:
1755
1756                         if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1757                                 goto finish;
1758
1759                         reexecute = true;
1760                         log_notice("Reexecuting.");
1761                         goto finish;
1762
1763                 case MANAGER_SWITCH_ROOT:
1764                         /* Steal the switch root parameters */
1765                         switch_root_dir = m->switch_root;
1766                         switch_root_init = m->switch_root_init;
1767                         m->switch_root = m->switch_root_init = NULL;
1768
1769                         if (!switch_root_init)
1770                                 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1771                                         goto finish;
1772
1773                         reexecute = true;
1774                         log_notice("Switching root.");
1775                         goto finish;
1776
1777                 case MANAGER_REBOOT:
1778                 case MANAGER_POWEROFF:
1779                 case MANAGER_HALT:
1780                 case MANAGER_KEXEC: {
1781                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1782                                 [MANAGER_REBOOT] = "reboot",
1783                                 [MANAGER_POWEROFF] = "poweroff",
1784                                 [MANAGER_HALT] = "halt",
1785                                 [MANAGER_KEXEC] = "kexec"
1786                         };
1787
1788                         assert_se(shutdown_verb = table[m->exit_code]);
1789                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1790
1791                         log_notice("Shutting down.");
1792                         goto finish;
1793                 }
1794
1795                 default:
1796                         assert_not_reached("Unknown exit code.");
1797                 }
1798         }
1799
1800 finish:
1801         if (m) {
1802                 manager_free(m);
1803                 m = NULL;
1804         }
1805
1806         for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1807                 free(arg_default_rlimit[j]);
1808                 arg_default_rlimit[j] = NULL;
1809         }
1810
1811         free(arg_default_unit);
1812         arg_default_unit = NULL;
1813
1814         free_join_controllers();
1815
1816         strv_free(arg_default_environment);
1817         arg_default_environment = NULL;
1818
1819         set_free(arg_syscall_archs);
1820         arg_syscall_archs = NULL;
1821
1822         label_finish();
1823
1824         if (reexecute) {
1825                 const char **args;
1826                 unsigned i, args_size;
1827                 sigset_t ss, o_ss;
1828
1829                 /* Close and disarm the watchdog, so that the new
1830                  * instance can reinitialize it, but doesn't get
1831                  * rebooted while we do that */
1832                 watchdog_close(true);
1833
1834                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1835                  * that the new systemd can pass the kernel default to
1836                  * its child processes */
1837                 if (saved_rlimit_nofile.rlim_cur > 0)
1838                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1839
1840                 if (switch_root_dir) {
1841                         /* Kill all remaining processes from the
1842                          * initrd, but don't wait for them, so that we
1843                          * can handle the SIGCHLD for them after
1844                          * deserializing. */
1845                         broadcast_signal(SIGTERM, false, true);
1846
1847                         /* And switch root */
1848                         r = switch_root(switch_root_dir);
1849                         if (r < 0)
1850                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1851                 }
1852
1853                 args_size = MAX(6, argc+1);
1854                 args = newa(const char*, args_size);
1855
1856                 if (!switch_root_init) {
1857                         char sfd[16];
1858
1859                         /* First try to spawn ourselves with the right
1860                          * path, and with full serialization. We do
1861                          * this only if the user didn't specify an
1862                          * explicit init to spawn. */
1863
1864                         assert(arg_serialization);
1865                         assert(fds);
1866
1867                         snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1868                         char_array_0(sfd);
1869
1870                         i = 0;
1871                         args[i++] = SYSTEMD_BINARY_PATH;
1872                         if (switch_root_dir)
1873                                 args[i++] = "--switched-root";
1874                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1875                         args[i++] = "--deserialize";
1876                         args[i++] = sfd;
1877                         args[i++] = NULL;
1878
1879                         /* do not pass along the environment we inherit from the kernel or initrd */
1880                         if (switch_root_dir)
1881                                 clearenv();
1882
1883                         assert(i <= args_size);
1884                         execv(args[0], (char* const*) args);
1885                 }
1886
1887                 /* Try the fallback, if there is any, without any
1888                  * serialization. We pass the original argv[] and
1889                  * envp[]. (Well, modulo the ordering changes due to
1890                  * getopt() in argv[], and some cleanups in envp[],
1891                  * but let's hope that doesn't matter.) */
1892
1893                 if (arg_serialization) {
1894                         fclose(arg_serialization);
1895                         arg_serialization = NULL;
1896                 }
1897
1898                 if (fds) {
1899                         fdset_free(fds);
1900                         fds = NULL;
1901                 }
1902
1903                 /* Reopen the console */
1904                 make_console_stdio();
1905
1906                 for (j = 1, i = 1; j < (unsigned) argc; j++)
1907                         args[i++] = argv[j];
1908                 args[i++] = NULL;
1909                 assert(i <= args_size);
1910
1911                 /* reenable any blocked signals, especially important
1912                  * if we switch from initial ramdisk to init=... */
1913                 sigemptyset(&ss);
1914                 sigprocmask(SIG_SETMASK, &ss, &o_ss);
1915
1916                 if (switch_root_init) {
1917                         args[0] = switch_root_init;
1918                         execv(args[0], (char* const*) args);
1919                         log_warning("Failed to execute configured init, trying fallback: %m");
1920                 }
1921
1922                 args[0] = "/sbin/init";
1923                 execv(args[0], (char* const*) args);
1924
1925                 if (errno == ENOENT) {
1926                         log_warning("No /sbin/init, trying fallback");
1927
1928                         args[0] = "/bin/sh";
1929                         args[1] = NULL;
1930                         execv(args[0], (char* const*) args);
1931                         log_error("Failed to execute /bin/sh, giving up: %m");
1932                 } else
1933                         log_warning("Failed to execute /sbin/init, giving up: %m");
1934
1935                 sigprocmask(SIG_SETMASK, &o_ss, NULL);
1936         }
1937
1938         if (arg_serialization) {
1939                 fclose(arg_serialization);
1940                 arg_serialization = NULL;
1941         }
1942
1943         if (fds) {
1944                 fdset_free(fds);
1945                 fds = NULL;
1946         }
1947
1948 #ifdef HAVE_VALGRIND_VALGRIND_H
1949         /* If we are PID 1 and running under valgrind, then let's exit
1950          * here explicitly. valgrind will only generate nice output on
1951          * exit(), not on exec(), hence let's do the former not the
1952          * latter here. */
1953         if (getpid() == 1 && RUNNING_ON_VALGRIND)
1954                 return 0;
1955 #endif
1956
1957         if (shutdown_verb) {
1958                 char log_level[DECIMAL_STR_MAX(int) + 1];
1959                 const char* command_line[9] = {
1960                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1961                         shutdown_verb,
1962                         "--log-level", log_level,
1963                         "--log-target",
1964                 };
1965                 unsigned pos = 5;
1966                 _cleanup_strv_free_ char **env_block = NULL;
1967
1968                 assert(command_line[pos] == NULL);
1969                 env_block = strv_copy(environ);
1970
1971                 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1972
1973                 switch (log_get_target()) {
1974                 case LOG_TARGET_KMSG:
1975                 case LOG_TARGET_JOURNAL_OR_KMSG:
1976                 case LOG_TARGET_SYSLOG_OR_KMSG:
1977                         command_line[pos++] = "kmsg";
1978                         break;
1979
1980                 case LOG_TARGET_CONSOLE:
1981                 default:
1982                         command_line[pos++] = "console";
1983                         break;
1984                 };
1985
1986                 if (log_get_show_color())
1987                         command_line[pos++] = "--log-color";
1988
1989                 if (log_get_show_location())
1990                         command_line[pos++] = "--log-location";
1991
1992                 assert(pos < ELEMENTSOF(command_line));
1993
1994                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1995                         char *e;
1996
1997                         /* If we reboot let's set the shutdown
1998                          * watchdog and tell the shutdown binary to
1999                          * repeatedly ping it */
2000                         watchdog_set_timeout(&arg_shutdown_watchdog);
2001                         watchdog_close(false);
2002
2003                         /* Tell the binary how often to ping, ignore failure */
2004                         if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2005                                 strv_push(&env_block, e);
2006                 } else
2007                         watchdog_close(true);
2008
2009                 /* Avoid the creation of new processes forked by the
2010                  * kernel; at this point, we will not listen to the
2011                  * signals anyway */
2012                 if (detect_container(NULL) <= 0)
2013                         cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2014
2015                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2016                 log_error("Failed to execute shutdown binary, %s: %m",
2017                           getpid() == 1 ? "freezing" : "quitting");
2018         }
2019
2020         if (getpid() == 1)
2021                 freeze();
2022
2023         return retval;
2024 }