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