src/core/main.c

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