src/core/main.c

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