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