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