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 usec_t arg_default_timer_accuracy_usec = 1 * USEC_PER_MINUTE;
 112 static usec_t arg_default_cpu_quota_period_usec = 100 * USEC_PER_MSEC;
 113 static Set* arg_syscall_archs = NULL;
 114 static FILE* arg_serialization = NULL;
 115 static bool arg_default_cpu_accounting = false;
 116 static bool arg_default_blockio_accounting = false;
 117 static bool arg_default_memory_accounting = false;
 118
 119 static void nop_handler(int sig) {}
 120
 121 noreturn static void crash(int sig) {
 122
 123         if (getpid() != 1)
 124                 /* Pass this on immediately, if this is not PID 1 */
 125                 raise(sig);
 126         else if (!arg_dump_core)
 127                 log_error("Caught <%s>, not dumping core.", signal_to_string(sig));
 128         else {
 129                 struct sigaction sa = {
 130                         .sa_handler = nop_handler,
 131                         .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 132                 };
 133                 pid_t pid;
 134
 135                 /* We want to wait for the core process, hence let's enable SIGCHLD */
 136                 sigaction(SIGCHLD, &sa, NULL);
 137
 138                 pid = fork();
 139                 if (pid < 0)
 140                         log_error("Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
 141
 142                 else if (pid == 0) {
 143                         struct rlimit rl = {};
 144
 145                         /* Enable default signal handler for core dump */
 146                         zero(sa);
 147                         sa.sa_handler = SIG_DFL;
 148                         sigaction(sig, &sa, NULL);
 149
 150                         /* Don't limit the core dump size */
 151                         rl.rlim_cur = RLIM_INFINITY;
 152                         rl.rlim_max = RLIM_INFINITY;
 153                         setrlimit(RLIMIT_CORE, &rl);
 154
 155                         /* Just to be sure... */
 156                         chdir("/");
 157
 158                         /* Raise the signal again */
 159                         raise(sig);
 160
 161                         assert_not_reached("We shouldn't be here...");
 162                         _exit(1);
 163
 164                 } else {
 165                         siginfo_t status;
 166                         int r;
 167
 168                         /* Order things nicely. */
 169                         r = wait_for_terminate(pid, &status);
 170                         if (r < 0)
 171                                 log_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
 172                         else if (status.si_code != CLD_DUMPED)
 173                                 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
 174                         else
 175                                 log_error("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
 176                 }
 177         }
 178
 179         if (arg_crash_chvt)
 180                 chvt(arg_crash_chvt);
 181
 182         if (arg_crash_shell) {
 183                 struct sigaction sa = {
 184                         .sa_handler = SIG_IGN,
 185                         .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
 186                 };
 187                 pid_t pid;
 188
 189                 log_info("Executing crash shell in 10s...");
 190                 sleep(10);
 191
 192                 /* Let the kernel reap children for us */
 193                 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 194
 195                 pid = fork();
 196                 if (pid < 0)
 197                         log_error("Failed to fork off crash shell: %m");
 198                 else if (pid == 0) {
 199                         make_console_stdio();
 200                         execl("/bin/sh", "/bin/sh", NULL);
 201
 202                         log_error("execl() failed: %m");
 203                         _exit(1);
 204                 }
 205
 206                 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
 207         }
 208
 209         log_info("Freezing execution.");
 210         freeze();
 211 }
 212
 213 static void install_crash_handler(void) {
 214         struct sigaction sa = {
 215                 .sa_handler = crash,
 216                 .sa_flags = SA_NODEFER,
 217         };
 218
 219         sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
 220 }
 221
 222 static int console_setup(bool do_reset) {
 223         int tty_fd, r;
 224
 225         /* If we are init, we connect stdin/stdout/stderr to /dev/null
 226          * and make sure we don't have a controlling tty. */
 227
 228         release_terminal();
 229
 230         if (!do_reset)
 231                 return 0;
 232
 233         tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
 234         if (tty_fd < 0) {
 235                 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
 236                 return -tty_fd;
 237         }
 238
 239         /* We don't want to force text mode.
 240          * plymouth may be showing pictures already from initrd. */
 241         r = reset_terminal_fd(tty_fd, false);
 242         if (r < 0)
 243                 log_error("Failed to reset /dev/console: %s", strerror(-r));
 244
 245         safe_close(tty_fd);
 246         return r;
 247 }
 248
 249 static int set_default_unit(const char *u) {
 250         char *c;
 251
 252         assert(u);
 253
 254         c = strdup(u);
 255         if (!c)
 256                 return -ENOMEM;
 257
 258         free(arg_default_unit);
 259         arg_default_unit = c;
 260
 261         return 0;
 262 }
 263
 264 static int parse_proc_cmdline_item(const char *key, const char *value) {
 265
 266         static const char * const rlmap[] = {
 267                 "emergency", SPECIAL_EMERGENCY_TARGET,
 268                 "-b",        SPECIAL_EMERGENCY_TARGET,
 269                 "single",    SPECIAL_RESCUE_TARGET,
 270                 "-s",        SPECIAL_RESCUE_TARGET,
 271                 "s",         SPECIAL_RESCUE_TARGET,
 272                 "S",         SPECIAL_RESCUE_TARGET,
 273                 "1",         SPECIAL_RESCUE_TARGET,
 274                 "2",         SPECIAL_RUNLEVEL2_TARGET,
 275                 "3",         SPECIAL_RUNLEVEL3_TARGET,
 276                 "4",         SPECIAL_RUNLEVEL4_TARGET,
 277                 "5",         SPECIAL_RUNLEVEL5_TARGET,
 278         };
 279         int r;
 280
 281         assert(key);
 282
 283         if (streq(key, "systemd.unit") && value) {
 284
 285                 if (!in_initrd())
 286                         return set_default_unit(value);
 287
 288         } else if (streq(key, "rd.systemd.unit") && value) {
 289
 290                 return set_default_unit(value);
 291
 292         } else if (streq(key, "systemd.log_target") && value) {
 293
 294                 if (log_set_target_from_string(value) < 0)
 295                         log_warning("Failed to parse log target %s. Ignoring.", value);
 296
 297         } else if (streq(key, "systemd.log_level") && value) {
 298
 299                 if (log_set_max_level_from_string(value) < 0)
 300                         log_warning("Failed to parse log level %s. Ignoring.", value);
 301
 302         } else if (streq(key, "systemd.log_color") && value) {
 303
 304                 if (log_show_color_from_string(value) < 0)
 305                         log_warning("Failed to parse log color setting %s. Ignoring.", value);
 306
 307         } else if (streq(key, "systemd.log_location") && value) {
 308
 309                 if (log_show_location_from_string(value) < 0)
 310                         log_warning("Failed to parse log location setting %s. Ignoring.", value);
 311
 312         } else if (streq(key, "systemd.dump_core") && value) {
 313
 314                 r = parse_boolean(value);
 315                 if (r < 0)
 316                         log_warning("Failed to parse dump core switch %s. Ignoring.", value);
 317                 else
 318                         arg_dump_core = r;
 319
 320         } else if (streq(key, "systemd.crash_shell") && value) {
 321
 322                 r = parse_boolean(value);
 323                 if (r < 0)
 324                         log_warning("Failed to parse crash shell switch %s. Ignoring.", value);
 325                 else
 326                         arg_crash_shell = r;
 327
 328         } else if (streq(key, "systemd.crash_chvt") && value) {
 329
 330                 if (safe_atoi(value, &r) < 0)
 331                         log_warning("Failed to parse crash chvt switch %s. Ignoring.", value);
 332                 else
 333                         arg_crash_chvt = r;
 334
 335         } else if (streq(key, "systemd.confirm_spawn") && value) {
 336
 337                 r = parse_boolean(value);
 338                 if (r < 0)
 339                         log_warning("Failed to parse confirm spawn switch %s. Ignoring.", value);
 340                 else
 341                         arg_confirm_spawn = r;
 342
 343         } else if (streq(key, "systemd.show_status") && value) {
 344
 345                 r = parse_show_status(value, &arg_show_status);
 346                 if (r < 0)
 347                         log_warning("Failed to parse show status switch %s. Ignoring.", value);
 348
 349         } else if (streq(key, "systemd.default_standard_output") && value) {
 350
 351                 r = exec_output_from_string(value);
 352                 if (r < 0)
 353                         log_warning("Failed to parse default standard output switch %s. Ignoring.", value);
 354                 else
 355                         arg_default_std_output = r;
 356
 357         } else if (streq(key, "systemd.default_standard_error") && value) {
 358
 359                 r = exec_output_from_string(value);
 360                 if (r < 0)
 361                         log_warning("Failed to parse default standard error switch %s. Ignoring.", value);
 362                 else
 363                         arg_default_std_error = r;
 364
 365         } else if (streq(key, "systemd.setenv") && value) {
 366
 367                 if (env_assignment_is_valid(value)) {
 368                         char **env;
 369
 370                         env = strv_env_set(arg_default_environment, value);
 371                         if (env)
 372                                 arg_default_environment = env;
 373                         else
 374                                 log_warning("Setting environment variable '%s' failed, ignoring: %s", value, strerror(ENOMEM));
 375                 } else
 376                         log_warning("Environment variable name '%s' is not valid. Ignoring.", value);
 377
 378         } else if (!streq(key, "systemd.restore_state") &&
 379                    !streq(key, "systemd.gpt_auto") &&
 380                    (startswith(key, "systemd.") || startswith(key, "rd.systemd."))) {
 381
 382                 const char *c;
 383
 384                 /* Ignore systemd.journald.xyz and friends */
 385                 c = key;
 386                 if (startswith(c, "rd."))
 387                         c += 3;
 388                 if (startswith(c, "systemd."))
 389                         c += 8;
 390                 if (c[strcspn(c, ".=")] != '.')  {
 391
 392                         log_warning("Unknown kernel switch %s. Ignoring.", key);
 393
 394                         log_info("Supported kernel switches:\n"
 395                                  "systemd.unit=UNIT                        Default unit to start\n"
 396                                  "rd.systemd.unit=UNIT                     Default unit to start when run in initrd\n"
 397                                  "systemd.dump_core=0|1                    Dump core on crash\n"
 398                                  "systemd.crash_shell=0|1                  Run shell on crash\n"
 399                                  "systemd.crash_chvt=N                     Change to VT #N on crash\n"
 400                                  "systemd.confirm_spawn=0|1                Confirm every process spawn\n"
 401                                  "systemd.show_status=0|1|auto             Show status updates on the console during bootup\n"
 402                                  "systemd.log_target=console|kmsg|journal|journal-or-kmsg|syslog|syslog-or-kmsg|null\n"
 403                                  "                                         Log target\n"
 404                                  "systemd.log_level=LEVEL                  Log level\n"
 405                                  "systemd.log_color=0|1                    Highlight important log messages\n"
 406                                  "systemd.log_location=0|1                 Include code location in log messages\n"
 407                                  "systemd.default_standard_output=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
 408                                  "                                         Set default log output for services\n"
 409                                  "systemd.default_standard_error=null|tty|syslog|syslog+console|kmsg|kmsg+console|journal|journal+console\n"
 410                                  "                                         Set default log error output for services\n"
 411                                  "systemd.setenv=ASSIGNMENT                Set an environment variable for all spawned processes\n"
 412                                  "systemd.restore_state=0|1                Restore backlight/rfkill state at boot\n");
 413                 }
 414
 415         } else if (streq(key, "quiet") && !value) {
 416                 if (arg_show_status == _SHOW_STATUS_UNSET)
 417                         arg_show_status = SHOW_STATUS_AUTO;
 418
 419         } else if (streq(key, "debug") && !value) {
 420                 log_set_max_level(LOG_DEBUG);
 421                 if (detect_container(NULL) > 0)
 422                         log_set_target(LOG_TARGET_CONSOLE);
 423
 424         } else if (!in_initrd() && !value) {
 425                 unsigned i;
 426
 427                 /* SysV compatibility */
 428                 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
 429                         if (streq(key, rlmap[i]))
 430                                 return set_default_unit(rlmap[i+1]);
 431         }
 432
 433         return 0;
 434 }
 435
 436 #define DEFINE_SETTER(name, func, descr)                              \
 437         static int name(const char *unit,                             \
 438                         const char *filename,                         \
 439                         unsigned line,                                \
 440                         const char *section,                          \
 441                         unsigned section_line,                        \
 442                         const char *lvalue,                           \
 443                         int ltype,                                    \
 444                         const char *rvalue,                           \
 445                         void *data,                                   \
 446                         void *userdata) {                             \
 447                                                                       \
 448                 int r;                                                \
 449                                                                       \
 450                 assert(filename);                                     \
 451                 assert(lvalue);                                       \
 452                 assert(rvalue);                                       \
 453                                                                       \
 454                 r = func(rvalue);                                     \
 455                 if (r < 0)                                            \
 456                         log_syntax(unit, LOG_ERR, filename, line, -r, \
 457                                    "Invalid " descr "'%s': %s",       \
 458                                    rvalue, strerror(-r));             \
 459                                                                       \
 460                 return 0;                                             \
 461         }
 462
 463 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
 464 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
 465 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
 466 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
 467
 468 static int config_parse_cpu_affinity2(
 469                 const char *unit,
 470                 const char *filename,
 471                 unsigned line,
 472                 const char *section,
 473                 unsigned section_line,
 474                 const char *lvalue,
 475                 int ltype,
 476                 const char *rvalue,
 477                 void *data,
 478                 void *userdata) {
 479
 480         char *w;
 481         size_t l;
 482         char *state;
 483         cpu_set_t *c = NULL;
 484         unsigned ncpus = 0;
 485
 486         assert(filename);
 487         assert(lvalue);
 488         assert(rvalue);
 489
 490         FOREACH_WORD_QUOTED(w, l, rvalue, state) {
 491                 char *t;
 492                 int r;
 493                 unsigned cpu;
 494
 495                 if (!(t = strndup(w, l)))
 496                         return log_oom();
 497
 498                 r = safe_atou(t, &cpu);
 499                 free(t);
 500
 501                 if (!c)
 502                         if (!(c = cpu_set_malloc(&ncpus)))
 503                                 return log_oom();
 504
 505                 if (r < 0 || cpu >= ncpus) {
 506                         log_syntax(unit, LOG_ERR, filename, line, -r,
 507                                    "Failed to parse CPU affinity '%s'", rvalue);
 508                         CPU_FREE(c);
 509                         return -EBADMSG;
 510                 }
 511
 512                 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
 513         }
 514
 515         if (c) {
 516                 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
 517                         log_warning_unit(unit, "Failed to set CPU affinity: %m");
 518
 519                 CPU_FREE(c);
 520         }
 521
 522         return 0;
 523 }
 524
 525 static int config_parse_show_status(
 526                 const char* unit,
 527                 const char *filename,
 528                 unsigned line,
 529                 const char *section,
 530                 unsigned section_line,
 531                 const char *lvalue,
 532                 int ltype,
 533                 const char *rvalue,
 534                 void *data,
 535                 void *userdata) {
 536
 537         int k;
 538         ShowStatus *b = data;
 539
 540         assert(filename);
 541         assert(lvalue);
 542         assert(rvalue);
 543         assert(data);
 544
 545         k = parse_show_status(rvalue, b);
 546         if (k < 0) {
 547                 log_syntax(unit, LOG_ERR, filename, line, -k,
 548                            "Failed to parse show status setting, ignoring: %s", rvalue);
 549                 return 0;
 550         }
 551
 552         return 0;
 553 }
 554
 555 static void strv_free_free(char ***l) {
 556         char ***i;
 557
 558         if (!l)
 559                 return;
 560
 561         for (i = l; *i; i++)
 562                 strv_free(*i);
 563
 564         free(l);
 565 }
 566
 567 static void free_join_controllers(void) {
 568         strv_free_free(arg_join_controllers);
 569         arg_join_controllers = NULL;
 570 }
 571
 572 static int config_parse_join_controllers(const char *unit,
 573                                          const char *filename,
 574                                          unsigned line,
 575                                          const char *section,
 576                                          unsigned section_line,
 577                                          const char *lvalue,
 578                                          int ltype,
 579                                          const char *rvalue,
 580                                          void *data,
 581                                          void *userdata) {
 582
 583         unsigned n = 0;
 584         char *state, *w;
 585         size_t length;
 586
 587         assert(filename);
 588         assert(lvalue);
 589         assert(rvalue);
 590
 591         free_join_controllers();
 592
 593         FOREACH_WORD_QUOTED(w, length, rvalue, state) {
 594                 char *s, **l;
 595
 596                 s = strndup(w, length);
 597                 if (!s)
 598                         return log_oom();
 599
 600                 l = strv_split(s, ",");
 601                 free(s);
 602
 603                 strv_uniq(l);
 604
 605                 if (strv_length(l) <= 1) {
 606                         strv_free(l);
 607                         continue;
 608                 }
 609
 610                 if (!arg_join_controllers) {
 611                         arg_join_controllers = new(char**, 2);
 612                         if (!arg_join_controllers) {
 613                                 strv_free(l);
 614                                 return log_oom();
 615                         }
 616
 617                         arg_join_controllers[0] = l;
 618                         arg_join_controllers[1] = NULL;
 619
 620                         n = 1;
 621                 } else {
 622                         char ***a;
 623                         char ***t;
 624
 625                         t = new0(char**, n+2);
 626                         if (!t) {
 627                                 strv_free(l);
 628                                 return log_oom();
 629                         }
 630
 631                         n = 0;
 632
 633                         for (a = arg_join_controllers; *a; a++) {
 634
 635                                 if (strv_overlap(*a, l)) {
 636                                         if (strv_extend_strv(&l, *a) < 0) {
 637                                                 strv_free(l);
 638                                                 strv_free_free(t);
 639                                                 return log_oom();
 640                                         }
 641
 642                                 } else {
 643                                         char **c;
 644
 645                                         c = strv_copy(*a);
 646                                         if (!c) {
 647                                                 strv_free(l);
 648                                                 strv_free_free(t);
 649                                                 return log_oom();
 650                                         }
 651
 652                                         t[n++] = c;
 653                                 }
 654                         }
 655
 656                         t[n++] = strv_uniq(l);
 657
 658                         strv_free_free(arg_join_controllers);
 659                         arg_join_controllers = t;
 660                 }
 661         }
 662
 663         return 0;
 664 }
 665
 666 static int parse_config_file(void) {
 667
 668         const ConfigTableItem items[] = {
 669                 { "Manager", "LogLevel",                  config_parse_level2,           0, NULL                                   },
 670                 { "Manager", "LogTarget",                 config_parse_target,           0, NULL                                   },
 671                 { "Manager", "LogColor",                  config_parse_color,            0, NULL                                   },
 672                 { "Manager", "LogLocation",               config_parse_location,         0, NULL                                   },
 673                 { "Manager", "DumpCore",                  config_parse_bool,             0, &arg_dump_core                         },
 674                 { "Manager", "CrashShell",                config_parse_bool,             0, &arg_crash_shell                       },
 675                 { "Manager", "ShowStatus",                config_parse_show_status,      0, &arg_show_status                       },
 676                 { "Manager", "CrashChVT",                 config_parse_int,              0, &arg_crash_chvt                        },
 677                 { "Manager", "CPUAffinity",               config_parse_cpu_affinity2,    0, NULL                                   },
 678                 { "Manager", "JoinControllers",           config_parse_join_controllers, 0, &arg_join_controllers                  },
 679                 { "Manager", "RuntimeWatchdogSec",        config_parse_sec,              0, &arg_runtime_watchdog                  },
 680                 { "Manager", "ShutdownWatchdogSec",       config_parse_sec,              0, &arg_shutdown_watchdog                 },
 681                 { "Manager", "CapabilityBoundingSet",     config_parse_bounding_set,     0, &arg_capability_bounding_set_drop      },
 682 #ifdef HAVE_SECCOMP
 683                 { "Manager", "SystemCallArchitectures",   config_parse_syscall_archs,    0, &arg_syscall_archs                     },
 684 #endif
 685                 { "Manager", "TimerSlackNSec",            config_parse_nsec,             0, &arg_timer_slack_nsec                  },
 686                 { "Manager", "DefaultTimerAccuracySec",   config_parse_sec,              0, &arg_default_timer_accuracy_usec       },
 687                 { "Manager", "DefaultCPUQuotaPeriodSec",  config_parse_sec,              0, &arg_default_cpu_quota_period_usec     },
 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_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1638         m->default_cpu_quota_period_usec = arg_default_cpu_quota_period_usec;
1639         m->default_std_output = arg_default_std_output;
1640         m->default_std_error = arg_default_std_error;
1641         m->default_restart_usec = arg_default_restart_usec;
1642         m->default_timeout_start_usec = arg_default_timeout_start_usec;
1643         m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1644         m->default_start_limit_interval = arg_default_start_limit_interval;
1645         m->default_start_limit_burst = arg_default_start_limit_burst;
1646         m->default_cpu_accounting = arg_default_cpu_accounting;
1647         m->default_blockio_accounting = arg_default_blockio_accounting;
1648         m->default_memory_accounting = arg_default_memory_accounting;
1649         m->runtime_watchdog = arg_runtime_watchdog;
1650         m->shutdown_watchdog = arg_shutdown_watchdog;
1651         m->userspace_timestamp = userspace_timestamp;
1652         m->kernel_timestamp = kernel_timestamp;
1653         m->initrd_timestamp = initrd_timestamp;
1654         m->security_start_timestamp = security_start_timestamp;
1655         m->security_finish_timestamp = security_finish_timestamp;
1656
1657         manager_set_default_rlimits(m, arg_default_rlimit);
1658         manager_environment_add(m, NULL, arg_default_environment);
1659         manager_set_show_status(m, arg_show_status);
1660
1661         /* Remember whether we should queue the default job */
1662         queue_default_job = !arg_serialization || arg_switched_root;
1663
1664         before_startup = now(CLOCK_MONOTONIC);
1665
1666         r = manager_startup(m, arg_serialization, fds);
1667         if (r < 0)
1668                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1669
1670         /* This will close all file descriptors that were opened, but
1671          * not claimed by any unit. */
1672         fdset_free(fds);
1673         fds = NULL;
1674
1675         if (arg_serialization) {
1676                 fclose(arg_serialization);
1677                 arg_serialization = NULL;
1678         }
1679
1680         if (queue_default_job) {
1681                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1682                 Unit *target = NULL;
1683                 Job *default_unit_job;
1684
1685                 log_debug("Activating default unit: %s", arg_default_unit);
1686
1687                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1688                 if (r < 0)
1689                         log_error("Failed to load default target: %s", bus_error_message(&error, r));
1690                 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1691                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1692                 else if (target->load_state == UNIT_MASKED)
1693                         log_error("Default target masked.");
1694
1695                 if (!target || target->load_state != UNIT_LOADED) {
1696                         log_info("Trying to load rescue target...");
1697
1698                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1699                         if (r < 0) {
1700                                 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1701                                 goto finish;
1702                         } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1703                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1704                                 goto finish;
1705                         } else if (target->load_state == UNIT_MASKED) {
1706                                 log_error("Rescue target masked.");
1707                                 goto finish;
1708                         }
1709                 }
1710
1711                 assert(target->load_state == UNIT_LOADED);
1712
1713                 if (arg_action == ACTION_TEST) {
1714                         printf("-> By units:\n");
1715                         manager_dump_units(m, stdout, "\t");
1716                 }
1717
1718                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1719                 if (r == -EPERM) {
1720                         log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1721
1722                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1723                         if (r < 0) {
1724                                 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1725                                 goto finish;
1726                         }
1727                 } else if (r < 0) {
1728                         log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1729                         goto finish;
1730                 }
1731
1732                 m->default_unit_job_id = default_unit_job->id;
1733
1734                 after_startup = now(CLOCK_MONOTONIC);
1735                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1736                          "Loaded units and determined initial transaction in %s.",
1737                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1738
1739                 if (arg_action == ACTION_TEST) {
1740                         printf("-> By jobs:\n");
1741                         manager_dump_jobs(m, stdout, "\t");
1742                         retval = EXIT_SUCCESS;
1743                         goto finish;
1744                 }
1745         }
1746
1747         for (;;) {
1748                 r = manager_loop(m);
1749                 if (r < 0) {
1750                         log_error("Failed to run mainloop: %s", strerror(-r));
1751                         goto finish;
1752                 }
1753
1754                 switch (m->exit_code) {
1755
1756                 case MANAGER_EXIT:
1757                         retval = EXIT_SUCCESS;
1758                         log_debug("Exit.");
1759                         goto finish;
1760
1761                 case MANAGER_RELOAD:
1762                         log_info("Reloading.");
1763                         r = manager_reload(m);
1764                         if (r < 0)
1765                                 log_error("Failed to reload: %s", strerror(-r));
1766                         break;
1767
1768                 case MANAGER_REEXECUTE:
1769
1770                         if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1771                                 goto finish;
1772
1773                         reexecute = true;
1774                         log_notice("Reexecuting.");
1775                         goto finish;
1776
1777                 case MANAGER_SWITCH_ROOT:
1778                         /* Steal the switch root parameters */
1779                         switch_root_dir = m->switch_root;
1780                         switch_root_init = m->switch_root_init;
1781                         m->switch_root = m->switch_root_init = NULL;
1782
1783                         if (!switch_root_init)
1784                                 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1785                                         goto finish;
1786
1787                         reexecute = true;
1788                         log_notice("Switching root.");
1789                         goto finish;
1790
1791                 case MANAGER_REBOOT:
1792                 case MANAGER_POWEROFF:
1793                 case MANAGER_HALT:
1794                 case MANAGER_KEXEC: {
1795                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1796                                 [MANAGER_REBOOT] = "reboot",
1797                                 [MANAGER_POWEROFF] = "poweroff",
1798                                 [MANAGER_HALT] = "halt",
1799                                 [MANAGER_KEXEC] = "kexec"
1800                         };
1801
1802                         assert_se(shutdown_verb = table[m->exit_code]);
1803                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1804
1805                         log_notice("Shutting down.");
1806                         goto finish;
1807                 }
1808
1809                 default:
1810                         assert_not_reached("Unknown exit code.");
1811                 }
1812         }
1813
1814 finish:
1815         if (m) {
1816                 manager_free(m);
1817                 m = NULL;
1818         }
1819
1820         for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1821                 free(arg_default_rlimit[j]);
1822                 arg_default_rlimit[j] = NULL;
1823         }
1824
1825         free(arg_default_unit);
1826         arg_default_unit = NULL;
1827
1828         free_join_controllers();
1829
1830         strv_free(arg_default_environment);
1831         arg_default_environment = NULL;
1832
1833         set_free(arg_syscall_archs);
1834         arg_syscall_archs = NULL;
1835
1836         label_finish();
1837
1838         if (reexecute) {
1839                 const char **args;
1840                 unsigned i, args_size;
1841
1842                 /* Close and disarm the watchdog, so that the new
1843                  * instance can reinitialize it, but doesn't get
1844                  * rebooted while we do that */
1845                 watchdog_close(true);
1846
1847                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1848                  * that the new systemd can pass the kernel default to
1849                  * its child processes */
1850                 if (saved_rlimit_nofile.rlim_cur > 0)
1851                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1852
1853                 if (switch_root_dir) {
1854                         /* Kill all remaining processes from the
1855                          * initrd, but don't wait for them, so that we
1856                          * can handle the SIGCHLD for them after
1857                          * deserializing. */
1858                         broadcast_signal(SIGTERM, false, true);
1859
1860                         /* And switch root */
1861                         r = switch_root(switch_root_dir);
1862                         if (r < 0)
1863                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1864                 }
1865
1866                 args_size = MAX(6, argc+1);
1867                 args = newa(const char*, args_size);
1868
1869                 if (!switch_root_init) {
1870                         char sfd[16];
1871
1872                         /* First try to spawn ourselves with the right
1873                          * path, and with full serialization. We do
1874                          * this only if the user didn't specify an
1875                          * explicit init to spawn. */
1876
1877                         assert(arg_serialization);
1878                         assert(fds);
1879
1880                         snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1881                         char_array_0(sfd);
1882
1883                         i = 0;
1884                         args[i++] = SYSTEMD_BINARY_PATH;
1885                         if (switch_root_dir)
1886                                 args[i++] = "--switched-root";
1887                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1888                         args[i++] = "--deserialize";
1889                         args[i++] = sfd;
1890                         args[i++] = NULL;
1891
1892                         /* do not pass along the environment we inherit from the kernel or initrd */
1893                         if (switch_root_dir)
1894                                 clearenv();
1895
1896                         assert(i <= args_size);
1897                         execv(args[0], (char* const*) args);
1898                 }
1899
1900                 /* Try the fallback, if there is any, without any
1901                  * serialization. We pass the original argv[] and
1902                  * envp[]. (Well, modulo the ordering changes due to
1903                  * getopt() in argv[], and some cleanups in envp[],
1904                  * but let's hope that doesn't matter.) */
1905
1906                 if (arg_serialization) {
1907                         fclose(arg_serialization);
1908                         arg_serialization = NULL;
1909                 }
1910
1911                 if (fds) {
1912                         fdset_free(fds);
1913                         fds = NULL;
1914                 }
1915
1916                 /* Reopen the console */
1917                 make_console_stdio();
1918
1919                 for (j = 1, i = 1; j < (unsigned) argc; j++)
1920                         args[i++] = argv[j];
1921                 args[i++] = NULL;
1922                 assert(i <= args_size);
1923
1924                 if (switch_root_init) {
1925                         args[0] = switch_root_init;
1926                         execv(args[0], (char* const*) args);
1927                         log_warning("Failed to execute configured init, trying fallback: %m");
1928                 }
1929
1930                 args[0] = "/sbin/init";
1931                 execv(args[0], (char* const*) args);
1932
1933                 if (errno == ENOENT) {
1934                         log_warning("No /sbin/init, trying fallback");
1935
1936                         args[0] = "/bin/sh";
1937                         args[1] = NULL;
1938                         execv(args[0], (char* const*) args);
1939                         log_error("Failed to execute /bin/sh, giving up: %m");
1940                 } else
1941                         log_warning("Failed to execute /sbin/init, giving up: %m");
1942         }
1943
1944         if (arg_serialization) {
1945                 fclose(arg_serialization);
1946                 arg_serialization = NULL;
1947         }
1948
1949         if (fds) {
1950                 fdset_free(fds);
1951                 fds = NULL;
1952         }
1953
1954 #ifdef HAVE_VALGRIND_VALGRIND_H
1955         /* If we are PID 1 and running under valgrind, then let's exit
1956          * here explicitly. valgrind will only generate nice output on
1957          * exit(), not on exec(), hence let's do the former not the
1958          * latter here. */
1959         if (getpid() == 1 && RUNNING_ON_VALGRIND)
1960                 return 0;
1961 #endif
1962
1963         if (shutdown_verb) {
1964                 char log_level[DECIMAL_STR_MAX(int) + 1];
1965                 const char* command_line[9] = {
1966                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1967                         shutdown_verb,
1968                         "--log-level", log_level,
1969                         "--log-target",
1970                 };
1971                 unsigned pos = 5;
1972                 _cleanup_strv_free_ char **env_block = NULL;
1973
1974                 assert(command_line[pos] == NULL);
1975                 env_block = strv_copy(environ);
1976
1977                 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1978
1979                 switch (log_get_target()) {
1980                 case LOG_TARGET_KMSG:
1981                 case LOG_TARGET_JOURNAL_OR_KMSG:
1982                 case LOG_TARGET_SYSLOG_OR_KMSG:
1983                         command_line[pos++] = "kmsg";
1984                         break;
1985
1986                 case LOG_TARGET_CONSOLE:
1987                 default:
1988                         command_line[pos++] = "console";
1989                         break;
1990                 };
1991
1992                 if (log_get_show_color())
1993                         command_line[pos++] = "--log-color";
1994
1995                 if (log_get_show_location())
1996                         command_line[pos++] = "--log-location";
1997
1998                 assert(pos < ELEMENTSOF(command_line));
1999
2000                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
2001                         char *e;
2002
2003                         /* If we reboot let's set the shutdown
2004                          * watchdog and tell the shutdown binary to
2005                          * repeatedly ping it */
2006                         watchdog_set_timeout(&arg_shutdown_watchdog);
2007                         watchdog_close(false);
2008
2009                         /* Tell the binary how often to ping, ignore failure */
2010                         if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2011                                 strv_push(&env_block, e);
2012                 } else
2013                         watchdog_close(true);
2014
2015                 /* Avoid the creation of new processes forked by the
2016                  * kernel; at this point, we will not listen to the
2017                  * signals anyway */
2018                 if (detect_container(NULL) <= 0)
2019                         cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2020
2021                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2022                 log_error("Failed to execute shutdown binary, %s: %m",
2023                           getpid() == 1 ? "freezing" : "quitting");
2024         }
2025
2026         if (getpid() == 1)
2027                 freeze();
2028
2029         return retval;
2030 }