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