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