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