src/core/main.c

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