src/core/main.c

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