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