src/core/main.c

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