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 "dbus-common.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 _cleanup_free_ *line = NULL;
 692         char *w, *state;
 693         int r;
 694         size_t l;
 695
 696         /* Don't read /proc/cmdline if we are in a container, since
 697          * that is only relevant for the host system */
 698         if (detect_container(NULL) > 0)
 699                 return 0;
 700
 701         r = read_one_line_file("/proc/cmdline", &line);
 702         if (r < 0) {
 703                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 704                 return 0;
 705         }
 706
 707         FOREACH_WORD_QUOTED(w, l, line, state) {
 708                 char _cleanup_free_ *word;
 709
 710                 word = strndup(w, l);
 711                 if (!word)
 712                         return log_oom();
 713
 714                 r = parse_proc_cmdline_word(word);
 715                 if (r < 0) {
 716                         log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
 717                         return r;
 718                 }
 719         }
 720
 721         return 0;
 722 }
 723
 724 static int parse_argv(int argc, char *argv[]) {
 725
 726         enum {
 727                 ARG_LOG_LEVEL = 0x100,
 728                 ARG_LOG_TARGET,
 729                 ARG_LOG_COLOR,
 730                 ARG_LOG_LOCATION,
 731                 ARG_UNIT,
 732                 ARG_SYSTEM,
 733                 ARG_USER,
 734                 ARG_TEST,
 735                 ARG_VERSION,
 736                 ARG_DUMP_CONFIGURATION_ITEMS,
 737                 ARG_DUMP_CORE,
 738                 ARG_CRASH_SHELL,
 739                 ARG_CONFIRM_SPAWN,
 740                 ARG_SHOW_STATUS,
 741                 ARG_DESERIALIZE,
 742                 ARG_SWITCHED_ROOT,
 743                 ARG_INTROSPECT,
 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                 { "introspect",               optional_argument, NULL, ARG_INTROSPECT               },
 767                 { "default-standard-output",  required_argument, NULL, ARG_DEFAULT_STD_OUTPUT,      },
 768                 { "default-standard-error",   required_argument, NULL, ARG_DEFAULT_STD_ERROR,       },
 769                 { NULL,                       0,                 NULL, 0                            }
 770         };
 771
 772         int c, r;
 773
 774         assert(argc >= 1);
 775         assert(argv);
 776
 777         if (getpid() == 1)
 778                 opterr = 0;
 779
 780         while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
 781
 782                 switch (c) {
 783
 784                 case ARG_LOG_LEVEL:
 785                         if ((r = log_set_max_level_from_string(optarg)) < 0) {
 786                                 log_error("Failed to parse log level %s.", optarg);
 787                                 return r;
 788                         }
 789
 790                         break;
 791
 792                 case ARG_LOG_TARGET:
 793
 794                         if ((r = log_set_target_from_string(optarg)) < 0) {
 795                                 log_error("Failed to parse log target %s.", optarg);
 796                                 return r;
 797                         }
 798
 799                         break;
 800
 801                 case ARG_LOG_COLOR:
 802
 803                         if (optarg) {
 804                                 if ((r = log_show_color_from_string(optarg)) < 0) {
 805                                         log_error("Failed to parse log color setting %s.", optarg);
 806                                         return r;
 807                                 }
 808                         } else
 809                                 log_show_color(true);
 810
 811                         break;
 812
 813                 case ARG_LOG_LOCATION:
 814
 815                         if (optarg) {
 816                                 if ((r = log_show_location_from_string(optarg)) < 0) {
 817                                         log_error("Failed to parse log location setting %s.", optarg);
 818                                         return r;
 819                                 }
 820                         } else
 821                                 log_show_location(true);
 822
 823                         break;
 824
 825                 case ARG_DEFAULT_STD_OUTPUT:
 826
 827                         if ((r = exec_output_from_string(optarg)) < 0) {
 828                                 log_error("Failed to parse default standard output setting %s.", optarg);
 829                                 return r;
 830                         } else
 831                                 arg_default_std_output = r;
 832                         break;
 833
 834                 case ARG_DEFAULT_STD_ERROR:
 835
 836                         if ((r = exec_output_from_string(optarg)) < 0) {
 837                                 log_error("Failed to parse default standard error output setting %s.", optarg);
 838                                 return r;
 839                         } else
 840                                 arg_default_std_error = r;
 841                         break;
 842
 843                 case ARG_UNIT:
 844
 845                         if ((r = set_default_unit(optarg)) < 0) {
 846                                 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
 847                                 return r;
 848                         }
 849
 850                         break;
 851
 852                 case ARG_SYSTEM:
 853                         arg_running_as = SYSTEMD_SYSTEM;
 854                         break;
 855
 856                 case ARG_USER:
 857                         arg_running_as = SYSTEMD_USER;
 858                         break;
 859
 860                 case ARG_TEST:
 861                         arg_action = ACTION_TEST;
 862                         break;
 863
 864                 case ARG_VERSION:
 865                         arg_action = ACTION_VERSION;
 866                         break;
 867
 868                 case ARG_DUMP_CONFIGURATION_ITEMS:
 869                         arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
 870                         break;
 871
 872                 case ARG_DUMP_CORE:
 873                         r = optarg ? parse_boolean(optarg) : 1;
 874                         if (r < 0) {
 875                                 log_error("Failed to parse dump core boolean %s.", optarg);
 876                                 return r;
 877                         }
 878                         arg_dump_core = r;
 879                         break;
 880
 881                 case ARG_CRASH_SHELL:
 882                         r = optarg ? parse_boolean(optarg) : 1;
 883                         if (r < 0) {
 884                                 log_error("Failed to parse crash shell boolean %s.", optarg);
 885                                 return r;
 886                         }
 887                         arg_crash_shell = r;
 888                         break;
 889
 890                 case ARG_CONFIRM_SPAWN:
 891                         r = optarg ? parse_boolean(optarg) : 1;
 892                         if (r < 0) {
 893                                 log_error("Failed to parse confirm spawn boolean %s.", optarg);
 894                                 return r;
 895                         }
 896                         arg_confirm_spawn = r;
 897                         break;
 898
 899                 case ARG_SHOW_STATUS:
 900                         r = optarg ? parse_boolean(optarg) : 1;
 901                         if (r < 0) {
 902                                 log_error("Failed to parse show status boolean %s.", optarg);
 903                                 return r;
 904                         }
 905                         arg_show_status = r;
 906                         break;
 907
 908                 case ARG_DESERIALIZE: {
 909                         int fd;
 910                         FILE *f;
 911
 912                         r = safe_atoi(optarg, &fd);
 913                         if (r < 0 || fd < 0) {
 914                                 log_error("Failed to parse deserialize option %s.", optarg);
 915                                 return r < 0 ? r : -EINVAL;
 916                         }
 917
 918                         fd_cloexec(fd, true);
 919
 920                         f = fdopen(fd, "r");
 921                         if (!f) {
 922                                 log_error("Failed to open serialization fd: %m");
 923                                 return -errno;
 924                         }
 925
 926                         if (serialization)
 927                                 fclose(serialization);
 928
 929                         serialization = f;
 930
 931                         break;
 932                 }
 933
 934                 case ARG_SWITCHED_ROOT:
 935                         arg_switched_root = true;
 936                         break;
 937
 938                 case ARG_INTROSPECT: {
 939                         const char * const * i = NULL;
 940
 941                         for (i = bus_interface_table; *i; i += 2)
 942                                 if (!optarg || streq(i[0], optarg)) {
 943                                         fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
 944                                               "<node>\n", stdout);
 945                                         fputs(i[1], stdout);
 946                                         fputs("</node>\n", stdout);
 947
 948                                         if (optarg)
 949                                                 break;
 950                                 }
 951
 952                         if (!i[0] && optarg)
 953                                 log_error("Unknown interface %s.", optarg);
 954
 955                         arg_action = ACTION_DONE;
 956                         break;
 957                 }
 958
 959                 case 'h':
 960                         arg_action = ACTION_HELP;
 961                         break;
 962
 963                 case 'D':
 964                         log_set_max_level(LOG_DEBUG);
 965                         break;
 966
 967                 case 'b':
 968                 case 's':
 969                 case 'z':
 970                         /* Just to eat away the sysvinit kernel
 971                          * cmdline args without getopt() error
 972                          * messages that we'll parse in
 973                          * parse_proc_cmdline_word() or ignore. */
 974
 975                 case '?':
 976                 default:
 977                         if (getpid() != 1) {
 978                                 log_error("Unknown option code %c", c);
 979                                 return -EINVAL;
 980                         }
 981
 982                         break;
 983                 }
 984
 985         if (optind < argc && getpid() != 1) {
 986                 /* Hmm, when we aren't run as init system
 987                  * let's complain about excess arguments */
 988
 989                 log_error("Excess arguments.");
 990                 return -EINVAL;
 991         }
 992
 993         if (detect_container(NULL) > 0) {
 994                 char **a;
 995
 996                 /* All /proc/cmdline arguments the kernel didn't
 997                  * understand it passed to us. We're not really
 998                  * interested in that usually since /proc/cmdline is
 999                  * more interesting and complete. With one exception:
1000                  * if we are run in a container /proc/cmdline is not
1001                  * relevant for the container, hence we rely on argv[]
1002                  * instead. */
1003
1004                 for (a = argv; a < argv + argc; a++)
1005                         if ((r = parse_proc_cmdline_word(*a)) < 0) {
1006                                 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
1007                                 return r;
1008                         }
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int help(void) {
1015
1016         printf("%s [OPTIONS...]\n\n"
1017                "Starts up and maintains the system or user services.\n\n"
1018                "  -h --help                      Show this help\n"
1019                "     --test                      Determine startup sequence, dump it and exit\n"
1020                "     --dump-configuration-items  Dump understood unit configuration items\n"
1021                "     --introspect[=INTERFACE]    Extract D-Bus interface data\n"
1022                "     --unit=UNIT                 Set default unit\n"
1023                "     --system                    Run a system instance, even if PID != 1\n"
1024                "     --user                      Run a user instance\n"
1025                "     --dump-core[=0|1]           Dump core on crash\n"
1026                "     --crash-shell[=0|1]         Run shell on crash\n"
1027                "     --confirm-spawn[=0|1]       Ask for confirmation when spawning processes\n"
1028                "     --show-status[=0|1]         Show status updates on the console during bootup\n"
1029                "     --log-target=TARGET         Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1030                "     --log-level=LEVEL           Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1031                "     --log-color[=0|1]           Highlight important log messages\n"
1032                "     --log-location[=0|1]        Include code location in log messages\n"
1033                "     --default-standard-output=  Set default standard output for services\n"
1034                "     --default-standard-error=   Set default standard error output for services\n",
1035                program_invocation_short_name);
1036
1037         return 0;
1038 }
1039
1040 static int version(void) {
1041         puts(PACKAGE_STRING);
1042         puts(SYSTEMD_FEATURES);
1043
1044         return 0;
1045 }
1046
1047 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
1048         FILE *f = NULL;
1049         FDSet *fds = NULL;
1050         int r;
1051
1052         assert(m);
1053         assert(_f);
1054         assert(_fds);
1055
1056         /* Make sure nothing is really destructed when we shut down */
1057         m->n_reloading ++;
1058
1059         r = manager_open_serialization(m, &f);
1060         if (r < 0) {
1061                 log_error("Failed to create serialization file: %s", strerror(-r));
1062                 goto fail;
1063         }
1064
1065         fds = fdset_new();
1066         if (!fds) {
1067                 r = -ENOMEM;
1068                 log_error("Failed to allocate fd set: %s", strerror(-r));
1069                 goto fail;
1070         }
1071
1072         r = manager_serialize(m, f, fds, switching_root);
1073         if (r < 0) {
1074                 log_error("Failed to serialize state: %s", strerror(-r));
1075                 goto fail;
1076         }
1077
1078         if (fseeko(f, 0, SEEK_SET) < 0) {
1079                 log_error("Failed to rewind serialization fd: %m");
1080                 goto fail;
1081         }
1082
1083         r = fd_cloexec(fileno(f), false);
1084         if (r < 0) {
1085                 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1086                 goto fail;
1087         }
1088
1089         r = fdset_cloexec(fds, false);
1090         if (r < 0) {
1091                 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1092                 goto fail;
1093         }
1094
1095         *_f = f;
1096         *_fds = fds;
1097
1098         return 0;
1099
1100 fail:
1101         fdset_free(fds);
1102
1103         if (f)
1104                 fclose(f);
1105
1106         return r;
1107 }
1108
1109 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1110         struct rlimit nl;
1111         int r;
1112
1113         assert(saved_rlimit);
1114
1115         /* Save the original RLIMIT_NOFILE so that we can reset it
1116          * later when transitioning from the initrd to the main
1117          * systemd or suchlike. */
1118         if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1119                 log_error("Reading RLIMIT_NOFILE failed: %m");
1120                 return -errno;
1121         }
1122
1123         /* Make sure forked processes get the default kernel setting */
1124         if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1125                 struct rlimit *rl;
1126
1127                 rl = newdup(struct rlimit, saved_rlimit, 1);
1128                 if (!rl)
1129                         return log_oom();
1130
1131                 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1132         }
1133
1134         /* Bump up the resource limit for ourselves substantially */
1135         nl.rlim_cur = nl.rlim_max = 64*1024;
1136         r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1137         if (r < 0) {
1138                 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1139                 return r;
1140         }
1141
1142         return 0;
1143 }
1144
1145 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1146         const char *e;
1147         unsigned long long a, b;
1148
1149         assert(t);
1150
1151         e = getenv("RD_TIMESTAMP");
1152         if (!e)
1153                 return NULL;
1154
1155         if (sscanf(e, "%llu %llu", &a, &b) != 2)
1156                 return NULL;
1157
1158         t->realtime = (usec_t) a;
1159         t->monotonic = (usec_t) b;
1160
1161         return t;
1162 }
1163
1164 static void test_mtab(void) {
1165         char *p;
1166
1167         /* Check that /etc/mtab is a symlink */
1168
1169         if (readlink_malloc("/etc/mtab", &p) >= 0) {
1170                 bool b;
1171
1172                 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1173                 free(p);
1174
1175                 if (b)
1176                         return;
1177         }
1178
1179         log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1180                     "This is not supported anymore. "
1181                     "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1182 }
1183
1184 static void test_usr(void) {
1185
1186         /* Check that /usr is not a separate fs */
1187
1188         if (dir_is_empty("/usr") <= 0)
1189                 return;
1190
1191         log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1192                     "Some things will probably break (sometimes even silently) in mysterious ways. "
1193                     "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1194 }
1195
1196 static void test_cgroups(void) {
1197
1198         if (access("/proc/cgroups", F_OK) >= 0)
1199                 return;
1200
1201         log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1202                     "Systems without control groups are not supported. "
1203                     "We will now sleep for 10s, and then continue boot-up. "
1204                     "Expect breakage and please do not file bugs. "
1205                     "Instead fix your kernel and enable CONFIG_CGROUPS. "
1206                     "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1207
1208         sleep(10);
1209 }
1210
1211 static int initialize_join_controllers(void) {
1212         /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1213          * + "net_prio". We'd like to add "cpuset" to the mix, but
1214          * "cpuset" does't really work for groups with no initialized
1215          * attributes. */
1216
1217         arg_join_controllers = new(char**, 3);
1218         if (!arg_join_controllers)
1219                 return -ENOMEM;
1220
1221         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1222         if (!arg_join_controllers[0])
1223                 return -ENOMEM;
1224
1225         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1226         if (!arg_join_controllers[1])
1227                 return -ENOMEM;
1228
1229         arg_join_controllers[2] = NULL;
1230         return 0;
1231 }
1232
1233 int main(int argc, char *argv[]) {
1234         Manager *m = NULL;
1235         int r, retval = EXIT_FAILURE;
1236         usec_t before_startup, after_startup;
1237         char timespan[FORMAT_TIMESPAN_MAX];
1238         FDSet *fds = NULL;
1239         bool reexecute = false;
1240         const char *shutdown_verb = NULL;
1241         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1242         static char systemd[] = "systemd";
1243         bool skip_setup = false;
1244         int j;
1245         bool loaded_policy = false;
1246         bool arm_reboot_watchdog = false;
1247         bool queue_default_job = false;
1248         char *switch_root_dir = NULL, *switch_root_init = NULL;
1249         static struct rlimit saved_rlimit_nofile = { 0, 0 };
1250
1251 #ifdef HAVE_SYSV_COMPAT
1252         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1253                 /* This is compatibility support for SysV, where
1254                  * calling init as a user is identical to telinit. */
1255
1256                 errno = -ENOENT;
1257                 execv(SYSTEMCTL_BINARY_PATH, argv);
1258                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1259                 return 1;
1260         }
1261 #endif
1262
1263         /* Determine if this is a reexecution or normal bootup. We do
1264          * the full command line parsing much later, so let's just
1265          * have a quick peek here. */
1266         if (strv_find(argv+1, "--deserialize"))
1267                 skip_setup = true;
1268
1269         /* If we have switched root, do all the special setup
1270          * things */
1271         if (strv_find(argv+1, "--switched-root"))
1272                 skip_setup = false;
1273
1274         /* If we get started via the /sbin/init symlink then we are
1275            called 'init'. After a subsequent reexecution we are then
1276            called 'systemd'. That is confusing, hence let's call us
1277            systemd right-away. */
1278         program_invocation_short_name = systemd;
1279         prctl(PR_SET_NAME, systemd);
1280
1281         saved_argv = argv;
1282         saved_argc = argc;
1283
1284         log_show_color(isatty(STDERR_FILENO) > 0);
1285
1286         if (getpid() == 1 && detect_container(NULL) <= 0) {
1287
1288                 /* Running outside of a container as PID 1 */
1289                 arg_running_as = SYSTEMD_SYSTEM;
1290                 make_null_stdio();
1291                 log_set_target(LOG_TARGET_KMSG);
1292                 log_open();
1293
1294                 if (in_initrd()) {
1295                         char *rd_timestamp = NULL;
1296
1297                         dual_timestamp_get(&initrd_timestamp);
1298                         asprintf(&rd_timestamp, "%llu %llu",
1299                                  (unsigned long long) initrd_timestamp.realtime,
1300                                  (unsigned long long) initrd_timestamp.monotonic);
1301                         if (rd_timestamp) {
1302                                 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1303                                 free(rd_timestamp);
1304                         }
1305                 }
1306
1307                 if (!skip_setup) {
1308                         mount_setup_early();
1309                         if (selinux_setup(&loaded_policy) < 0)
1310                                 goto finish;
1311                         if (ima_setup() < 0)
1312                                 goto finish;
1313                         if (smack_setup() < 0)
1314                                 goto finish;
1315                 }
1316
1317                 if (label_init(NULL) < 0)
1318                         goto finish;
1319
1320                 if (!skip_setup) {
1321                         if (hwclock_is_localtime() > 0) {
1322                                 int min;
1323
1324                                 /* The first-time call to settimeofday() does a time warp in the kernel */
1325                                 r = hwclock_set_timezone(&min);
1326                                 if (r < 0)
1327                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1328                                 else
1329                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1330                         } else if (!in_initrd()) {
1331                                 /*
1332                                  * Do dummy first-time call to seal the kernel's time warp magic
1333                                  *
1334                                  * Do not call this this from inside the initrd. The initrd might not
1335                                  * carry /etc/adjtime with LOCAL, but the real system could be set up
1336                                  * that way. In such case, we need to delay the time-warp or the sealing
1337                                  * until we reach the real system.
1338                                  */
1339                                 hwclock_reset_timezone();
1340
1341                                 /* Tell the kernel our time zone */
1342                                 r = hwclock_set_timezone(NULL);
1343                                 if (r < 0)
1344                                         log_error("Failed to set the kernel's time zone, ignoring: %s", strerror(-r));
1345                         }
1346                 }
1347
1348                 /* Set the default for later on, but don't actually
1349                  * open the logs like this for now. Note that if we
1350                  * are transitioning from the initrd there might still
1351                  * be journal fd open, and we shouldn't attempt
1352                  * opening that before we parsed /proc/cmdline which
1353                  * might redirect output elsewhere. */
1354                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1355
1356         } else if (getpid() == 1) {
1357
1358                 /* Running inside a container, as PID 1 */
1359                 arg_running_as = SYSTEMD_SYSTEM;
1360                 log_set_target(LOG_TARGET_CONSOLE);
1361                 log_open();
1362
1363                 /* For the later on, see above... */
1364                 log_set_target(LOG_TARGET_JOURNAL);
1365
1366         } else {
1367
1368                 /* Running as user instance */
1369                 arg_running_as = SYSTEMD_USER;
1370                 log_set_target(LOG_TARGET_AUTO);
1371                 log_open();
1372         }
1373
1374         /* Initialize default unit */
1375         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1376         if (r < 0) {
1377                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1378                 goto finish;
1379         }
1380
1381         r = initialize_join_controllers();
1382         if (r < 0)
1383                 goto finish;
1384
1385         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1386          * /proc/$PID/fd is available. */
1387         if (getpid() == 1) {
1388                 r = mount_setup(loaded_policy);
1389                 if (r < 0)
1390                         goto finish;
1391         }
1392
1393         /* Reset all signal handlers. */
1394         assert_se(reset_all_signal_handlers() == 0);
1395
1396         /* If we are init, we can block sigkill. Yay. */
1397         ignore_signals(SIGNALS_IGNORE, -1);
1398
1399         if (parse_config_file() < 0)
1400                 goto finish;
1401
1402         if (arg_running_as == SYSTEMD_SYSTEM)
1403                 if (parse_proc_cmdline() < 0)
1404                         goto finish;
1405
1406         log_parse_environment();
1407
1408         if (parse_argv(argc, argv) < 0)
1409                 goto finish;
1410
1411         if (arg_action == ACTION_TEST &&
1412             geteuid() == 0) {
1413                 log_error("Don't run test mode as root.");
1414                 goto finish;
1415         }
1416
1417         if (arg_running_as == SYSTEMD_USER &&
1418             arg_action == ACTION_RUN &&
1419             sd_booted() <= 0) {
1420                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1421                 goto finish;
1422         }
1423
1424         if (arg_running_as == SYSTEMD_SYSTEM &&
1425             arg_action == ACTION_RUN &&
1426             running_in_chroot() > 0) {
1427                 log_error("Cannot be run in a chroot() environment.");
1428                 goto finish;
1429         }
1430
1431         if (arg_action == ACTION_HELP) {
1432                 retval = help();
1433                 goto finish;
1434         } else if (arg_action == ACTION_VERSION) {
1435                 retval = version();
1436                 goto finish;
1437         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1438                 unit_dump_config_items(stdout);
1439                 retval = EXIT_SUCCESS;
1440                 goto finish;
1441         } else if (arg_action == ACTION_DONE) {
1442                 retval = EXIT_SUCCESS;
1443                 goto finish;
1444         }
1445
1446         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1447
1448         /* Close logging fds, in order not to confuse fdset below */
1449         log_close();
1450
1451         /* Remember open file descriptors for later deserialization */
1452         r = fdset_new_fill(&fds);
1453         if (r < 0) {
1454                 log_error("Failed to allocate fd set: %s", strerror(-r));
1455                 goto finish;
1456         } else
1457                 fdset_cloexec(fds, true);
1458
1459         if (serialization)
1460                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1461
1462         /* Set up PATH unless it is already set */
1463         setenv("PATH",
1464 #ifdef HAVE_SPLIT_USR
1465                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1466 #else
1467                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1468 #endif
1469                arg_running_as == SYSTEMD_SYSTEM);
1470
1471         if (arg_running_as == SYSTEMD_SYSTEM) {
1472                 /* Parse the data passed to us. We leave this
1473                  * variables set, but the manager later on will not
1474                  * pass them on to our children. */
1475                 if (!in_initrd())
1476                         parse_initrd_timestamp(&initrd_timestamp);
1477
1478                 /* Unset some environment variables passed in from the
1479                  * kernel that don't really make sense for us. */
1480                 unsetenv("HOME");
1481                 unsetenv("TERM");
1482
1483                 /* When we are invoked by a shell, these might be set,
1484                  * but make little sense to pass on */
1485                 unsetenv("PWD");
1486                 unsetenv("SHLVL");
1487                 unsetenv("_");
1488
1489                 /* When we are invoked by a chroot-like tool such as
1490                  * nspawn, these might be set, but make little sense
1491                  * to pass on */
1492                 unsetenv("USER");
1493                 unsetenv("LOGNAME");
1494
1495                 /* We suppress the socket activation env vars, as
1496                  * we'll try to match *any* open fd to units if
1497                  * possible. */
1498                 unsetenv("LISTEN_FDS");
1499                 unsetenv("LISTEN_PID");
1500
1501                 /* All other variables are left as is, so that clients
1502                  * can still read them via /proc/1/environ */
1503         }
1504
1505         /* Move out of the way, so that we won't block unmounts */
1506         assert_se(chdir("/")  == 0);
1507
1508         if (arg_running_as == SYSTEMD_SYSTEM) {
1509                 /* Become a session leader if we aren't one yet. */
1510                 setsid();
1511
1512                 /* Disable the umask logic */
1513                 umask(0);
1514         }
1515
1516         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1517         dbus_connection_set_change_sigpipe(FALSE);
1518
1519         /* Reset the console, but only if this is really init and we
1520          * are freshly booted */
1521         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1522                 console_setup(getpid() == 1 && !skip_setup);
1523
1524         /* Open the logging devices, if possible and necessary */
1525         log_open();
1526
1527         /* Make sure we leave a core dump without panicing the
1528          * kernel. */
1529         if (getpid() == 1) {
1530                 install_crash_handler();
1531
1532                 r = mount_cgroup_controllers(arg_join_controllers);
1533                 if (r < 0)
1534                         goto finish;
1535         }
1536
1537         if (arg_running_as == SYSTEMD_SYSTEM) {
1538                 const char *virtualization = NULL;
1539
1540                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1541
1542                 detect_virtualization(&virtualization);
1543                 if (virtualization)
1544                         log_info("Detected virtualization '%s'.", virtualization);
1545
1546                 if (in_initrd())
1547                         log_info("Running in initial RAM disk.");
1548
1549         } else
1550                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES ")");
1551
1552         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1553                 locale_setup();
1554
1555                 if (arg_show_status || plymouth_running())
1556                         status_welcome();
1557
1558 #ifdef HAVE_KMOD
1559                 kmod_setup();
1560 #endif
1561                 hostname_setup();
1562                 machine_id_setup();
1563                 loopback_setup();
1564
1565                 test_mtab();
1566                 test_usr();
1567                 test_cgroups();
1568         }
1569
1570         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1571                 watchdog_set_timeout(&arg_runtime_watchdog);
1572
1573         if (arg_timer_slack_nsec != (nsec_t) -1)
1574                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1575                         log_error("Failed to adjust timer slack: %m");
1576
1577         if (arg_capability_bounding_set_drop) {
1578                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1579                 if (r < 0) {
1580                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1581                         goto finish;
1582                 }
1583                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1584                 if (r < 0) {
1585                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1586                         goto finish;
1587                 }
1588         }
1589
1590         if (arg_running_as == SYSTEMD_USER) {
1591                 /* Become reaper of our children */
1592                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1593                         log_warning("Failed to make us a subreaper: %m");
1594                         if (errno == EINVAL)
1595                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1596                 }
1597         }
1598
1599         if (arg_running_as == SYSTEMD_SYSTEM)
1600                 bump_rlimit_nofile(&saved_rlimit_nofile);
1601
1602         r = manager_new(arg_running_as, &m);
1603         if (r < 0) {
1604                 log_error("Failed to allocate manager object: %s", strerror(-r));
1605                 goto finish;
1606         }
1607
1608         m->confirm_spawn = arg_confirm_spawn;
1609         m->default_std_output = arg_default_std_output;
1610         m->default_std_error = arg_default_std_error;
1611         m->runtime_watchdog = arg_runtime_watchdog;
1612         m->shutdown_watchdog = arg_shutdown_watchdog;
1613
1614         manager_set_default_rlimits(m, arg_default_rlimit);
1615
1616         if (dual_timestamp_is_set(&initrd_timestamp))
1617                 m->initrd_timestamp = initrd_timestamp;
1618
1619         if (arg_default_controllers)
1620                 manager_set_default_controllers(m, arg_default_controllers);
1621
1622         manager_set_show_status(m, arg_show_status);
1623
1624         /* Remember whether we should queue the default job */
1625         queue_default_job = !serialization || arg_switched_root;
1626
1627         before_startup = now(CLOCK_MONOTONIC);
1628
1629         r = manager_startup(m, serialization, fds);
1630         if (r < 0)
1631                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1632
1633         /* This will close all file descriptors that were opened, but
1634          * not claimed by any unit. */
1635         fdset_free(fds);
1636
1637         if (serialization) {
1638                 fclose(serialization);
1639                 serialization = NULL;
1640         }
1641
1642         if (queue_default_job) {
1643                 DBusError error;
1644                 Unit *target = NULL;
1645                 Job *default_unit_job;
1646
1647                 dbus_error_init(&error);
1648
1649                 log_debug("Activating default unit: %s", arg_default_unit);
1650
1651                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1652                 if (r < 0) {
1653                         log_error("Failed to load default target: %s", bus_error(&error, r));
1654                         dbus_error_free(&error);
1655                 } else if (target->load_state == UNIT_ERROR)
1656                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1657                 else if (target->load_state == UNIT_MASKED)
1658                         log_error("Default target masked.");
1659
1660                 if (!target || target->load_state != UNIT_LOADED) {
1661                         log_info("Trying to load rescue target...");
1662
1663                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1664                         if (r < 0) {
1665                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1666                                 dbus_error_free(&error);
1667                                 goto finish;
1668                         } else if (target->load_state == UNIT_ERROR) {
1669                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1670                                 goto finish;
1671                         } else if (target->load_state == UNIT_MASKED) {
1672                                 log_error("Rescue target masked.");
1673                                 goto finish;
1674                         }
1675                 }
1676
1677                 assert(target->load_state == UNIT_LOADED);
1678
1679                 if (arg_action == ACTION_TEST) {
1680                         printf("-> By units:\n");
1681                         manager_dump_units(m, stdout, "\t");
1682                 }
1683
1684                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1685                 if (r == -EPERM) {
1686                         log_error("Default target could not be isolated, starting instead: %s", bus_error(&error, r));
1687                         dbus_error_free(&error);
1688
1689                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1690                         if (r < 0) {
1691                                 log_error("Failed to start default target: %s", bus_error(&error, r));
1692                                 dbus_error_free(&error);
1693                                 goto finish;
1694                         }
1695                 } else if (r < 0) {
1696                         log_error("Failed to isolate default target: %s", bus_error(&error, r));
1697                         dbus_error_free(&error);
1698                         goto finish;
1699                 }
1700
1701                 m->default_unit_job_id = default_unit_job->id;
1702
1703                 after_startup = now(CLOCK_MONOTONIC);
1704                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1705                          "Loaded units and determined initial transaction in %s.",
1706                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1707
1708                 if (arg_action == ACTION_TEST) {
1709                         printf("-> By jobs:\n");
1710                         manager_dump_jobs(m, stdout, "\t");
1711                         retval = EXIT_SUCCESS;
1712                         goto finish;
1713                 }
1714         }
1715
1716         for (;;) {
1717                 r = manager_loop(m);
1718                 if (r < 0) {
1719                         log_error("Failed to run mainloop: %s", strerror(-r));
1720                         goto finish;
1721                 }
1722
1723                 switch (m->exit_code) {
1724
1725                 case MANAGER_EXIT:
1726                         retval = EXIT_SUCCESS;
1727                         log_debug("Exit.");
1728                         goto finish;
1729
1730                 case MANAGER_RELOAD:
1731                         log_info("Reloading.");
1732                         r = manager_reload(m);
1733                         if (r < 0)
1734                                 log_error("Failed to reload: %s", strerror(-r));
1735                         break;
1736
1737                 case MANAGER_REEXECUTE:
1738
1739                         if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1740                                 goto finish;
1741
1742                         reexecute = true;
1743                         log_notice("Reexecuting.");
1744                         goto finish;
1745
1746                 case MANAGER_SWITCH_ROOT:
1747                         /* Steal the switch root parameters */
1748                         switch_root_dir = m->switch_root;
1749                         switch_root_init = m->switch_root_init;
1750                         m->switch_root = m->switch_root_init = NULL;
1751
1752                         if (!switch_root_init)
1753                                 if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1754                                         goto finish;
1755
1756                         reexecute = true;
1757                         log_notice("Switching root.");
1758                         goto finish;
1759
1760                 case MANAGER_REBOOT:
1761                 case MANAGER_POWEROFF:
1762                 case MANAGER_HALT:
1763                 case MANAGER_KEXEC: {
1764                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1765                                 [MANAGER_REBOOT] = "reboot",
1766                                 [MANAGER_POWEROFF] = "poweroff",
1767                                 [MANAGER_HALT] = "halt",
1768                                 [MANAGER_KEXEC] = "kexec"
1769                         };
1770
1771                         assert_se(shutdown_verb = table[m->exit_code]);
1772                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1773
1774                         log_notice("Shutting down.");
1775                         goto finish;
1776                 }
1777
1778                 default:
1779                         assert_not_reached("Unknown exit code.");
1780                 }
1781         }
1782
1783 finish:
1784         if (m)
1785                 manager_free(m);
1786
1787         for (j = 0; j < RLIMIT_NLIMITS; j++)
1788                 free(arg_default_rlimit[j]);
1789
1790         free(arg_default_unit);
1791         strv_free(arg_default_controllers);
1792         free_join_controllers();
1793
1794         dbus_shutdown();
1795         label_finish();
1796
1797         if (reexecute) {
1798                 const char **args;
1799                 unsigned i, args_size;
1800
1801                 /* Close and disarm the watchdog, so that the new
1802                  * instance can reinitialize it, but doesn't get
1803                  * rebooted while we do that */
1804                 watchdog_close(true);
1805
1806                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1807                  * that the new systemd can pass the kernel default to
1808                  * its child processes */
1809                 if (saved_rlimit_nofile.rlim_cur > 0)
1810                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1811
1812                 if (switch_root_dir) {
1813                         /* Kill all remaining processes from the
1814                          * initrd, but don't wait for them, so that we
1815                          * can handle the SIGCHLD for them after
1816                          * deserializing. */
1817                         broadcast_signal(SIGTERM, false);
1818
1819                         /* And switch root */
1820                         r = switch_root(switch_root_dir);
1821                         if (r < 0)
1822                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1823                 }
1824
1825                 args_size = MAX(6, argc+1);
1826                 args = newa(const char*, args_size);
1827
1828                 if (!switch_root_init) {
1829                         char sfd[16];
1830
1831                         /* First try to spawn ourselves with the right
1832                          * path, and with full serialization. We do
1833                          * this only if the user didn't specify an
1834                          * explicit init to spawn. */
1835
1836                         assert(serialization);
1837                         assert(fds);
1838
1839                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1840                         char_array_0(sfd);
1841
1842                         i = 0;
1843                         args[i++] = SYSTEMD_BINARY_PATH;
1844                         if (switch_root_dir)
1845                                 args[i++] = "--switched-root";
1846                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1847                         args[i++] = "--deserialize";
1848                         args[i++] = sfd;
1849                         args[i++] = NULL;
1850
1851                         assert(i <= args_size);
1852                         execv(args[0], (char* const*) args);
1853                 }
1854
1855                 /* Try the fallback, if there is any, without any
1856                  * serialization. We pass the original argv[] and
1857                  * envp[]. (Well, modulo the ordering changes due to
1858                  * getopt() in argv[], and some cleanups in envp[],
1859                  * but let's hope that doesn't matter.) */
1860
1861                 if (serialization) {
1862                         fclose(serialization);
1863                         serialization = NULL;
1864                 }
1865
1866                 if (fds) {
1867                         fdset_free(fds);
1868                         fds = NULL;
1869                 }
1870
1871                 /* Reopen the console */
1872                 make_console_stdio();
1873
1874                 for (j = 1, i = 1; j < argc; j++)
1875                         args[i++] = argv[j];
1876                 args[i++] = NULL;
1877                 assert(i <= args_size);
1878
1879                 if (switch_root_init) {
1880                         args[0] = switch_root_init;
1881                         execv(args[0], (char* const*) args);
1882                         log_warning("Failed to execute configured init, trying fallback: %m");
1883                 }
1884
1885                 args[0] = "/sbin/init";
1886                 execv(args[0], (char* const*) args);
1887
1888                 if (errno == ENOENT) {
1889                         log_warning("No /sbin/init, trying fallback");
1890
1891                         args[0] = "/bin/sh";
1892                         args[1] = NULL;
1893                         execv(args[0], (char* const*) args);
1894                         log_error("Failed to execute /bin/sh, giving up: %m");
1895                 } else
1896                         log_warning("Failed to execute /sbin/init, giving up: %m");
1897         }
1898
1899         if (serialization)
1900                 fclose(serialization);
1901
1902         if (fds)
1903                 fdset_free(fds);
1904
1905         if (shutdown_verb) {
1906                 const char * command_line[] = {
1907                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1908                         shutdown_verb,
1909                         NULL
1910                 };
1911                 char **env_block;
1912
1913                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1914                         char e[32];
1915
1916                         /* If we reboot let's set the shutdown
1917                          * watchdog and tell the shutdown binary to
1918                          * repeatedly ping it */
1919                         watchdog_set_timeout(&arg_shutdown_watchdog);
1920                         watchdog_close(false);
1921
1922                         /* Tell the binary how often to ping */
1923                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1924                         char_array_0(e);
1925
1926                         env_block = strv_append(environ, e);
1927                 } else {
1928                         env_block = strv_copy(environ);
1929                         watchdog_close(true);
1930                 }
1931
1932                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1933                 free(env_block);
1934                 log_error("Failed to execute shutdown binary, freezing: %m");
1935         }
1936
1937         if (getpid() == 1)
1938                 freeze();
1939
1940         return retval;
1941 }