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