src/core/main.c

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