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