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_errno(errno, "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_errno(errno, "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_errno(errno, "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                                 return log_error_errno(errno, "Failed to open serialization fd: %m");
 889
 890                         if (arg_serialization)
 891                                 fclose(arg_serialization);
 892
 893                         arg_serialization = f;
 894
 895                         break;
 896                 }
 897
 898                 case ARG_SWITCHED_ROOT:
 899                         arg_switched_root = true;
 900                         break;
 901
 902                 case 'h':
 903                         arg_action = ACTION_HELP;
 904                         if (arg_no_pager < 0)
 905                                 arg_no_pager = true;
 906                         break;
 907
 908                 case 'D':
 909                         log_set_max_level(LOG_DEBUG);
 910                         break;
 911
 912                 case 'b':
 913                 case 's':
 914                 case 'z':
 915                         /* Just to eat away the sysvinit kernel
 916                          * cmdline args without getopt() error
 917                          * messages that we'll parse in
 918                          * parse_proc_cmdline_word() or ignore. */
 919
 920                 case '?':
 921                         if (getpid() != 1)
 922                                 return -EINVAL;
 923                         else
 924                                 return 0;
 925
 926                 default:
 927                         assert_not_reached("Unhandled option code.");
 928                 }
 929
 930         if (optind < argc && getpid() != 1) {
 931                 /* Hmm, when we aren't run as init system
 932                  * let's complain about excess arguments */
 933
 934                 log_error("Excess arguments.");
 935                 return -EINVAL;
 936         }
 937
 938         return 0;
 939 }
 940
 941 static int help(void) {
 942
 943         printf("%s [OPTIONS...]\n\n"
 944                "Starts up and maintains the system or user services.\n\n"
 945                "  -h --help                      Show this help\n"
 946                "     --test                      Determine startup sequence, dump it and exit\n"
 947                "     --no-pager                  Do not pipe output into a pager\n"
 948                "     --dump-configuration-items  Dump understood unit configuration items\n"
 949                "     --unit=UNIT                 Set default unit\n"
 950                "     --system                    Run a system instance, even if PID != 1\n"
 951                "     --user                      Run a user instance\n"
 952                "     --dump-core[=0|1]           Dump core on crash\n"
 953                "     --crash-shell[=0|1]         Run shell on crash\n"
 954                "     --confirm-spawn[=0|1]       Ask for confirmation when spawning processes\n"
 955                "     --show-status[=0|1]         Show status updates on the console during bootup\n"
 956                "     --log-target=TARGET         Set log target (console, journal, kmsg, journal-or-kmsg, null)\n"
 957                "     --log-level=LEVEL           Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
 958                "     --log-color[=0|1]           Highlight important log messages\n"
 959                "     --log-location[=0|1]        Include code location in log messages\n"
 960                "     --default-standard-output=  Set default standard output for services\n"
 961                "     --default-standard-error=   Set default standard error output for services\n",
 962                program_invocation_short_name);
 963
 964         return 0;
 965 }
 966
 967 static int version(void) {
 968         puts(PACKAGE_STRING);
 969         puts(SYSTEMD_FEATURES);
 970
 971         return 0;
 972 }
 973
 974 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
 975         FILE *f = NULL;
 976         FDSet *fds = NULL;
 977         int r;
 978
 979         assert(m);
 980         assert(_f);
 981         assert(_fds);
 982
 983         r = manager_open_serialization(m, &f);
 984         if (r < 0) {
 985                 log_error_errno(r, "Failed to create serialization file: %m");
 986                 goto fail;
 987         }
 988
 989         /* Make sure nothing is really destructed when we shut down */
 990         m->n_reloading ++;
 991         bus_manager_send_reloading(m, true);
 992
 993         fds = fdset_new();
 994         if (!fds) {
 995                 r = -ENOMEM;
 996                 log_error_errno(r, "Failed to allocate fd set: %m");
 997                 goto fail;
 998         }
 999
