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 ManagerRunningAs arg_running_as = _MANAGER_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 == MANAGER_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 = MANAGER_SYSTEM;
 876                         break;
 877
 878                 case ARG_USER:
 879                         arg_running_as = MANAGER_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         log_show_location(false);
1289         log_set_max_level(LOG_INFO);
1290
1291         if (getpid() == 1) {
1292                 if (in_initrd()) {
1293                         char *rd_timestamp = NULL;
1294
1295                         dual_timestamp_get(&initrd_timestamp);
1296                         asprintf(&rd_timestamp, "%llu %llu",
1297                                  (unsigned long long) initrd_timestamp.realtime,
1298                                  (unsigned long long) initrd_timestamp.monotonic);
1299                         if (rd_timestamp) {
1300                                 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1301                                 free(rd_timestamp);
1302                         }
1303                 }
1304
1305                 arg_running_as = MANAGER_SYSTEM;
1306
1307                 make_null_stdio();
1308                 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
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                 log_open();
1318
1319                 if (label_init(NULL) < 0)
1320                         goto finish;
1321
1322                 if (!skip_setup) {
1323                         if (hwclock_is_localtime() > 0) {
1324                                 int min;
1325
1326                                 /* The first-time call to settimeofday() does a time warp in the kernel */
1327                                 r = hwclock_set_timezone(&min);
1328                                 if (r < 0)
1329                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1330                                 else
1331                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1332                         } else {
1333                                 /* Do dummy first-time call to seal the kernel's time warp magic */
1334                                 hwclock_reset_timezone();
1335
1336                                 /* Tell the kernel our time zone */
1337                                 r = hwclock_set_timezone(NULL);
1338                                 if (r < 0)
1339                                         log_error("Failed to set the kernel's time zone, ignoring: %s", strerror(-r));
1340                         }
1341                 }
1342         } else {
1343                 arg_running_as = MANAGER_USER;
1344                 log_set_target(LOG_TARGET_AUTO);
1345                 log_open();
1346         }
1347
1348         /* Initialize default unit */
1349         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1350         if (r < 0) {
1351                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1352                 goto finish;
1353         }
1354
1355         /* By default, mount "cpu" and "cpuacct" together */
1356         arg_join_controllers = new(char**, 3);
1357         if (!arg_join_controllers)
1358                 goto finish;
1359
1360         arg_join_controllers[0] = strv_new("cpu", "cpuacct", "cpuset", NULL);
1361         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1362         arg_join_controllers[2] = NULL;
1363
1364         if (!arg_join_controllers[0])
1365                 goto finish;
1366
1367         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1368          * /proc/$PID/fd is available. */
1369         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1370                 r = mount_setup(loaded_policy);
1371                 if (r < 0)
1372                         goto finish;
1373         }
1374
1375         /* Reset all signal handlers. */
1376         assert_se(reset_all_signal_handlers() == 0);
1377
1378         /* If we are init, we can block sigkill. Yay. */
1379         ignore_signals(SIGNALS_IGNORE, -1);
1380
1381         if (parse_config_file() < 0)
1382                 goto finish;
1383
1384         if (arg_running_as == MANAGER_SYSTEM)
1385                 if (parse_proc_cmdline() < 0)
1386                         goto finish;
1387
1388         log_parse_environment();
1389
1390         if (parse_argv(argc, argv) < 0)
1391                 goto finish;
1392
1393         if (arg_action == ACTION_TEST && geteuid() == 0) {
1394                 log_error("Don't run test mode as root.");
1395                 goto finish;
1396         }
1397
1398         if (arg_running_as == MANAGER_SYSTEM &&
1399             arg_action == ACTION_RUN &&
1400             running_in_chroot() > 0) {
1401                 log_error("Cannot be run in a chroot() environment.");
1402                 goto finish;
1403         }
1404
1405         if (arg_action == ACTION_HELP) {
1406                 retval = help();
1407                 goto finish;
1408         } else if (arg_action == ACTION_VERSION) {
1409                 retval = version();
1410                 goto finish;
1411         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1412                 unit_dump_config_items(stdout);
1413                 retval = EXIT_SUCCESS;
1414                 goto finish;
1415         } else if (arg_action == ACTION_DONE) {
1416                 retval = EXIT_SUCCESS;
1417                 goto finish;
1418         }
1419
1420         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1421
1422         /* Close logging fds, in order not to confuse fdset below */
1423         log_close();
1424
1425         /* Remember open file descriptors for later deserialization */
1426         if (serialization) {
1427                 r = fdset_new_fill(&fds);
1428                 if (r < 0) {
1429                         log_error("Failed to allocate fd set: %s", strerror(-r));
1430                         goto finish;
1431                 }
1432
1433                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1434         } else
1435                 close_all_fds(NULL, 0);
1436
1437         /* Set up PATH unless it is already set */
1438         setenv("PATH",
1439 #ifdef HAVE_SPLIT_USR
1440                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1441 #else
1442                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1443 #endif
1444                arg_running_as == MANAGER_SYSTEM);
1445
1446         if (arg_running_as == MANAGER_SYSTEM) {
1447                 /* Parse the data passed to us. We leave this
1448                  * variables set, but the manager later on will not
1449                  * pass them on to our children. */
1450                 if (!in_initrd())
1451                         parse_initrd_timestamp(&initrd_timestamp);
1452
1453                 /* Unset some environment variables passed in from the
1454                  * kernel that don't really make sense for us. */
1455                 unsetenv("HOME");
1456                 unsetenv("TERM");
1457
1458                 /* When we are invoked by a shell, these might be set,
1459                  * but make little sense to pass on */
1460                 unsetenv("PWD");
1461                 unsetenv("SHLVL");
1462                 unsetenv("_");
1463
1464                 /* When we are invoked by a chroot-like tool such as
1465                  * nspawn, these might be set, but make little sense
1466                  * to pass on */
1467                 unsetenv("USER");
1468                 unsetenv("LOGNAME");
1469
1470                 /* All other variables are left as is, so that clients
1471                  * can still read them via /proc/1/environ */
1472         }
1473
1474         /* Move out of the way, so that we won't block unmounts */
1475         assert_se(chdir("/")  == 0);
1476
1477         if (arg_running_as == MANAGER_SYSTEM) {
1478                 /* Become a session leader if we aren't one yet. */
1479                 setsid();
1480
1481                 /* Disable the umask logic */
1482                 umask(0);
1483         }
1484
1485         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1486         dbus_connection_set_change_sigpipe(FALSE);
1487
1488         /* Reset the console, but only if this is really init and we
1489          * are freshly booted */
1490         if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN)
1491                 console_setup(getpid() == 1 && !skip_setup);
1492
1493         /* Open the logging devices, if possible and necessary */
1494         log_open();
1495
1496         /* Make sure we leave a core dump without panicing the
1497          * kernel. */
1498         if (getpid() == 1)
1499                 install_crash_handler();
1500
1501         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1502                 r = mount_cgroup_controllers(arg_join_controllers);
1503                 if (r < 0)
1504                         goto finish;
1505         }
1506
1507         if (arg_running_as == MANAGER_SYSTEM) {
1508                 const char *virtualization = NULL;
1509
1510                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1511
1512                 detect_virtualization(&virtualization);
1513                 if (virtualization)
1514                         log_info("Detected virtualization '%s'.", virtualization);
1515
1516                 if (in_initrd())
1517                         log_info("Running in initial RAM disk.");
1518
1519         } else
1520                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1521
1522         if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1523                 locale_setup();
1524
1525                 if (arg_show_status || plymouth_running())
1526                         status_welcome();
1527
1528                 kmod_setup();
1529                 hostname_setup();
1530                 machine_id_setup();
1531                 loopback_setup();
1532
1533                 test_mtab();
1534                 test_usr();
1535                 test_cgroups();
1536         }
1537
1538         if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1539                 watchdog_set_timeout(&arg_runtime_watchdog);
1540
1541         if (arg_timer_slack_nsec != (nsec_t) -1)
1542                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1543                         log_error("Failed to adjust timer slack: %m");
1544
1545         if (arg_capability_bounding_set_drop) {
1546                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1547                 if (r < 0) {
1548                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1549                         goto finish;
1550                 }
1551                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1552                 if (r < 0) {
1553                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1554                         goto finish;
1555                 }
1556         }
1557
1558         if (arg_running_as == MANAGER_USER) {
1559                 /* Become reaper of our children */
1560                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1561                         log_warning("Failed to make us a subreaper: %m");
1562                         if (errno == EINVAL)
1563                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1564                 }
1565         }
1566
1567         if (arg_running_as == MANAGER_SYSTEM)
1568                 bump_rlimit_nofile(&saved_rlimit_nofile);
1569
1570         r = manager_new(arg_running_as, &m);
1571         if (r < 0) {
1572                 log_error("Failed to allocate manager object: %s", strerror(-r));
1573                 goto finish;
1574         }
1575
1576         m->confirm_spawn = arg_confirm_spawn;
1577         m->default_std_output = arg_default_std_output;
1578         m->default_std_error = arg_default_std_error;
1579         m->runtime_watchdog = arg_runtime_watchdog;
1580         m->shutdown_watchdog = arg_shutdown_watchdog;
1581
1582         manager_set_default_rlimits(m, arg_default_rlimit);
1583
1584         if (dual_timestamp_is_set(&initrd_timestamp))
1585                 m->initrd_timestamp = initrd_timestamp;
1586
1587         if (arg_default_controllers)
1588                 manager_set_default_controllers(m, arg_default_controllers);
1589
1590         manager_set_show_status(m, arg_show_status);
1591
1592         /* Remember whether we should queue the default job */
1593         queue_default_job = !serialization || arg_switched_root;
1594
1595         before_startup = now(CLOCK_MONOTONIC);
1596
1597         r = manager_startup(m, serialization, fds);
1598         if (r < 0)
1599                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1600
1601         /* This will close all file descriptors that were opened, but
1602          * not claimed by any unit. */
1603         if (fds) {
1604                 fdset_free(fds);
1605                 fds = NULL;
1606         }
1607
1608         if (serialization) {
1609                 fclose(serialization);
1610                 serialization = NULL;
1611         }
1612
1613         if (queue_default_job) {
1614                 DBusError error;
1615                 Unit *target = NULL;
1616                 Job *default_unit_job;
1617
1618                 dbus_error_init(&error);
1619
1620                 log_debug("Activating default unit: %s", arg_default_unit);
1621
1622                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1623                 if (r < 0) {
1624                         log_error("Failed to load default target: %s", bus_error(&error, r));
1625                         dbus_error_free(&error);
1626                 } else if (target->load_state == UNIT_ERROR)
1627                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1628                 else if (target->load_state == UNIT_MASKED)
1629                         log_error("Default target masked.");
1630
1631                 if (!target || target->load_state != UNIT_LOADED) {
1632                         log_info("Trying to load rescue target...");
1633
1634                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1635                         if (r < 0) {
1636                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1637                                 dbus_error_free(&error);
1638                                 goto finish;
1639                         } else if (target->load_state == UNIT_ERROR) {
1640                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1641                                 goto finish;
1642                         } else if (target->load_state == UNIT_MASKED) {
1643                                 log_error("Rescue target masked.");
1644                                 goto finish;
1645                         }
1646                 }
1647
1648                 assert(target->load_state == UNIT_LOADED);
1649
1650                 if (arg_action == ACTION_TEST) {
1651                         printf("-> By units:\n");
1652                         manager_dump_units(m, stdout, "\t");
1653                 }
1654
1655                 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1656                 if (r < 0) {
1657                         log_error("Failed to start default target: %s", bus_error(&error, r));
1658                         dbus_error_free(&error);
1659                         goto finish;
1660                 }
1661                 m->default_unit_job_id = default_unit_job->id;
1662
1663                 after_startup = now(CLOCK_MONOTONIC);
1664                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1665                          "Loaded units and determined initial transaction in %s.",
1666                           format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1667
1668                 if (arg_action == ACTION_TEST) {
1669                         printf("-> By jobs:\n");
1670                         manager_dump_jobs(m, stdout, "\t");
1671                         retval = EXIT_SUCCESS;
1672                         goto finish;
1673                 }
1674         }
1675
1676         for (;;) {
1677                 r = manager_loop(m);
1678                 if (r < 0) {
1679                         log_error("Failed to run mainloop: %s", strerror(-r));
1680                         goto finish;
1681                 }
1682
1683                 switch (m->exit_code) {
1684
1685                 case MANAGER_EXIT:
1686                         retval = EXIT_SUCCESS;
1687                         log_debug("Exit.");
1688                         goto finish;
1689
1690                 case MANAGER_RELOAD:
1691                         log_info("Reloading.");
1692                         r = manager_reload(m);
1693                         if (r < 0)
1694                                 log_error("Failed to reload: %s", strerror(-r));
1695                         break;
1696
1697                 case MANAGER_REEXECUTE:
1698
1699                         if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1700                                 goto finish;
1701
1702                         reexecute = true;
1703                         log_notice("Reexecuting.");
1704                         goto finish;
1705
1706                 case MANAGER_SWITCH_ROOT:
1707                         /* Steal the switch root parameters */
1708                         switch_root_dir = m->switch_root;
1709                         switch_root_init = m->switch_root_init;
1710                         m->switch_root = m->switch_root_init = NULL;
1711
1712                         if (!switch_root_init)
1713                                 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1714                                         goto finish;
1715
1716                         reexecute = true;
1717                         log_notice("Switching root.");
1718                         goto finish;
1719
1720                 case MANAGER_REBOOT:
1721                 case MANAGER_POWEROFF:
1722                 case MANAGER_HALT:
1723                 case MANAGER_KEXEC: {
1724                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1725                                 [MANAGER_REBOOT] = "reboot",
1726                                 [MANAGER_POWEROFF] = "poweroff",
1727                                 [MANAGER_HALT] = "halt",
1728                                 [MANAGER_KEXEC] = "kexec"
1729                         };
1730
1731                         assert_se(shutdown_verb = table[m->exit_code]);
1732                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1733
1734                         log_notice("Shutting down.");
1735                         goto finish;
1736                 }
1737
1738                 default:
1739                         assert_not_reached("Unknown exit code.");
1740                 }
1741         }
1742
1743 finish:
1744         if (m)
1745                 manager_free(m);
1746
1747         for (j = 0; j < RLIMIT_NLIMITS; j++)
1748                 free(arg_default_rlimit[j]);
1749
1750         free(arg_default_unit);
1751         strv_free(arg_default_controllers);
1752         free_join_controllers();
1753
1754         dbus_shutdown();
1755         label_finish();
1756
1757         if (reexecute) {
1758                 const char **args;
1759                 unsigned i, args_size;
1760
1761                 /* Close and disarm the watchdog, so that the new
1762                  * instance can reinitialize it, but doesn't get
1763                  * rebooted while we do that */
1764                 watchdog_close(true);
1765
1766                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1767                  * that the new systemd can pass the kernel default to
1768                  * its child processes */
1769                 if (saved_rlimit_nofile.rlim_cur > 0)
1770                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1771
1772                 if (switch_root_dir) {
1773                         /* Kill all remaining processes from the
1774                          * initrd, but don't wait for them, so that we
1775                          * can handle the SIGCHLD for them after
1776                          * deserializing. */
1777                         broadcast_signal(SIGTERM, false);
1778
1779                         /* And switch root */
1780                         r = switch_root(switch_root_dir);
1781                         if (r < 0)
1782                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1783                 }
1784
1785                 args_size = MAX(6, argc+1);
1786                 args = newa(const char*, args_size);
1787
1788                 if (!switch_root_init) {
1789                         char sfd[16];
1790
1791                         /* First try to spawn ourselves with the right
1792                          * path, and with full serialization. We do
1793                          * this only if the user didn't specify an
1794                          * explicit init to spawn. */
1795
1796                         assert(serialization);
1797                         assert(fds);
1798
1799                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1800                         char_array_0(sfd);
1801
1802                         i = 0;
1803                         args[i++] = SYSTEMD_BINARY_PATH;
1804                         if (switch_root_dir)
1805                                 args[i++] = "--switched-root";
1806                         args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1807                         args[i++] = "--deserialize";
1808                         args[i++] = sfd;
1809                         args[i++] = NULL;
1810
1811                         assert(i <= args_size);
1812                         execv(args[0], (char* const*) args);
1813                 }
1814
1815                 /* Try the fallback, if there is any, without any
1816                  * serialization. We pass the original argv[] and
1817                  * envp[]. (Well, modulo the ordering changes due to
1818                  * getopt() in argv[], and some cleanups in envp[],
1819                  * but let's hope that doesn't matter.) */
1820
1821                 if (serialization) {
1822                         fclose(serialization);
1823                         serialization = NULL;
1824                 }
1825
1826                 if (fds) {
1827                         fdset_free(fds);
1828                         fds = NULL;
1829                 }
1830
1831                 /* Reopen the console */
1832                 make_console_stdio();
1833
1834                 for (j = 1, i = 1; j < argc; j++)
1835                         args[i++] = argv[j];
1836                 args[i++] = NULL;
1837                 assert(i <= args_size);
1838
1839                 if (switch_root_init) {
1840                         args[0] = switch_root_init;
1841                         execv(args[0], (char* const*) args);
1842                         log_warning("Failed to execute configured init, trying fallback: %m");
1843                 }
1844
1845                 args[0] = "/sbin/init";
1846                 execv(args[0], (char* const*) args);
1847
1848                 if (errno == ENOENT) {
1849                         log_warning("No /sbin/init, trying fallback");
1850
1851                         args[0] = "/bin/sh";
1852                         args[1] = NULL;
1853                         execv(args[0], (char* const*) args);
1854                         log_error("Failed to execute /bin/sh, giving up: %m");
1855                 } else
1856                         log_warning("Failed to execute /sbin/init, giving up: %m");
1857         }
1858
1859         if (serialization)
1860                 fclose(serialization);
1861
1862         if (fds)
1863                 fdset_free(fds);
1864
1865         if (shutdown_verb) {
1866                 const char * command_line[] = {
1867                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1868                         shutdown_verb,
1869                         NULL
1870                 };
1871                 char **env_block;
1872
1873                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1874                         char e[32];
1875
1876                         /* If we reboot let's set the shutdown
1877                          * watchdog and tell the shutdown binary to
1878                          * repeatedly ping it */
1879                         watchdog_set_timeout(&arg_shutdown_watchdog);
1880                         watchdog_close(false);
1881
1882                         /* Tell the binary how often to ping */
1883                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1884                         char_array_0(e);
1885
1886                         env_block = strv_append(environ, e);
1887                 } else {
1888                         env_block = strv_copy(environ);
1889                         watchdog_close(true);
1890                 }
1891
1892                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1893                 free(env_block);
1894                 log_error("Failed to execute shutdown binary, freezing: %m");
1895         }
1896
1897         if (getpid() == 1)
1898                 freeze();
1899
1900         return retval;
1901 }