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