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