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