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 {
1354                                 /* Do dummy first-time call to seal the kernel's time warp magic */
1355                                 hwclock_reset_timezone();
1356
1357                                 /* Tell the kernel our time zone */
1358                                 r = hwclock_set_timezone(NULL);
1359                                 if (r < 0)
1360                                         log_error("Failed to set the kernel's time zone, ignoring: %s", strerror(-r));
1361                         }
1362                 }
1363
1364                 /* Set the default for later on, but don't actually
1365                  * open the logs like this for now. Note that if we
1366                  * are transitioning from the initrd there might still
1367                  * be journal fd open, and we shouldn't attempt
1368                  * opening that before we parsed /proc/cmdline which
1369                  * might redirect output elsewhere. */
1370                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1371
1372         } else if (getpid() == 1) {
1373
1374                 /* Running inside a container, as PID 1 */
1375                 arg_running_as = SYSTEMD_SYSTEM;
1376                 log_set_target(LOG_TARGET_CONSOLE);
1377                 log_open();
1378
1379                 /* For the later on, see above... */
1380                 log_set_target(LOG_TARGET_JOURNAL);
1381
1382         } else {
1383
1384                 /* Running as user instance */
1385                 arg_running_as = SYSTEMD_USER;
1386                 log_set_target(LOG_TARGET_AUTO);
1387                 log_open();
1388         }
1389
1390         /* Initialize default unit */
1391         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1392         if (r < 0) {
1393                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1394                 goto finish;
1395         }
1396
1397         r = initialize_join_controllers();
1398         if (r < 0)
1399                 goto finish;
1400
1401         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1402          * /proc/$PID/fd is available. */
1403         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1404                 r = mount_setup(loaded_policy);
1405                 if (r < 0)
1406                         goto finish;
1407         }
1408
1409         /* Reset all signal handlers. */
1410         assert_se(reset_all_signal_handlers() == 0);
1411
1412         /* If we are init, we can block sigkill. Yay. */
1413         ignore_signals(SIGNALS_IGNORE, -1);
1414
1415         if (parse_config_file() < 0)
1416                 goto finish;
1417
1418         if (arg_running_as == SYSTEMD_SYSTEM)
1419                 if (parse_proc_cmdline() < 0)
1420                         goto finish;
1421
1422         log_parse_environment();
1423
1424         if (parse_argv(argc, argv) < 0)
1425                 goto finish;
1426
1427         if (arg_action == ACTION_TEST &&
1428             geteuid() == 0) {
1429                 log_error("Don't run test mode as root.");
1430                 goto finish;
1431         }
1432
1433         if (arg_running_as == SYSTEMD_USER &&
1434             arg_action == ACTION_RUN &&
1435             sd_booted() <= 0) {
1436                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1437                 goto finish;
1438         }
1439
1440         if (arg_running_as == SYSTEMD_SYSTEM &&
1441             arg_action == ACTION_RUN &&
1442             running_in_chroot() > 0) {
1443                 log_error("Cannot be run in a chroot() environment.");
1444                 goto finish;
1445         }
1446
1447         if (arg_action == ACTION_HELP) {
1448                 retval = help();
1449                 goto finish;
1450         } else if (arg_action == ACTION_VERSION) {
1451                 retval = version();
1452                 goto finish;
1453         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1454                 unit_dump_config_items(stdout);
1455                 retval = EXIT_SUCCESS;
1456                 goto finish;
1457         } else if (arg_action == ACTION_DONE) {
1458                 retval = EXIT_SUCCESS;
1459                 goto finish;
1460         }
1461
1462         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1463
1464         /* Close logging fds, in order not to confuse fdset below */
1465         log_close();
1466
1467         /* Remember open file descriptors for later deserialization */
1468         if (serialization) {
1469                 r = fdset_new_fill(&fds);
1470                 if (r < 0) {
1471                         log_error("Failed to allocate fd set: %s", strerror(-r));
1472                         goto finish;
1473                 }
1474
1475                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1476         } else
1477                 close_all_fds(NULL, 0);
1478
1479         /* Set up PATH unless it is already set */
1480         setenv("PATH",
1481 #ifdef HAVE_SPLIT_USR
1482                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1483 #else
1484                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1485 #endif
1486                arg_running_as == SYSTEMD_SYSTEM);
1487
1488         if (arg_running_as == SYSTEMD_SYSTEM) {
1489                 /* Parse the data passed to us. We leave this
1490                  * variables set, but the manager later on will not
1491                  * pass them on to our children. */
1492                 if (!in_initrd())
1493                         parse_initrd_timestamp(&initrd_timestamp);
1494
1495                 /* Unset some environment variables passed in from the
1496                  * kernel that don't really make sense for us. */
1497                 unsetenv("HOME");
1498                 unsetenv("TERM");
1499
1500                 /* When we are invoked by a shell, these might be set,
1501                  * but make little sense to pass on */
1502                 unsetenv("PWD");
1503                 unsetenv("SHLVL");
1504                 unsetenv("_");
1505
1506                 /* When we are invoked by a chroot-like tool such as
1507                  * nspawn, these might be set, but make little sense
1508                  * to pass on */
1509                 unsetenv("USER");
1510                 unsetenv("LOGNAME");
1511
1512                 /* All other variables are left as is, so that clients
1513                  * can still read them via /proc/1/environ */
1514         }
1515
1516         /* Move out of the way, so that we won't block unmounts */
1517         assert_se(chdir("/")  == 0);
1518
1519         if (arg_running_as == SYSTEMD_SYSTEM) {
1520                 /* Become a session leader if we aren't one yet. */
1521                 setsid();
1522
1523                 /* Disable the umask logic */
1524                 umask(0);
1525         }
1526
1527         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1528         dbus_connection_set_change_sigpipe(FALSE);
1529
1530         /* Reset the console, but only if this is really init and we
1531          * are freshly booted */
1532         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1533                 console_setup(getpid() == 1 && !skip_setup);
1534
1535         /* Open the logging devices, if possible and necessary */
1536         log_open();
1537
1538         /* Make sure we leave a core dump without panicing the
1539          * kernel. */
1540         if (getpid() == 1)
1541                 install_crash_handler();
1542
1543         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1544                 r = mount_cgroup_controllers(arg_join_controllers);
1545                 if (r < 0)
1546                         goto finish;
1547         }
1548
1549         if (arg_running_as == SYSTEMD_SYSTEM) {
1550                 const char *virtualization = NULL;
1551
1552                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1553
1554                 detect_virtualization(&virtualization);
1555                 if (virtualization)
1556                         log_info("Detected virtualization '%s'.", virtualization);
1557
1558                 if (in_initrd())
1559                         log_info("Running in initial RAM disk.");
1560
1561         } else
1562                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1563
1564         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1565                 locale_setup();
1566
1567                 if (arg_show_status || plymouth_running())
1568                         status_welcome();
1569
1570                 kmod_setup();
1571                 hostname_setup();
1572                 machine_id_setup();
1573                 loopback_setup();
1574
1575                 test_mtab();
1576                 test_usr();
1577                 test_cgroups();
1578         }
1579
1580         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1581                 watchdog_set_timeout(&arg_runtime_watchdog);
1582
1583         if (arg_timer_slack_nsec != (nsec_t) -1)
1584                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1585                         log_error("Failed to adjust timer slack: %m");
1586
1587         if (arg_capability_bounding_set_drop) {
1588                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1589                 if (r < 0) {
1590                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1591                         goto finish;
1592                 }
1593                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1594                 if (r < 0) {
1595                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1596                         goto finish;
1597                 }
1598         }
1599
1600         if (arg_running_as == SYSTEMD_USER) {
1601                 /* Become reaper of our children */
1602                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1603                         log_warning("Failed to make us a subreaper: %m");
1604                         if (errno == EINVAL)
1605                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1606                 }
1607         }
1608
1609         if (arg_running_as == SYSTEMD_SYSTEM)
1610                 bump_rlimit_nofile(&saved_rlimit_nofile);
1611
1612         r = manager_new(arg_running_as, &m);
1613         if (r < 0) {
1614                 log_error("Failed to allocate manager object: %s", strerror(-r));
1615                 goto finish;
1616         }
1617
1618         m->confirm_spawn = arg_confirm_spawn;
1619         m->default_std_output = arg_default_std_output;
1620         m->default_std_error = arg_default_std_error;
1621         m->runtime_watchdog = arg_runtime_watchdog;
1622         m->shutdown_watchdog = arg_shutdown_watchdog;
1623
1624         manager_set_default_rlimits(m, arg_default_rlimit);
1625
1626         if (dual_timestamp_is_set(&initrd_timestamp))
1627                 m->initrd_timestamp = initrd_timestamp;
1628
1629         if (arg_default_controllers)
1630                 manager_set_default_controllers(m, arg_default_controllers);
1631
1632         manager_set_show_status(m, arg_show_status);
1633
1634         /* Remember whether we should queue the default job */
1635         queue_default_job = !serialization || arg_switched_root;
1636
1637         before_startup = now(CLOCK_MONOTONIC);
1638
1639         r = manager_startup(m, serialization, fds);
1640         if (r < 0)
1641                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1642
1643         /* This will close all file descriptors that were opened, but
1644          * not claimed by any unit. */
1645         if (fds) {
1646                 fdset_free(fds);
1647                 fds = NULL;
1648         }
1649
1650         if (serialization) {
1651                 fclose(serialization);
1652                 serialization = NULL;
1653         }
1654
1655         if (queue_default_job) {
1656                 DBusError error;
1657                 Unit *target = NULL;
1658                 Job *default_unit_job;
1659
1660                 dbus_error_init(&error);
1661
1662                 log_debug("Activating default unit: %s", arg_default_unit);
1663
1664                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1665                 if (r < 0) {
1666                         log_error("Failed to load default target: %s", bus_error(&error, r));
1667                         dbus_error_free(&error);
1668                 } else if (target->load_state == UNIT_ERROR)
1669                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1670                 else if (target->load_state == UNIT_MASKED)
1671                         log_error("Default target masked.");
1672
1673                 if (!target || target->load_state != UNIT_LOADED) {
1674                         log_info("Trying to load rescue target...");
1675
1676                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1677                         if (r < 0) {
1678                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1679                                 dbus_error_free(&error);
1680                                 goto finish;
1681                         } else if (target->load_state == UNIT_ERROR) {
1682                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1683                                 goto finish;
1684                         } else if (target->load_state == UNIT_MASKED) {
1685                                 log_error("Rescue target masked.");
1686                                 goto finish;
1687                         }
1688                 }
1689
1690                 assert(target->load_state == UNIT_LOADED);
1691
1692                 if (arg_action == ACTION_TEST) {
1693                         printf("-> By units:\n");
1694                         manager_dump_units(m, stdout, "\t");
1695                 }
1696
1697                 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1698                 if (r < 0) {
1699                         log_error("Failed to start default target: %s", bus_error(&error, r));
1700                         dbus_error_free(&error);
1701                         goto finish;
1702                 }
1703                 m->default_unit_job_id = default_unit_job->id;
1704
1705                 after_startup = now(CLOCK_MONOTONIC);
1706                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1707                          "Loaded units and determined initial transaction in %s.",
1708                           format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1709
1710                 if (arg_action == ACTION_TEST) {
1711                         printf("-> By jobs:\n");
1712                         manager_dump_jobs(m, stdout, "\t");
1713                         retval = EXIT_SUCCESS;
1714                         goto finish;
1715                 }
1716         }
1717
1718         for (;;) {
1719                 r = manager_loop(m);
1720                 if (r < 0) {
1721                         log_error("Failed to run mainloop: %s", strerror(-r));
1722                         goto finish;
1723                 }
1724
1725                 switch (m->exit_code) {
1726
1727                 case MANAGER_EXIT:
1728                         retval = EXIT_SUCCESS;
1729                         log_debug("Exit.");
1730                         goto finish;
1731
1732                 case MANAGER_RELOAD:
1733                         log_info("Reloading.");
1734                         r = manager_reload(m);
1735                         if (r < 0)
1736                                 log_error("Failed to reload: %s", strerror(-r));
1737                         break;
1738
1739                 case MANAGER_REEXECUTE:
1740
1741                         if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1742                                 goto finish;
1743
1744                         reexecute = true;
1745                         log_notice("Reexecuting.");
1746                         goto finish;
1747
1748                 case MANAGER_SWITCH_ROOT:
1749                         /* Steal the switch root parameters */
1750                         switch_root_dir = m->switch_root;
1751                         switch_root_init = m->switch_root_init;
1752                         m->switch_root = m->switch_root_init = NULL;
1753
1754                         if (!switch_root_init)
1755                                 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1756                                         goto finish;
1757
1758                         reexecute = true;
1759                         log_notice("Switching root.");
1760                         goto finish;
1761
1762                 case MANAGER_REBOOT:
1763                 case MANAGER_POWEROFF:
1764                 case MANAGER_HALT:
1765                 case MANAGER_KEXEC: {
1766                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1767                                 [MANAGER_REBOOT] = "reboot",
1768                                 [MANAGER_POWEROFF] = "poweroff",
1769                                 [MANAGER_HALT] = "halt",
1770                                 [MANAGER_KEXEC] = "kexec"
1771                         };
1772
1773                         assert_se(shutdown_verb = table[m->exit_code]);
1774                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1775
1776                         log_notice("Shutting down.");
1777                         goto finish;
1778                 }
1779
1780                 default:
1781                         assert_not_reached("Unknown exit code.");
1782                 }
1783         }
1784
1785 finish:
1786         if (m)
1787                 manager_free(m);
1788
1789         for (j = 0; j < RLIMIT_NLIMITS; j++)
1790                 free(arg_default_rlimit[j]);
1791
1792         free(arg_default_unit);
1793         strv_free(arg_default_controllers);
1794         free_join_controllers();
1795
1796         dbus_shutdown();
1797         label_finish();
1798
1799         if (reexecute) {
1800                 const char **args;
1801                 unsigned i, args_size;
1802
1803                 /* Close and disarm the watchdog, so that the new
1804                  * instance can reinitialize it, but doesn't get
1805                  * rebooted while we do that */
1806                 watchdog_close(true);
1807
1808                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1809                  * that the new systemd can pass the kernel default to
1810                  * its child processes */
1811                 if (saved_rlimit_nofile.rlim_cur > 0)
1812                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1813
1814                 if (switch_root_dir) {
1815                         /* Kill all remaining processes from the
1816                          * initrd, but don't wait for them, so that we
1817                          * can handle the SIGCHLD for them after
1818                          * deserializing. */
1819                         broadcast_signal(SIGTERM, false);
1820
1821                         /* And switch root */
1822                         r = switch_root(switch_root_dir);
1823                         if (r < 0)
1824                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1825                 }
1826
1827                 args_size = MAX(6, argc+1);
1828                 args = newa(const char*, args_size);
1829
1830                 if (!switch_root_init) {
1831                         char sfd[16];
1832
1833                         /* First try to spawn ourselves with the right
1834                          * path, and with full serialization. We do
1835                          * this only if the user didn't specify an
1836                          * explicit init to spawn. */
1837
1838                         assert(serialization);
1839                         assert(fds);
1840
1841                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1842                         char_array_0(sfd);
1843
1844                         i = 0;
1845                         args[i++] = SYSTEMD_BINARY_PATH;
1846                         if (switch_root_dir)
1847                                 args[i++] = "--switched-root";
1848                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1849                         args[i++] = "--deserialize";
1850                         args[i++] = sfd;
1851                         args[i++] = NULL;
1852
1853                         assert(i <= args_size);
1854                         execv(args[0], (char* const*) args);
1855                 }
1856
1857                 /* Try the fallback, if there is any, without any
1858                  * serialization. We pass the original argv[] and
1859                  * envp[]. (Well, modulo the ordering changes due to
1860                  * getopt() in argv[], and some cleanups in envp[],
1861                  * but let's hope that doesn't matter.) */
1862
1863                 if (serialization) {
1864                         fclose(serialization);
1865                         serialization = NULL;
1866                 }
1867
1868                 if (fds) {
1869                         fdset_free(fds);
1870                         fds = NULL;
1871                 }
1872
1873                 /* Reopen the console */
1874                 make_console_stdio();
1875
1876                 for (j = 1, i = 1; j < argc; j++)
1877                         args[i++] = argv[j];
1878                 args[i++] = NULL;
1879                 assert(i <= args_size);
1880
1881                 if (switch_root_init) {
1882                         args[0] = switch_root_init;
1883                         execv(args[0], (char* const*) args);
1884                         log_warning("Failed to execute configured init, trying fallback: %m");
1885                 }
1886
1887                 args[0] = "/sbin/init";
1888                 execv(args[0], (char* const*) args);
1889
1890                 if (errno == ENOENT) {
1891                         log_warning("No /sbin/init, trying fallback");
1892
1893                         args[0] = "/bin/sh";
1894                         args[1] = NULL;
1895                         execv(args[0], (char* const*) args);
1896                         log_error("Failed to execute /bin/sh, giving up: %m");
1897                 } else
1898                         log_warning("Failed to execute /sbin/init, giving up: %m");
1899         }
1900
1901         if (serialization)
1902                 fclose(serialization);
1903
1904         if (fds)
1905                 fdset_free(fds);
1906
1907         if (shutdown_verb) {
1908                 const char * command_line[] = {
1909                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1910                         shutdown_verb,
1911                         NULL
1912                 };
1913                 char **env_block;
1914
1915                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1916                         char e[32];
1917
1918                         /* If we reboot let's set the shutdown
1919                          * watchdog and tell the shutdown binary to
1920                          * repeatedly ping it */
1921                         watchdog_set_timeout(&arg_shutdown_watchdog);
1922                         watchdog_close(false);
1923
1924                         /* Tell the binary how often to ping */
1925                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1926                         char_array_0(e);
1927
1928                         env_block = strv_append(environ, e);
1929                 } else {
1930                         env_block = strv_copy(environ);
1931                         watchdog_close(true);
1932                 }
1933
1934                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1935                 free(env_block);
1936                 log_error("Failed to execute shutdown binary, freezing: %m");
1937         }
1938
1939         if (getpid() == 1)
1940                 freeze();
1941
1942         return retval;
1943 }