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