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