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