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: %m");
 172                 else if (pid == 0) {
 173                         make_console_stdio();
 174                         execl("/bin/sh", "/bin/sh", NULL);
 175
 176                         log_error("execl() failed: %m");
 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 %m. Ignoring.");
 354                 } else {
 355                         *eq = 0;
 356                         r = setenv(cenv, eq + 1, 1);
 357                         if (r < 0)
 358                                 log_warning("setenv failed %m. Ignoring.");
 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 log_oom();
 499
 500                 r = safe_atou(t, &cpu);
 501                 free(t);
 502
 503                 if (!c)
 504                         if (!(c = cpu_set_malloc(&ncpus)))
 505                                 return log_oom();
 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 log_oom();
 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 log_oom();
 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 log_oom();
 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 log_oom();
 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 log_oom();
 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                 if (r < 0) {
 731                         log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
 732                         free(word);
 733                         goto finish;
 734                 }
 735
 736                 free(word);
 737         }
 738
 739         r = 0;
 740
 741 finish:
 742         free(line);
 743         return r;
 744 }
 745
 746 static int parse_argv(int argc, char *argv[]) {
 747
 748         enum {
 749                 ARG_LOG_LEVEL = 0x100,
 750                 ARG_LOG_TARGET,
 751                 ARG_LOG_COLOR,
 752                 ARG_LOG_LOCATION,
 753                 ARG_UNIT,
 754                 ARG_SYSTEM,
 755                 ARG_USER,
 756                 ARG_TEST,
 757                 ARG_VERSION,
 758                 ARG_DUMP_CONFIGURATION_ITEMS,
 759                 ARG_DUMP_CORE,
 760                 ARG_CRASH_SHELL,
 761                 ARG_CONFIRM_SPAWN,
 762                 ARG_SHOW_STATUS,
 763                 ARG_DESERIALIZE,
 764                 ARG_SWITCHED_ROOT,
 765                 ARG_INTROSPECT,
 766                 ARG_DEFAULT_STD_OUTPUT,
 767                 ARG_DEFAULT_STD_ERROR
 768         };
 769
 770         static const struct option options[] = {
 771                 { "log-level",                required_argument, NULL, ARG_LOG_LEVEL                },
 772                 { "log-target",               required_argument, NULL, ARG_LOG_TARGET               },
 773                 { "log-color",                optional_argument, NULL, ARG_LOG_COLOR                },
 774                 { "log-location",             optional_argument, NULL, ARG_LOG_LOCATION             },
 775                 { "unit",                     required_argument, NULL, ARG_UNIT                     },
 776                 { "system",                   no_argument,       NULL, ARG_SYSTEM                   },
 777                 { "user",                     no_argument,       NULL, ARG_USER                     },
 778                 { "test",                     no_argument,       NULL, ARG_TEST                     },
 779                 { "help",                     no_argument,       NULL, 'h'                          },
 780                 { "version",                  no_argument,       NULL, ARG_VERSION                  },
 781                 { "dump-configuration-items", no_argument,       NULL, ARG_DUMP_CONFIGURATION_ITEMS },
 782                 { "dump-core",                optional_argument, NULL, ARG_DUMP_CORE                },
 783                 { "crash-shell",              optional_argument, NULL, ARG_CRASH_SHELL              },
 784                 { "confirm-spawn",            optional_argument, NULL, ARG_CONFIRM_SPAWN            },
 785                 { "show-status",              optional_argument, NULL, ARG_SHOW_STATUS              },
 786                 { "deserialize",              required_argument, NULL, ARG_DESERIALIZE              },
 787                 { "switched-root",            no_argument,       NULL, ARG_SWITCHED_ROOT            },
 788                 { "introspect",               optional_argument, NULL, ARG_INTROSPECT               },
 789                 { "default-standard-output",  required_argument, NULL, ARG_DEFAULT_STD_OUTPUT,      },
 790                 { "default-standard-error",   required_argument, NULL, ARG_DEFAULT_STD_ERROR,       },
 791                 { NULL,                       0,                 NULL, 0                            }
 792         };
 793
 794         int c, r;
 795
 796         assert(argc >= 1);
 797         assert(argv);
 798
 799         if (getpid() == 1)
 800                 opterr = 0;
 801
 802         while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
 803
 804                 switch (c) {
 805
 806                 case ARG_LOG_LEVEL:
 807                         if ((r = log_set_max_level_from_string(optarg)) < 0) {
 808                                 log_error("Failed to parse log level %s.", optarg);
 809                                 return r;
 810                         }
 811
 812                         break;
 813
 814                 case ARG_LOG_TARGET:
 815
 816                         if ((r = log_set_target_from_string(optarg)) < 0) {
 817                                 log_error("Failed to parse log target %s.", optarg);
 818                                 return r;
 819                         }
 820
 821                         break;
 822
 823                 case ARG_LOG_COLOR:
 824
 825                         if (optarg) {
 826                                 if ((r = log_show_color_from_string(optarg)) < 0) {
 827                                         log_error("Failed to parse log color setting %s.", optarg);
 828                                         return r;
 829                                 }
 830                         } else
 831                                 log_show_color(true);
 832
 833                         break;
 834
 835                 case ARG_LOG_LOCATION:
 836
 837                         if (optarg) {
 838                                 if ((r = log_show_location_from_string(optarg)) < 0) {
 839                                         log_error("Failed to parse log location setting %s.", optarg);
 840                                         return r;
 841                                 }
 842                         } else
 843                                 log_show_location(true);
 844
 845                         break;
 846
 847                 case ARG_DEFAULT_STD_OUTPUT:
 848
 849                         if ((r = exec_output_from_string(optarg)) < 0) {
 850                                 log_error("Failed to parse default standard output setting %s.", optarg);
 851                                 return r;
 852                         } else
 853                                 arg_default_std_output = r;
 854                         break;
 855
 856                 case ARG_DEFAULT_STD_ERROR:
 857
 858                         if ((r = exec_output_from_string(optarg)) < 0) {
 859                                 log_error("Failed to parse default standard error output setting %s.", optarg);
 860                                 return r;
 861                         } else
 862                                 arg_default_std_error = r;
 863                         break;
 864
 865                 case ARG_UNIT:
 866
 867                         if ((r = set_default_unit(optarg)) < 0) {
 868                                 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
 869                                 return r;
 870                         }
 871
 872                         break;
 873
 874                 case ARG_SYSTEM:
 875                         arg_running_as = MANAGER_SYSTEM;
 876                         break;
 877
 878                 case ARG_USER:
 879                         arg_running_as = MANAGER_USER;
 880                         break;
 881
 882                 case ARG_TEST:
 883                         arg_action = ACTION_TEST;
 884                         break;
 885
 886                 case ARG_VERSION:
 887                         arg_action = ACTION_VERSION;
 888                         break;
 889
 890                 case ARG_DUMP_CONFIGURATION_ITEMS:
 891                         arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
 892                         break;
 893
 894                 case ARG_DUMP_CORE:
 895                         r = optarg ? parse_boolean(optarg) : 1;
 896                         if (r < 0) {
 897                                 log_error("Failed to parse dump core boolean %s.", optarg);
 898                                 return r;
 899                         }
 900                         arg_dump_core = r;
 901                         break;
 902
 903                 case ARG_CRASH_SHELL:
 904                         r = optarg ? parse_boolean(optarg) : 1;
 905                         if (r < 0) {
 906                                 log_error("Failed to parse crash shell boolean %s.", optarg);
 907                                 return r;
 908                         }
 909                         arg_crash_shell = r;
 910                         break;
 911
 912                 case ARG_CONFIRM_SPAWN:
 913                         r = optarg ? parse_boolean(optarg) : 1;
 914                         if (r < 0) {
 915                                 log_error("Failed to parse confirm spawn boolean %s.", optarg);
 916                                 return r;
 917                         }
 918                         arg_confirm_spawn = r;
 919                         break;
 920
 921                 case ARG_SHOW_STATUS:
 922                         r = optarg ? parse_boolean(optarg) : 1;
 923                         if (r < 0) {
 924                                 log_error("Failed to parse show status boolean %s.", optarg);
 925                                 return r;
 926                         }
 927                         arg_show_status = r;
 928                         break;
 929
 930                 case ARG_DESERIALIZE: {
 931                         int fd;
 932                         FILE *f;
 933
 934                         if ((r = safe_atoi(optarg, &fd)) < 0 || fd < 0) {
 935                                 log_error("Failed to parse deserialize option %s.", optarg);
 936                                 return r;
 937                         }
 938
 939                         if (!(f = fdopen(fd, "r"))) {
 940                                 log_error("Failed to open serialization fd: %m");
 941                                 return r;
 942                         }
 943
 944                         if (serialization)
 945                                 fclose(serialization);
 946
 947                         serialization = f;
 948
 949                         break;
 950                 }
 951
 952                 case ARG_SWITCHED_ROOT:
 953                         arg_switched_root = true;
 954                         break;
 955
 956                 case ARG_INTROSPECT: {
 957                         const char * const * i = NULL;
 958
 959                         for (i = bus_interface_table; *i; i += 2)
 960                                 if (!optarg || streq(i[0], optarg)) {
 961                                         fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
 962                                               "<node>\n", stdout);
 963                                         fputs(i[1], stdout);
 964                                         fputs("</node>\n", stdout);
 965
 966                                         if (optarg)
 967                                                 break;
 968                                 }
 969
 970                         if (!i[0] && optarg)
 971                                 log_error("Unknown interface %s.", optarg);
 972
 973                         arg_action = ACTION_DONE;
 974                         break;
 975                 }
 976
 977                 case 'h':
 978                         arg_action = ACTION_HELP;
 979                         break;
 980
 981                 case 'D':
 982                         log_set_max_level(LOG_DEBUG);
 983                         break;
 984
 985                 case 'b':
 986                 case 's':
 987                 case 'z':
 988                         /* Just to eat away the sysvinit kernel
 989                          * cmdline args without getopt() error
 990                          * messages that we'll parse in
 991                          * parse_proc_cmdline_word() or ignore. */
 992
 993                 case '?':
 994                 default:
 995                         if (getpid() != 1) {
 996                                 log_error("Unknown option code %c", c);
 997                                 return -EINVAL;
 998                         }
 999
1000                         break;
1001                 }
1002
1003         if (optind < argc && getpid() != 1) {
1004                 /* Hmm, when we aren't run as init system
1005                  * let's complain about excess arguments */
1006
1007                 log_error("Excess arguments.");
1008                 return -EINVAL;
1009         }
1010
1011         if (detect_container(NULL) > 0) {
1012                 char **a;
1013
1014                 /* All /proc/cmdline arguments the kernel didn't
1015                  * understand it passed to us. We're not really
1016                  * interested in that usually since /proc/cmdline is
1017                  * more interesting and complete. With one exception:
1018                  * if we are run in a container /proc/cmdline is not
1019                  * relevant for the container, hence we rely on argv[]
1020                  * instead. */
1021
1022                 for (a = argv; a < argv + argc; a++)
1023                         if ((r = parse_proc_cmdline_word(*a)) < 0) {
1024                                 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
1025                                 return r;
1026                         }
1027         }
1028
1029         return 0;
1030 }
1031
1032 static int help(void) {
1033
1034         printf("%s [OPTIONS...]\n\n"
1035                "Starts up and maintains the system or user services.\n\n"
1036                "  -h --help                      Show this help\n"
1037                "     --test                      Determine startup sequence, dump it and exit\n"
1038                "     --dump-configuration-items  Dump understood unit configuration items\n"
1039                "     --introspect[=INTERFACE]    Extract D-Bus interface data\n"
1040                "     --unit=UNIT                 Set default unit\n"
1041                "     --system                    Run a system instance, even if PID != 1\n"
1042                "     --user                      Run a user instance\n"
1043                "     --dump-core[=0|1]           Dump core on crash\n"
1044                "     --crash-shell[=0|1]         Run shell on crash\n"
1045                "     --confirm-spawn[=0|1]       Ask for confirmation when spawning processes\n"
1046                "     --show-status[=0|1]         Show status updates on the console during bootup\n"
1047                "     --log-target=TARGET         Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1048                "     --log-level=LEVEL           Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1049                "     --log-color[=0|1]           Highlight important log messages\n"
1050                "     --log-location[=0|1]        Include code location in log messages\n"
1051                "     --default-standard-output=  Set default standard output for services\n"
1052                "     --default-standard-error=   Set default standard error output for services\n",
1053                program_invocation_short_name);
1054
1055         return 0;
1056 }
1057
1058 static int version(void) {
1059         puts(PACKAGE_STRING);
1060         puts(DISTRIBUTION);
1061         puts(SYSTEMD_FEATURES);
1062
1063         return 0;
1064 }
1065
1066 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool serialize_jobs) {
1067         FILE *f = NULL;
1068         FDSet *fds = NULL;
1069         int r;
1070
1071         assert(m);
1072         assert(_f);
1073         assert(_fds);
1074
1075         /* Make sure nothing is really destructed when we shut down */
1076         m->n_reloading ++;
1077
1078         r = manager_open_serialization(m, &f);
1079         if (r < 0) {
1080                 log_error("Failed to create serialization file: %s", strerror(-r));
1081                 goto fail;
1082         }
1083
1084         fds = fdset_new();
1085         if (!fds) {
1086                 r = -ENOMEM;
1087                 log_error("Failed to allocate fd set: %s", strerror(-r));
1088                 goto fail;
1089         }
1090
1091         r = manager_serialize(m, f, fds, serialize_jobs);
1092         if (r < 0) {
1093                 log_error("Failed to serialize state: %s", strerror(-r));
1094                 goto fail;
1095         }
1096
1097         if (fseeko(f, 0, SEEK_SET) < 0) {
1098                 log_error("Failed to rewind serialization fd: %m");
1099                 goto fail;
1100         }
1101
1102         r = fd_cloexec(fileno(f), false);
1103         if (r < 0) {
1104                 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1105                 goto fail;
1106         }
1107
1108         r = fdset_cloexec(fds, false);
1109         if (r < 0) {
1110                 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1111                 goto fail;
1112         }
1113
1114         *_f = f;
1115         *_fds = fds;
1116
1117         return 0;
1118
1119 fail:
1120         fdset_free(fds);
1121
1122         if (f)
1123                 fclose(f);
1124
1125         return r;
1126 }
1127
1128 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1129         const char *e;
1130         unsigned long long a, b;
1131
1132         assert(t);
1133
1134         e = getenv("RD_TIMESTAMP");
1135         if (!e)
1136                 return NULL;
1137
1138         if (sscanf(e, "%llu %llu", &a, &b) != 2)
1139                 return NULL;
1140
1141         t->realtime = (usec_t) a;
1142         t->monotonic = (usec_t) b;
1143
1144         return t;
1145 }
1146
1147 static void test_mtab(void) {
1148         char *p;
1149
1150         /* Check that /etc/mtab is a symlink */
1151
1152         if (readlink_malloc("/etc/mtab", &p) >= 0) {
1153                 bool b;
1154
1155                 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1156                 free(p);
1157
1158                 if (b)
1159                         return;
1160         }
1161
1162         log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1163                     "This is not supported anymore. "
1164                     "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1165 }
1166
1167 static void test_usr(void) {
1168
1169         /* Check that /usr is not a separate fs */
1170
1171         if (dir_is_empty("/usr") <= 0)
1172                 return;
1173
1174         log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1175                     "Some things will probably break (sometimes even silently) in mysterious ways. "
1176                     "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1177 }
1178
1179 static void test_cgroups(void) {
1180
1181         if (access("/proc/cgroups", F_OK) >= 0)
1182                 return;
1183
1184         log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1185                     "Systems without control groups are not supported. "
1186                     "We will now sleep for 10s, and then continue boot-up. "
1187                     "Expect breakage and please do not file bugs. "
1188                     "Instead fix your kernel and enable CONFIG_CGROUPS. "
1189                     "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1190
1191         sleep(10);
1192 }
1193
1194 int main(int argc, char *argv[]) {
1195         Manager *m = NULL;
1196         int r, retval = EXIT_FAILURE;
1197         usec_t before_startup, after_startup;
1198         char timespan[FORMAT_TIMESPAN_MAX];
1199         FDSet *fds = NULL;
1200         bool reexecute = false;
1201         const char *shutdown_verb = NULL;
1202         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1203         static char systemd[] = "systemd";
1204         bool skip_setup = false;
1205         int j;
1206         bool loaded_policy = false;
1207         bool arm_reboot_watchdog = false;
1208         bool queue_default_job = false;
1209         char *switch_root_dir = NULL, *switch_root_init = NULL;
1210
1211 #ifdef HAVE_SYSV_COMPAT
1212         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1213                 /* This is compatibility support for SysV, where
1214                  * calling init as a user is identical to telinit. */
1215
1216                 errno = -ENOENT;
1217                 execv(SYSTEMCTL_BINARY_PATH, argv);
1218                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1219                 return 1;
1220         }
1221 #endif
1222
1223         /* Determine if this is a reexecution or normal bootup. We do
1224          * the full command line parsing much later, so let's just
1225          * have a quick peek here. */
1226         for (j = 1; j < argc; j++)
1227                 if (streq(argv[j], "--deserialize")) {
1228                         skip_setup = true;
1229                         break;
1230                 }
1231
1232         /* If we have switched root, do all the special setup
1233          * things */
1234         for (j = 1; j < argc; j++)
1235                 if (streq(argv[j], "--switched-root")) {
1236                         skip_setup = false;
1237                         break;
1238                 }
1239
1240         /* If we get started via the /sbin/init symlink then we are
1241            called 'init'. After a subsequent reexecution we are then
1242            called 'systemd'. That is confusing, hence let's call us
1243            systemd right-away. */
1244         program_invocation_short_name = systemd;
1245         prctl(PR_SET_NAME, systemd);
1246
1247         saved_argv = argv;
1248         saved_argc = argc;
1249
1250         log_show_color(isatty(STDERR_FILENO) > 0);
1251         log_show_location(false);
1252         log_set_max_level(LOG_INFO);
1253
1254         if (getpid() == 1) {
1255                 if (in_initrd()) {
1256                         char *rd_timestamp = NULL;
1257
1258                         dual_timestamp_get(&initrd_timestamp);
1259                         asprintf(&rd_timestamp, "%llu %llu",
1260                                  (unsigned long long) initrd_timestamp.realtime,
1261                                  (unsigned long long) initrd_timestamp.monotonic);
1262                         if (rd_timestamp) {
1263                                 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1264                                 free(rd_timestamp);
1265                         }
1266                 }
1267
1268                 arg_running_as = MANAGER_SYSTEM;
1269                 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
1270
1271                 if (!skip_setup) {
1272                         if (selinux_setup(&loaded_policy) < 0)
1273                                 goto finish;
1274                         if (ima_setup() < 0)
1275                                 goto finish;
1276                 }
1277
1278                 log_open();
1279
1280                 if (label_init(NULL) < 0)
1281                         goto finish;
1282
1283                 if (!skip_setup)
1284                         if (hwclock_is_localtime() > 0) {
1285                                 int min;
1286
1287                                 r = hwclock_apply_localtime_delta(&min);
1288                                 if (r < 0)
1289                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1290                                 else
1291                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1292                         }
1293
1294         } else {
1295                 arg_running_as = MANAGER_USER;
1296                 log_set_target(LOG_TARGET_AUTO);
1297                 log_open();
1298         }
1299
1300         /* Initialize default unit */
1301         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1302         if (r < 0) {
1303                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1304                 goto finish;
1305         }
1306
1307         /* By default, mount "cpu" and "cpuacct" together */
1308         arg_join_controllers = new(char**, 2);
1309         if (!arg_join_controllers)
1310                 goto finish;
1311
1312         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1313         arg_join_controllers[1] = NULL;
1314
1315         if (!arg_join_controllers[0])
1316                 goto finish;
1317
1318         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1319          * /proc/$PID/fd is available. */
1320         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1321                 r = mount_setup(loaded_policy);
1322                 if (r < 0)
1323                         goto finish;
1324         }
1325
1326         /* Reset all signal handlers. */
1327         assert_se(reset_all_signal_handlers() == 0);
1328
1329         /* If we are init, we can block sigkill. Yay. */
1330         ignore_signals(SIGNALS_IGNORE, -1);
1331
1332         if (parse_config_file() < 0)
1333                 goto finish;
1334
1335         if (arg_running_as == MANAGER_SYSTEM)
1336                 if (parse_proc_cmdline() < 0)
1337                         goto finish;
1338
1339         log_parse_environment();
1340
1341         if (parse_argv(argc, argv) < 0)
1342                 goto finish;
1343
1344         if (arg_action == ACTION_TEST && geteuid() == 0) {
1345                 log_error("Don't run test mode as root.");
1346                 goto finish;
1347         }
1348
1349         if (arg_running_as == MANAGER_SYSTEM &&
1350             arg_action == ACTION_RUN &&
1351             running_in_chroot() > 0) {
1352                 log_error("Cannot be run in a chroot() environment.");
1353                 goto finish;
1354         }
1355
1356         if (arg_action == ACTION_HELP) {
1357                 retval = help();
1358                 goto finish;
1359         } else if (arg_action == ACTION_VERSION) {
1360                 retval = version();
1361                 goto finish;
1362         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1363                 unit_dump_config_items(stdout);
1364                 retval = EXIT_SUCCESS;
1365                 goto finish;
1366         } else if (arg_action == ACTION_DONE) {
1367                 retval = EXIT_SUCCESS;
1368                 goto finish;
1369         }
1370
1371         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1372
1373         /* Close logging fds, in order not to confuse fdset below */
1374         log_close();
1375
1376         /* Remember open file descriptors for later deserialization */
1377         if (serialization) {
1378                 r = fdset_new_fill(&fds);
1379                 if (r < 0) {
1380                         log_error("Failed to allocate fd set: %s", strerror(-r));
1381                         goto finish;
1382                 }
1383
1384                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1385         } else
1386                 close_all_fds(NULL, 0);
1387
1388         /* Set up PATH unless it is already set */
1389         setenv("PATH",
1390 #ifdef HAVE_SPLIT_USR
1391                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1392 #else
1393                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1394 #endif
1395                arg_running_as == MANAGER_SYSTEM);
1396
1397         if (arg_running_as == MANAGER_SYSTEM) {
1398                 /* Parse the data passed to us. We leave this
1399                  * variables set, but the manager later on will not
1400                  * pass them on to our children. */
1401                 if (!in_initrd())
1402                         parse_initrd_timestamp(&initrd_timestamp);
1403
1404                 /* Unset some environment variables passed in from the
1405                  * kernel that don't really make sense for us. */
1406                 unsetenv("HOME");
1407                 unsetenv("TERM");
1408
1409                 /* When we are invoked by a shell, these might be set,
1410                  * but make little sense to pass on */
1411                 unsetenv("PWD");
1412                 unsetenv("SHLVL");
1413                 unsetenv("_");
1414
1415                 /* When we are invoked by a chroot-like tool such as
1416                  * nspawn, these might be set, but make little sense
1417                  * to pass on */
1418                 unsetenv("USER");
1419                 unsetenv("LOGNAME");
1420
1421                 /* All other variables are left as is, so that clients
1422                  * can still read them via /proc/1/environ */
1423         }
1424
1425         /* Move out of the way, so that we won't block unmounts */
1426         assert_se(chdir("/")  == 0);
1427
1428         if (arg_running_as == MANAGER_SYSTEM) {
1429                 /* Become a session leader if we aren't one yet. */
1430                 setsid();
1431
1432                 /* Disable the umask logic */
1433                 umask(0);
1434         }
1435
1436         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1437         dbus_connection_set_change_sigpipe(FALSE);
1438
1439         /* Reset the console, but only if this is really init and we
1440          * are freshly booted */
1441         if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1442                 console_setup(getpid() == 1 && !skip_setup);
1443                 make_null_stdio();
1444         }
1445
1446         /* Open the logging devices, if possible and necessary */
1447         log_open();
1448
1449         /* Make sure we leave a core dump without panicing the
1450          * kernel. */
1451         if (getpid() == 1)
1452                 install_crash_handler();
1453
1454         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1455                 r = mount_cgroup_controllers(arg_join_controllers);
1456                 if (r < 0)
1457                         goto finish;
1458         }
1459
1460         if (arg_running_as == MANAGER_SYSTEM) {
1461                 const char *virtualization = NULL;
1462
1463                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1464
1465                 detect_virtualization(&virtualization);
1466                 if (virtualization)
1467                         log_info("Detected virtualization '%s'.", virtualization);
1468
1469                 if (in_initrd())
1470                         log_info("Running in initial RAM disk.");
1471
1472         } else
1473                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1474
1475         if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1476                 locale_setup();
1477
1478                 if (arg_show_status || plymouth_running())
1479                         status_welcome();
1480
1481                 kmod_setup();
1482                 hostname_setup();
1483                 machine_id_setup();
1484                 loopback_setup();
1485
1486                 test_mtab();
1487                 test_usr();
1488                 test_cgroups();
1489         }
1490
1491         if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1492                 watchdog_set_timeout(&arg_runtime_watchdog);
1493
1494         if (arg_timer_slack_nsec != (nsec_t) -1)
1495                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1496                         log_error("Failed to adjust timer slack: %m");
1497
1498         if (arg_capability_bounding_set_drop) {
1499                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1500                 if (r < 0) {
1501                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1502                         goto finish;
1503                 }
1504                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1505                 if (r < 0) {
1506                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1507                         goto finish;
1508                 }
1509         }
1510
1511         if (arg_running_as == MANAGER_USER) {
1512                 /* Become reaper of our children */
1513                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1514                         log_warning("Failed to make us a subreaper: %m");
1515                         if (errno == EINVAL)
1516                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1517                 }
1518         }
1519
1520         r = manager_new(arg_running_as, &m);
1521         if (r < 0) {
1522                 log_error("Failed to allocate manager object: %s", strerror(-r));
1523                 goto finish;
1524         }
1525
1526         m->confirm_spawn = arg_confirm_spawn;
1527         m->default_std_output = arg_default_std_output;
1528         m->default_std_error = arg_default_std_error;
1529         m->runtime_watchdog = arg_runtime_watchdog;
1530         m->shutdown_watchdog = arg_shutdown_watchdog;
1531
1532         manager_set_default_rlimits(m, arg_default_rlimit);
1533
1534         if (dual_timestamp_is_set(&initrd_timestamp))
1535                 m->initrd_timestamp = initrd_timestamp;
1536
1537         if (arg_default_controllers)
1538                 manager_set_default_controllers(m, arg_default_controllers);
1539
1540         manager_set_show_status(m, arg_show_status);
1541
1542         /* Remember whether we should queue the default job */
1543         queue_default_job = !serialization || arg_switched_root;
1544
1545         before_startup = now(CLOCK_MONOTONIC);
1546
1547         r = manager_startup(m, serialization, fds);
1548         if (r < 0)
1549                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1550
1551         /* This will close all file descriptors that were opened, but
1552          * not claimed by any unit. */
1553         if (fds) {
1554                 fdset_free(fds);
1555                 fds = NULL;
1556         }
1557
1558         if (serialization) {
1559                 fclose(serialization);
1560                 serialization = NULL;
1561         }
1562
1563         if (queue_default_job) {
1564                 DBusError error;
1565                 Unit *target = NULL;
1566                 Job *default_unit_job;
1567
1568                 dbus_error_init(&error);
1569
1570                 log_debug("Activating default unit: %s", arg_default_unit);
1571
1572                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1573                 if (r < 0) {
1574                         log_error("Failed to load default target: %s", bus_error(&error, r));
1575                         dbus_error_free(&error);
1576                 } else if (target->load_state == UNIT_ERROR)
1577                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1578                 else if (target->load_state == UNIT_MASKED)
1579                         log_error("Default target masked.");
1580
1581                 if (!target || target->load_state != UNIT_LOADED) {
1582                         log_info("Trying to load rescue target...");
1583
1584                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1585                         if (r < 0) {
1586                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1587                                 dbus_error_free(&error);
1588                                 goto finish;
1589                         } else if (target->load_state == UNIT_ERROR) {
1590                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1591                                 goto finish;
1592                         } else if (target->load_state == UNIT_MASKED) {
1593                                 log_error("Rescue target masked.");
1594                                 goto finish;
1595                         }
1596                 }
1597
1598                 assert(target->load_state == UNIT_LOADED);
1599
1600                 if (arg_action == ACTION_TEST) {
1601                         printf("-> By units:\n");
1602                         manager_dump_units(m, stdout, "\t");
1603                 }
1604
1605                 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1606                 if (r < 0) {
1607                         log_error("Failed to start default target: %s", bus_error(&error, r));
1608                         dbus_error_free(&error);
1609                         goto finish;
1610                 }
1611                 m->default_unit_job_id = default_unit_job->id;
1612
1613                 after_startup = now(CLOCK_MONOTONIC);
1614                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1615                          "Loaded units and determined initial transaction in %s.",
1616                           format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1617
1618                 if (arg_action == ACTION_TEST) {
1619                         printf("-> By jobs:\n");
1620                         manager_dump_jobs(m, stdout, "\t");
1621                         retval = EXIT_SUCCESS;
1622                         goto finish;
1623                 }
1624         }
1625
1626         for (;;) {
1627                 r = manager_loop(m);
1628                 if (r < 0) {
1629                         log_error("Failed to run mainloop: %s", strerror(-r));
1630                         goto finish;
1631                 }
1632
1633                 switch (m->exit_code) {
1634
1635                 case MANAGER_EXIT:
1636                         retval = EXIT_SUCCESS;
1637                         log_debug("Exit.");
1638                         goto finish;
1639
1640                 case MANAGER_RELOAD:
1641                         log_info("Reloading.");
1642                         r = manager_reload(m);
1643                         if (r < 0)
1644                                 log_error("Failed to reload: %s", strerror(-r));
1645                         break;
1646
1647                 case MANAGER_REEXECUTE:
1648
1649                         if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1650                                 goto finish;
1651
1652                         reexecute = true;
1653                         log_notice("Reexecuting.");
1654                         goto finish;
1655
1656                 case MANAGER_SWITCH_ROOT:
1657                         /* Steal the switch root parameters */
1658                         switch_root_dir = m->switch_root;
1659                         switch_root_init = m->switch_root_init;
1660                         m->switch_root = m->switch_root_init = NULL;
1661
1662                         if (!switch_root_init)
1663                                 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1664                                         goto finish;
1665
1666                         reexecute = true;
1667                         log_notice("Switching root.");
1668                         goto finish;
1669
1670                 case MANAGER_REBOOT:
1671                 case MANAGER_POWEROFF:
1672                 case MANAGER_HALT:
1673                 case MANAGER_KEXEC: {
1674                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1675                                 [MANAGER_REBOOT] = "reboot",
1676                                 [MANAGER_POWEROFF] = "poweroff",
1677                                 [MANAGER_HALT] = "halt",
1678                                 [MANAGER_KEXEC] = "kexec"
1679                         };
1680
1681                         assert_se(shutdown_verb = table[m->exit_code]);
1682                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1683
1684                         log_notice("Shutting down.");
1685                         goto finish;
1686                 }
1687
1688                 default:
1689                         assert_not_reached("Unknown exit code.");
1690                 }
1691         }
1692
1693 finish:
1694         if (m)
1695                 manager_free(m);
1696
1697         for (j = 0; j < RLIMIT_NLIMITS; j++)
1698                 free (arg_default_rlimit[j]);
1699
1700         free(arg_default_unit);
1701         strv_free(arg_default_controllers);
1702         free_join_controllers();
1703
1704         dbus_shutdown();
1705         label_finish();
1706
1707         if (reexecute) {
1708                 const char **args;
1709                 unsigned i, args_size;
1710
1711                 /* Close and disarm the watchdog, so that the new
1712                  * instance can reinitialize it, but doesn't get
1713                  * rebooted while we do that */
1714                 watchdog_close(true);
1715
1716                 if (switch_root_dir) {
1717                         /* Kill all remaining processes from the
1718                          * initrd, but don't wait for them, so that we
1719                          * can handle the SIGCHLD for them after
1720                          * deserializing. */
1721                         broadcast_signal(SIGTERM, false);
1722
1723                         /* And switch root */
1724                         r = switch_root(switch_root_dir);
1725                         if (r < 0)
1726                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1727                 }
1728
1729                 args_size = MAX(6, argc+1);
1730                 args = newa(const char*, args_size);
1731
1732                 if (!switch_root_init) {
1733                         char sfd[16];
1734
1735                         /* First try to spawn ourselves with the right
1736                          * path, and with full serialization. We do
1737                          * this only if the user didn't specify an
1738                          * explicit init to spawn. */
1739
1740                         assert(serialization);
1741                         assert(fds);
1742
1743                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1744                         char_array_0(sfd);
1745
1746                         i = 0;
1747                         args[i++] = SYSTEMD_BINARY_PATH;
1748                         if (switch_root_dir)
1749                                 args[i++] = "--switched-root";
1750                         args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1751                         args[i++] = "--deserialize";
1752                         args[i++] = sfd;
1753                         args[i++] = NULL;
1754
1755                         assert(i <= args_size);
1756                         execv(args[0], (char* const*) args);
1757                 }
1758
1759                 /* Try the fallback, if there is any, without any
1760                  * serialization. We pass the original argv[] and
1761                  * envp[]. (Well, modulo the ordering changes due to
1762                  * getopt() in argv[], and some cleanups in envp[],
1763                  * but let's hope that doesn't matter.) */
1764
1765                 if (serialization) {
1766                         fclose(serialization);
1767                         serialization = NULL;
1768                 }
1769
1770                 if (fds) {
1771                         fdset_free(fds);
1772                         fds = NULL;
1773                 }
1774
1775                 /* Reopen the console */
1776                 make_console_stdio();
1777
1778                 for (j = 1, i = 1; j < argc; j++)
1779                         args[i++] = argv[j];
1780                 args[i++] = NULL;
1781                 assert(i <= args_size);
1782
1783                 if (switch_root_init) {
1784                         args[0] = switch_root_init;
1785                         execv(args[0], (char* const*) args);
1786                         log_warning("Failed to execute configured init, trying fallback: %m");
1787                 }
1788
1789                 args[0] = "/sbin/init";
1790                 execv(args[0], (char* const*) args);
1791
1792                 if (errno == ENOENT) {
1793                         log_warning("No /sbin/init, trying fallback");
1794
1795                         args[0] = "/bin/sh";
1796                         args[1] = NULL;
1797                         execv(args[0], (char* const*) args);
1798                         log_error("Failed to execute /bin/sh, giving up: %m");
1799                 } else
1800                         log_warning("Failed to execute /sbin/init, giving up: %m");
1801         }
1802
1803         if (serialization)
1804                 fclose(serialization);
1805
1806         if (fds)
1807                 fdset_free(fds);
1808
1809         if (shutdown_verb) {
1810                 const char * command_line[] = {
1811                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1812                         shutdown_verb,
1813                         NULL
1814                 };
1815                 char **env_block;
1816
1817                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1818                         char e[32];
1819
1820                         /* If we reboot let's set the shutdown
1821                          * watchdog and tell the shutdown binary to
1822                          * repeatedly ping it */
1823                         watchdog_set_timeout(&arg_shutdown_watchdog);
1824                         watchdog_close(false);
1825
1826                         /* Tell the binary how often to ping */
1827                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1828                         char_array_0(e);
1829
1830                         env_block = strv_append(environ, e);
1831                 } else {
1832                         env_block = strv_copy(environ);
1833                         watchdog_close(true);
1834                 }
1835
1836                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1837                 free(env_block);
1838                 log_error("Failed to execute shutdown binary, freezing: %m");
1839         }
1840
1841         if (getpid() == 1)
1842                 freeze();
1843
1844         return retval;
1845 }