src/core/main.c

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