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