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