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