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