1000         r = manager_serialize(m, f, fds, switching_root);
1001         if (r < 0) {
1002                 log_error_errno(r, "Failed to serialize state: %m");
1003                 goto fail;
1004         }
1005
1006         if (fseeko(f, 0, SEEK_SET) < 0) {
1007                 log_error_errno(errno, "Failed to rewind serialization fd: %m");
1008                 goto fail;
1009         }
1010
1011         r = fd_cloexec(fileno(f), false);
1012         if (r < 0) {
1013                 log_error_errno(r, "Failed to disable O_CLOEXEC for serialization: %m");
1014                 goto fail;
1015         }
1016
1017         r = fdset_cloexec(fds, false);
1018         if (r < 0) {
1019                 log_error_errno(r, "Failed to disable O_CLOEXEC for serialization fds: %m");
1020                 goto fail;
1021         }
1022
1023         *_f = f;
1024         *_fds = fds;
1025
1026         return 0;
1027
1028 fail:
1029         fdset_free(fds);
1030
1031         if (f)
1032                 fclose(f);
1033
1034         return r;
1035 }
1036
1037 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1038         struct rlimit nl;
1039         int r;
1040
1041         assert(saved_rlimit);
1042
1043         /* Save the original RLIMIT_NOFILE so that we can reset it
1044          * later when transitioning from the initrd to the main
1045          * systemd or suchlike. */
1046         if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0)
1047                 return log_error_errno(errno, "Reading RLIMIT_NOFILE failed: %m");
1048
1049         /* Make sure forked processes get the default kernel setting */
1050         if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1051                 struct rlimit *rl;
1052
1053                 rl = newdup(struct rlimit, saved_rlimit, 1);
1054                 if (!rl)
1055                         return log_oom();
1056
1057                 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1058         }
1059
1060         /* Bump up the resource limit for ourselves substantially */
1061         nl.rlim_cur = nl.rlim_max = 64*1024;
1062         r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1063         if (r < 0)
1064                 return log_error_errno(r, "Setting RLIMIT_NOFILE failed: %m");
1065
1066         return 0;
1067 }
1068
1069 static void test_mtab(void) {
1070
1071         static const char ok[] =
1072                 "/proc/self/mounts\0"
1073                 "/proc/mounts\0"
1074                 "../proc/self/mounts\0"
1075                 "../proc/mounts\0";
1076
1077         _cleanup_free_ char *p = NULL;
1078         int r;
1079
1080         /* Check that /etc/mtab is a symlink to the right place or
1081          * non-existing. But certainly not a file, or a symlink to
1082          * some weird place... */
1083
1084         r = readlink_malloc("/etc/mtab", &p);
1085         if (r == -ENOENT)
1086                 return;
1087         if (r >= 0 && nulstr_contains(ok, p))
1088                 return;
1089
1090         log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1091                     "This is not supported anymore. "
1092                     "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1093 }
1094
1095 static void test_usr(void) {
1096
1097         /* Check that /usr is not a separate fs */
1098
1099         if (dir_is_empty("/usr") <= 0)
1100                 return;
1101
1102         log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1103                     "Some things will probably break (sometimes even silently) in mysterious ways. "
1104                     "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1105 }
1106
1107 static int initialize_join_controllers(void) {
1108         /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1109          * + "net_prio". We'd like to add "cpuset" to the mix, but
1110          * "cpuset" does't really work for groups with no initialized
1111          * attributes. */
1112
1113         arg_join_controllers = new(char**, 3);
1114         if (!arg_join_controllers)
1115                 return -ENOMEM;
1116
1117         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1118         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1119         arg_join_controllers[2] = NULL;
1120
1121         if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1122                 free_join_controllers();
1123                 return -ENOMEM;
1124         }
1125
1126         return 0;
1127 }
1128
1129 static int enforce_syscall_archs(Set *archs) {
1130 #ifdef HAVE_SECCOMP
1131         scmp_filter_ctx *seccomp;
1132         Iterator i;
1133         void *id;
1134         int r;
1135
1136         seccomp = seccomp_init(SCMP_ACT_ALLOW);
1137         if (!seccomp)
1138                 return log_oom();
1139
1140         SET_FOREACH(id, arg_syscall_archs, i) {
1141                 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1142                 if (r == -EEXIST)
1143                         continue;
1144                 if (r < 0) {
1145                         log_error_errno(r, "Failed to add architecture to seccomp: %m");
1146                         goto finish;
1147                 }
1148         }
1149
1150         r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1151         if (r < 0) {
1152                 log_error_errno(r, "Failed to unset NO_NEW_PRIVS: %m");
1153                 goto finish;
1154         }
1155
1156         r = seccomp_load(seccomp);
1157         if (r < 0)
1158                 log_error_errno(r, "Failed to add install architecture seccomp: %m");
1159
1160 finish:
1161         seccomp_release(seccomp);
1162         return r;
1163 #else
1164         return 0;
1165 #endif
1166 }
1167
1168 static int status_welcome(void) {
1169         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1170         int r;
1171
1172         r = parse_env_file("/etc/os-release", NEWLINE,
1173                            "PRETTY_NAME", &pretty_name,
1174                            "ANSI_COLOR", &ansi_color,
1175                            NULL);
1176         if (r == -ENOENT) {
1177                 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1178                                    "PRETTY_NAME", &pretty_name,
1179                                    "ANSI_COLOR", &ansi_color,
1180                                    NULL);
1181         }
1182
1183         if (r < 0 && r != -ENOENT)
1184                 log_warning_errno(r, "Failed to read os-release file: %m");
1185
1186         return status_printf(NULL, false, false,
1187                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1188                              isempty(ansi_color) ? "1" : ansi_color,
1189                              isempty(pretty_name) ? "Linux" : pretty_name);
1190 }
1191
1192 static int write_container_id(void) {
1193         const char *c;
1194
1195         c = getenv("container");
1196         if (isempty(c))
1197                 return 0;
1198
1199         return write_string_file("/run/systemd/container", c);
1200 }
1201
1202 int main(int argc, char *argv[]) {
1203         Manager *m = NULL;
1204         int r, retval = EXIT_FAILURE;
1205         usec_t before_startup, after_startup;
1206         char timespan[FORMAT_TIMESPAN_MAX];
1207         FDSet *fds = NULL;
1208         bool reexecute = false;
1209         const char *shutdown_verb = NULL;
1210         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1211         dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1212         dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1213         dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1214         dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1215         static char systemd[] = "systemd";
1216         bool skip_setup = false;
1217         unsigned j;
1218         bool loaded_policy = false;
1219         bool arm_reboot_watchdog = false;
1220         bool queue_default_job = false;
1221         bool empty_etc = false;
1222         char *switch_root_dir = NULL, *switch_root_init = NULL;
1223         static struct rlimit saved_rlimit_nofile = { 0, 0 };
1224         const char *error_message = NULL;
1225
1226 #ifdef HAVE_SYSV_COMPAT
1227         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1228                 /* This is compatibility support for SysV, where
1229                  * calling init as a user is identical to telinit. */
1230
1231                 errno = -ENOENT;
1232                 execv(SYSTEMCTL_BINARY_PATH, argv);
1233                 log_error_errno(errno, "Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1234                 return 1;
1235         }
1236 #endif
1237
1238         dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1239         dual_timestamp_get(&userspace_timestamp);
1240
1241         /* Determine if this is a reexecution or normal bootup. We do
1242          * the full command line parsing much later, so let's just
1243          * have a quick peek here. */
1244         if (strv_find(argv+1, "--deserialize"))
1245                 skip_setup = true;
1246
1247         /* If we have switched root, do all the special setup
1248          * things */
1249         if (strv_find(argv+1, "--switched-root"))
1250                 skip_setup = false;
1251
1252         /* If we get started via the /sbin/init symlink then we are
1253            called 'init'. After a subsequent reexecution we are then
1254            called 'systemd'. That is confusing, hence let's call us
1255            systemd right-away. */
1256         program_invocation_short_name = systemd;
1257         prctl(PR_SET_NAME, systemd);
1258
1259         saved_argv = argv;
1260         saved_argc = argc;
1261
1262         log_show_color(isatty(STDERR_FILENO) > 0);
1263         log_set_upgrade_syslog_to_journal(true);
1264
1265         /* Disable the umask logic */
1266         if (getpid() == 1)
1267                 umask(0);
1268
1269         if (getpid() == 1 && detect_container(NULL) <= 0) {
1270
1271                 /* Running outside of a container as PID 1 */
1272                 arg_running_as = SYSTEMD_SYSTEM;
1273                 make_null_stdio();
1274                 log_set_target(LOG_TARGET_KMSG);
1275                 log_open();
1276
1277                 if (in_initrd())
1278                         initrd_timestamp = userspace_timestamp;
1279
1280                 if (!skip_setup) {
1281                         mount_setup_early();
1282                         dual_timestamp_get(&security_start_timestamp);
1283                         if (mac_selinux_setup(&loaded_policy) < 0) {
1284                                 error_message = "Failed to load SELinux policy";
1285                                 goto finish;
1286                         } else if (ima_setup() < 0) {
1287                                 error_message = "Failed to load IMA policy";
1288                                 goto finish;
1289                         } else if (mac_smack_setup(&loaded_policy) < 0) {
1290                                 error_message = "Failed to load SMACK policy";
1291                                 goto finish;
1292                         }
1293                         dual_timestamp_get(&security_finish_timestamp);
1294                 }
1295
1296                 if (mac_selinux_init(NULL) < 0) {
1297                         error_message = "Failed to initialize SELinux policy";
1298                         goto finish;
1299                 }
1300
1301                 if (!skip_setup) {
1302                         if (clock_is_localtime() > 0) {
1303                                 int min;
1304
1305                                 /*
1306                                  * The very first call of settimeofday() also does a time warp in the kernel.
1307                                  *
1308                                  * In the rtc-in-local time mode, we set the kernel's timezone, and rely on
1309                                  * external tools to take care of maintaining the RTC and do all adjustments.
1310                                  * This matches the behavior of Windows, which leaves the RTC alone if the
1311                                  * registry tells that the RTC runs in UTC.
1312                                  */
1313                                 r = clock_set_timezone(&min);
1314                                 if (r < 0)
1315                                         log_error_errno(r, "Failed to apply local time delta, ignoring: %m");
1316                                 else
1317                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1318                         } else if (!in_initrd()) {
1319                                 /*
1320                                  * Do a dummy very first call to seal the kernel's time warp magic.
1321                                  *
1322                                  * Do not call this this from inside the initrd. The initrd might not
1323                                  * carry /etc/adjtime with LOCAL, but the real system could be set up
1324                                  * that way. In such case, we need to delay the time-warp or the sealing
1325                                  * until we reach the real system.
1326                                  *
1327                                  * Do no set the kernel's timezone. The concept of local time cannot
1328                                  * be supported reliably, the time will jump or be incorrect at every daylight
1329                                  * saving time change. All kernel local time concepts will be treated
1330                                  * as UTC that way.
1331                                  */
1332                                 clock_reset_timewarp();
1333                         }
1334                 }
1335
1336                 /* Set the default for later on, but don't actually
1337                  * open the logs like this for now. Note that if we
1338                  * are transitioning from the initrd there might still
1339                  * be journal fd open, and we shouldn't attempt
1340                  * opening that before we parsed /proc/cmdline which
1341                  * might redirect output elsewhere. */
1342                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1343
1344         } else if (getpid() == 1) {
1345                 /* Running inside a container, as PID 1 */
1346                 arg_running_as = SYSTEMD_SYSTEM;
1347                 log_set_target(LOG_TARGET_CONSOLE);
1348                 log_close_console(); /* force reopen of /dev/console */
1349                 log_open();
1350
1351                 /* For the later on, see above... */
1352                 log_set_target(LOG_TARGET_JOURNAL);
1353
1354                 /* clear the kernel timestamp,
1355                  * because we are in a container */
1356                 kernel_timestamp.monotonic = 0ULL;
1357                 kernel_timestamp.realtime = 0ULL;
1358
1359         } else {
1360                 /* Running as user instance */
1361                 arg_running_as = SYSTEMD_USER;
1362                 log_set_target(LOG_TARGET_AUTO);
1363                 log_open();
1364
1365                 /* clear the kernel timestamp,
1366                  * because we are not PID 1 */
1367                 kernel_timestamp.monotonic = 0ULL;
1368                 kernel_timestamp.realtime = 0ULL;
1369         }
1370
1371         /* Initialize default unit */
1372         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1373         if (r < 0) {
1374                 log_emergency_errno(r, "Failed to set default unit %s: %m", SPECIAL_DEFAULT_TARGET);
1375                 error_message = "Failed to set default unit";
1376                 goto finish;
1377         }
1378
1379         r = initialize_join_controllers();
1380         if (r < 0) {
1381                 error_message = "Failed to initalize cgroup controllers";
1382                 goto finish;
1383         }
1384
1385         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1386          * /proc/$PID/fd is available. */
1387         if (getpid() == 1) {
1388
1389                 /* Load the kernel modules early, so that we kdbus.ko is loaded before kdbusfs shall be mounted */
1390                 if (!skip_setup)
1391                         kmod_setup();
1392
1393                 r = mount_setup(loaded_policy);
1394                 if (r < 0) {
1395                         error_message = "Failed to mount API filesystems";
1396                         goto finish;
1397                 }
1398         }
1399
1400         /* Reset all signal handlers. */
1401         assert_se(reset_all_signal_handlers() == 0);
1402
1403         ignore_signals(SIGNALS_IGNORE, -1);
1404
1405         if (parse_config_file() < 0) {
1406                 error_message = "Failed to parse config file";
1407                 goto finish;
1408         }
1409
1410         if (arg_running_as == SYSTEMD_SYSTEM) {
1411                 r = parse_proc_cmdline(parse_proc_cmdline_item);
1412                 if (r < 0)
1413                         log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
1414         }
1415
1416         /* Note that this also parses bits from the kernel command
1417          * line, including "debug". */
1418         log_parse_environment();
1419
1420         if (parse_argv(argc, argv) < 0) {
1421                 error_message = "Failed to parse commandline arguments";
1422                 goto finish;
1423         }
1424
1425         if (arg_action == ACTION_TEST &&
1426             geteuid() == 0) {
1427                 log_error("Don't run test mode as root.");
1428                 goto finish;
1429         }
1430
1431         if (arg_running_as == SYSTEMD_USER &&
1432             arg_action == ACTION_RUN &&
1433             sd_booted() <= 0) {
1434                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1435                 goto finish;
1436         }
1437
1438         if (arg_running_as == SYSTEMD_SYSTEM &&
1439             arg_action == ACTION_RUN &&
1440             running_in_chroot() > 0) {
1441                 log_error("Cannot be run in a chroot() environment.");
1442                 goto finish;
1443         }
1444
1445         if (arg_action == ACTION_TEST)
1446                 skip_setup = true;
1447
1448         pager_open_if_enabled();
1449
1450         if (arg_action == ACTION_HELP) {
1451                 retval = help();
1452                 goto finish;
1453         } else if (arg_action == ACTION_VERSION) {
1454                 retval = version();
1455                 goto finish;
1456         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1457                 unit_dump_config_items(stdout);
1458                 retval = EXIT_SUCCESS;
1459                 goto finish;
1460         } else if (arg_action == ACTION_DONE) {
1461                 retval = EXIT_SUCCESS;
1462                 goto finish;
1463         }
1464
1465         if (arg_running_as == SYSTEMD_USER &&
1466             !getenv("XDG_RUNTIME_DIR")) {
1467                 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1468                 goto finish;
1469         }
1470
1471         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1472
1473         /* Close logging fds, in order not to confuse fdset below */
1474         log_close();
1475
1476         /* Remember open file descriptors for later deserialization */
1477         r = fdset_new_fill(&fds);
1478         if (r < 0) {
1479                 log_emergency_errno(r, "Failed to allocate fd set: %m");
1480                 error_message = "Failed to allocate fd set";
1481                 goto finish;
1482         } else
1483                 fdset_cloexec(fds, true);
1484
1485         if (arg_serialization)
1486                 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1487
1488         if (arg_running_as == SYSTEMD_SYSTEM)
1489                 /* Become a session leader if we aren't one yet. */
1490                 setsid();
1491
1492         /* Move out of the way, so that we won't block unmounts */
1493         assert_se(chdir("/")  == 0);
1494
1495         /* Reset the console, but only if this is really init and we
1496          * are freshly booted */
1497         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN) {
1498
1499                 /* If we are init, we connect stdin/stdout/stderr to
1500                  * /dev/null and make sure we don't have a controlling
1501                  * tty. */
1502                 release_terminal();
1503
1504                 if (getpid() == 1 && !skip_setup)
1505                         console_setup();
1506         }
1507
1508         /* Open the logging devices, if possible and necessary */
1509         log_open();
1510
1511         if (arg_show_status == _SHOW_STATUS_UNSET)
1512                 arg_show_status = SHOW_STATUS_YES;
1513
1514         /* Make sure we leave a core dump without panicing the
1515          * kernel. */
1516         if (getpid() == 1) {
1517                 install_crash_handler();
1518
1519                 r = mount_cgroup_controllers(arg_join_controllers);
1520                 if (r < 0)
1521                         goto finish;
1522         }
1523
1524         if (arg_running_as == SYSTEMD_SYSTEM) {
1525                 const char *virtualization = NULL;
1526
1527                 log_info(PACKAGE_STRING " running in %ssystem mode. (" SYSTEMD_FEATURES ")",
1528                          arg_action == ACTION_TEST ? "test " : "" );
1529
1530                 detect_virtualization(&virtualization);
1531                 if (virtualization)
1532                         log_info("Detected virtualization '%s'.", virtualization);
1533
1534                 write_container_id();
1535
1536                 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1537
1538                 if (in_initrd())
1539                         log_info("Running in initial RAM disk.");
1540
1541                 /* Let's check whether /etc is already populated. We
1542                  * don't actually really check for that, but use
1543                  * /etc/machine-id as flag file. This allows container
1544                  * managers and installers to provision a couple of
1545                  * files already. If the container manager wants to
1546                  * provision the machine ID itself it should pass
1547                  * $container_uuid to PID 1.*/
1548
1549                 empty_etc = access("/etc/machine-id", F_OK) < 0;
1550                 if (empty_etc)
1551                         log_info("Running with unpopulated /etc.");
1552         } else {
1553                 _cleanup_free_ char *t;
1554
1555                 t = uid_to_name(getuid());
1556                 log_debug(PACKAGE_STRING " running in %suser mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1557                           arg_action == ACTION_TEST ? " test" : "", getuid(), t);
1558         }
1559
1560         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1561                 if (arg_show_status > 0 || plymouth_running())
1562                         status_welcome();
1563
1564                 hostname_setup();
1565                 machine_id_setup(NULL);
1566                 loopback_setup();
1567
1568                 test_mtab();
1569                 test_usr();
1570         }
1571
1572         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1573                 watchdog_set_timeout(&arg_runtime_watchdog);
1574
1575         if (arg_timer_slack_nsec != NSEC_INFINITY)
1576                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1577                         log_error_errno(errno, "Failed to adjust timer slack: %m");
1578
1579         if (arg_capability_bounding_set_drop) {
1580                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1581                 if (r < 0) {
1582                         log_emergency_errno(r, "Failed to drop capability bounding set of usermode helpers: %m");
1583                         error_message = "Failed to drop capability bounding set of usermode helpers";
1584                         goto finish;
1585                 }
1586                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1587                 if (r < 0) {
1588                         log_emergency_errno(r, "Failed to drop capability bounding set: %m");
1589                         error_message = "Failed to drop capability bounding set";
1590                         goto finish;
1591                 }
1592         }
1593
1594         if (arg_syscall_archs) {
1595                 r = enforce_syscall_archs(arg_syscall_archs);
1596                 if (r < 0) {
1597                         error_message = "Failed to set syscall architectures";
1598                         goto finish;
1599                 }
1600         }
1601
1602         if (arg_running_as == SYSTEMD_USER) {
1603                 /* Become reaper of our children */
1604                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1605                         log_warning_errno(errno, "Failed to make us a subreaper: %m");
1606                         if (errno == EINVAL)
1607                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1608                 }
1609         }
1610
1611         if (arg_running_as == SYSTEMD_SYSTEM) {
1612                 bump_rlimit_nofile(&saved_rlimit_nofile);
1613
1614                 if (empty_etc) {
1615                         r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1616                         if (r < 0)
1617                                 log_warning_errno(r, "Failed to populate /etc with preset unit settings, ignoring: %m");
1618                         else
1619                                 log_info("Populated /etc with preset unit settings.");
1620                 }
1621         }
1622
1623         r = manager_new(arg_running_as, arg_action == ACTION_TEST, &m);
1624         if (r < 0) {
1625                 log_emergency_errno(r, "Failed to allocate manager object: %m");
1626                 error_message = "Failed to allocate manager object";
1627                 goto finish;
1628         }
1629
1630         m->confirm_spawn = arg_confirm_spawn;
1631         m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1632         m->default_std_output = arg_default_std_output;
1633         m->default_std_error = arg_default_std_error;
1634         m->default_restart_usec = arg_default_restart_usec;
1635         m->default_timeout_start_usec = arg_default_timeout_start_usec;
1636         m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1637         m->default_start_limit_interval = arg_default_start_limit_interval;
1638         m->default_start_limit_burst = arg_default_start_limit_burst;
1639         m->default_cpu_accounting = arg_default_cpu_accounting;
1640         m->default_blockio_accounting = arg_default_blockio_accounting;
1641         m->default_memory_accounting = arg_default_memory_accounting;
1642         m->runtime_watchdog = arg_runtime_watchdog;
1643         m->shutdown_watchdog = arg_shutdown_watchdog;
1644
1645         m->userspace_timestamp = userspace_timestamp;
1646         m->kernel_timestamp = kernel_timestamp;
1647         m->initrd_timestamp = initrd_timestamp;
1648         m->security_start_timestamp = security_start_timestamp;
1649         m->security_finish_timestamp = security_finish_timestamp;
1650
1651         manager_set_default_rlimits(m, arg_default_rlimit);
1652         manager_environment_add(m, NULL, arg_default_environment);
1653         manager_set_show_status(m, arg_show_status);
1654         manager_set_first_boot(m, empty_etc);
1655
1656         /* Remember whether we should queue the default job */
1657         queue_default_job = !arg_serialization || arg_switched_root;
1658
1659         before_startup = now(CLOCK_MONOTONIC);
1660
1661         r = manager_startup(m, arg_serialization, fds);
1662         if (r < 0)
1663                 log_error_errno(r, "Failed to fully start up daemon: %m");
1664
1665         /* This will close all file descriptors that were opened, but
1666          * not claimed by any unit. */
1667         fdset_free(fds);
1668         fds = NULL;
1669
1670         if (arg_serialization) {
1671                 fclose(arg_serialization);
1672                 arg_serialization = NULL;
1673         }
1674
1675         if (queue_default_job) {
1676                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1677                 Unit *target = NULL;
1678                 Job *default_unit_job;
1679
1680                 log_debug("Activating default unit: %s", arg_default_unit);
1681
1682                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1683                 if (r < 0)
1684                         log_error("Failed to load default target: %s", bus_error_message(&error, r));
1685                 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1686                         log_error_errno(target->load_error, "Failed to load default target: %m");
1687                 else if (target->load_state == UNIT_MASKED)
1688                         log_error("Default target masked.");
1689
1690                 if (!target || target->load_state != UNIT_LOADED) {
1691                         log_info("Trying to load rescue target...");
1692
1693                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1694                         if (r < 0) {
1695                                 log_emergency("Failed to load rescue target: %s", bus_error_message(&error, r));
1696                                 error_message = "Failed to load rescue target";
1697                                 goto finish;
1698                         } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1699                                 log_emergency_errno(target->load_error, "Failed to load rescue target: %m");
1700                                 error_message = "Failed to load rescue target";
1701                                 goto finish;
1702                         } else if (target->load_state == UNIT_MASKED) {
1703                                 log_emergency("Rescue target masked.");
1704                                 error_message = "Rescue target masked";
1705                                 goto finish;
1706                         }
1707                 }
1708
1709                 assert(target->load_state == UNIT_LOADED);
1710
1711                 if (arg_action == ACTION_TEST) {
1712                         printf("-> By units:\n");
1713                         manager_dump_units(m, stdout, "\t");
1714                 }
1715
1716                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1717                 if (r == -EPERM) {
1718                         log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1719
1720                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1721                         if (r < 0) {
1722                                 log_emergency("Failed to start default target: %s", bus_error_message(&error, r));
1723                                 error_message = "Failed to start default target";
1724                                 goto finish;
1725                         }
1726                 } else if (r < 0) {
1727                         log_emergency("Failed to isolate default target: %s", bus_error_message(&error, r));
1728                         error_message = "Failed to isolate default target";
1729                         goto finish;
1730                 }
1731
1732                 m->default_unit_job_id = default_unit_job->id;
1733
1734                 after_startup = now(CLOCK_MONOTONIC);
1735                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1736                          "Loaded units and determined initial transaction in %s.",
1737                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 100 * USEC_PER_MSEC));
1738
1739                 if (arg_action == ACTION_TEST) {
1740                         printf("-> By jobs:\n");
1741                         manager_dump_jobs(m, stdout, "\t");
1742                         retval = EXIT_SUCCESS;
1743                         goto finish;
1744                 }
1745         }
1746
1747         for (;;) {
1748                 r = manager_loop(m);
1749                 if (r < 0) {
1750                         log_emergency_errno(r, "Failed to run main loop: %m");
1751                         error_message = "Failed to run main loop";
1752                         goto finish;
1753                 }
1754
1755                 switch (m->exit_code) {
1756
1757                 case MANAGER_EXIT:
1758                         retval = EXIT_SUCCESS;
1759                         log_debug("Exit.");
1760                         goto finish;
1761
1762                 case MANAGER_RELOAD:
1763                         log_info("Reloading.");
1764                         r = manager_reload(m);
1765                         if (r < 0)
1766                                 log_error_errno(r, "Failed to reload: %m");
1767                         break;
1768
1769                 case MANAGER_REEXECUTE:
1770
1771                         if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0) {
1772                                 error_message = "Failed to prepare for reexection";
1773                                 goto finish;
1774                         }
1775
1776                         reexecute = true;
1777                         log_notice("Reexecuting.");
1778                         goto finish;
1779
1780                 case MANAGER_SWITCH_ROOT:
1781                         /* Steal the switch root parameters */
1782                         switch_root_dir = m->switch_root;
1783                         switch_root_init = m->switch_root_init;
1784                         m->switch_root = m->switch_root_init = NULL;
1785
1786                         if (!switch_root_init)
1787                                 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0) {
1788                                         error_message = "Failed to prepare for reexection";
1789                                         goto finish;
1790                                 }
1791
1792                         reexecute = true;
1793                         log_notice("Switching root.");
1794                         goto finish;
1795
1796                 case MANAGER_REBOOT:
1797                 case MANAGER_POWEROFF:
1798                 case MANAGER_HALT:
1799                 case MANAGER_KEXEC: {
1800                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1801                                 [MANAGER_REBOOT] = "reboot",
1802                                 [MANAGER_POWEROFF] = "poweroff",
1803                                 [MANAGER_HALT] = "halt",
1804                                 [MANAGER_KEXEC] = "kexec"
1805                         };
1806
1807                         assert_se(shutdown_verb = table[m->exit_code]);
1808                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1809
1810                         log_notice("Shutting down.");
1811                         goto finish;
1812                 }
1813
1814                 default:
1815                         assert_not_reached("Unknown exit code.");
1816                 }
1817         }
1818
1819 finish:
1820         pager_close();
1821
1822         m = manager_free(m);
1823
1824         for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1825                 free(arg_default_rlimit[j]);
1826                 arg_default_rlimit[j] = NULL;
1827         }
1828
1829         free(arg_default_unit);
1830         arg_default_unit = NULL;
1831
1832         free_join_controllers();
1833
1834         strv_free(arg_default_environment);
1835         arg_default_environment = NULL;
1836
1837         set_free(arg_syscall_archs);
1838         arg_syscall_archs = NULL;
1839
1840         mac_selinux_finish();
1841
1842         if (reexecute) {
1843                 const char **args;
1844                 unsigned i, args_size;
1845
1846                 /* Close and disarm the watchdog, so that the new
1847                  * instance can reinitialize it, but doesn't get
1848                  * rebooted while we do that */
1849                 watchdog_close(true);
1850
1851                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1852                  * that the new systemd can pass the kernel default to
1853                  * its child processes */
1854                 if (saved_rlimit_nofile.rlim_cur > 0)
1855                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1856
1857                 if (switch_root_dir) {
1858                         /* Kill all remaining processes from the
1859                          * initrd, but don't wait for them, so that we
1860                          * can handle the SIGCHLD for them after
1861                          * deserializing. */
1862                         broadcast_signal(SIGTERM, false, true);
1863
1864                         /* And switch root with MS_MOVE, because we remove the old directory afterwards and detach it. */
1865                         r = switch_root(switch_root_dir, "/mnt", true, MS_MOVE);
1866                         if (r < 0)
1867                                 log_error_errno(r, "Failed to switch root, trying to continue: %m");
1868                 }
1869
1870                 args_size = MAX(6, argc+1);
1871                 args = newa(const char*, args_size);
1872
1873                 if (!switch_root_init) {
1874                         char sfd[16];
1875
1876                         /* First try to spawn ourselves with the right
1877                          * path, and with full serialization. We do
1878                          * this only if the user didn't specify an
1879                          * explicit init to spawn. */
1880
1881                         assert(arg_serialization);
1882                         assert(fds);
1883
1884                         snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1885                         char_array_0(sfd);
1886
1887                         i = 0;
1888                         args[i++] = SYSTEMD_BINARY_PATH;
1889                         if (switch_root_dir)
1890                                 args[i++] = "--switched-root";
1891                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1892                         args[i++] = "--deserialize";
1893                         args[i++] = sfd;
1894                         args[i++] = NULL;
1895
1896                         /* do not pass along the environment we inherit from the kernel or initrd */
1897                         if (switch_root_dir)
1898                                 clearenv();
1899
1900                         assert(i <= args_size);
1901                         execv(args[0], (char* const*) args);
1902                 }
1903
1904                 /* Try the fallback, if there is any, without any
1905                  * serialization. We pass the original argv[] and
1906                  * envp[]. (Well, modulo the ordering changes due to
1907                  * getopt() in argv[], and some cleanups in envp[],
1908                  * but let's hope that doesn't matter.) */
1909
1910                 if (arg_serialization) {
1911                         fclose(arg_serialization);
1912                         arg_serialization = NULL;
1913                 }
1914
1915                 if (fds) {
1916                         fdset_free(fds);
1917                         fds = NULL;
1918                 }
1919
1920                 /* Reopen the console */
1921                 make_console_stdio();
1922
1923                 for (j = 1, i = 1; j < (unsigned) argc; j++)
1924                         args[i++] = argv[j];
1925                 args[i++] = NULL;
1926                 assert(i <= args_size);
1927
1928                 /* Reenable any blocked signals, especially important
1929                  * if we switch from initial ramdisk to init=... */
1930                 reset_all_signal_handlers();
1931                 reset_signal_mask();
1932
1933                 if (switch_root_init) {
1934                         args[0] = switch_root_init;
1935                         execv(args[0], (char* const*) args);
1936                         log_warning_errno(errno, "Failed to execute configured init, trying fallback: %m");
1937                 }
1938
1939                 args[0] = "/sbin/init";
1940                 execv(args[0], (char* const*) args);
1941
1942                 if (errno == ENOENT) {
1943                         log_warning("No /sbin/init, trying fallback");
1944
1945                         args[0] = "/bin/sh";
1946                         args[1] = NULL;
1947                         execv(args[0], (char* const*) args);
1948                         log_error_errno(errno, "Failed to execute /bin/sh, giving up: %m");
1949                 } else
1950                         log_warning_errno(errno, "Failed to execute /sbin/init, giving up: %m");
1951         }
1952
1953         if (arg_serialization) {
1954                 fclose(arg_serialization);
1955                 arg_serialization = NULL;
1956         }
1957
1958         if (fds) {
1959                 fdset_free(fds);
1960                 fds = NULL;
1961         }
1962
1963 #ifdef HAVE_VALGRIND_VALGRIND_H
1964         /* If we are PID 1 and running under valgrind, then let's exit
1965          * here explicitly. valgrind will only generate nice output on
1966          * exit(), not on exec(), hence let's do the former not the
1967          * latter here. */
1968         if (getpid() == 1 && RUNNING_ON_VALGRIND)
1969                 return 0;
1970 #endif
1971
1972         if (shutdown_verb) {
1973                 char log_level[DECIMAL_STR_MAX(int) + 1];
1974                 const char* command_line[9] = {
1975                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1976                         shutdown_verb,
1977                         "--log-level", log_level,
1978                         "--log-target",
1979                 };
1980                 unsigned pos = 5;
1981                 _cleanup_strv_free_ char **env_block = NULL;
1982
1983                 assert(command_line[pos] == NULL);
1984                 env_block = strv_copy(environ);
1985
1986                 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1987
1988                 switch (log_get_target()) {
1989                 case LOG_TARGET_KMSG:
1990                 case LOG_TARGET_JOURNAL_OR_KMSG:
1991                 case LOG_TARGET_SYSLOG_OR_KMSG:
1992                         command_line[pos++] = "kmsg";
1993                         break;
1994
1995                 case LOG_TARGET_CONSOLE:
1996                 default:
1997                         command_line[pos++] = "console";
1998                         break;
1999                 };
2000
2001                 if (log_get_show_color())
2002                         command_line[pos++] = "--log-color";
2003
2004                 if (log_get_show_location())
2005                         command_line[pos++] = "--log-location";
2006
2007                 assert(pos < ELEMENTSOF(command_line));
2008
2009                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
2010                         char *e;
2011
2012                         /* If we reboot let's set the shutdown
2013                          * watchdog and tell the shutdown binary to
2014                          * repeatedly ping it */
2015                         watchdog_set_timeout(&arg_shutdown_watchdog);
2016                         watchdog_close(false);
2017
2018                         /* Tell the binary how often to ping, ignore failure */
2019                         if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2020                                 strv_push(&env_block, e);
2021                 } else
2022                         watchdog_close(true);
2023
2024                 /* Avoid the creation of new processes forked by the
2025                  * kernel; at this point, we will not listen to the
2026                  * signals anyway */
2027                 if (detect_container(NULL) <= 0)
2028                         cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2029
2030                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2031                 log_error_errno(errno, "Failed to execute shutdown binary, %s: %m",
2032                           getpid() == 1 ? "freezing" : "quitting");
2033         }
2034
2035         if (getpid() == 1) {
2036                 if (error_message)
2037                         manager_status_printf(NULL, STATUS_TYPE_EMERGENCY,
2038                                               ANSI_HIGHLIGHT_RED_ON "!!!!!!" ANSI_HIGHLIGHT_OFF,
2039                                               "%s, freezing.", error_message);
2040                 freeze();
2041         }
2042
2043         return retval;
2044 }