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