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