src/core/main.c

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