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