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