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 *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         fclose(f);
 726
 727         return 0;
 728 }
 729
 730 static int parse_proc_cmdline(void) {
 731         char *line, *w, *state;
 732         int r;
 733         size_t l;
 734
 735         /* Don't read /proc/cmdline if we are in a container, since
 736          * that is only relevant for the host system */
 737         if (detect_container(NULL) > 0)
 738                 return 0;
 739
 740         if ((r = read_one_line_file("/proc/cmdline", &line)) < 0) {
 741                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
 742                 return 0;
 743         }
 744
 745         FOREACH_WORD_QUOTED(w, l, line, state) {
 746                 char *word;
 747
 748                 if (!(word = strndup(w, l))) {
 749                         r = -ENOMEM;
 750                         goto finish;
 751                 }
 752
 753                 r = parse_proc_cmdline_word(word);
 754                 if (r < 0) {
 755                         log_error("Failed on cmdline argument %s: %s", word, strerror(-r));
 756                         free(word);
 757                         goto finish;
 758                 }
 759
 760                 free(word);
 761         }
 762
 763         r = 0;
 764
 765 finish:
 766         free(line);
 767         return r;
 768 }
 769
 770 static int parse_argv(int argc, char *argv[]) {
 771
 772         enum {
 773                 ARG_LOG_LEVEL = 0x100,
 774                 ARG_LOG_TARGET,
 775                 ARG_LOG_COLOR,
 776                 ARG_LOG_LOCATION,
 777                 ARG_UNIT,
 778                 ARG_SYSTEM,
 779                 ARG_USER,
 780                 ARG_TEST,
 781                 ARG_VERSION,
 782                 ARG_DUMP_CONFIGURATION_ITEMS,
 783                 ARG_DUMP_CORE,
 784                 ARG_CRASH_SHELL,
 785                 ARG_CONFIRM_SPAWN,
 786                 ARG_SHOW_STATUS,
 787                 ARG_DESERIALIZE,
 788                 ARG_SWITCHED_ROOT,
 789                 ARG_INTROSPECT,
 790                 ARG_DEFAULT_STD_OUTPUT,
 791                 ARG_DEFAULT_STD_ERROR
 792         };
 793
 794         static const struct option options[] = {
 795                 { "log-level",                required_argument, NULL, ARG_LOG_LEVEL                },
 796                 { "log-target",               required_argument, NULL, ARG_LOG_TARGET               },
 797                 { "log-color",                optional_argument, NULL, ARG_LOG_COLOR                },
 798                 { "log-location",             optional_argument, NULL, ARG_LOG_LOCATION             },
 799                 { "unit",                     required_argument, NULL, ARG_UNIT                     },
 800                 { "system",                   no_argument,       NULL, ARG_SYSTEM                   },
 801                 { "user",                     no_argument,       NULL, ARG_USER                     },
 802                 { "test",                     no_argument,       NULL, ARG_TEST                     },
 803                 { "help",                     no_argument,       NULL, 'h'                          },
 804                 { "version",                  no_argument,       NULL, ARG_VERSION                  },
 805                 { "dump-configuration-items", no_argument,       NULL, ARG_DUMP_CONFIGURATION_ITEMS },
 806                 { "dump-core",                optional_argument, NULL, ARG_DUMP_CORE                },
 807                 { "crash-shell",              optional_argument, NULL, ARG_CRASH_SHELL              },
 808                 { "confirm-spawn",            optional_argument, NULL, ARG_CONFIRM_SPAWN            },
 809                 { "show-status",              optional_argument, NULL, ARG_SHOW_STATUS              },
 810                 { "deserialize",              required_argument, NULL, ARG_DESERIALIZE              },
 811                 { "switched-root",            no_argument,       NULL, ARG_SWITCHED_ROOT            },
 812                 { "introspect",               optional_argument, NULL, ARG_INTROSPECT               },
 813                 { "default-standard-output",  required_argument, NULL, ARG_DEFAULT_STD_OUTPUT,      },
 814                 { "default-standard-error",   required_argument, NULL, ARG_DEFAULT_STD_ERROR,       },
 815                 { NULL,                       0,                 NULL, 0                            }
 816         };
 817
 818         int c, r;
 819
 820         assert(argc >= 1);
 821         assert(argv);
 822
 823         if (getpid() == 1)
 824                 opterr = 0;
 825
 826         while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
 827
 828                 switch (c) {
 829
 830                 case ARG_LOG_LEVEL:
 831                         if ((r = log_set_max_level_from_string(optarg)) < 0) {
 832                                 log_error("Failed to parse log level %s.", optarg);
 833                                 return r;
 834                         }
 835
 836                         break;
 837
 838                 case ARG_LOG_TARGET:
 839
 840                         if ((r = log_set_target_from_string(optarg)) < 0) {
 841                                 log_error("Failed to parse log target %s.", optarg);
 842                                 return r;
 843                         }
 844
 845                         break;
 846
 847                 case ARG_LOG_COLOR:
 848
 849                         if (optarg) {
 850                                 if ((r = log_show_color_from_string(optarg)) < 0) {
 851                                         log_error("Failed to parse log color setting %s.", optarg);
 852                                         return r;
 853                                 }
 854                         } else
 855                                 log_show_color(true);
 856
 857                         break;
 858
 859                 case ARG_LOG_LOCATION:
 860
 861                         if (optarg) {
 862                                 if ((r = log_show_location_from_string(optarg)) < 0) {
 863                                         log_error("Failed to parse log location setting %s.", optarg);
 864                                         return r;
 865                                 }
 866                         } else
 867                                 log_show_location(true);
 868
 869                         break;
 870
 871                 case ARG_DEFAULT_STD_OUTPUT:
 872
 873                         if ((r = exec_output_from_string(optarg)) < 0) {
 874                                 log_error("Failed to parse default standard output setting %s.", optarg);
 875                                 return r;
 876                         } else
 877                                 arg_default_std_output = r;
 878                         break;
 879
 880                 case ARG_DEFAULT_STD_ERROR:
 881
 882                         if ((r = exec_output_from_string(optarg)) < 0) {
 883                                 log_error("Failed to parse default standard error output setting %s.", optarg);
 884                                 return r;
 885                         } else
 886                                 arg_default_std_error = r;
 887                         break;
 888
 889                 case ARG_UNIT:
 890
 891                         if ((r = set_default_unit(optarg)) < 0) {
 892                                 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
 893                                 return r;
 894                         }
 895
 896                         break;
 897
 898                 case ARG_SYSTEM:
 899                         arg_running_as = SYSTEMD_SYSTEM;
 900                         break;
 901
 902                 case ARG_USER:
 903                         arg_running_as = SYSTEMD_USER;
 904                         break;
 905
 906                 case ARG_TEST:
 907                         arg_action = ACTION_TEST;
 908                         break;
 909
 910                 case ARG_VERSION:
 911                         arg_action = ACTION_VERSION;
 912                         break;
 913
 914                 case ARG_DUMP_CONFIGURATION_ITEMS:
 915                         arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
 916                         break;
 917
 918                 case ARG_DUMP_CORE:
 919                         r = optarg ? parse_boolean(optarg) : 1;
 920                         if (r < 0) {
 921                                 log_error("Failed to parse dump core boolean %s.", optarg);
 922                                 return r;
 923                         }
 924                         arg_dump_core = r;
 925                         break;
 926
 927                 case ARG_CRASH_SHELL:
 928                         r = optarg ? parse_boolean(optarg) : 1;
 929                         if (r < 0) {
 930                                 log_error("Failed to parse crash shell boolean %s.", optarg);
 931                                 return r;
 932                         }
 933                         arg_crash_shell = r;
 934                         break;
 935
 936                 case ARG_CONFIRM_SPAWN:
 937                         r = optarg ? parse_boolean(optarg) : 1;
 938                         if (r < 0) {
 939                                 log_error("Failed to parse confirm spawn boolean %s.", optarg);
 940                                 return r;
 941                         }
 942                         arg_confirm_spawn = r;
 943                         break;
 944
 945                 case ARG_SHOW_STATUS:
 946                         r = optarg ? parse_boolean(optarg) : 1;
 947                         if (r < 0) {
 948                                 log_error("Failed to parse show status boolean %s.", optarg);
 949                                 return r;
 950                         }
 951                         arg_show_status = r;
 952                         break;
 953
 954                 case ARG_DESERIALIZE: {
 955                         int fd;
 956                         FILE *f;
 957
 958                         r = safe_atoi(optarg, &fd);
 959                         if (r < 0 || fd < 0) {
 960                                 log_error("Failed to parse deserialize option %s.", optarg);
 961                                 return r < 0 ? r : -EINVAL;
 962                         }
 963
 964                         fd_cloexec(fd, true);
 965
 966                         f = fdopen(fd, "r");
 967                         if (!f) {
 968                                 log_error("Failed to open serialization fd: %m");
 969                                 return -errno;
 970                         }
 971
 972                         if (serialization)
 973                                 fclose(serialization);
 974
 975                         serialization = f;
 976
 977                         break;
 978                 }
 979
 980                 case ARG_SWITCHED_ROOT:
 981                         arg_switched_root = true;
 982                         break;
 983
 984                 case ARG_INTROSPECT: {
 985                         const char * const * i = NULL;
 986
 987                         for (i = bus_interface_table; *i; i += 2)
 988                                 if (!optarg || streq(i[0], optarg)) {
 989                                         fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
 990                                               "<node>\n", stdout);
 991                                         fputs(i[1], stdout);
 992                                         fputs("</node>\n", stdout);
 993
 994                                         if (optarg)
 995                                                 break;
 996                                 }
 997
 998                         if (!i[0] && optarg)
 999                                 log_error("Unknown interface %s.", optarg);
1000
1001                         arg_action = ACTION_DONE;
1002                         break;
1003                 }
1004
1005                 case 'h':
1006                         arg_action = ACTION_HELP;
1007                         break;
1008
1009                 case 'D':
1010                         log_set_max_level(LOG_DEBUG);
1011                         break;
1012
1013                 case 'b':
1014                 case 's':
1015                 case 'z':
1016                         /* Just to eat away the sysvinit kernel
1017                          * cmdline args without getopt() error
1018                          * messages that we'll parse in
1019                          * parse_proc_cmdline_word() or ignore. */
1020
1021                 case '?':
1022                 default:
1023                         if (getpid() != 1) {
1024                                 log_error("Unknown option code %c", c);
1025                                 return -EINVAL;
1026                         }
1027
1028                         break;
1029                 }
1030
1031         if (optind < argc && getpid() != 1) {
1032                 /* Hmm, when we aren't run as init system
1033                  * let's complain about excess arguments */
1034
1035                 log_error("Excess arguments.");
1036                 return -EINVAL;
1037         }
1038
1039         if (detect_container(NULL) > 0) {
1040                 char **a;
1041
1042                 /* All /proc/cmdline arguments the kernel didn't
1043                  * understand it passed to us. We're not really
1044                  * interested in that usually since /proc/cmdline is
1045                  * more interesting and complete. With one exception:
1046                  * if we are run in a container /proc/cmdline is not
1047                  * relevant for the container, hence we rely on argv[]
1048                  * instead. */
1049
1050                 for (a = argv; a < argv + argc; a++)
1051                         if ((r = parse_proc_cmdline_word(*a)) < 0) {
1052                                 log_error("Failed on cmdline argument %s: %s", *a, strerror(-r));
1053                                 return r;
1054                         }
1055         }
1056
1057         return 0;
1058 }
1059
1060 static int help(void) {
1061
1062         printf("%s [OPTIONS...]\n\n"
1063                "Starts up and maintains the system or user services.\n\n"
1064                "  -h --help                      Show this help\n"
1065                "     --test                      Determine startup sequence, dump it and exit\n"
1066                "     --dump-configuration-items  Dump understood unit configuration items\n"
1067                "     --introspect[=INTERFACE]    Extract D-Bus interface data\n"
1068                "     --unit=UNIT                 Set default unit\n"
1069                "     --system                    Run a system instance, even if PID != 1\n"
1070                "     --user                      Run a user instance\n"
1071                "     --dump-core[=0|1]           Dump core on crash\n"
1072                "     --crash-shell[=0|1]         Run shell on crash\n"
1073                "     --confirm-spawn[=0|1]       Ask for confirmation when spawning processes\n"
1074                "     --show-status[=0|1]         Show status updates on the console during bootup\n"
1075                "     --log-target=TARGET         Set log target (console, journal, syslog, kmsg, journal-or-kmsg, syslog-or-kmsg, null)\n"
1076                "     --log-level=LEVEL           Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
1077                "     --log-color[=0|1]           Highlight important log messages\n"
1078                "     --log-location[=0|1]        Include code location in log messages\n"
1079                "     --default-standard-output=  Set default standard output for services\n"
1080                "     --default-standard-error=   Set default standard error output for services\n",
1081                program_invocation_short_name);
1082
1083         return 0;
1084 }
1085
1086 static int version(void) {
1087         puts(PACKAGE_STRING);
1088         puts(SYSTEMD_FEATURES);
1089
1090         return 0;
1091 }
1092
1093 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool serialize_jobs) {
1094         FILE *f = NULL;
1095         FDSet *fds = NULL;
1096         int r;
1097
1098         assert(m);
1099         assert(_f);
1100         assert(_fds);
1101
1102         /* Make sure nothing is really destructed when we shut down */
1103         m->n_reloading ++;
1104
1105         r = manager_open_serialization(m, &f);
1106         if (r < 0) {
1107                 log_error("Failed to create serialization file: %s", strerror(-r));
1108                 goto fail;
1109         }
1110
1111         fds = fdset_new();
1112         if (!fds) {
1113                 r = -ENOMEM;
1114                 log_error("Failed to allocate fd set: %s", strerror(-r));
1115                 goto fail;
1116         }
1117
1118         r = manager_serialize(m, f, fds, serialize_jobs);
1119         if (r < 0) {
1120                 log_error("Failed to serialize state: %s", strerror(-r));
1121                 goto fail;
1122         }
1123
1124         if (fseeko(f, 0, SEEK_SET) < 0) {
1125                 log_error("Failed to rewind serialization fd: %m");
1126                 goto fail;
1127         }
1128
1129         r = fd_cloexec(fileno(f), false);
1130         if (r < 0) {
1131                 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
1132                 goto fail;
1133         }
1134
1135         r = fdset_cloexec(fds, false);
1136         if (r < 0) {
1137                 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
1138                 goto fail;
1139         }
1140
1141         *_f = f;
1142         *_fds = fds;
1143
1144         return 0;
1145
1146 fail:
1147         fdset_free(fds);
1148
1149         if (f)
1150                 fclose(f);
1151
1152         return r;
1153 }
1154
1155 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1156         struct rlimit nl;
1157         int r;
1158
1159         assert(saved_rlimit);
1160
1161         /* Save the original RLIMIT_NOFILE so that we can reset it
1162          * later when transitioning from the initrd to the main
1163          * systemd or suchlike. */
1164         if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0) {
1165                 log_error("Reading RLIMIT_NOFILE failed: %m");
1166                 return -errno;
1167         }
1168
1169         /* Make sure forked processes get the default kernel setting */
1170         if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1171                 struct rlimit *rl;
1172
1173                 rl = newdup(struct rlimit, saved_rlimit, 1);
1174                 if (!rl)
1175                         return log_oom();
1176
1177                 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1178         }
1179
1180         /* Bump up the resource limit for ourselves substantially */
1181         nl.rlim_cur = nl.rlim_max = 64*1024;
1182         r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1183         if (r < 0) {
1184                 log_error("Setting RLIMIT_NOFILE failed: %s", strerror(-r));
1185                 return r;
1186         }
1187
1188         return 0;
1189 }
1190
1191 static struct dual_timestamp* parse_initrd_timestamp(struct dual_timestamp *t) {
1192         const char *e;
1193         unsigned long long a, b;
1194
1195         assert(t);
1196
1197         e = getenv("RD_TIMESTAMP");
1198         if (!e)
1199                 return NULL;
1200
1201         if (sscanf(e, "%llu %llu", &a, &b) != 2)
1202                 return NULL;
1203
1204         t->realtime = (usec_t) a;
1205         t->monotonic = (usec_t) b;
1206
1207         return t;
1208 }
1209
1210 static void test_mtab(void) {
1211         char *p;
1212
1213         /* Check that /etc/mtab is a symlink */
1214
1215         if (readlink_malloc("/etc/mtab", &p) >= 0) {
1216                 bool b;
1217
1218                 b = streq(p, "/proc/self/mounts") || streq(p, "/proc/mounts");
1219                 free(p);
1220
1221                 if (b)
1222                         return;
1223         }
1224
1225         log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1226                     "This is not supported anymore. "
1227                     "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1228 }
1229
1230 static void test_usr(void) {
1231
1232         /* Check that /usr is not a separate fs */
1233
1234         if (dir_is_empty("/usr") <= 0)
1235                 return;
1236
1237         log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1238                     "Some things will probably break (sometimes even silently) in mysterious ways. "
1239                     "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1240 }
1241
1242 static void test_cgroups(void) {
1243
1244         if (access("/proc/cgroups", F_OK) >= 0)
1245                 return;
1246
1247         log_warning("CONFIG_CGROUPS was not set when your kernel was compiled. "
1248                     "Systems without control groups are not supported. "
1249                     "We will now sleep for 10s, and then continue boot-up. "
1250                     "Expect breakage and please do not file bugs. "
1251                     "Instead fix your kernel and enable CONFIG_CGROUPS. "
1252                     "Consult http://0pointer.de/blog/projects/cgroups-vs-cgroups.html for more information.");
1253
1254         sleep(10);
1255 }
1256
1257 static int initialize_join_controllers(void) {
1258         /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1259          * + "net_prio". We'd like to add "cpuset" to the mix, but
1260          * "cpuset" does't really work for groups with no initialized
1261          * attributes. */
1262
1263         arg_join_controllers = new(char**, 3);
1264         if (!arg_join_controllers)
1265                 return -ENOMEM;
1266
1267         arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1268         if (!arg_join_controllers[0])
1269                 return -ENOMEM;
1270
1271         arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1272         if (!arg_join_controllers[1])
1273                 return -ENOMEM;
1274
1275         arg_join_controllers[2] = NULL;
1276         return 0;
1277 }
1278
1279 int main(int argc, char *argv[]) {
1280         Manager *m = NULL;
1281         int r, retval = EXIT_FAILURE;
1282         usec_t before_startup, after_startup;
1283         char timespan[FORMAT_TIMESPAN_MAX];
1284         FDSet *fds = NULL;
1285         bool reexecute = false;
1286         const char *shutdown_verb = NULL;
1287         dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1288         static char systemd[] = "systemd";
1289         bool skip_setup = false;
1290         int j;
1291         bool loaded_policy = false;
1292         bool arm_reboot_watchdog = false;
1293         bool queue_default_job = false;
1294         char *switch_root_dir = NULL, *switch_root_init = NULL;
1295         static struct rlimit saved_rlimit_nofile = { 0, 0 };
1296
1297 #ifdef HAVE_SYSV_COMPAT
1298         if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1299                 /* This is compatibility support for SysV, where
1300                  * calling init as a user is identical to telinit. */
1301
1302                 errno = -ENOENT;
1303                 execv(SYSTEMCTL_BINARY_PATH, argv);
1304                 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1305                 return 1;
1306         }
1307 #endif
1308
1309         /* Determine if this is a reexecution or normal bootup. We do
1310          * the full command line parsing much later, so let's just
1311          * have a quick peek here. */
1312         if (strv_find(argv+1, "--deserialize"))
1313                 skip_setup = true;
1314
1315         /* If we have switched root, do all the special setup
1316          * things */
1317         if (strv_find(argv+1, "--switched-root"))
1318                 skip_setup = false;
1319
1320         /* If we get started via the /sbin/init symlink then we are
1321            called 'init'. After a subsequent reexecution we are then
1322            called 'systemd'. That is confusing, hence let's call us
1323            systemd right-away. */
1324         program_invocation_short_name = systemd;
1325         prctl(PR_SET_NAME, systemd);
1326
1327         saved_argv = argv;
1328         saved_argc = argc;
1329
1330         log_show_color(isatty(STDERR_FILENO) > 0);
1331
1332         if (getpid() == 1 && detect_container(NULL) <= 0) {
1333
1334                 /* Running outside of a container as PID 1 */
1335                 arg_running_as = SYSTEMD_SYSTEM;
1336                 make_null_stdio();
1337                 log_set_target(LOG_TARGET_KMSG);
1338                 log_open();
1339
1340                 if (in_initrd()) {
1341                         char *rd_timestamp = NULL;
1342
1343                         dual_timestamp_get(&initrd_timestamp);
1344                         asprintf(&rd_timestamp, "%llu %llu",
1345                                  (unsigned long long) initrd_timestamp.realtime,
1346                                  (unsigned long long) initrd_timestamp.monotonic);
1347                         if (rd_timestamp) {
1348                                 setenv("RD_TIMESTAMP", rd_timestamp, 1);
1349                                 free(rd_timestamp);
1350                         }
1351                 }
1352
1353                 if (!skip_setup) {
1354                         mount_setup_early();
1355                         if (selinux_setup(&loaded_policy) < 0)
1356                                 goto finish;
1357                         if (ima_setup() < 0)
1358                                 goto finish;
1359                         if (smack_setup() < 0)
1360                                 goto finish;
1361                 }
1362
1363                 if (label_init(NULL) < 0)
1364                         goto finish;
1365
1366                 if (!skip_setup) {
1367                         if (hwclock_is_localtime() > 0) {
1368                                 int min;
1369
1370                                 /* The first-time call to settimeofday() does a time warp in the kernel */
1371                                 r = hwclock_set_timezone(&min);
1372                                 if (r < 0)
1373                                         log_error("Failed to apply local time delta, ignoring: %s", strerror(-r));
1374                                 else
1375                                         log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1376                         } else if (!in_initrd()) {
1377                                 /*
1378                                  * Do dummy first-time call to seal the kernel's time warp magic
1379                                  *
1380                                  * Do not call this this from inside the initrd. The initrd might not
1381                                  * carry /etc/adjtime with LOCAL, but the real system could be set up
1382                                  * that way. In such case, we need to delay the time-warp or the sealing
1383                                  * until we reach the real system.
1384                                  */
1385                                 hwclock_reset_timezone();
1386
1387                                 /* Tell the kernel our time zone */
1388                                 r = hwclock_set_timezone(NULL);
1389                                 if (r < 0)
1390                                         log_error("Failed to set the kernel's time zone, ignoring: %s", strerror(-r));
1391                         }
1392                 }
1393
1394                 /* Set the default for later on, but don't actually
1395                  * open the logs like this for now. Note that if we
1396                  * are transitioning from the initrd there might still
1397                  * be journal fd open, and we shouldn't attempt
1398                  * opening that before we parsed /proc/cmdline which
1399                  * might redirect output elsewhere. */
1400                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1401
1402         } else if (getpid() == 1) {
1403
1404                 /* Running inside a container, as PID 1 */
1405                 arg_running_as = SYSTEMD_SYSTEM;
1406                 log_set_target(LOG_TARGET_CONSOLE);
1407                 log_open();
1408
1409                 /* For the later on, see above... */
1410                 log_set_target(LOG_TARGET_JOURNAL);
1411
1412         } else {
1413
1414                 /* Running as user instance */
1415                 arg_running_as = SYSTEMD_USER;
1416                 log_set_target(LOG_TARGET_AUTO);
1417                 log_open();
1418         }
1419
1420         /* Initialize default unit */
1421         r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1422         if (r < 0) {
1423                 log_error("Failed to set default unit %s: %s", SPECIAL_DEFAULT_TARGET, strerror(-r));
1424                 goto finish;
1425         }
1426
1427         r = initialize_join_controllers();
1428         if (r < 0)
1429                 goto finish;
1430
1431         /* Mount /proc, /sys and friends, so that /proc/cmdline and
1432          * /proc/$PID/fd is available. */
1433         if (getpid() == 1) {
1434                 r = mount_setup(loaded_policy);
1435                 if (r < 0)
1436                         goto finish;
1437         }
1438
1439         /* Reset all signal handlers. */
1440         assert_se(reset_all_signal_handlers() == 0);
1441
1442         /* If we are init, we can block sigkill. Yay. */
1443         ignore_signals(SIGNALS_IGNORE, -1);
1444
1445         if (parse_config_file() < 0)
1446                 goto finish;
1447
1448         if (arg_running_as == SYSTEMD_SYSTEM)
1449                 if (parse_proc_cmdline() < 0)
1450                         goto finish;
1451
1452         log_parse_environment();
1453
1454         if (parse_argv(argc, argv) < 0)
1455                 goto finish;
1456
1457         if (arg_action == ACTION_TEST &&
1458             geteuid() == 0) {
1459                 log_error("Don't run test mode as root.");
1460                 goto finish;
1461         }
1462
1463         if (arg_running_as == SYSTEMD_USER &&
1464             arg_action == ACTION_RUN &&
1465             sd_booted() <= 0) {
1466                 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1467                 goto finish;
1468         }
1469
1470         if (arg_running_as == SYSTEMD_SYSTEM &&
1471             arg_action == ACTION_RUN &&
1472             running_in_chroot() > 0) {
1473                 log_error("Cannot be run in a chroot() environment.");
1474                 goto finish;
1475         }
1476
1477         if (arg_action == ACTION_HELP) {
1478                 retval = help();
1479                 goto finish;
1480         } else if (arg_action == ACTION_VERSION) {
1481                 retval = version();
1482                 goto finish;
1483         } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1484                 unit_dump_config_items(stdout);
1485                 retval = EXIT_SUCCESS;
1486                 goto finish;
1487         } else if (arg_action == ACTION_DONE) {
1488                 retval = EXIT_SUCCESS;
1489                 goto finish;
1490         }
1491
1492         assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1493
1494         /* Close logging fds, in order not to confuse fdset below */
1495         log_close();
1496
1497         /* Remember open file descriptors for later deserialization */
1498         r = fdset_new_fill(&fds);
1499         if (r < 0) {
1500                 log_error("Failed to allocate fd set: %s", strerror(-r));
1501                 goto finish;
1502         } else
1503                 fdset_cloexec(fds, true);
1504
1505         if (serialization)
1506                 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
1507
1508         /* Set up PATH unless it is already set */
1509         setenv("PATH",
1510 #ifdef HAVE_SPLIT_USR
1511                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1512 #else
1513                "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
1514 #endif
1515                arg_running_as == SYSTEMD_SYSTEM);
1516
1517         if (arg_running_as == SYSTEMD_SYSTEM) {
1518                 /* Parse the data passed to us. We leave this
1519                  * variables set, but the manager later on will not
1520                  * pass them on to our children. */
1521                 if (!in_initrd())
1522                         parse_initrd_timestamp(&initrd_timestamp);
1523
1524                 /* Unset some environment variables passed in from the
1525                  * kernel that don't really make sense for us. */
1526                 unsetenv("HOME");
1527                 unsetenv("TERM");
1528
1529                 /* When we are invoked by a shell, these might be set,
1530                  * but make little sense to pass on */
1531                 unsetenv("PWD");
1532                 unsetenv("SHLVL");
1533                 unsetenv("_");
1534
1535                 /* When we are invoked by a chroot-like tool such as
1536                  * nspawn, these might be set, but make little sense
1537                  * to pass on */
1538                 unsetenv("USER");
1539                 unsetenv("LOGNAME");
1540
1541                 /* We suppress the socket activation env vars, as
1542                  * we'll try to match *any* open fd to units if
1543                  * possible. */
1544                 unsetenv("LISTEN_FDS");
1545                 unsetenv("LISTEN_PID");
1546
1547                 /* All other variables are left as is, so that clients
1548                  * can still read them via /proc/1/environ */
1549         }
1550
1551         /* Move out of the way, so that we won't block unmounts */
1552         assert_se(chdir("/")  == 0);
1553
1554         if (arg_running_as == SYSTEMD_SYSTEM) {
1555                 /* Become a session leader if we aren't one yet. */
1556                 setsid();
1557
1558                 /* Disable the umask logic */
1559                 umask(0);
1560         }
1561
1562         /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
1563         dbus_connection_set_change_sigpipe(FALSE);
1564
1565         /* Reset the console, but only if this is really init and we
1566          * are freshly booted */
1567         if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN)
1568                 console_setup(getpid() == 1 && !skip_setup);
1569
1570         /* Open the logging devices, if possible and necessary */
1571         log_open();
1572
1573         /* Make sure we leave a core dump without panicing the
1574          * kernel. */
1575         if (getpid() == 1) {
1576                 install_crash_handler();
1577
1578                 r = mount_cgroup_controllers(arg_join_controllers);
1579                 if (r < 0)
1580                         goto finish;
1581         }
1582
1583         if (arg_running_as == SYSTEMD_SYSTEM) {
1584                 const char *virtualization = NULL;
1585
1586                 log_info(PACKAGE_STRING " running in system mode. (" SYSTEMD_FEATURES ")");
1587
1588                 detect_virtualization(&virtualization);
1589                 if (virtualization)
1590                         log_info("Detected virtualization '%s'.", virtualization);
1591
1592                 if (in_initrd())
1593                         log_info("Running in initial RAM disk.");
1594
1595         } else
1596                 log_debug(PACKAGE_STRING " running in user mode. (" SYSTEMD_FEATURES ")");
1597
1598         if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1599                 locale_setup();
1600
1601                 if (arg_show_status || plymouth_running())
1602                         status_welcome();
1603
1604 #ifdef HAVE_KMOD
1605                 kmod_setup();
1606 #endif
1607                 hostname_setup();
1608                 machine_id_setup();
1609                 loopback_setup();
1610
1611                 test_mtab();
1612                 test_usr();
1613                 test_cgroups();
1614         }
1615
1616         if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1617                 watchdog_set_timeout(&arg_runtime_watchdog);
1618
1619         if (arg_timer_slack_nsec != (nsec_t) -1)
1620                 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1621                         log_error("Failed to adjust timer slack: %m");
1622
1623         if (arg_capability_bounding_set_drop) {
1624                 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1625                 if (r < 0) {
1626                         log_error("Failed to drop capability bounding set: %s", strerror(-r));
1627                         goto finish;
1628                 }
1629                 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1630                 if (r < 0) {
1631                         log_error("Failed to drop capability bounding set of usermode helpers: %s", strerror(-r));
1632                         goto finish;
1633                 }
1634         }
1635
1636         if (arg_running_as == SYSTEMD_USER) {
1637                 /* Become reaper of our children */
1638                 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1639                         log_warning("Failed to make us a subreaper: %m");
1640                         if (errno == EINVAL)
1641                                 log_info("Perhaps the kernel version is too old (< 3.4?)");
1642                 }
1643         }
1644
1645         if (arg_running_as == SYSTEMD_SYSTEM)
1646                 bump_rlimit_nofile(&saved_rlimit_nofile);
1647
1648         r = manager_new(arg_running_as, &m);
1649         if (r < 0) {
1650                 log_error("Failed to allocate manager object: %s", strerror(-r));
1651                 goto finish;
1652         }
1653
1654         m->confirm_spawn = arg_confirm_spawn;
1655         m->default_std_output = arg_default_std_output;
1656         m->default_std_error = arg_default_std_error;
1657         m->runtime_watchdog = arg_runtime_watchdog;
1658         m->shutdown_watchdog = arg_shutdown_watchdog;
1659
1660         manager_set_default_rlimits(m, arg_default_rlimit);
1661
1662         if (dual_timestamp_is_set(&initrd_timestamp))
1663                 m->initrd_timestamp = initrd_timestamp;
1664
1665         if (arg_default_controllers)
1666                 manager_set_default_controllers(m, arg_default_controllers);
1667
1668         manager_set_show_status(m, arg_show_status);
1669
1670         /* Remember whether we should queue the default job */
1671         queue_default_job = !serialization || arg_switched_root;
1672
1673         before_startup = now(CLOCK_MONOTONIC);
1674
1675         r = manager_startup(m, serialization, fds);
1676         if (r < 0)
1677                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1678
1679         /* This will close all file descriptors that were opened, but
1680          * not claimed by any unit. */
1681         fdset_free(fds);
1682
1683         if (serialization) {
1684                 fclose(serialization);
1685                 serialization = NULL;
1686         }
1687
1688         if (queue_default_job) {
1689                 DBusError error;
1690                 Unit *target = NULL;
1691                 Job *default_unit_job;
1692
1693                 dbus_error_init(&error);
1694
1695                 log_debug("Activating default unit: %s", arg_default_unit);
1696
1697                 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1698                 if (r < 0) {
1699                         log_error("Failed to load default target: %s", bus_error(&error, r));
1700                         dbus_error_free(&error);
1701                 } else if (target->load_state == UNIT_ERROR)
1702                         log_error("Failed to load default target: %s", strerror(-target->load_error));
1703                 else if (target->load_state == UNIT_MASKED)
1704                         log_error("Default target masked.");
1705
1706                 if (!target || target->load_state != UNIT_LOADED) {
1707                         log_info("Trying to load rescue target...");
1708
1709                         r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1710                         if (r < 0) {
1711                                 log_error("Failed to load rescue target: %s", bus_error(&error, r));
1712                                 dbus_error_free(&error);
1713                                 goto finish;
1714                         } else if (target->load_state == UNIT_ERROR) {
1715                                 log_error("Failed to load rescue target: %s", strerror(-target->load_error));
1716                                 goto finish;
1717                         } else if (target->load_state == UNIT_MASKED) {
1718                                 log_error("Rescue target masked.");
1719                                 goto finish;
1720                         }
1721                 }
1722
1723                 assert(target->load_state == UNIT_LOADED);
1724
1725                 if (arg_action == ACTION_TEST) {
1726                         printf("-> By units:\n");
1727                         manager_dump_units(m, stdout, "\t");
1728                 }
1729
1730                 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1731                 if (r == -EPERM) {
1732                         log_error("Default target could not be isolated, starting instead: %s", bus_error(&error, r));
1733                         dbus_error_free(&error);
1734
1735                         r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1736                         if (r < 0) {
1737                                 log_error("Failed to start default target: %s", bus_error(&error, r));
1738                                 dbus_error_free(&error);
1739                                 goto finish;
1740                         }
1741                 } else if (r < 0) {
1742                         log_error("Failed to isolate default target: %s", bus_error(&error, r));
1743                         dbus_error_free(&error);
1744                         goto finish;
1745                 }
1746
1747                 m->default_unit_job_id = default_unit_job->id;
1748
1749                 after_startup = now(CLOCK_MONOTONIC);
1750                 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1751                          "Loaded units and determined initial transaction in %s.",
1752                          format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 0));
1753
1754                 if (arg_action == ACTION_TEST) {
1755                         printf("-> By jobs:\n");
1756                         manager_dump_jobs(m, stdout, "\t");
1757                         retval = EXIT_SUCCESS;
1758                         goto finish;
1759                 }
1760         }
1761
1762         for (;;) {
1763                 r = manager_loop(m);
1764                 if (r < 0) {
1765                         log_error("Failed to run mainloop: %s", strerror(-r));
1766                         goto finish;
1767                 }
1768
1769                 switch (m->exit_code) {
1770
1771                 case MANAGER_EXIT:
1772                         retval = EXIT_SUCCESS;
1773                         log_debug("Exit.");
1774                         goto finish;
1775
1776                 case MANAGER_RELOAD:
1777                         log_info("Reloading.");
1778                         r = manager_reload(m);
1779                         if (r < 0)
1780                                 log_error("Failed to reload: %s", strerror(-r));
1781                         break;
1782
1783                 case MANAGER_REEXECUTE:
1784
1785                         if (prepare_reexecute(m, &serialization, &fds, true) < 0)
1786                                 goto finish;
1787
1788                         reexecute = true;
1789                         log_notice("Reexecuting.");
1790                         goto finish;
1791
1792                 case MANAGER_SWITCH_ROOT:
1793                         /* Steal the switch root parameters */
1794                         switch_root_dir = m->switch_root;
1795                         switch_root_init = m->switch_root_init;
1796                         m->switch_root = m->switch_root_init = NULL;
1797
1798                         if (!switch_root_init)
1799                                 if (prepare_reexecute(m, &serialization, &fds, false) < 0)
1800                                         goto finish;
1801
1802                         reexecute = true;
1803                         log_notice("Switching root.");
1804                         goto finish;
1805
1806                 case MANAGER_REBOOT:
1807                 case MANAGER_POWEROFF:
1808                 case MANAGER_HALT:
1809                 case MANAGER_KEXEC: {
1810                         static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1811                                 [MANAGER_REBOOT] = "reboot",
1812                                 [MANAGER_POWEROFF] = "poweroff",
1813                                 [MANAGER_HALT] = "halt",
1814                                 [MANAGER_KEXEC] = "kexec"
1815                         };
1816
1817                         assert_se(shutdown_verb = table[m->exit_code]);
1818                         arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1819
1820                         log_notice("Shutting down.");
1821                         goto finish;
1822                 }
1823
1824                 default:
1825                         assert_not_reached("Unknown exit code.");
1826                 }
1827         }
1828
1829 finish:
1830         if (m)
1831                 manager_free(m);
1832
1833         for (j = 0; j < RLIMIT_NLIMITS; j++)
1834                 free(arg_default_rlimit[j]);
1835
1836         free(arg_default_unit);
1837         strv_free(arg_default_controllers);
1838         free_join_controllers();
1839
1840         dbus_shutdown();
1841         label_finish();
1842
1843         if (reexecute) {
1844                 const char **args;
1845                 unsigned i, args_size;
1846
1847                 /* Close and disarm the watchdog, so that the new
1848                  * instance can reinitialize it, but doesn't get
1849                  * rebooted while we do that */
1850                 watchdog_close(true);
1851
1852                 /* Reset the RLIMIT_NOFILE to the kernel default, so
1853                  * that the new systemd can pass the kernel default to
1854                  * its child processes */
1855                 if (saved_rlimit_nofile.rlim_cur > 0)
1856                         setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1857
1858                 if (switch_root_dir) {
1859                         /* Kill all remaining processes from the
1860                          * initrd, but don't wait for them, so that we
1861                          * can handle the SIGCHLD for them after
1862                          * deserializing. */
1863                         broadcast_signal(SIGTERM, false);
1864
1865                         /* And switch root */
1866                         r = switch_root(switch_root_dir);
1867                         if (r < 0)
1868                                 log_error("Failed to switch root, ignoring: %s", strerror(-r));
1869                 }
1870
1871                 args_size = MAX(6, argc+1);
1872                 args = newa(const char*, args_size);
1873
1874                 if (!switch_root_init) {
1875                         char sfd[16];
1876
1877                         /* First try to spawn ourselves with the right
1878                          * path, and with full serialization. We do
1879                          * this only if the user didn't specify an
1880                          * explicit init to spawn. */
1881
1882                         assert(serialization);
1883                         assert(fds);
1884
1885                         snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
1886                         char_array_0(sfd);
1887
1888                         i = 0;
1889                         args[i++] = SYSTEMD_BINARY_PATH;
1890                         if (switch_root_dir)
1891                                 args[i++] = "--switched-root";
1892                         args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1893                         args[i++] = "--deserialize";
1894                         args[i++] = sfd;
1895                         args[i++] = NULL;
1896
1897                         assert(i <= args_size);
1898                         execv(args[0], (char* const*) args);
1899                 }
1900
1901                 /* Try the fallback, if there is any, without any
1902                  * serialization. We pass the original argv[] and
1903                  * envp[]. (Well, modulo the ordering changes due to
1904                  * getopt() in argv[], and some cleanups in envp[],
1905                  * but let's hope that doesn't matter.) */
1906
1907                 if (serialization) {
1908                         fclose(serialization);
1909                         serialization = NULL;
1910                 }
1911
1912                 if (fds) {
1913                         fdset_free(fds);
1914                         fds = NULL;
1915                 }
1916
1917                 /* Reopen the console */
1918                 make_console_stdio();
1919
1920                 for (j = 1, i = 1; j < argc; j++)
1921                         args[i++] = argv[j];
1922                 args[i++] = NULL;
1923                 assert(i <= args_size);
1924
1925                 if (switch_root_init) {
1926                         args[0] = switch_root_init;
1927                         execv(args[0], (char* const*) args);
1928                         log_warning("Failed to execute configured init, trying fallback: %m");
1929                 }
1930
1931                 args[0] = "/sbin/init";
1932                 execv(args[0], (char* const*) args);
1933
1934                 if (errno == ENOENT) {
1935                         log_warning("No /sbin/init, trying fallback");
1936
1937                         args[0] = "/bin/sh";
1938                         args[1] = NULL;
1939                         execv(args[0], (char* const*) args);
1940                         log_error("Failed to execute /bin/sh, giving up: %m");
1941                 } else
1942                         log_warning("Failed to execute /sbin/init, giving up: %m");
1943         }
1944
1945         if (serialization)
1946                 fclose(serialization);
1947
1948         if (fds)
1949                 fdset_free(fds);
1950
1951         if (shutdown_verb) {
1952                 const char * command_line[] = {
1953                         SYSTEMD_SHUTDOWN_BINARY_PATH,
1954                         shutdown_verb,
1955                         NULL
1956                 };
1957                 char **env_block;
1958
1959                 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
1960                         char e[32];
1961
1962                         /* If we reboot let's set the shutdown
1963                          * watchdog and tell the shutdown binary to
1964                          * repeatedly ping it */
1965                         watchdog_set_timeout(&arg_shutdown_watchdog);
1966                         watchdog_close(false);
1967
1968                         /* Tell the binary how often to ping */
1969                         snprintf(e, sizeof(e), "WATCHDOG_USEC=%llu", (unsigned long long) arg_shutdown_watchdog);
1970                         char_array_0(e);
1971
1972                         env_block = strv_append(environ, e);
1973                 } else {
1974                         env_block = strv_copy(environ);
1975                         watchdog_close(true);
1976                 }
1977
1978                 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
1979                 free(env_block);
1980                 log_error("Failed to execute shutdown binary, freezing: %m");
1981         }
1982
1983         if (getpid() == 1)
1984                 freeze();
1985
1986         return retval;
1987 }