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