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