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