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_error("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_error("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_error("Caught <%s>, waitpid() failed: %s", signal_to_string(sig), strerror(-r));
 179                         else if (status.si_code != CLD_DUMPED)
 180                                 log_error("Caught <%s>, core dump failed.", signal_to_string(sig));
 181                         else
 182                                 log_error("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_error("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_error("execl() failed: %m");
 210                         _exit(1);
 211                 }
 212
 213                 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
 214         }
 215
 216         log_info("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("Failed to open /dev/console: %s", strerror(-tty_fd));
 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("Failed to reset /dev/console: %s", strerror(-r));
 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_warning_unit(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("Failed to set default unit %s: %s", optarg, strerror(-r));
 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("Failed to create serialization file: %s", strerror(-r));
 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("Failed to allocate fd set: %s", strerror(-r));
1005                 goto fail;
1006         }
1007
1008         r = manager_serialize(m, f, fds, switching_root);
1009         if (r < 0) {
1010                 log_error("Failed to serialize state: %s", strerror(-r));
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("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1022                 goto fail;
1023         }
1024
1025         r = fdset_cloexec(fds, false);
1026         if (r < 0) {
1027                 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
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("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
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("Failed to add architecture to seccomp: %s", strerror(-r));
1158                         goto finish;
1159                 }
1160         }
1161
1162         r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1163         if (r < 0) {
1164                 log_error("Failed to unset NO_NEW_PRIVS: %s", strerror(-r));
1165                 goto finish;
1166         }
1167
1168         r = seccomp_load(seccomp);
1169         if (r < 0)
1170                 log_error("Failed to add install architecture seccomp: %s", strerror(-r));
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("Failed to read os-release file: %s", strerror(-r));
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
1237 #ifdef HAVE_SYSV_COMPAT
1238         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1239                 /* This is compatibility support for SysV, where
1240                  * calling init as a user is identical to telinit. */
1241
1242                 errno = -ENOENT;
1243                 execv(SYSTEMCTL_BINARY_PATH, argv);
1244                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1245                 return 1;
1246         }
1247 #endif
1248
1249         dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1250         dual_timestamp_get(&userspace_timestamp);
1251
1252         /* Determine if this is a reexecution or normal bootup. We do
1253          * the full command line parsing much later, so let's just
1254          * have a quick peek here. */
1255         if (strv_find(argv+1, "--deserialize"))
1256                 skip_setup = true;
1257
1258         /* If we have switched root, do all the special setup
1259          * things */
1260         if (strv_find(argv+1, "--switched-root"))
1261                 skip_setup = false;
1262
1263         /* If we get started via the /sbin/init symlink then we are
1264            called 'init'. After a subsequent reexecution we are then
1265            called 'systemd'. That is confusing, hence let's call us
1266            systemd right-away. */
1267         program_invocation_short_name = systemd;
1268         prctl(PR_SET_NAME, systemd);
1269
1270         saved_argv = argv;
1271         saved_argc = argc;
1272
1273         log_show_color(isatty(STDERR_FILENO) > 0);
1274         log_set_upgrade_syslog_to_journal(true);
1275
1276         /* Disable the umask logic */
1277         if (getpid() == 1)
1278                 umask(0);
1279
1280         if (getpid() == 1 && detect_container(NULL) <= 0) {
1281
1282                 /* Running outside of a container as PID 1 */
1283                 arg_running_as = SYSTEMD_SYSTEM;
1284                 make_null_stdio();
1285                 log_set_target(LOG_TARGET_KMSG);
1286                 log_open();
1287
1288                 if (in_initrd())
1289                         initrd_timestamp = userspace_timestamp;
1290
1291                 if (!skip_setup) {
1292                         mount_setup_early();
1293                         dual_timestamp_get(&security_start_timestamp);
1294                         if (mac_selinux_setup(&loaded_policy) < 0)
1295                                 goto finish;
1296                         if (ima_setup() < 0)
1297                                 goto finish;
1298                         if (mac_smack_setup(&loaded_policy) < 0)
1299                                 goto finish;
1300                         dual_timestamp_get(&security_finish_timestamp);
1301                 }
1302
1303                 if (mac_selinux_init(NULL) < 0)
1304                         goto finish;
1305
1306                 if (!skip_setup) {
1307                         if (clock_is_localtime() > 0) {
1308                                 int min;
1309
1310                                 /*
1311                                  * The very first call of settimeofday() also does a time warp in the kernel.
1312                                  *
1313                                  * In the rtc-in-local time mode, we set the kernel's timezone, and rely on
1314                                  * external tools to take care of maintaining the RTC and do all adjustments.
1315                                  * This matches the behavior of Windows, which leaves the RTC alone if the
1316                                  * registry tells that the RTC runs in UTC.
1317                                  */
1318                                 r = clock_set_timezone(&min);
1319                                 if (r < 0)
1320                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1321                                 else
1322                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1323                         } else if (!in_initrd()) {
1324                                 /*
1325                                  * Do a dummy very first call to seal the kernel's time warp magic.
1326                                  *
1327                                  * Do not call this this from inside the initrd. The initrd might not
1328                                  * carry /etc/adjtime with LOCAL, but the real system could be set up
1329                                  * that way. In such case, we need to delay the time-warp or the sealing
1330                                  * until we reach the real system.
1331                                  *
1332                                  * Do no set the kernel's timezone. The concept of local time cannot
1333                                  * be supported reliably, the time will jump or be incorrect at every daylight
1334                                  * saving time change. All kernel local time concepts will be treated
1335                                  * as UTC that way.
1336                                  */
1337                                 clock_reset_timewarp();
1338                         }
1339                 }
1340
1341                 /* Set the default for later on, but don't actually
1342                  * open the logs like this for now. Note that if we
1343                  * are transitioning from the initrd there might still
1344                  * be journal fd open, and we shouldn't attempt
1345                  * opening that before we parsed /proc/cmdline which
1346                  * might redirect output elsewhere. */
1347                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1348
1349         } else if (getpid() == 1) {
1350                 /* Running inside a container, as PID 1 */
1351                 arg_running_as = SYSTEMD_SYSTEM;
1352                 log_set_target(LOG_TARGET_CONSOLE);
1353                 log_close_console(); /* force reopen of /dev/console */
1354                 log_open();
1355
1356                 /* For the later on, see above... */
1357                 log_set_target(LOG_TARGET_JOURNAL);
1358
1359                 /* clear the kernel timestamp,
1360                  * because we are in a container */
1361                 kernel_timestamp.monotonic = 0ULL;
1362                 kernel_timestamp.realtime = 0ULL;
1363
1364         } else {
1365                 /* Running as user instance */
1366                 arg_running_as = SYSTEMD_USER;
1367                 log_set_target(LOG_TARGET_AUTO);
1368                 log_open();
1369
1370                 /* clear the kernel timestamp,
1371                  * because we are not PID 1 */
1372                 kernel_timestamp.monotonic = 0ULL;
1373                 kernel_timestamp.realtime = 0ULL;
1374         }
1375
1376         /* Initialize default unit */
1377         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1378         if (r < 0) {
1379                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1380                 goto finish;
1381         }
1382
1383         r = initialize_join_controllers();
1384         if (r < 0)
1385                 goto finish;
1386
1387         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1388          * /proc/$PID/fd is available. */
1389         if (getpid() == 1) {
1390
1391                 /* Load the kernel modules early, so that we kdbus.ko is loaded before kdbusfs shall be mounted */
1392                 if (!skip_setup)
1393                         kmod_setup();
1394
1395                 r = mount_setup(loaded_policy);
1396                 if (r < 0)
1397                         goto finish;
1398         }
1399
1400         /* Reset all signal handlers. */
1401         assert_se(reset_all_signal_handlers() == 0);
1402
1403         ignore_signals(SIGNALS_IGNORE, -1);
1404
1405         if (parse_config_file() < 0)
1406                 goto finish;
1407
1408         if (arg_running_as == SYSTEMD_SYSTEM) {
1409                 r = parse_proc_cmdline(parse_proc_cmdline_item);
1410                 if (r < 0)
1411                         log_warning("Failed to parse kernel command line, ignoring: %s", strerror(-r));
1412         }
1413
1414         /* Note that this also parses bits from the kernel command
1415          * line, including "debug". */
1416         log_parse_environment();
1417
1418         if (parse_argv(argc, argv) < 0)
1419                 goto finish;
1420
1421         if (arg_action == ACTION_TEST &&
1422             geteuid() == 0) {
1423                 log_error("Don't run test mode as root.");
1424                 goto finish;
1425         }
1426
1427         if (arg_running_as == SYSTEMD_USER &&
1428             arg_action == ACTION_RUN &&
1429             sd_booted() <= 0) {
1430                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1431                 goto finish;
1432         }
1433
1434         if (arg_running_as == SYSTEMD_SYSTEM &&
1435             arg_action == ACTION_RUN &&
1436             running_in_chroot() > 0) {
1437                 log_error("Cannot be run in a chroot() environment.");
1438                 goto finish;
1439         }
1440
1441         if (arg_action == ACTION_TEST)
1442                 skip_setup = true;
1443
1444         pager_open_if_enabled();
1445
1446         if (arg_action == ACTION_HELP) {
1447                 retval = help();
1448                 goto finish;
1449         } else if (arg_action == ACTION_VERSION) {
1450                 retval = version();
1451                 goto finish;
1452         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1453                 unit_dump_config_items(stdout);
1454                 retval = EXIT_SUCCESS;
1455                 goto finish;
1456         } else if (arg_action == ACTION_DONE) {
1457                 retval = EXIT_SUCCESS;
1458                 goto finish;
1459         }
1460
1461         if (arg_running_as == SYSTEMD_USER &&
1462             !getenv("XDG_RUNTIME_DIR")) {
1463                 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1464                 goto finish;
1465         }
1466
1467         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1468
1469         /* Close logging fds, in order not to confuse fdset below */
1470         log_close();
1471
1472         /* Remember open file descriptors for later deserialization */
1473         r = fdset_new_fill(&fds);
1474         if (r < 0) {
1475                 log_error("Failed to allocate fd set: %s", strerror(-r));
1476                 goto finish;
1477         } else
1478                 fdset_cloexec(fds, true);
1479
1480         if (arg_serialization)
1481                 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1482
1483         if (arg_running_as == SYSTEMD_SYSTEM)
1484                 /* Become a session leader if we aren't one yet. */
1485                 setsid();
1486
1487         /* Move out of the way, so that we won't block unmounts */
1488         assert_se(chdir("/")  == 0);
1489
1490         /* Reset the console, but only if this is really init and we
1491          * are freshly booted */
1492         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN) {
1493
1494                 /* If we are init, we connect stdin/stdout/stderr to
1495                  * /dev/null and make sure we don't have a controlling
1496                  * tty. */
1497                 release_terminal();
1498
1499                 if (getpid() == 1 && !skip_setup)
1500                         console_setup();
1501         }
1502
1503         /* Open the logging devices, if possible and necessary */
1504         log_open();
1505
1506         if (arg_show_status == _SHOW_STATUS_UNSET)
1507                 arg_show_status = SHOW_STATUS_YES;
1508
1509         /* Make sure we leave a core dump without panicing the
1510          * kernel. */
1511         if (getpid() == 1) {
1512                 install_crash_handler();
1513
1514                 r = mount_cgroup_controllers(arg_join_controllers);
1515                 if (r < 0)
1516                         goto finish;
1517         }
1518
1519         if (arg_running_as == SYSTEMD_SYSTEM) {
1520                 const char *virtualization = NULL;
1521
1522                 log_info(PACKAGE_STRING " running in %ssystem mode. (" SYSTEMD_FEATURES ")",
1523                          arg_action == ACTION_TEST ? "test " : "" );
1524
1525                 detect_virtualization(&virtualization);
1526                 if (virtualization)
1527                         log_info("Detected virtualization '%s'.", virtualization);
1528
1529                 write_container_id();
1530
1531                 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1532
1533                 if (in_initrd())
1534                         log_info("Running in initial RAM disk.");
1535
1536                 /* Let's check whether /etc is already populated. We
1537                  * don't actually really check for that, but use
1538                  * /etc/machine-id as flag file. This allows container
1539                  * managers and installers to provision a couple of
1540                  * files already. If the container manager wants to
1541                  * provision the machine ID itself it should pass
1542                  * $container_uuid to PID 1.*/
1543
1544                 empty_etc = access("/etc/machine-id", F_OK) < 0;
1545                 if (empty_etc)
1546                         log_info("Running with unpopulated /etc.");
1547         } else {
1548                 _cleanup_free_ char *t;
1549
1550                 t = uid_to_name(getuid());
1551                 log_debug(PACKAGE_STRING " running in %suser mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1552                           arg_action == ACTION_TEST ? " test" : "", getuid(), t);
1553         }
1554
1555         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1556                 if (arg_show_status > 0 || plymouth_running())
1557                         status_welcome();
1558
1559                 hostname_setup();
1560                 machine_id_setup(NULL);
1561                 loopback_setup();
1562
1563                 test_mtab();
1564                 test_usr();
1565         }
1566
1567         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1568                 watchdog_set_timeout(&arg_runtime_watchdog);
1569
1570         if (arg_timer_slack_nsec != NSEC_INFINITY)
1571                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1572                         log_error("Failed to adjust timer slack: %m");
1573
1574         if (arg_capability_bounding_set_drop) {
1575                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1576                 if (r < 0) {
1577                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1578                         goto finish;
1579                 }
1580                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1581                 if (r < 0) {
1582                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1583                         goto finish;
1584                 }
1585         }
1586
1587         if (arg_syscall_archs) {
1588                 r = enforce_syscall_archs(arg_syscall_archs);
1589                 if (r < 0)
1590                         goto finish;
1591         }
1592
1593         if (arg_running_as == SYSTEMD_USER) {
1594                 /* Become reaper of our children */
1595                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1596                         log_warning("Failed to make us a subreaper: %m");
1597                         if (errno == EINVAL)
1598                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1599                 }
1600         }
1601
1602         if (arg_running_as == SYSTEMD_SYSTEM) {
1603                 bump_rlimit_nofile(&saved_rlimit_nofile);
1604
1605                 if (empty_etc) {
1606                         r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1607                         if (r < 0)
1608                                 log_warning("Failed to populate /etc with preset unit settings, ignoring: %s", strerror(-r));
1609                         else
1610                                 log_info("Populated /etc with preset unit settings.");
1611                 }
1612         }
1613
1614         r = manager_new(arg_running_as, arg_action == ACTION_TEST, &m);
1615         if (r < 0) {
1616                 log_error("Failed to allocate manager object: %s", strerror(-r));
1617                 goto finish;
1618         }
1619
1620         m->confirm_spawn = arg_confirm_spawn;
1621         m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1622         m->default_std_output = arg_default_std_output;
1623         m->default_std_error = arg_default_std_error;
1624         m->default_restart_usec = arg_default_restart_usec;
1625         m->default_timeout_start_usec = arg_default_timeout_start_usec;
1626         m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1627         m->default_start_limit_interval = arg_default_start_limit_interval;
1628         m->default_start_limit_burst = arg_default_start_limit_burst;
1629         m->default_cpu_accounting = arg_default_cpu_accounting;
1630         m->default_blockio_accounting = arg_default_blockio_accounting;
1631         m->default_memory_accounting = arg_default_memory_accounting;
1632         m->runtime_watchdog = arg_runtime_watchdog;
1633         m->shutdown_watchdog = arg_shutdown_watchdog;
1634
1635         m->userspace_timestamp = userspace_timestamp;
1636         m->kernel_timestamp = kernel_timestamp;
1637         m->initrd_timestamp = initrd_timestamp;
1638         m->security_start_timestamp = security_start_timestamp;
1639         m->security_finish_timestamp = security_finish_timestamp;
1640
1641         manager_set_default_rlimits(m, arg_default_rlimit);
1642         manager_environment_add(m, NULL, arg_default_environment);
1643         manager_set_show_status(m, arg_show_status);
1644         manager_set_first_boot(m, empty_etc);
1645
1646         /* Remember whether we should queue the default job */
1647         queue_default_job = !arg_serialization || arg_switched_root;
1648
1649         before_startup = now(CLOCK_MONOTONIC);
1650
1651         r = manager_startup(m, arg_serialization, fds);
1652         if (r < 0)
1653                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1654
1655         /* This will close all file descriptors that were opened, but
1656          * not claimed by any unit. */
1657         fdset_free(fds);
1658         fds = NULL;
1659
1660         if (arg_serialization) {
1661                 fclose(arg_serialization);
1662                 arg_serialization = NULL;
1663         }
1664
1665         if (queue_default_job) {
1666                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1667                 Unit *target = NULL;
1668                 Job *default_unit_job;
1669
1670                 log_debug("Activating default unit: %s", arg_default_unit);
1671
1672                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1673                 if (r < 0)
1674                         log_error("Failed to load default target: %s", bus_error_message(&error, r));
1675                 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1676                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1677                 else if (target->load_state == UNIT_MASKED)
1678                         log_error("Default target masked.");
1679
1680                 if (!target || target->load_state != UNIT_LOADED) {
1681                         log_info("Trying to load rescue target...");
1682
1683                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1684                         if (r < 0) {
1685                                 log_error("Failed to load rescue target: %s", bus_error_message(&error, r));
1686                                 goto finish;
1687                         } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1688                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1689                                 goto finish;
1690                         } else if (target->load_state == UNIT_MASKED) {
1691                                 log_error("Rescue target masked.");
1692                                 goto finish;
1693                         }
1694                 }
1695
1696                 assert(target->load_state == UNIT_LOADED);
1697
1698                 if (arg_action == ACTION_TEST) {
1699                         printf("-> By units:\n");
1700                         manager_dump_units(m, stdout, "\t");
1701                 }
1702
1703                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1704                 if (r == -EPERM) {
1705                         log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1706
1707                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1708                         if (r < 0) {
1709                                 log_error("Failed to start default target: %s", bus_error_message(&error, r));
1710                                 goto finish;
1711                         }
1712                 } else if (r < 0) {
1713                         log_error("Failed to isolate default target: %s", bus_error_message(&error, r));
1714                         goto finish;
1715                 }
1716
1717                 m->default_unit_job_id = default_unit_job->id;
1718
1719                 after_startup = now(CLOCK_MONOTONIC);
1720                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1721                          "Loaded units and determined initial transaction in %s.",
1722                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 100 * USEC_PER_MSEC));
1723
1724                 if (arg_action == ACTION_TEST) {
1725                         printf("-> By jobs:\n");
1726                         manager_dump_jobs(m, stdout, "\t");
1727                         retval = EXIT_SUCCESS;
1728                         goto finish;
1729                 }
1730         }
1731
1732         for (;;) {
1733                 r = manager_loop(m);
1734                 if (r < 0) {
1735                         log_error("Failed to run mainloop: %s", strerror(-r));
1736                         goto finish;
1737                 }
1738
1739                 switch (m->exit_code) {
1740
1741                 case MANAGER_EXIT:
1742                         retval = EXIT_SUCCESS;
1743                         log_debug("Exit.");
1744                         goto finish;
1745
1746                 case MANAGER_RELOAD:
1747                         log_info("Reloading.");
1748                         r = manager_reload(m);
1749                         if (r < 0)
1750                                 log_error("Failed to reload: %s", strerror(-r));
1751                         break;
1752
1753                 case MANAGER_REEXECUTE:
1754
1755                         if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0)
1756                                 goto finish;
1757
1758                         reexecute = true;
1759                         log_notice("Reexecuting.");
1760                         goto finish;
1761
1762                 case MANAGER_SWITCH_ROOT:
1763                         /* Steal the switch root parameters */
1764                         switch_root_dir = m->switch_root;
1765                         switch_root_init = m->switch_root_init;
1766                         m->switch_root = m->switch_root_init = NULL;
1767
1768                         if (!switch_root_init)
1769                                 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0)
1770                                         goto finish;
1771
1772                         reexecute = true;
1773                         log_notice("Switching root.");
1774                         goto finish;
1775
1776                 case MANAGER_REBOOT:
1777                 case MANAGER_POWEROFF:
1778                 case MANAGER_HALT:
1779                 case MANAGER_KEXEC: {
1780                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1781                                 [MANAGER_REBOOT] = "reboot",
1782                                 [MANAGER_POWEROFF] = "poweroff",
1783                                 [MANAGER_HALT] = "halt",
1784                                 [MANAGER_KEXEC] = "kexec"
1785                         };
1786
1787                         assert_se(shutdown_verb = table[m->exit_code]);
1788                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1789
1790                         log_notice("Shutting down.");
1791                         goto finish;
1792                 }
1793
1794                 default:
1795                         assert_not_reached("Unknown exit code.");
1796                 }
1797         }
1798
1799 finish:
1800         pager_close();
1801
1802         if (m) {
1803                 manager_free(m);
1804                 m = NULL;
1805         }
1806
1807         for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1808                 free(arg_default_rlimit[j]);
1809                 arg_default_rlimit[j] = NULL;
1810         }
1811
1812         free(arg_default_unit);
1813         arg_default_unit = NULL;
1814
1815         free_join_controllers();
1816
1817         strv_free(arg_default_environment);
1818         arg_default_environment = NULL;
1819
1820         set_free(arg_syscall_archs);
1821         arg_syscall_archs = NULL;
1822
1823         mac_selinux_finish();
1824
1825         if (reexecute) {
1826                 const char **args;
1827                 unsigned i, args_size;
1828
1829                 /* Close and disarm the watchdog, so that the new
1830                  * instance can reinitialize it, but doesn't get
1831                  * rebooted while we do that */
1832                 watchdog_close(true);
1833
1834                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1835                  * that the new systemd can pass the kernel default to
1836                  * its child processes */
1837                 if (saved_rlimit_nofile.rlim_cur > 0)
1838                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1839
1840                 if (switch_root_dir) {
1841                         /* Kill all remaining processes from the
1842                          * initrd, but don't wait for them, so that we
1843                          * can handle the SIGCHLD for them after
1844                          * deserializing. */
1845                         broadcast_signal(SIGTERM, false, true);
1846
1847                         /* And switch root with MS_MOVE, because we remove the old directory afterwards and detach it. */
1848                         r = switch_root(switch_root_dir, "/mnt", true, MS_MOVE);
1849                         if (r < 0)
1850                                 log_error("Failed to switch root, trying to continue: %s", strerror(-r));
1851                 }
1852
1853                 args_size = MAX(6, argc+1);
1854                 args = newa(const char*, args_size);
1855
1856                 if (!switch_root_init) {
1857                         char sfd[16];
1858
1859                         /* First try to spawn ourselves with the right
1860                          * path, and with full serialization. We do
1861                          * this only if the user didn't specify an
1862                          * explicit init to spawn. */
1863
1864                         assert(arg_serialization);
1865                         assert(fds);
1866
1867                         snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1868                         char_array_0(sfd);
1869
1870                         i = 0;
1871                         args[i++] = SYSTEMD_BINARY_PATH;
1872                         if (switch_root_dir)
1873                                 args[i++] = "--switched-root";
1874                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1875                         args[i++] = "--deserialize";
1876                         args[i++] = sfd;
1877                         args[i++] = NULL;
1878
1879                         /* do not pass along the environment we inherit from the kernel or initrd */
1880                         if (switch_root_dir)
1881                                 clearenv();
1882
1883                         assert(i <= args_size);
1884                         execv(args[0], (char* const*) args);
1885                 }
1886
1887                 /* Try the fallback, if there is any, without any
1888                  * serialization. We pass the original argv[] and
1889                  * envp[]. (Well, modulo the ordering changes due to
1890                  * getopt() in argv[], and some cleanups in envp[],
1891                  * but let's hope that doesn't matter.) */
1892
1893                 if (arg_serialization) {
1894                         fclose(arg_serialization);
1895                         arg_serialization = NULL;
1896                 }
1897
1898                 if (fds) {
1899                         fdset_free(fds);
1900                         fds = NULL;
1901                 }
1902
1903                 /* Reopen the console */
1904                 make_console_stdio();
1905
1906                 for (j = 1, i = 1; j < (unsigned) argc; j++)
1907                         args[i++] = argv[j];
1908                 args[i++] = NULL;
1909                 assert(i <= args_size);
1910
1911                 /* Reenable any blocked signals, especially important
1912                  * if we switch from initial ramdisk to init=... */
1913                 reset_all_signal_handlers();
1914                 reset_signal_mask();
1915
1916                 if (switch_root_init) {
1917                         args[0] = switch_root_init;
1918                         execv(args[0], (char* const*) args);
1919                         log_warning("Failed to execute configured init, trying fallback: %m");
1920                 }
1921
1922                 args[0] = "/sbin/init";
1923                 execv(args[0], (char* const*) args);
1924
1925                 if (errno == ENOENT) {
1926                         log_warning("No /sbin/init, trying fallback");
1927
1928                         args[0] = "/bin/sh";
1929                         args[1] = NULL;
1930                         execv(args[0], (char* const*) args);
1931                         log_error("Failed to execute /bin/sh, giving up: %m");
1932                 } else
1933                         log_warning("Failed to execute /sbin/init, giving up: %m");
1934         }
1935
1936         if (arg_serialization) {
1937                 fclose(arg_serialization);
1938                 arg_serialization = NULL;
1939         }
1940
1941         if (fds) {
1942                 fdset_free(fds);
1943                 fds = NULL;
1944         }
1945
1946 #ifdef HAVE_VALGRIND_VALGRIND_H
1947         /* If we are PID 1 and running under valgrind, then let's exit
1948          * here explicitly. valgrind will only generate nice output on
1949          * exit(), not on exec(), hence let's do the former not the
1950          * latter here. */
1951         if (getpid() == 1 && RUNNING_ON_VALGRIND)
1952                 return 0;
1953 #endif
1954
1955         if (shutdown_verb) {
1956                 char log_level[DECIMAL_STR_MAX(int) + 1];
1957                 const char* command_line[9] = {
1958                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1959                         shutdown_verb,
1960                         "--log-level", log_level,
1961                         "--log-target",
1962                 };
1963                 unsigned pos = 5;
1964                 _cleanup_strv_free_ char **env_block = NULL;
1965
1966                 assert(command_line[pos] == NULL);
1967                 env_block = strv_copy(environ);
1968
1969                 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1970
1971                 switch (log_get_target()) {
1972                 case LOG_TARGET_KMSG:
1973                 case LOG_TARGET_JOURNAL_OR_KMSG:
1974                 case LOG_TARGET_SYSLOG_OR_KMSG:
1975                         command_line[pos++] = "kmsg";
1976                         break;
1977
1978                 case LOG_TARGET_CONSOLE:
1979                 default:
1980                         command_line[pos++] = "console";
1981                         break;
1982                 };
1983
1984                 if (log_get_show_color())
1985                         command_line[pos++] = "--log-color";
1986
1987                 if (log_get_show_location())
1988                         command_line[pos++] = "--log-location";
1989
1990                 assert(pos < ELEMENTSOF(command_line));
1991
1992                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1993                         char *e;
1994
1995                         /* If we reboot let's set the shutdown
1996                          * watchdog and tell the shutdown binary to
1997                          * repeatedly ping it */
1998                         watchdog_set_timeout(&arg_shutdown_watchdog);
1999                         watchdog_close(false);
2000
2001                         /* Tell the binary how often to ping, ignore failure */
2002                         if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2003                                 strv_push(&env_block, e);
2004                 } else
2005                         watchdog_close(true);
2006
2007                 /* Avoid the creation of new processes forked by the
2008                  * kernel; at this point, we will not listen to the
2009                  * signals anyway */
2010                 if (detect_container(NULL) <= 0)
2011                         cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2012
2013                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2014                 log_error("Failed to execute shutdown binary, %s: %m",
2015                           getpid() == 1 ? "freezing" : "quitting");
2016         }
2017
2018         if (getpid() == 1)
2019                 freeze();
2020
2021         return retval;
2022 }