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