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