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