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;
1172
1173         if (path_equal(switch_root, "/"))
1174                 return 0;
1175
1176         if (chdir(switch_root) < 0) {
1177                 r = -errno;
1178                 goto fail;
1179         }
1180
1181         if (mount(switch_root, "/", NULL, MS_MOVE, NULL) < 0) {
1182                 r = -errno;
1183                 chdir("/");
1184                 goto fail;
1185         }
1186
1187         if (chroot(".") < 0)
1188                 log_warning("Failed to change root, ignoring: %s", strerror(-r));
1189
1190         /* FIXME: remove old root */
1191
1192         return 0;
1193
1194 fail:
1195         log_error("Failed to switch root, ignoring: %s", strerror(-r));
1196
1197         return r;
1198 }
1199
1200 int main(int argc, char *argv[]) {
1201         Manager *m = NULL;
1202         int r, retval = EXIT_FAILURE;
1203         usec_t before_startup, after_startup;
1204         char timespan[FORMAT_TIMESPAN_MAX];
1205         FDSet *fds = NULL;
1206         bool reexecute = false;
1207         const char *shutdown_verb = NULL;
1208         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1209         static char systemd[] = "systemd";
1210         bool is_reexec = false;
1211         int j;
1212         bool loaded_policy = false;
1213         bool arm_reboot_watchdog = false;
1214         char *switch_root = NULL, *switch_root_init = NULL;
1215
1216 #ifdef HAVE_SYSV_COMPAT
1217         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1218                 /* This is compatibility support for SysV, where
1219                  * calling init as a user is identical to telinit. */
1220
1221                 errno = -ENOENT;
1222                 execv(SYSTEMCTL_BINARY_PATH, argv);
1223                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1224                 return 1;
1225         }
1226 #endif
1227
1228         /* Determine if this is a reexecution or normal bootup. We do
1229          * the full command line parsing much later, so let's just
1230          * have a quick peek here. */
1231
1232         for (j = 1; j < argc; j++)
1233                 if (streq(argv[j], "--deserialize")) {
1234                         is_reexec = true;
1235                         break;
1236                 }
1237
1238         /* If we get started via the /sbin/init symlink then we are
1239            called 'init'. After a subsequent reexecution we are then
1240            called 'systemd'. That is confusing, hence let's call us
1241            systemd right-away. */
1242         program_invocation_short_name = systemd;
1243         prctl(PR_SET_NAME, systemd);
1244
1245         saved_argv = argv;
1246         saved_argc = argc;
1247
1248         log_show_color(isatty(STDERR_FILENO) > 0);
1249         log_show_location(false);
1250         log_set_max_level(LOG_INFO);
1251
1252         if (getpid() == 1) {
1253                 arg_running_as = MANAGER_SYSTEM;
1254                 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
1255
1256                 if (!is_reexec) {
1257                         if (selinux_setup(&loaded_policy) < 0)
1258                                 goto finish;
1259                         if (ima_setup() < 0)
1260                                 goto finish;
1261                 }
1262
1263                 log_open();
1264
1265                 if (label_init(NULL) < 0)
1266                         goto finish;
1267
1268                 if (!is_reexec)
1269                         if (hwclock_is_localtime() > 0) {
1270                                 int min;
1271
1272                                 r = hwclock_apply_localtime_delta(&min);
1273                                 if (r < 0)
1274                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1275                                 else
1276                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1277                         }
1278
1279         } else {
1280                 arg_running_as = MANAGER_USER;
1281                 log_set_target(LOG_TARGET_AUTO);
1282                 log_open();
1283         }
1284
1285         /* Initialize default unit */
1286         if (set_default_unit(SPECIAL_DEFAULT_TARGET) < 0)
1287                 goto finish;
1288
1289         /* By default, mount "cpu" and "cpuacct" together */
1290         arg_join_controllers = new(char**, 2);
1291         if (!arg_join_controllers)
1292                 goto finish;
1293
1294         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1295         arg_join_controllers[1] = NULL;
1296
1297         if (!arg_join_controllers[0])
1298                 goto finish;
1299
1300         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1301          * /proc/$PID/fd is available. */
1302         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1303                 r = mount_setup(loaded_policy);
1304                 if (r < 0)
1305                         goto finish;
1306         }
1307
1308         /* Reset all signal handlers. */
1309         assert_se(reset_all_signal_handlers() == 0);
1310
1311         /* If we are init, we can block sigkill. Yay. */
1312         ignore_signals(SIGNALS_IGNORE, -1);
1313
1314         if (parse_config_file() < 0)
1315                 goto finish;
1316
1317         if (arg_running_as == MANAGER_SYSTEM)
1318                 if (parse_proc_cmdline() < 0)
1319                         goto finish;
1320
1321         log_parse_environment();
1322
1323         if (parse_argv(argc, argv) < 0)
1324                 goto finish;
1325
1326         if (arg_action == ACTION_TEST && geteuid() == 0) {
1327                 log_error("Don't run test mode as root.");
1328                 goto finish;
1329         }
1330
1331         if (arg_running_as == MANAGER_SYSTEM &&
1332             arg_action == ACTION_RUN &&
1333             running_in_chroot() > 0) {
1334                 log_error("Cannot be run in a chroot() environment.");
1335                 goto finish;
1336         }
1337
1338         if (arg_action == ACTION_HELP) {
1339                 retval = help();
1340                 goto finish;
1341         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1342                 unit_dump_config_items(stdout);
1343                 retval = EXIT_SUCCESS;
1344                 goto finish;
1345         } else if (arg_action == ACTION_DONE) {
1346                 retval = EXIT_SUCCESS;
1347                 goto finish;
1348         }
1349
1350         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1351
1352         /* Close logging fds, in order not to confuse fdset below */
1353         log_close();
1354
1355         /* Remember open file descriptors for later deserialization */
1356         if (serialization) {
1357                 r = fdset_new_fill(&fds);
1358                 if (r < 0) {
1359                         log_error("Failed to allocate fd set: %s", strerror(-r));
1360                         goto finish;
1361                 }
1362
1363                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1364         } else
1365                 close_all_fds(NULL, 0);
1366
1367         /* Set up PATH unless it is already set */
1368         setenv("PATH",
1369 #ifdef HAVE_SPLIT_USR
1370                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1371 #else
1372                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1373 #endif
1374                arg_running_as == MANAGER_SYSTEM);
1375
1376         if (arg_running_as == MANAGER_SYSTEM) {
1377                 /* Parse the data passed to us. We leave this
1378                  * variables set, but the manager later on will not
1379                  * pass them on to our children. */
1380                 parse_initrd_timestamp(&initrd_timestamp);
1381
1382                 /* Unset some environment variables passed in from the
1383                  * kernel that don't really make sense for us. */
1384                 unsetenv("HOME");
1385                 unsetenv("TERM");
1386
1387                 /* When we are invoked by a shell, these might be set,
1388                  * but make little sense to pass on */
1389                 unsetenv("PWD");
1390                 unsetenv("SHLVL");
1391                 unsetenv("_");
1392
1393                 /* When we are invoked by a tool chroot-like such as
1394                  * nspawn, these might be set, but make little sense
1395                  * to pass on */
1396                 unsetenv("USER");
1397                 unsetenv("LOGNAME");
1398
1399                 /* All other variables are left as is, so that clients
1400                  * can still read them via /proc/1/environ */
1401         }
1402
1403         /* Move out of the way, so that we won't block unmounts */
1404         assert_se(chdir("/")  == 0);
1405
1406         if (arg_running_as == MANAGER_SYSTEM) {
1407                 /* Become a session leader if we aren't one yet. */
1408                 setsid();
1409
1410                 /* Disable the umask logic */
1411                 umask(0);
1412         }
1413
1414         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1415         dbus_connection_set_change_sigpipe(FALSE);
1416
1417         /* Reset the console, but only if this is really init and we
1418          * are freshly booted */
1419         if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN) {
1420                 console_setup(getpid() == 1 && !is_reexec);
1421                 make_null_stdio();
1422         }
1423
1424         /* Open the logging devices, if possible and necessary */
1425         log_open();
1426
1427         /* Make sure we leave a core dump without panicing the
1428          * kernel. */
1429         if (getpid() == 1)
1430                 install_crash_handler();
1431
1432         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1433                 r = mount_cgroup_controllers(arg_join_controllers);
1434                 if (r < 0)
1435                         goto finish;
1436         }
1437
1438         log_full(arg_running_as == MANAGER_SYSTEM ? LOG_INFO : LOG_DEBUG,
1439                  PACKAGE_STRING " running in %s mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")", manager_running_as_to_string(arg_running_as));
1440
1441         if (arg_running_as == MANAGER_SYSTEM && !is_reexec) {
1442                 locale_setup();
1443
1444                 if (arg_show_status || plymouth_running())
1445                         status_welcome();
1446
1447                 kmod_setup();
1448                 hostname_setup();
1449                 machine_id_setup();
1450                 loopback_setup();
1451
1452                 test_mtab();
1453                 test_usr();
1454                 test_cgroups();
1455         }
1456
1457         if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1458                 watchdog_set_timeout(&arg_runtime_watchdog);
1459
1460         r = manager_new(arg_running_as, &m);
1461         if (r < 0) {
1462                 log_error("Failed to allocate manager object: %s", strerror(-r));
1463                 goto finish;
1464         }
1465
1466         m->confirm_spawn = arg_confirm_spawn;
1467 #ifdef HAVE_SYSV_COMPAT
1468         m->sysv_console = arg_sysv_console;
1469 #endif
1470         m->default_std_output = arg_default_std_output;
1471         m->default_std_error = arg_default_std_error;
1472         m->runtime_watchdog = arg_runtime_watchdog;
1473         m->shutdown_watchdog = arg_shutdown_watchdog;
1474
1475         if (dual_timestamp_is_set(&initrd_timestamp))
1476                 m->initrd_timestamp = initrd_timestamp;
1477
1478         if (arg_default_controllers)
1479                 manager_set_default_controllers(m, arg_default_controllers);
1480
1481         manager_set_show_status(m, arg_show_status);
1482
1483         before_startup = now(CLOCK_MONOTONIC);
1484
1485         r = manager_startup(m, serialization, fds);
1486         if (r < 0)
1487                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1488
1489         if (fds) {
1490                 /* This will close all file descriptors that were opened, but
1491                  * not claimed by any unit. */
1492
1493                 fdset_free(fds);
1494                 fds = NULL;
1495         }
1496
1497         if (serialization) {
1498                 fclose(serialization);
1499                 serialization = NULL;
1500         } else {
1501                 DBusError error;
1502                 Unit *target = NULL;
1503                 Job *default_unit_job;
1504
1505                 dbus_error_init(&error);
1506
1507                 log_debug("Activating default unit: %s", arg_default_unit);
1508
1509                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1510                 if (r < 0) {
1511                         log_error("Failed to load default target: %s", bus_error(&error, r));
1512                         dbus_error_free(&error);
1513                 } else if (target->load_state == UNIT_ERROR)
1514                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1515                 else if (target->load_state == UNIT_MASKED)
1516                         log_error("Default target masked.");
1517
1518                 if (!target || target->load_state != UNIT_LOADED) {
1519                         log_info("Trying to load rescue target...");
1520
1521                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1522                         if (r < 0) {
1523                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1524                                 dbus_error_free(&error);
1525                                 goto finish;
1526                         } else if (target->load_state == UNIT_ERROR) {
1527                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1528                                 goto finish;
1529                         } else if (target->load_state == UNIT_MASKED) {
1530                                 log_error("Rescue target masked.");
1531                                 goto finish;
1532                         }
1533                 }
1534
1535                 assert(target->load_state == UNIT_LOADED);
1536
1537                 if (arg_action == ACTION_TEST) {
1538                         printf("-> By units:\n");
1539                         manager_dump_units(m, stdout, "\t");
1540                 }
1541
1542                 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1543                 if (r < 0) {
1544                         log_error("Failed to start default target: %s", bus_error(&error, r));
1545                         dbus_error_free(&error);
1546                         goto finish;
1547                 }
1548                 m->default_unit_job_id = default_unit_job->id;
1549
1550                 after_startup = now(CLOCK_MONOTONIC);
1551                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1552                          "Loaded units and determined initial transaction in %s.",
1553                           format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1554
1555                 if (arg_action == ACTION_TEST) {
1556                         printf("-> By jobs:\n");
1557                         manager_dump_jobs(m, stdout, "\t");
1558                         retval = EXIT_SUCCESS;
1559                         goto finish;
1560                 }
1561         }
1562
1563         for (;;) {
1564                 r = manager_loop(m);
1565                 if (r < 0) {
1566                         log_error("Failed to run mainloop: %s", strerror(-r));
1567                         goto finish;
1568                 }
1569
1570                 switch (m->exit_code) {
1571
1572                 case MANAGER_EXIT:
1573                         retval = EXIT_SUCCESS;
1574                         log_debug("Exit.");
1575                         goto finish;
1576
1577                 case MANAGER_RELOAD:
1578                         log_info("Reloading.");
1579                         r = manager_reload(m);
1580                         if (r < 0)
1581                                 log_error("Failed to reload: %s", strerror(-r));
1582                         break;
1583
1584                 case MANAGER_REEXECUTE:
1585
1586                         if (prepare_reexecute(m, &serialization, &fds) < 0)
1587                                 goto finish;
1588
1589                         reexecute = true;
1590                         log_notice("Reexecuting.");
1591                         goto finish;
1592
1593                 case MANAGER_SWITCH_ROOT:
1594                         /* Steal the switch root parameters */
1595                         switch_root = m->switch_root;
1596                         switch_root_init = m->switch_root_init;
1597                         m->switch_root = m->switch_root_init = NULL;
1598
1599                         if (!switch_root_init)
1600                                 if (prepare_reexecute(m, &serialization, &fds) < 0)
1601                                         goto finish;
1602
1603                         reexecute = true;
1604                         log_notice("Switching root.");
1605                         goto finish;
1606
1607                 case MANAGER_REBOOT:
1608                 case MANAGER_POWEROFF:
1609                 case MANAGER_HALT:
1610                 case MANAGER_KEXEC: {
1611                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1612                                 [MANAGER_REBOOT] = "reboot",
1613                                 [MANAGER_POWEROFF] = "poweroff",
1614                                 [MANAGER_HALT] = "halt",
1615                                 [MANAGER_KEXEC] = "kexec"
1616                         };
1617
1618                         assert_se(shutdown_verb = table[m->exit_code]);
1619                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1620
1621                         log_notice("Shutting down.");
1622                         goto finish;
1623                 }
1624
1625                 default:
1626                         assert_not_reached("Unknown exit code.");
1627                 }
1628         }
1629
1630 finish:
1631         if (m)
1632                 manager_free(m);
1633
1634         free(arg_default_unit);
1635         strv_free(arg_default_controllers);
1636         free_join_controllers();
1637
1638         dbus_shutdown();
1639         label_finish();
1640
1641         if (reexecute) {
1642                 const char **args;
1643                 unsigned i, args_size;
1644
1645                 /* Close and disarm the watchdog, so that the new
1646                  * instance can reinitialize it, but doesn't get
1647                  * rebooted while we do that */
1648                 watchdog_close(true);
1649
1650                 if (switch_root)
1651                         do_switch_root(switch_root);
1652
1653                 args_size = MAX(5, argc+1);
1654                 args = newa(const char*, args_size);
1655
1656                 if (!switch_root_init) {
1657                         char sfd[16];
1658
1659                         /* First try to spawn ourselves with the right
1660                          * path, and with full serialization. We do
1661                          * this only if the user didn't specify an
1662                          * explicit init to spawn. */
1663
1664                         assert(serialization);
1665                         assert(fds);
1666
1667                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1668                         char_array_0(sfd);
1669
1670                         i = 0;
1671                         args[i++] = SYSTEMD_BINARY_PATH;
1672                         args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1673                         args[i++] = "--deserialize";
1674                         args[i++] = sfd;
1675                         args[i++] = NULL;
1676
1677                         assert(i <= args_size);
1678                         execv(args[0], (char* const*) args);
1679                 }
1680
1681                 /* Try the fallback, if there is any, without any
1682                  * serialization. We pass the original argv[] and
1683                  * envp[]. (Well, modulo the ordering changes due to
1684                  * getopt() in argv[], and some cleanups in envp[],
1685                  * but let's hope that doesn't matter.) */
1686
1687                 if (serialization)
1688                         fclose(serialization);
1689
1690                 if (fds)
1691                         fdset_free(fds);
1692
1693                 i = 0;
1694                 args[i++] = switch_root_init ? switch_root_init : "/sbin/init";
1695                 for (j = 1; j < argc; j++)
1696                         args[i++] = argv[j];
1697                 args[i++] = NULL;
1698
1699                 assert(i <= args_size);
1700                 execv(args[0], (char* const*) args);
1701
1702                 log_error("Failed to reexecute: %m");
1703         }
1704
1705         if (serialization)
1706                 fclose(serialization);
1707
1708         if (fds)
1709                 fdset_free(fds);
1710
1711         if (shutdown_verb) {
1712                 const char * command_line[] = {
1713                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1714                         shutdown_verb,
1715                         NULL
1716                 };
1717                 char **env_block;
1718
1719                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1720                         char e[32];
1721
1722                         /* If we reboot let's set the shutdown
1723                          * watchdog and tell the shutdown binary to
1724                          * repeatedly ping it */
1725                         watchdog_set_timeout(&arg_shutdown_watchdog);
1726                         watchdog_close(false);
1727
1728                         /* Tell the binary how often to ping */
1729                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1730                         char_array_0(e);
1731
1732                         env_block = strv_append(environ, e);
1733                 } else {
1734                         env_block = strv_copy(environ);
1735                         watchdog_close(true);
1736                 }
1737
1738                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1739                 free(env_block);
1740                 log_error("Failed to execute shutdown binary, freezing: %m");
1741         }
1742
1743         if (getpid() == 1)
1744                 freeze();
1745
1746         return retval;
1747 }