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