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