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