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