src/core/main.c

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