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