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