src/core/main.c

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