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