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