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 ManagerRunningAs arg_running_as = _MANAGER_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 == MANAGER_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 = MANAGER_SYSTEM;
 876                         break;
 877
 878                 case ARG_USER:
 879                         arg_running_as = MANAGER_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 int main(int argc, char *argv[]) {
1231         Manager *m = NULL;
1232         int r, retval = EXIT_FAILURE;
1233         usec_t before_startup, after_startup;
1234         char timespan[FORMAT_TIMESPAN_MAX];
1235         FDSet *fds = NULL;
1236         bool reexecute = false;
1237         const char *shutdown_verb = NULL;
1238         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1239         static char systemd[] = "systemd";
1240         bool skip_setup = false;
1241         int j;
1242         bool loaded_policy = false;
1243         bool arm_reboot_watchdog = false;
1244         bool queue_default_job = false;
1245         char *switch_root_dir = NULL, *switch_root_init = NULL;
1246         static struct rlimit saved_rlimit_nofile = { 0, 0 };
1247
1248 #ifdef HAVE_SYSV_COMPAT
1249         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1250                 /* This is compatibility support for SysV, where
1251                  * calling init as a user is identical to telinit. */
1252
1253                 errno = -ENOENT;
1254                 execv(SYSTEMCTL_BINARY_PATH, argv);
1255                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1256                 return 1;
1257         }
1258 #endif
1259
1260         /* Determine if this is a reexecution or normal bootup. We do
1261          * the full command line parsing much later, so let's just
1262          * have a quick peek here. */
1263         for (j = 1; j < argc; j++)
1264                 if (streq(argv[j], "--deserialize")) {
1265                         skip_setup = true;
1266                         break;
1267                 }
1268
1269         /* If we have switched root, do all the special setup
1270          * things */
1271         for (j = 1; j < argc; j++)
1272                 if (streq(argv[j], "--switched-root")) {
1273                         skip_setup = false;
1274                         break;
1275                 }
1276
1277         /* If we get started via the /sbin/init symlink then we are
1278            called 'init'. After a subsequent reexecution we are then
1279            called 'systemd'. That is confusing, hence let's call us
1280            systemd right-away. */
1281         program_invocation_short_name = systemd;
1282         prctl(PR_SET_NAME, systemd);
1283
1284         saved_argv = argv;
1285         saved_argc = argc;
1286
1287         log_show_color(isatty(STDERR_FILENO) > 0);
1288         log_show_location(false);
1289         log_set_max_level(LOG_INFO);
1290
1291         if (getpid() == 1) {
1292                 if (in_initrd()) {
1293                         char *rd_timestamp = NULL;
1294
1295                         dual_timestamp_get(&initrd_timestamp);
1296                         asprintf(&rd_timestamp, "%llu %llu",
1297                                  (unsigned long long) initrd_timestamp.realtime,
1298                                  (unsigned long long) initrd_timestamp.monotonic);
1299                         if (rd_timestamp) {
1300                                 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1301                                 free(rd_timestamp);
1302                         }
1303                 }
1304
1305                 arg_running_as = MANAGER_SYSTEM;
1306
1307                 make_null_stdio();
1308                 log_set_target(detect_container(NULL) > 0 ? LOG_TARGET_JOURNAL : LOG_TARGET_JOURNAL_OR_KMSG);
1309
1310                 if (!skip_setup) {
1311                         if (selinux_setup(&loaded_policy) < 0)
1312                                 goto finish;
1313                         if (ima_setup() < 0)
1314                                 goto finish;
1315                 }
1316
1317                 log_open();
1318
1319                 if (label_init(NULL) < 0)
1320                         goto finish;
1321
1322                 if (!skip_setup)
1323                         if (hwclock_is_localtime() > 0) {
1324                                 int min;
1325
1326                                 r = hwclock_apply_localtime_delta(&min);
1327                                 if (r < 0)
1328                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1329                                 else
1330                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1331                         }
1332
1333         } else {
1334                 arg_running_as = MANAGER_USER;
1335                 log_set_target(LOG_TARGET_AUTO);
1336                 log_open();
1337         }
1338
1339         /* Initialize default unit */
1340         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1341         if (r < 0) {
1342                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1343                 goto finish;
1344         }
1345
1346         /* By default, mount "cpu" and "cpuacct" together */
1347         arg_join_controllers = new(char**, 3);
1348         if (!arg_join_controllers)
1349                 goto finish;
1350
1351         arg_join_controllers[0] = strv_new("cpu", "cpuacct", "cpuset", NULL);
1352         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1353         arg_join_controllers[2] = NULL;
1354
1355         if (!arg_join_controllers[0])
1356                 goto finish;
1357
1358         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1359          * /proc/$PID/fd is available. */
1360         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1361                 r = mount_setup(loaded_policy);
1362                 if (r < 0)
1363                         goto finish;
1364         }
1365
1366         /* Reset all signal handlers. */
1367         assert_se(reset_all_signal_handlers() == 0);
1368
1369         /* If we are init, we can block sigkill. Yay. */
1370         ignore_signals(SIGNALS_IGNORE, -1);
1371
1372         if (parse_config_file() < 0)
1373                 goto finish;
1374
1375         if (arg_running_as == MANAGER_SYSTEM)
1376                 if (parse_proc_cmdline() < 0)
1377                         goto finish;
1378
1379         log_parse_environment();
1380
1381         if (parse_argv(argc, argv) < 0)
1382                 goto finish;
1383
1384         if (arg_action == ACTION_TEST && geteuid() == 0) {
1385                 log_error("Don't run test mode as root.");
1386                 goto finish;
1387         }
1388
1389         if (arg_running_as == MANAGER_SYSTEM &&
1390             arg_action == ACTION_RUN &&
1391             running_in_chroot() > 0) {
1392                 log_error("Cannot be run in a chroot() environment.");
1393                 goto finish;
1394         }
1395
1396         if (arg_action == ACTION_HELP) {
1397                 retval = help();
1398                 goto finish;
1399         } else if (arg_action == ACTION_VERSION) {
1400                 retval = version();
1401                 goto finish;
1402         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1403                 unit_dump_config_items(stdout);
1404                 retval = EXIT_SUCCESS;
1405                 goto finish;
1406         } else if (arg_action == ACTION_DONE) {
1407                 retval = EXIT_SUCCESS;
1408                 goto finish;
1409         }
1410
1411         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1412
1413         /* Close logging fds, in order not to confuse fdset below */
1414         log_close();
1415
1416         /* Remember open file descriptors for later deserialization */
1417         if (serialization) {
1418                 r = fdset_new_fill(&fds);
1419                 if (r < 0) {
1420                         log_error("Failed to allocate fd set: %s", strerror(-r));
1421                         goto finish;
1422                 }
1423
1424                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1425         } else
1426                 close_all_fds(NULL, 0);
1427
1428         /* Set up PATH unless it is already set */
1429         setenv("PATH",
1430 #ifdef HAVE_SPLIT_USR
1431                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1432 #else
1433                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1434 #endif
1435                arg_running_as == MANAGER_SYSTEM);
1436
1437         if (arg_running_as == MANAGER_SYSTEM) {
1438                 /* Parse the data passed to us. We leave this
1439                  * variables set, but the manager later on will not
1440                  * pass them on to our children. */
1441                 if (!in_initrd())
1442                         parse_initrd_timestamp(&initrd_timestamp);
1443
1444                 /* Unset some environment variables passed in from the
1445                  * kernel that don't really make sense for us. */
1446                 unsetenv("HOME");
1447                 unsetenv("TERM");
1448
1449                 /* When we are invoked by a shell, these might be set,
1450                  * but make little sense to pass on */
1451                 unsetenv("PWD");
1452                 unsetenv("SHLVL");
1453                 unsetenv("_");
1454
1455                 /* When we are invoked by a chroot-like tool such as
1456                  * nspawn, these might be set, but make little sense
1457                  * to pass on */
1458                 unsetenv("USER");
1459                 unsetenv("LOGNAME");
1460
1461                 /* All other variables are left as is, so that clients
1462                  * can still read them via /proc/1/environ */
1463         }
1464
1465         /* Move out of the way, so that we won't block unmounts */
1466         assert_se(chdir("/")  == 0);
1467
1468         if (arg_running_as == MANAGER_SYSTEM) {
1469                 /* Become a session leader if we aren't one yet. */
1470                 setsid();
1471
1472                 /* Disable the umask logic */
1473                 umask(0);
1474         }
1475
1476         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1477         dbus_connection_set_change_sigpipe(FALSE);
1478
1479         /* Reset the console, but only if this is really init and we
1480          * are freshly booted */
1481         if (arg_running_as == MANAGER_SYSTEM && arg_action == ACTION_RUN)
1482                 console_setup(getpid() == 1 && !skip_setup);
1483
1484         /* Open the logging devices, if possible and necessary */
1485         log_open();
1486
1487         /* Make sure we leave a core dump without panicing the
1488          * kernel. */
1489         if (getpid() == 1)
1490                 install_crash_handler();
1491
1492         if (geteuid() == 0 && !getenv("SYSTEMD_SKIP_API_MOUNTS")) {
1493                 r = mount_cgroup_controllers(arg_join_controllers);
1494                 if (r < 0)
1495                         goto finish;
1496         }
1497
1498         if (arg_running_as == MANAGER_SYSTEM) {
1499                 const char *virtualization = NULL;
1500
1501                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1502
1503                 detect_virtualization(&virtualization);
1504                 if (virtualization)
1505                         log_info("Detected virtualization '%s'.", virtualization);
1506
1507                 if (in_initrd())
1508                         log_info("Running in initial RAM disk.");
1509
1510         } else
1511                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES "; " DISTRIBUTION ")");
1512
1513         if (arg_running_as == MANAGER_SYSTEM && !skip_setup) {
1514                 locale_setup();
1515
1516                 if (arg_show_status || plymouth_running())
1517                         status_welcome();
1518
1519                 kmod_setup();
1520                 hostname_setup();
1521                 machine_id_setup();
1522                 loopback_setup();
1523
1524                 test_mtab();
1525                 test_usr();
1526                 test_cgroups();
1527         }
1528
1529         if (arg_running_as == MANAGER_SYSTEM && arg_runtime_watchdog > 0)
1530                 watchdog_set_timeout(&arg_runtime_watchdog);
1531
1532         if (arg_timer_slack_nsec != (nsec_t) -1)
1533                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1534                         log_error("Failed to adjust timer slack: %m");
1535
1536         if (arg_capability_bounding_set_drop) {
1537                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1538                 if (r < 0) {
1539                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1540                         goto finish;
1541                 }
1542                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1543                 if (r < 0) {
1544                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1545                         goto finish;
1546                 }
1547         }
1548
1549         if (arg_running_as == MANAGER_USER) {
1550                 /* Become reaper of our children */
1551                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1552                         log_warning("Failed to make us a subreaper: %m");
1553                         if (errno == EINVAL)
1554                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1555                 }
1556         }
1557
1558         if (arg_running_as == MANAGER_SYSTEM)
1559                 bump_rlimit_nofile(&saved_rlimit_nofile);
1560
1561         r = manager_new(arg_running_as, &m);
1562         if (r < 0) {
1563                 log_error("Failed to allocate manager object: %s", strerror(-r));
1564                 goto finish;
1565         }
1566
1567         m->confirm_spawn = arg_confirm_spawn;
1568         m->default_std_output = arg_default_std_output;
1569         m->default_std_error = arg_default_std_error;
1570         m->runtime_watchdog = arg_runtime_watchdog;
1571         m->shutdown_watchdog = arg_shutdown_watchdog;
1572
1573         manager_set_default_rlimits(m, arg_default_rlimit);
1574
1575         if (dual_timestamp_is_set(&initrd_timestamp))
1576                 m->initrd_timestamp = initrd_timestamp;
1577
1578         if (arg_default_controllers)
1579                 manager_set_default_controllers(m, arg_default_controllers);
1580
1581         manager_set_show_status(m, arg_show_status);
1582
1583         /* Remember whether we should queue the default job */
1584         queue_default_job = !serialization || arg_switched_root;
1585
1586         before_startup = now(CLOCK_MONOTONIC);
1587
1588         r = manager_startup(m, serialization, fds);
1589         if (r < 0)
1590                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1591
1592         /* This will close all file descriptors that were opened, but
1593          * not claimed by any unit. */
1594         if (fds) {
1595                 fdset_free(fds);
1596                 fds = NULL;
1597         }
1598
1599         if (serialization) {
1600                 fclose(serialization);
1601                 serialization = NULL;
1602         }
1603
1604         if (queue_default_job) {
1605                 DBusError error;
1606                 Unit *target = NULL;
1607                 Job *default_unit_job;
1608
1609                 dbus_error_init(&error);
1610
1611                 log_debug("Activating default unit: %s", arg_default_unit);
1612
1613                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1614                 if (r < 0) {
1615                         log_error("Failed to load default target: %s", bus_error(&error, r));
1616                         dbus_error_free(&error);
1617                 } else if (target->load_state == UNIT_ERROR)
1618                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1619                 else if (target->load_state == UNIT_MASKED)
1620                         log_error("Default target masked.");
1621
1622                 if (!target || target->load_state != UNIT_LOADED) {
1623                         log_info("Trying to load rescue target...");
1624
1625                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1626                         if (r < 0) {
1627                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1628                                 dbus_error_free(&error);
1629                                 goto finish;
1630                         } else if (target->load_state == UNIT_ERROR) {
1631                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1632                                 goto finish;
1633                         } else if (target->load_state == UNIT_MASKED) {
1634                                 log_error("Rescue target masked.");
1635                                 goto finish;
1636                         }
1637                 }
1638
1639                 assert(target->load_state == UNIT_LOADED);
1640
1641                 if (arg_action == ACTION_TEST) {
1642                         printf("-> By units:\n");
1643                         manager_dump_units(m, stdout, "\t");
1644                 }
1645
1646                 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1647                 if (r < 0) {
1648                         log_error("Failed to start default target: %s", bus_error(&error, r));
1649                         dbus_error_free(&error);
1650                         goto finish;
1651                 }
1652                 m->default_unit_job_id = default_unit_job->id;
1653
1654                 after_startup = now(CLOCK_MONOTONIC);
1655                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1656                          "Loaded units and determined initial transaction in %s.",
1657                           format_timespan(timespan, sizeof(timespan), after_startup - before_startup));
1658
1659                 if (arg_action == ACTION_TEST) {
1660                         printf("-> By jobs:\n");
1661                         manager_dump_jobs(m, stdout, "\t");
1662                         retval = EXIT_SUCCESS;
1663                         goto finish;
1664                 }
1665         }
1666
1667         for (;;) {
1668                 r = manager_loop(m);
1669                 if (r < 0) {
1670                         log_error("Failed to run mainloop: %s", strerror(-r));
1671                         goto finish;
1672                 }
1673
1674                 switch (m->exit_code) {
1675
1676                 case MANAGER_EXIT:
1677                         retval = EXIT_SUCCESS;
1678                         log_debug("Exit.");
1679                         goto finish;
1680
1681                 case MANAGER_RELOAD:
1682                         log_info("Reloading.");
1683                         r = manager_reload(m);
1684                         if (r < 0)
1685                                 log_error("Failed to reload: %s", strerror(-r));
1686                         break;
1687
1688                 case MANAGER_REEXECUTE:
1689
1690                         if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1691                                 goto finish;
1692
1693                         reexecute = true;
1694                         log_notice("Reexecuting.");
1695                         goto finish;
1696
1697                 case MANAGER_SWITCH_ROOT:
1698                         /* Steal the switch root parameters */
1699                         switch_root_dir = m->switch_root;
1700                         switch_root_init = m->switch_root_init;
1701                         m->switch_root = m->switch_root_init = NULL;
1702
1703                         if (!switch_root_init)
1704                                 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1705                                         goto finish;
1706
1707                         reexecute = true;
1708                         log_notice("Switching root.");
1709                         goto finish;
1710
1711                 case MANAGER_REBOOT:
1712                 case MANAGER_POWEROFF:
1713                 case MANAGER_HALT:
1714                 case MANAGER_KEXEC: {
1715                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1716                                 [MANAGER_REBOOT] = "reboot",
1717                                 [MANAGER_POWEROFF] = "poweroff",
1718                                 [MANAGER_HALT] = "halt",
1719                                 [MANAGER_KEXEC] = "kexec"
1720                         };
1721
1722                         assert_se(shutdown_verb = table[m->exit_code]);
1723                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1724
1725                         log_notice("Shutting down.");
1726                         goto finish;
1727                 }
1728
1729                 default:
1730                         assert_not_reached("Unknown exit code.");
1731                 }
1732         }
1733
1734 finish:
1735         if (m)
1736                 manager_free(m);
1737
1738         for (j = 0; j < RLIMIT_NLIMITS; j++)
1739                 free(arg_default_rlimit[j]);
1740
1741         free(arg_default_unit);
1742         strv_free(arg_default_controllers);
1743         free_join_controllers();
1744
1745         dbus_shutdown();
1746         label_finish();
1747
1748         if (reexecute) {
1749                 const char **args;
1750                 unsigned i, args_size;
1751
1752                 /* Close and disarm the watchdog, so that the new
1753                  * instance can reinitialize it, but doesn't get
1754                  * rebooted while we do that */
1755                 watchdog_close(true);
1756
1757                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1758                  * that the new systemd can pass the kernel default to
1759                  * its child processes */
1760                 if (saved_rlimit_nofile.rlim_cur > 0)
1761                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1762
1763                 if (switch_root_dir) {
1764                         /* Kill all remaining processes from the
1765                          * initrd, but don't wait for them, so that we
1766                          * can handle the SIGCHLD for them after
1767                          * deserializing. */
1768                         broadcast_signal(SIGTERM, false);
1769
1770                         /* And switch root */
1771                         r = switch_root(switch_root_dir);
1772                         if (r < 0)
1773                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1774                 }
1775
1776                 args_size = MAX(6, argc+1);
1777                 args = newa(const char*, args_size);
1778
1779                 if (!switch_root_init) {
1780                         char sfd[16];
1781
1782                         /* First try to spawn ourselves with the right
1783                          * path, and with full serialization. We do
1784                          * this only if the user didn't specify an
1785                          * explicit init to spawn. */
1786
1787                         assert(serialization);
1788                         assert(fds);
1789
1790                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1791                         char_array_0(sfd);
1792
1793                         i = 0;
1794                         args[i++] = SYSTEMD_BINARY_PATH;
1795                         if (switch_root_dir)
1796                                 args[i++] = "--switched-root";
1797                         args[i++] = arg_running_as == MANAGER_SYSTEM ? "--system" : "--user";
1798                         args[i++] = "--deserialize";
1799                         args[i++] = sfd;
1800                         args[i++] = NULL;
1801
1802                         assert(i <= args_size);
1803                         execv(args[0], (char* const*) args);
1804                 }
1805
1806                 /* Try the fallback, if there is any, without any
1807                  * serialization. We pass the original argv[] and
1808                  * envp[]. (Well, modulo the ordering changes due to
1809                  * getopt() in argv[], and some cleanups in envp[],
1810                  * but let's hope that doesn't matter.) */
1811
1812                 if (serialization) {
1813                         fclose(serialization);
1814                         serialization = NULL;
1815                 }
1816
1817                 if (fds) {
1818                         fdset_free(fds);
1819                         fds = NULL;
1820                 }
1821
1822                 /* Reopen the console */
1823                 make_console_stdio();
1824
1825                 for (j = 1, i = 1; j < argc; j++)
1826                         args[i++] = argv[j];
1827                 args[i++] = NULL;
1828                 assert(i <= args_size);
1829
1830                 if (switch_root_init) {
1831                         args[0] = switch_root_init;
1832                         execv(args[0], (char* const*) args);
1833                         log_warning("Failed to execute configured init, trying fallback: %m");
1834                 }
1835
1836                 args[0] = "/sbin/init";
1837                 execv(args[0], (char* const*) args);
1838
1839                 if (errno == ENOENT) {
1840                         log_warning("No /sbin/init, trying fallback");
1841
1842                         args[0] = "/bin/sh";
1843                         args[1] = NULL;
1844                         execv(args[0], (char* const*) args);
1845                         log_error("Failed to execute /bin/sh, giving up: %m");
1846                 } else
1847                         log_warning("Failed to execute /sbin/init, giving up: %m");
1848         }
1849
1850         if (serialization)
1851                 fclose(serialization);
1852
1853         if (fds)
1854                 fdset_free(fds);
1855
1856         if (shutdown_verb) {
1857                 const char * command_line[] = {
1858                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1859                         shutdown_verb,
1860                         NULL
1861                 };
1862                 char **env_block;
1863
1864                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1865                         char e[32];
1866
1867                         /* If we reboot let's set the shutdown
1868                          * watchdog and tell the shutdown binary to
1869                          * repeatedly ping it */
1870                         watchdog_set_timeout(&arg_shutdown_watchdog);
1871                         watchdog_close(false);
1872
1873                         /* Tell the binary how often to ping */
1874                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1875                         char_array_0(e);
1876
1877                         env_block = strv_append(environ, e);
1878                 } else {
1879                         env_block = strv_copy(environ);
1880                         watchdog_close(true);
1881                 }
1882
1883                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1884                 free(env_block);
1885                 log_error("Failed to execute shutdown binary, freezing: %m");
1886         }
1887
1888         if (getpid() == 1)
1889                 freeze();
1890
1891         return retval;
1892 }