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