src/core/main.c

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