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