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