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