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