src/core/main.c

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