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
1155         static const char ok[] =
1156                 "/proc/self/mounts\0"
1157                 "/proc/mounts\0"
1158                 "../proc/self/mounts\0"
1159                 "../proc/mounts\0";
1160
1161         _cleanup_free_ char *p = NULL;
1162         int r;
1163
1164         /* Check that /etc/mtab is a symlink to the right place or
1165          * non-existing. But certainly not a file, or a symlink to
1166          * some weird place... */
1167
1168         r = readlink_malloc("/etc/mtab", &p);
1169         if (r == -ENOENT)
1170                 return;
1171         if (r >= 0 && nulstr_contains(ok, p))
1172                 return;
1173
1174         log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1175                     "This is not supported anymore. "
1176                     "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1177 }
1178
1179 static void test_usr(void) {
1180
1181         /* Check that /usr is not a separate fs */
1182
1183         if (dir_is_empty("/usr") <= 0)
1184                 return;
1185
1186         log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1187                     "Some things will probably break (sometimes even silently) in mysterious ways. "
1188                     "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1189 }
1190
1191 static int initialize_join_controllers(void) {
1192         /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1193          * + "net_prio". We'd like to add "cpuset" to the mix, but
1194          * "cpuset" does't really work for groups with no initialized
1195          * attributes. */
1196
1197         arg_join_controllers = new(char**, 3);
1198         if (!arg_join_controllers)
1199                 return -ENOMEM;
1200
1201         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1202         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1203         arg_join_controllers[2] = NULL;
1204
1205         if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1206                 free_join_controllers();
1207                 return -ENOMEM;
1208         }
1209
1210         return 0;
1211 }
1212
1213 static int enforce_syscall_archs(Set *archs) {
1214 #ifdef HAVE_SECCOMP
1215         scmp_filter_ctx *seccomp;
1216         Iterator i;
1217         void *id;
1218         int r;
1219
1220         seccomp = seccomp_init(SCMP_ACT_ALLOW);
1221         if (!seccomp)
1222                 return log_oom();
1223
1224         SET_FOREACH(id, arg_syscall_archs, i) {
1225                 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1226                 if (r == -EEXIST)
1227                         continue;
1228                 if (r < 0) {
1229                         log_error("Failed to add architecture to seccomp: %s", strerror(-r));
1230                         goto finish;
1231                 }
1232         }
1233
1234         r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1235         if (r < 0) {
1236                 log_error("Failed to unset NO_NEW_PRIVS: %s", strerror(-r));
1237                 goto finish;
1238         }
1239
1240         r = seccomp_load(seccomp);
1241         if (r < 0)
1242                 log_error("Failed to add install architecture seccomp: %s", strerror(-r));
1243
1244 finish:
1245         seccomp_release(seccomp);
1246         return r;
1247 #else
1248         return 0;
1249 #endif
1250 }
1251
1252 static int status_welcome(void) {
1253         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1254         int r;
1255
1256         r = parse_env_file("/etc/os-release", NEWLINE,
1257                            "PRETTY_NAME", &pretty_name,
1258                            "ANSI_COLOR", &ansi_color,
1259                            NULL);
1260         if (r == -ENOENT) {
1261                 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1262                                    "PRETTY_NAME", &pretty_name,
1263                                    "ANSI_COLOR", &ansi_color,
1264                                    NULL);
1265         }
1266
1267         if (r < 0 && r != -ENOENT)
1268                 log_warning("Failed to read os-release file: %s", strerror(-r));
1269
1270         return status_printf(NULL, false, false,
1271                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1272                              isempty(ansi_color) ? "1" : ansi_color,
1273                              isempty(pretty_name) ? "Linux" : pretty_name);
1274 }
1275
1276 static int write_container_id(void) {
1277         const char *c;
1278
1279         c = getenv("container");
1280         if (isempty(c))
1281                 return 0;
1282
1283         return write_string_file("/run/systemd/container", c);
1284 }
1285
1286 int main(int argc, char *argv[]) {
1287         Manager *m = NULL;
1288         int r, retval = EXIT_FAILURE;
1289         usec_t before_startup, after_startup;
1290         char timespan[FORMAT_TIMESPAN_MAX];
1291         FDSet *fds = NULL;
1292         bool reexecute = false;
1293         const char *shutdown_verb = NULL;
1294         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1295         dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1296         dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1297         dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1298         dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1299         static char systemd[] = "systemd";
1300         bool skip_setup = false;
1301         unsigned j;
1302         bool loaded_policy = false;
1303         bool arm_reboot_watchdog = false;
1304         bool queue_default_job = false;
1305         char *switch_root_dir = NULL, *switch_root_init = NULL;
1306         static struct rlimit saved_rlimit_nofile = { 0, 0 };
1307
1308 #ifdef HAVE_SYSV_COMPAT
1309         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1310                 /* This is compatibility support for SysV, where
1311                  * calling init as a user is identical to telinit. */
1312
1313                 errno = -ENOENT;
1314                 execv(SYSTEMCTL_BINARY_PATH, argv);
1315                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1316                 return 1;
1317         }
1318 #endif
1319
1320         dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1321         dual_timestamp_get(&userspace_timestamp);
1322
1323         /* Determine if this is a reexecution or normal bootup. We do
1324          * the full command line parsing much later, so let's just
1325          * have a quick peek here. */
1326         if (strv_find(argv+1, "--deserialize"))
1327                 skip_setup = true;
1328
1329         /* If we have switched root, do all the special setup
1330          * things */
1331         if (strv_find(argv+1, "--switched-root"))
1332                 skip_setup = false;
1333
1334         /* If we get started via the /sbin/init symlink then we are
1335            called 'init'. After a subsequent reexecution we are then
1336            called 'systemd'. That is confusing, hence let's call us
1337            systemd right-away. */
1338         program_invocation_short_name = systemd;
1339         prctl(PR_SET_NAME, systemd);
1340
1341         saved_argv = argv;
1342         saved_argc = argc;
1343
1344         log_show_color(isatty(STDERR_FILENO) > 0);
1345
1346         /* Disable the umask logic */
1347         if (getpid() == 1)
1348                 umask(0);
1349
1350         if (getpid() == 1 && detect_container(NULL) <= 0) {
1351
1352                 /* Running outside of a container as PID 1 */
1353                 arg_running_as = SYSTEMD_SYSTEM;
1354                 make_null_stdio();
1355                 log_set_target(LOG_TARGET_KMSG);
1356                 log_open();
1357
1358                 if (in_initrd())
1359                         initrd_timestamp = userspace_timestamp;
1360
1361                 if (!skip_setup) {
1362                         mount_setup_early();
1363                         dual_timestamp_get(&security_start_timestamp);
1364                         if (selinux_setup(&loaded_policy) < 0)
1365                                 goto finish;
1366                         if (ima_setup() < 0)
1367                                 goto finish;
1368                         if (smack_setup(&loaded_policy) < 0)
1369                                 goto finish;
1370                         dual_timestamp_get(&security_finish_timestamp);
1371                 }
1372
1373                 if (label_init(NULL) < 0)
1374                         goto finish;
1375
1376                 if (!skip_setup) {
1377                         if (clock_is_localtime() > 0) {
1378                                 int min;
1379
1380                                 /* The first-time call to settimeofday() does a time warp in the kernel */
1381                                 r = clock_set_timezone(&min);
1382                                 if (r < 0)
1383                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1384                                 else
1385                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1386                         } else if (!in_initrd()) {
1387                                 /*
1388                                  * Do dummy first-time call to seal the kernel's time warp magic
1389                                  *
1390                                  * Do not call this this from inside the initrd. The initrd might not
1391                                  * carry /etc/adjtime with LOCAL, but the real system could be set up
1392                                  * that way. In such case, we need to delay the time-warp or the sealing
1393                                  * until we reach the real system.
1394                                  */
1395                                 clock_reset_timezone();
1396
1397                                 /* Tell the kernel our timezone */
1398                                 r = clock_set_timezone(NULL);
1399                                 if (r < 0)
1400                                         log_error("Failed to set the kernel's timezone, ignoring: %s", strerror(-r));
1401                         }
1402                 }
1403
1404                 /* Set the default for later on, but don't actually
1405                  * open the logs like this for now. Note that if we
1406                  * are transitioning from the initrd there might still
1407                  * be journal fd open, and we shouldn't attempt
1408                  * opening that before we parsed /proc/cmdline which
1409                  * might redirect output elsewhere. */
1410                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1411
1412         } else if (getpid() == 1) {
1413                 /* Running inside a container, as PID 1 */
1414                 arg_running_as = SYSTEMD_SYSTEM;
1415                 log_set_target(LOG_TARGET_CONSOLE);
1416                 log_close_console(); /* force reopen of /dev/console */
1417                 log_open();
1418
1419                 /* For the later on, see above... */
1420                 log_set_target(LOG_TARGET_JOURNAL);
1421
1422                 /* clear the kernel timestamp,
1423                  * because we are in a container */
1424                 kernel_timestamp.monotonic = 0ULL;
1425                 kernel_timestamp.realtime = 0ULL;
1426
1427         } else {
1428                 /* Running as user instance */
1429                 arg_running_as = SYSTEMD_USER;
1430                 log_set_target(LOG_TARGET_AUTO);
1431                 log_open();
1432
1433                 /* clear the kernel timestamp,
1434                  * because we are not PID 1 */
1435                 kernel_timestamp.monotonic = 0ULL;
1436                 kernel_timestamp.realtime = 0ULL;
1437         }
1438
1439         /* Initialize default unit */
1440         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1441         if (r < 0) {
1442                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1443                 goto finish;
1444         }
1445
1446         r = initialize_join_controllers();
1447         if (r < 0)
1448                 goto finish;
1449
1450         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1451          * /proc/$PID/fd is available. */
1452         if (getpid() == 1) {
1453                 r = mount_setup(loaded_policy);
1454                 if (r < 0)
1455                         goto finish;
1456         }
1457
1458         /* Reset all signal handlers. */
1459         assert_se(reset_all_signal_handlers() == 0);
1460
1461         ignore_signals(SIGNALS_IGNORE, -1);
1462
1463         if (parse_config_file() < 0)
1464                 goto finish;
1465
1466         if (arg_running_as == SYSTEMD_SYSTEM)
1467                 if (parse_proc_cmdline(parse_proc_cmdline_item) < 0)
1468                         goto finish;
1469
1470         log_parse_environment();
1471
1472         if (parse_argv(argc, argv) < 0)
1473                 goto finish;
1474
1475         if (arg_action == ACTION_TEST &&
1476             geteuid() == 0) {
1477                 log_error("Don't run test mode as root.");
1478                 goto finish;
1479         }
1480
1481         if (arg_running_as == SYSTEMD_USER &&
1482             arg_action == ACTION_RUN &&
1483             sd_booted() <= 0) {
1484                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1485                 goto finish;
1486         }
1487
1488         if (arg_running_as == SYSTEMD_SYSTEM &&
1489             arg_action == ACTION_RUN &&
1490             running_in_chroot() > 0) {
1491                 log_error("Cannot be run in a chroot() environment.");
1492                 goto finish;
1493         }
1494
1495         if (arg_action == ACTION_HELP) {
1496                 retval = help();
1497                 goto finish;
1498         } else if (arg_action == ACTION_VERSION) {
1499                 retval = version();
1500                 goto finish;
1501         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1502                 unit_dump_config_items(stdout);
1503                 retval = EXIT_SUCCESS;
1504                 goto finish;
1505         } else if (arg_action == ACTION_DONE) {
1506                 retval = EXIT_SUCCESS;
1507                 goto finish;
1508         }
1509
1510         if (arg_running_as == SYSTEMD_USER &&
1511             !getenv("XDG_RUNTIME_DIR")) {
1512                 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1513                 goto finish;
1514         }
1515
1516         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1517
1518         /* Close logging fds, in order not to confuse fdset below */
1519         log_close();
1520
1521         /* Remember open file descriptors for later deserialization */
1522         r = fdset_new_fill(&fds);
1523         if (r < 0) {
1524                 log_error("Failed to allocate fd set: %s", strerror(-r));
1525                 goto finish;
1526         } else
1527                 fdset_cloexec(fds, true);
1528
1529         if (arg_serialization)
1530                 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1531
1532         if (arg_running_as == SYSTEMD_SYSTEM)
1533                 /* Become a session leader if we aren't one yet. */
1534                 setsid();
1535
1536         /* Move out of the way, so that we won't block unmounts */
1537         assert_se(chdir("/")  == 0);
1538
1539         /* Reset the console, but only if this is really init and we
1540          * are freshly booted */
1541         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1542                 console_setup(getpid() == 1 && !skip_setup);
1543
1544         /* Open the logging devices, if possible and necessary */
1545         log_open();
1546
1547         if (arg_show_status == _SHOW_STATUS_UNSET)
1548                 arg_show_status = SHOW_STATUS_YES;
1549
1550         /* Make sure we leave a core dump without panicing the
1551          * kernel. */
1552         if (getpid() == 1) {
1553                 install_crash_handler();
1554
1555                 r = mount_cgroup_controllers(arg_join_controllers);
1556                 if (r < 0)
1557                         goto finish;
1558         }
1559
1560         if (arg_running_as == SYSTEMD_SYSTEM) {
1561                 const char *virtualization = NULL;
1562
1563                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1564
1565                 detect_virtualization(&virtualization);
1566                 if (virtualization)
1567                         log_info("Detected virtualization '%s'.", virtualization);
1568
1569                 write_container_id();
1570
1571                 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1572
1573                 if (in_initrd())
1574                         log_info("Running in initial RAM disk.");
1575
1576         } else {
1577                 _cleanup_free_ char *t = uid_to_name(getuid());
1578                 log_debug(PACKAGE_STRING " running in user mode for user "PID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1579                           getuid(), t);
1580         }
1581
1582         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1583                 if (arg_show_status > 0 || plymouth_running())
1584                         status_welcome();
1585
1586 #ifdef HAVE_KMOD
1587                 if (detect_container(NULL) <= 0)
1588                         kmod_setup();
1589 #endif
1590                 hostname_setup();
1591                 machine_id_setup("");
1592                 loopback_setup();
1593
1594                 test_mtab();
1595                 test_usr();
1596         }
1597
1598         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1599                 watchdog_set_timeout(&arg_runtime_watchdog);
1600
1601         if (arg_timer_slack_nsec != (nsec_t) -1)
1602                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1603                         log_error("Failed to adjust timer slack: %m");
1604
1605         if (arg_capability_bounding_set_drop) {
1606                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1607                 if (r < 0) {
1608                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1609                         goto finish;
1610                 }
1611                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1612                 if (r < 0) {
1613                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1614                         goto finish;
1615                 }
1616         }
1617
1618         if (arg_syscall_archs) {
1619                 r = enforce_syscall_archs(arg_syscall_archs);
1620                 if (r < 0)
1621                         goto finish;
1622         }
1623
1624         if (arg_running_as == SYSTEMD_USER) {
1625                 /* Become reaper of our children */
1626                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1627                         log_warning("Failed to make us a subreaper: %m");
1628                         if (errno == EINVAL)
1629                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1630                 }
1631         }
1632
1633         if (arg_running_as == SYSTEMD_SYSTEM)
1634                 bump_rlimit_nofile(&saved_rlimit_nofile);
1635
1636         r = manager_new(arg_running_as, &m);
1637         if (r < 0) {
1638                 log_error("Failed to allocate manager object: %s", strerror(-r));
1639                 goto finish;
1640         }
1641
1642         m->confirm_spawn = arg_confirm_spawn;
1643         m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1644         m->default_std_output = arg_default_std_output;
1645         m->default_std_error = arg_default_std_error;
1646         m->default_restart_usec = arg_default_restart_usec;
1647         m->default_timeout_start_usec = arg_default_timeout_start_usec;
1648         m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1649         m->default_start_limit_interval = arg_default_start_limit_interval;
1650         m->default_start_limit_burst = arg_default_start_limit_burst;
1651         m->default_cpu_accounting = arg_default_cpu_accounting;
1652         m->default_blockio_accounting = arg_default_blockio_accounting;
1653         m->default_memory_accounting = arg_default_memory_accounting;
1654         m->runtime_watchdog = arg_runtime_watchdog;
1655         m->shutdown_watchdog = arg_shutdown_watchdog;
1656         m->userspace_timestamp = userspace_timestamp;
1657         m->kernel_timestamp = kernel_timestamp;
1658         m->initrd_timestamp = initrd_timestamp;
1659         m->security_start_timestamp = security_start_timestamp;
1660         m->security_finish_timestamp = security_finish_timestamp;
1661
1662         manager_set_default_rlimits(m, arg_default_rlimit);
1663         manager_environment_add(m, NULL, arg_default_environment);
1664         manager_set_show_status(m, arg_show_status);
1665
1666         /* Remember whether we should queue the default job */
1667         queue_default_job = !arg_serialization || arg_switched_root;
1668
1669         before_startup = now(CLOCK_MONOTONIC);
1670
1671         r = manager_startup(m, arg_serialization, fds);
1672         if (r < 0)
1673                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1674
1675         /* This will close all file descriptors that were opened, but
1676          * not claimed by any unit. */
1677         fdset_free(fds);
1678         fds = NULL;
1679
1680         if (arg_serialization) {
1681                 fclose(arg_serialization);
1682                 arg_serialization = NULL;
1683         }
1684
1685         if (queue_default_job) {
1686                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1687                 Unit *target = NULL;
1688                 Job *default_unit_job;
1689
1690                 log_debug("Activating default unit: %s", arg_default_unit);
1691
1692                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1693                 if (r < 0)
1694                         log_error("Failed to load default target: %s", bus_error_message(&error, r));
1695                 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1696                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1697                 else if (target->load_state == UNIT_MASKED)
1698                         log_error("Default target masked.");
1699
1700                 if (!target || target->load_state != UNIT_LOADED) {
1701                         log_info("Trying to load rescue target...");
1702
1703                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1704                         if (r < 0) {
1705                                 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1706                                 goto finish;
1707                         } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1708                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1709                                 goto finish;
1710                         } else if (target->load_state == UNIT_MASKED) {
1711                                 log_error("Rescue target masked.");
1712                                 goto finish;
1713                         }
1714                 }
1715
1716                 assert(target->load_state == UNIT_LOADED);
1717
1718                 if (arg_action == ACTION_TEST) {
1719                         printf("-> By units:\n");
1720                         manager_dump_units(m, stdout, "\t");
1721                 }
1722
1723                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1724                 if (r == -EPERM) {
1725                         log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1726
1727                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1728                         if (r < 0) {
1729                                 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1730                                 goto finish;
1731                         }
1732                 } else if (r < 0) {
1733                         log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1734                         goto finish;
1735                 }
1736
1737                 m->default_unit_job_id = default_unit_job->id;
1738
1739                 after_startup = now(CLOCK_MONOTONIC);
1740                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1741                          "Loaded units and determined initial transaction in %s.",
1742                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1743
1744                 if (arg_action == ACTION_TEST) {
1745                         printf("-> By jobs:\n");
1746                         manager_dump_jobs(m, stdout, "\t");
1747                         retval = EXIT_SUCCESS;
1748                         goto finish;
1749                 }
1750         }
1751
1752         for (;;) {
1753                 r = manager_loop(m);
1754                 if (r < 0) {
1755                         log_error("Failed to run mainloop: %s", strerror(-r));
1756                         goto finish;
1757                 }
1758
1759                 switch (m->exit_code) {
1760
1761                 case MANAGER_EXIT:
1762                         retval = EXIT_SUCCESS;
1763                         log_debug("Exit.");
1764                         goto finish;
1765
1766                 case MANAGER_RELOAD:
1767                         log_info("Reloading.");
1768                         r = manager_reload(m);
1769                         if (r < 0)
1770                                 log_error("Failed to reload: %s", strerror(-r));
1771                         break;
1772
1773                 case MANAGER_REEXECUTE:
1774
1775                         if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1776                                 goto finish;
1777
1778                         reexecute = true;
1779                         log_notice("Reexecuting.");
1780                         goto finish;
1781
1782                 case MANAGER_SWITCH_ROOT:
1783                         /* Steal the switch root parameters */
1784                         switch_root_dir = m->switch_root;
1785                         switch_root_init = m->switch_root_init;
1786                         m->switch_root = m->switch_root_init = NULL;
1787
1788                         if (!switch_root_init)
1789                                 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1790                                         goto finish;
1791
1792                         reexecute = true;
1793                         log_notice("Switching root.");
1794                         goto finish;
1795
1796                 case MANAGER_REBOOT:
1797                 case MANAGER_POWEROFF:
1798                 case MANAGER_HALT:
1799                 case MANAGER_KEXEC: {
1800                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1801                                 [MANAGER_REBOOT] = "reboot",
1802                                 [MANAGER_POWEROFF] = "poweroff",
1803                                 [MANAGER_HALT] = "halt",
1804                                 [MANAGER_KEXEC] = "kexec"
1805                         };
1806
1807                         assert_se(shutdown_verb = table[m->exit_code]);
1808                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1809
1810                         log_notice("Shutting down.");
1811                         goto finish;
1812                 }
1813
1814                 default:
1815                         assert_not_reached("Unknown exit code.");
1816                 }
1817         }
1818
1819 finish:
1820         if (m) {
1821                 manager_free(m);
1822                 m = NULL;
1823         }
1824
1825         for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1826                 free(arg_default_rlimit[j]);
1827                 arg_default_rlimit[j] = NULL;
1828         }
1829
1830         free(arg_default_unit);
1831         arg_default_unit = NULL;
1832
1833         free_join_controllers();
1834
1835         strv_free(arg_default_environment);
1836         arg_default_environment = NULL;
1837
1838         set_free(arg_syscall_archs);
1839         arg_syscall_archs = NULL;
1840
1841         label_finish();
1842
1843         if (reexecute) {
1844                 const char **args;
1845                 unsigned i, args_size;
1846
1847                 /* Close and disarm the watchdog, so that the new
1848                  * instance can reinitialize it, but doesn't get
1849                  * rebooted while we do that */
1850                 watchdog_close(true);
1851
1852                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1853                  * that the new systemd can pass the kernel default to
1854                  * its child processes */
1855                 if (saved_rlimit_nofile.rlim_cur > 0)
1856                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1857
1858                 if (switch_root_dir) {
1859                         /* Kill all remaining processes from the
1860                          * initrd, but don't wait for them, so that we
1861                          * can handle the SIGCHLD for them after
1862                          * deserializing. */
1863                         broadcast_signal(SIGTERM, false, true);
1864
1865                         /* And switch root */
1866                         r = switch_root(switch_root_dir);
1867                         if (r < 0)
1868                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1869                 }
1870
1871                 args_size = MAX(6, argc+1);
1872                 args = newa(const char*, args_size);
1873
1874                 if (!switch_root_init) {
1875                         char sfd[16];
1876
1877                         /* First try to spawn ourselves with the right
1878                          * path, and with full serialization. We do
1879                          * this only if the user didn't specify an
1880                          * explicit init to spawn. */
1881
1882                         assert(arg_serialization);
1883                         assert(fds);
1884
1885                         snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1886                         char_array_0(sfd);
1887
1888                         i = 0;
1889                         args[i++] = SYSTEMD_BINARY_PATH;
1890                         if (switch_root_dir)
1891                                 args[i++] = "--switched-root";
1892                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1893                         args[i++] = "--deserialize";
1894                         args[i++] = sfd;
1895                         args[i++] = NULL;
1896
1897                         /* do not pass along the environment we inherit from the kernel or initrd */
1898                         if (switch_root_dir)
1899                                 clearenv();
1900
1901                         assert(i <= args_size);
1902                         execv(args[0], (char* const*) args);
1903                 }
1904
1905                 /* Try the fallback, if there is any, without any
1906                  * serialization. We pass the original argv[] and
1907                  * envp[]. (Well, modulo the ordering changes due to
1908                  * getopt() in argv[], and some cleanups in envp[],
1909                  * but let's hope that doesn't matter.) */
1910
1911                 if (arg_serialization) {
1912                         fclose(arg_serialization);
1913                         arg_serialization = NULL;
1914                 }
1915
1916                 if (fds) {
1917                         fdset_free(fds);
1918                         fds = NULL;
1919                 }
1920
1921                 /* Reopen the console */
1922                 make_console_stdio();
1923
1924                 for (j = 1, i = 1; j < (unsigned) argc; j++)
1925                         args[i++] = argv[j];
1926                 args[i++] = NULL;
1927                 assert(i <= args_size);
1928
1929                 if (switch_root_init) {
1930                         args[0] = switch_root_init;
1931                         execv(args[0], (char* const*) args);
1932                         log_warning("Failed to execute configured init, trying fallback: %m");
1933                 }
1934
1935                 args[0] = "/sbin/init";
1936                 execv(args[0], (char* const*) args);
1937
1938                 if (errno == ENOENT) {
1939                         log_warning("No /sbin/init, trying fallback");
1940
1941                         args[0] = "/bin/sh";
1942                         args[1] = NULL;
1943                         execv(args[0], (char* const*) args);
1944                         log_error("Failed to execute /bin/sh, giving up: %m");
1945                 } else
1946                         log_warning("Failed to execute /sbin/init, giving up: %m");
1947         }
1948
1949         if (arg_serialization) {
1950                 fclose(arg_serialization);
1951                 arg_serialization = NULL;
1952         }
1953
1954         if (fds) {
1955                 fdset_free(fds);
1956                 fds = NULL;
1957         }
1958
1959 #ifdef HAVE_VALGRIND_VALGRIND_H
1960         /* If we are PID 1 and running under valgrind, then let's exit
1961          * here explicitly. valgrind will only generate nice output on
1962          * exit(), not on exec(), hence let's do the former not the
1963          * latter here. */
1964         if (getpid() == 1 && RUNNING_ON_VALGRIND)
1965                 return 0;
1966 #endif
1967
1968         if (shutdown_verb) {
1969                 char log_level[DECIMAL_STR_MAX(int) + 1];
1970                 const char* command_line[9] = {
1971                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1972                         shutdown_verb,
1973                         "--log-level", log_level,
1974                         "--log-target",
1975                 };
1976                 unsigned pos = 5;
1977                 _cleanup_strv_free_ char **env_block = NULL;
1978
1979                 assert(command_line[pos] == NULL);
1980                 env_block = strv_copy(environ);
1981
1982                 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1983
1984                 switch (log_get_target()) {
1985                 case LOG_TARGET_KMSG:
1986                 case LOG_TARGET_JOURNAL_OR_KMSG:
1987                 case LOG_TARGET_SYSLOG_OR_KMSG:
1988                         command_line[pos++] = "kmsg";
1989                         break;
1990
1991                 case LOG_TARGET_CONSOLE:
1992                 default:
1993                         command_line[pos++] = "console";
1994                         break;
1995                 };
1996
1997                 if (log_get_show_color())
1998                         command_line[pos++] = "--log-color";
1999
2000                 if (log_get_show_location())
2001                         command_line[pos++] = "--log-location";
2002
2003                 assert(pos < ELEMENTSOF(command_line));
2004
2005                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
2006                         char *e;
2007
2008                         /* If we reboot let's set the shutdown
2009                          * watchdog and tell the shutdown binary to
2010                          * repeatedly ping it */
2011                         watchdog_set_timeout(&arg_shutdown_watchdog);
2012                         watchdog_close(false);
2013
2014                         /* Tell the binary how often to ping, ignore failure */
2015                         if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2016                                 strv_push(&env_block, e);
2017                 } else
2018                         watchdog_close(true);
2019
2020                 /* Avoid the creation of new processes forked by the
2021                  * kernel; at this point, we will not listen to the
2022                  * signals anyway */
2023                 if (detect_container(NULL) <= 0)
2024                         cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2025
2026                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2027                 log_error("Failed to execute shutdown binary, %s: %m",
2028                           getpid() == 1 ? "freezing" : "quitting");
2029         }
2030
2031         if (getpid() == 1)
2032                 freeze();
2033
2034         return retval;
2035 }