src/shutdown/shutdown.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2010 ProFUSION embedded systems
   4 ***/
   5
   6 #include <errno.h>
   7 #include <getopt.h>
   8 #include <linux/reboot.h>
   9 #include <stdbool.h>
  10 #include <stdlib.h>
  11 #include <sys/mman.h>
  12 #include <sys/mount.h>
  13 #include <sys/reboot.h>
  14 #include <sys/stat.h>
  15 #include <unistd.h>
  16
  17 #include "sd-daemon.h"
  18 #include "sd-messages.h"
  19
  20 #include "alloc-util.h"
  21 #include "async.h"
  22 #include "binfmt-util.h"
  23 #include "cgroup-setup.h"
  24 #include "cgroup-util.h"
  25 #include "constants.h"
  26 #include "coredump-util.h"
  27 #include "detach-dm.h"
  28 #include "detach-loopback.h"
  29 #include "detach-md.h"
  30 #include "detach-swap.h"
  31 #include "errno-util.h"
  32 #include "exec-util.h"
  33 #include "fd-util.h"
  34 #include "fileio.h"
  35 #include "getopt-defs.h"
  36 #include "initrd-util.h"
  37 #include "killall.h"
  38 #include "log.h"
  39 #include "parse-util.h"
  40 #include "process-util.h"
  41 #include "reboot-util.h"
  42 #include "rlimit-util.h"
  43 #include "signal-util.h"
  44 #include "string-util.h"
  45 #include "switch-root.h"
  46 #include "sysctl-util.h"
  47 #include "terminal-util.h"
  48 #include "umount.h"
  49 #include "virt.h"
  50 #include "watchdog.h"
  51
  52 #define SYNC_PROGRESS_ATTEMPTS 3
  53 #define SYNC_TIMEOUT_USEC (10*USEC_PER_SEC)
  54
  55 static char* arg_verb;
  56 static uint8_t arg_exit_code;
  57 static usec_t arg_timeout = DEFAULT_TIMEOUT_USEC;
  58
  59 static int parse_argv(int argc, char *argv[]) {
  60         enum {
  61                 COMMON_GETOPT_ARGS,
  62                 SHUTDOWN_GETOPT_ARGS,
  63         };
  64
  65         static const struct option options[] = {
  66                 COMMON_GETOPT_OPTIONS,
  67                 SHUTDOWN_GETOPT_OPTIONS,
  68                 {}
  69         };
  70
  71         int c, r;
  72
  73         assert(argc >= 1);
  74         assert(argv);
  75
  76         /* Resetting to 0 forces the invocation of an internal initialization routine of getopt_long()
  77          * that checks for GNU extensions in optstring ('-' or '+' at the beginning). */
  78         optind = 0;
  79
  80         /* "-" prevents getopt from permuting argv[] and moving the verb away
  81          * from argv[1]. Our interface to initrd promises it'll be there. */
  82         while ((c = getopt_long(argc, argv, "-", options, NULL)) >= 0)
  83                 switch (c) {
  84
  85                 case ARG_LOG_LEVEL:
  86                         r = log_set_max_level_from_string(optarg);
  87                         if (r < 0)
  88                                 log_error_errno(r, "Failed to parse log level %s, ignoring: %m", optarg);
  89
  90                         break;
  91
  92                 case ARG_LOG_TARGET:
  93                         r = log_set_target_from_string(optarg);
  94                         if (r < 0)
  95                                 log_error_errno(r, "Failed to parse log target %s, ignoring: %m", optarg);
  96
  97                         break;
  98
  99                 case ARG_LOG_COLOR:
 100
 101                         if (optarg) {
 102                                 r = log_show_color_from_string(optarg);
 103                                 if (r < 0)
 104                                         log_error_errno(r, "Failed to parse log color setting %s, ignoring: %m", optarg);
 105                         } else
 106                                 log_show_color(true);
 107
 108                         break;
 109
 110                 case ARG_LOG_LOCATION:
 111                         if (optarg) {
 112                                 r = log_show_location_from_string(optarg);
 113                                 if (r < 0)
 114                                         log_error_errno(r, "Failed to parse log location setting %s, ignoring: %m", optarg);
 115                         } else
 116                                 log_show_location(true);
 117
 118                         break;
 119
 120                 case ARG_LOG_TIME:
 121
 122                         if (optarg) {
 123                                 r = log_show_time_from_string(optarg);
 124                                 if (r < 0)
 125                                         log_error_errno(r, "Failed to parse log time setting %s, ignoring: %m", optarg);
 126                         } else
 127                                 log_show_time(true);
 128
 129                         break;
 130
 131                 case ARG_EXIT_CODE:
 132                         r = safe_atou8(optarg, &arg_exit_code);
 133                         if (r < 0)
 134                                 log_error_errno(r, "Failed to parse exit code %s, ignoring: %m", optarg);
 135
 136                         break;
 137
 138                 case ARG_TIMEOUT:
 139                         r = parse_sec(optarg, &arg_timeout);
 140                         if (r < 0)
 141                                 log_error_errno(r, "Failed to parse shutdown timeout %s, ignoring: %m", optarg);
 142
 143                         break;
 144
 145                 case '\001':
 146                         if (!arg_verb)
 147                                 arg_verb = optarg;
 148                         else
 149                                 log_error("Excess arguments, ignoring");
 150                         break;
 151
 152                 case '?':
 153                         return -EINVAL;
 154
 155                 default:
 156                         assert_not_reached();
 157                 }
 158
 159         if (!arg_verb)
 160                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 161                                        "Verb argument missing.");
 162
 163         return 0;
 164 }
 165
 166 static int switch_root_initramfs(void) {
 167         /* Do not detach the old root, because /run/initramfs/shutdown needs to access it.
 168          *
 169          * Disable sync() during switch-root, we after all sync'ed here plenty, and a dumb sync (as opposed
 170          * to the "smart" sync() we did here that looks at progress parameters) would defeat much of our
 171          * efforts here. As the new root will be /run/initramfs/, it is not necessary to mount /run/
 172          * recursively. */
 173         return switch_root(
 174                         /* new_root= */ "/run/initramfs",
 175                         /* old_root_after= */ "/oldroot",
 176                         /* flags= */ SWITCH_ROOT_DONT_SYNC);
 177 }
 178
 179 /* Read the following fields from /proc/meminfo:
 180  *
 181  *  NFS_Unstable
 182  *  Writeback
 183  *  Dirty
 184  *
 185  * Return true if the sum of these fields is greater than the previous
 186  * value input. For all other issues, report the failure and indicate that
 187  * the sync is not making progress.
 188  */
 189 static int sync_making_progress(unsigned long long *prev_dirty) {
 190         _cleanup_fclose_ FILE *f = NULL;
 191         unsigned long long val = 0;
 192         int ret;
 193
 194         f = fopen("/proc/meminfo", "re");
 195         if (!f)
 196                 return log_warning_errno(errno, "Failed to open /proc/meminfo: %m");
 197
 198         for (;;) {
 199                 _cleanup_free_ char *line = NULL;
 200                 unsigned long long ull = 0;
 201                 int q;
 202
 203                 q = read_line(f, LONG_LINE_MAX, &line);
 204                 if (q < 0)
 205                         return log_warning_errno(q, "Failed to parse /proc/meminfo: %m");
 206                 if (q == 0)
 207                         break;
 208
 209                 if (!first_word(line, "NFS_Unstable:") && !first_word(line, "Writeback:") && !first_word(line, "Dirty:"))
 210                         continue;
 211
 212                 errno = 0;
 213                 if (sscanf(line, "%*s %llu %*s", &ull) != 1) {
 214                         if (errno != 0)
 215                                 log_warning_errno(errno, "Failed to parse /proc/meminfo: %m");
 216                         else
 217                                 log_warning("Failed to parse /proc/meminfo");
 218
 219                         return false;
 220                 }
 221
 222                 val += ull;
 223         }
 224
 225         ret = *prev_dirty > val;
 226         *prev_dirty = val;
 227         return ret;
 228 }
 229
 230 static void sync_with_progress(void) {
 231         unsigned long long dirty = ULLONG_MAX;
 232         unsigned checks;
 233         pid_t pid;
 234         int r;
 235
 236         BLOCK_SIGNALS(SIGCHLD);
 237
 238         /* Due to the possibility of the sync operation hanging, we fork a child process and monitor
 239          * the progress. If the timeout lapses, the assumption is that the particular sync stalled. */
 240
 241         r = asynchronous_sync(&pid);
 242         if (r < 0) {
 243                 log_error_errno(r, "Failed to fork sync(): %m");
 244                 return;
 245         }
 246
 247         log_info("Syncing filesystems and block devices.");
 248
 249         /* Start monitoring the sync operation. If more than
 250          * SYNC_PROGRESS_ATTEMPTS lapse without progress being made,
 251          * we assume that the sync is stalled */
 252         for (checks = 0; checks < SYNC_PROGRESS_ATTEMPTS; checks++) {
 253                 r = wait_for_terminate_with_timeout(pid, SYNC_TIMEOUT_USEC);
 254                 if (r == 0)
 255                         /* Sync finished without error.
 256                          * (The sync itself does not return an error code) */
 257                         return;
 258                 else if (r == -ETIMEDOUT) {
 259                         /* Reset the check counter if the "Dirty" value is
 260                          * decreasing */
 261                         if (sync_making_progress(&dirty) > 0)
 262                                 checks = 0;
 263                 } else {
 264                         log_error_errno(r, "Failed to sync filesystems and block devices: %m");
 265                         return;
 266                 }
 267         }
 268
 269         /* Only reached in the event of a timeout. We should issue a kill
 270          * to the stray process. */
 271         log_error("Syncing filesystems and block devices - timed out, issuing SIGKILL to PID "PID_FMT".", pid);
 272         (void) kill(pid, SIGKILL);
 273 }
 274
 275 static int read_current_sysctl_printk_log_level(void) {
 276         _cleanup_free_ char *sysctl_printk_vals = NULL, *sysctl_printk_curr = NULL;
 277         int current_lvl;
 278         const char *p;
 279         int r;
 280
 281         r = sysctl_read("kernel/printk", &sysctl_printk_vals);
 282         if (r < 0)
 283                 return log_debug_errno(r, "Cannot read sysctl kernel.printk: %m");
 284
 285         p = sysctl_printk_vals;
 286         r = extract_first_word(&p, &sysctl_printk_curr, NULL, 0);
 287         if (r < 0)
 288                 return log_debug_errno(r, "Failed to split out kernel printk priority: %m");
 289         if (r == 0)
 290                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Short read while reading kernel.printk sysctl");
 291
 292         r = safe_atoi(sysctl_printk_curr, &current_lvl);
 293         if (r < 0)
 294                 return log_debug_errno(r, "Failed to parse kernel.printk sysctl: %s", sysctl_printk_vals);
 295
 296         return current_lvl;
 297 }
 298
 299 static void bump_sysctl_printk_log_level(int min_level) {
 300         int current_lvl, r;
 301
 302         /* Set the logging level to be able to see messages with log level smaller or equal to min_level */
 303
 304         current_lvl = read_current_sysctl_printk_log_level();
 305         if (current_lvl < 0 || current_lvl >= min_level + 1)
 306                 return;
 307
 308         r = sysctl_writef("kernel/printk", "%i", min_level + 1);
 309         if (r < 0)
 310                 log_debug_errno(r, "Failed to bump kernel.printk to %i: %m", min_level + 1);
 311 }
 312
 313 static void init_watchdog(void) {
 314         const char *s;
 315         int r;
 316
 317         s = getenv("WATCHDOG_DEVICE");
 318         if (s) {
 319                 r = watchdog_set_device(s);
 320                 if (r < 0)
 321                         log_warning_errno(r, "Failed to set watchdog device to %s, ignoring: %m", s);
 322         }
 323
 324         s = getenv("WATCHDOG_USEC");
 325         if (s) {
 326                 usec_t usec;
 327
 328                 r = safe_atou64(s, &usec);
 329                 if (r < 0)
 330                         log_warning_errno(r, "Failed to parse watchdog timeout '%s', ignoring: %m", s);
 331                 else
 332                         (void) watchdog_setup(usec);
 333         }
 334 }
 335
 336 static void notify_supervisor(void) {
 337         /* Notify VMM/container manager of the desired mode of reboot and the boot parameter */
 338         _cleanup_free_ char *reboot_parameter = NULL;
 339         int r;
 340
 341         r = read_reboot_parameter(&reboot_parameter);
 342         if (r < 0 && r != -ENOENT)
 343                 log_debug_errno(r, "Failed to read reboot parameter, ignoring: %m");
 344
 345         if (reboot_parameter)
 346                 (void) sd_notifyf(/* unset_environment= */ false,
 347                                   "X_SYSTEMD_SHUTDOWN=%s\n"
 348                                   "X_SYSTEMD_REBOOT_PARAMETER=%s",
 349                                   arg_verb, reboot_parameter);
 350         else
 351                 (void) sd_notifyf(/* unset_environment= */ false,
 352                                   "X_SYSTEMD_SHUTDOWN=%s",
 353                                   arg_verb);
 354 }
 355
 356 int main(int argc, char *argv[]) {
 357         static const char* const dirs[] = {
 358                 SYSTEM_SHUTDOWN_PATH,
 359                 NULL
 360         };
 361         _cleanup_free_ char *cgroup = NULL;
 362         char *arguments[3];
 363         int cmd, r;
 364
 365         /* Close random fds we might have get passed, just for paranoia, before we open any new fds, for
 366          * example for logging. After all this tool's purpose is about detaching any pinned resources, and
 367          * open file descriptors are the primary way to pin resources. Note that we don't really expect any
 368          * fds to be passed here. */
 369         (void) close_all_fds(NULL, 0);
 370
 371         /* The log target defaults to console, but the original systemd process will pass its log target in through a
 372          * command line argument, which will override this default. Also, ensure we'll never log to the journal or
 373          * syslog, as these logging daemons are either already dead or will die very soon. */
 374
 375         log_set_target(LOG_TARGET_CONSOLE);
 376         log_set_prohibit_ipc(true);
 377         log_parse_environment();
 378
 379         if (getpid_cached() == 1)
 380                 log_set_always_reopen_console(true);
 381
 382         r = parse_argv(argc, argv);
 383         if (r < 0)
 384                 goto error;
 385
 386         log_open();
 387
 388         umask(0022);
 389
 390         if (getpid_cached() != 1) {
 391                 r = log_error_errno(SYNTHETIC_ERRNO(EPERM), "Not executed by init (PID 1).");
 392                 goto error;
 393         }
 394
 395         if (streq(arg_verb, "reboot"))
 396                 cmd = RB_AUTOBOOT;
 397         else if (streq(arg_verb, "poweroff"))
 398                 cmd = RB_POWER_OFF;
 399         else if (streq(arg_verb, "halt"))
 400                 cmd = RB_HALT_SYSTEM;
 401         else if (streq(arg_verb, "kexec"))
 402                 cmd = LINUX_REBOOT_CMD_KEXEC;
 403         else if (streq(arg_verb, "exit"))
 404                 cmd = 0; /* ignored, just checking that arg_verb is valid */
 405         else {
 406                 r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown action '%s'.", arg_verb);
 407                 goto error;
 408         }
 409
 410         /* This is primarily useful when running systemd in a VM, as it provides the user running the VM with
 411          * a mechanism to pick up systemd's exit status in the VM. Note that we execute this as early as
 412          * possible since otherwise we might shut down the VM before the AF_VSOCK buffers have been flushed.
 413          * While this doesn't guarantee the message will arrive, in practice we do enough work after this
 414          * that the message should always arrive on the host */
 415         (void) sd_notifyf(0, "EXIT_STATUS=%i", arg_exit_code);
 416
 417         (void) cg_get_root_path(&cgroup);
 418         bool in_container = detect_container() > 0;
 419
 420         /* If the logging messages are going to KMSG, and if we are not running from a container, then try to
 421          * update the sysctl kernel.printk current value in order to see "info" messages; This current log
 422          * level is not updated if already big enough.
 423          */
 424         if (!in_container &&
 425             IN_SET(log_get_target(),
 426                    LOG_TARGET_AUTO,
 427                    LOG_TARGET_JOURNAL_OR_KMSG,
 428                    LOG_TARGET_SYSLOG_OR_KMSG,
 429                    LOG_TARGET_KMSG))
 430                 bump_sysctl_printk_log_level(LOG_WARNING);
 431
 432         init_watchdog();
 433
 434         /* Lock us into memory */
 435         (void) mlockall(MCL_CURRENT|MCL_FUTURE);
 436
 437         /* We need to make mounts private so that we can MS_MOVE in unmount_all(). Kernel does not allow
 438          * MS_MOVE when parent mountpoints have shared propagation. */
 439         if (mount(NULL, "/", NULL, MS_REC|MS_PRIVATE, NULL) < 0)
 440                 log_warning_errno(errno, "Failed to make mounts private, ignoring: %m");
 441
 442         /* Synchronize everything that is not written to disk yet at this point already. This is a good idea so that
 443          * slow IO is processed here already and the final process killing spree is not impacted by processes
 444          * desperately trying to sync IO to disk within their timeout. Do not remove this sync, data corruption will
 445          * result. */
 446         if (!in_container)
 447                 sync_with_progress();
 448
 449         disable_coredumps();
 450         disable_binfmt();
 451
 452         log_info("Sending SIGTERM to remaining processes...");
 453         broadcast_signal(SIGTERM, true, true, arg_timeout);
 454
 455         log_info("Sending SIGKILL to remaining processes...");
 456         broadcast_signal(SIGKILL, true, false, arg_timeout);
 457
 458         bool need_umount = !in_container, need_swapoff = !in_container, need_loop_detach = !in_container,
 459              need_dm_detach = !in_container, need_md_detach = !in_container, can_initrd, last_try = false;
 460         can_initrd = !in_container && !in_initrd() && access("/run/initramfs/shutdown", X_OK) == 0;
 461
 462         /* Unmount all mountpoints, swaps, and loopback devices */
 463         for (;;) {
 464                 bool changed = false;
 465
 466                 (void) watchdog_ping();
 467
 468                 /* Let's trim the cgroup tree on each iteration so that we leave an empty cgroup tree around,
 469                  * so that container managers get a nice notify event when we are down */
 470                 if (cgroup)
 471                         (void) cg_trim(SYSTEMD_CGROUP_CONTROLLER, cgroup, false);
 472
 473                 if (need_umount) {
 474                         log_info("Unmounting file systems.");
 475                         r = umount_all(&changed, last_try);
 476                         if (r == 0) {
 477                                 need_umount = false;
 478                                 log_info("All filesystems unmounted.");
 479                         } else if (r > 0)
 480                                 log_info("Not all file systems unmounted, %d left.", r);
 481                         else
 482                                 log_error_errno(r, "Unable to unmount file systems: %m");
 483                 }
 484
 485                 if (need_swapoff) {
 486                         log_info("Deactivating swaps.");
 487                         r = swapoff_all(&changed);
 488                         if (r == 0) {
 489                                 need_swapoff = false;
 490                                 log_info("All swaps deactivated.");
 491                         } else if (r > 0)
 492                                 log_info("Not all swaps deactivated, %d left.", r);
 493                         else
 494                                 log_error_errno(r, "Unable to deactivate swaps: %m");
 495                 }
 496
 497                 if (need_loop_detach) {
 498                         log_info("Detaching loop devices.");
 499                         r = loopback_detach_all(&changed, last_try);
 500                         if (r == 0) {
 501                                 need_loop_detach = false;
 502                                 log_info("All loop devices detached.");
 503                         } else if (r > 0)
 504                                 log_info("Not all loop devices detached, %d left.", r);
 505                         else
 506                                 log_error_errno(r, "Unable to detach loop devices: %m");
 507                 }
 508
 509                 if (need_md_detach) {
 510                         log_info("Stopping MD devices.");
 511                         r = md_detach_all(&changed, last_try);
 512                         if (r == 0) {
 513                                 need_md_detach = false;
 514                                 log_info("All MD devices stopped.");
 515                         } else if (r > 0)
 516                                 log_info("Not all MD devices stopped, %d left.", r);
 517                         else
 518                                 log_error_errno(r, "Unable to stop MD devices: %m");
 519                 }
 520
 521                 if (need_dm_detach) {
 522                         log_info("Detaching DM devices.");
 523                         r = dm_detach_all(&changed, last_try);
 524                         if (r == 0) {
 525                                 need_dm_detach = false;
 526                                 log_info("All DM devices detached.");
 527                         } else if (r > 0)
 528                                 log_info("Not all DM devices detached, %d left.", r);
 529                         else
 530                                 log_error_errno(r, "Unable to detach DM devices: %m");
 531                 }
 532
 533                 if (!need_umount && !need_swapoff && !need_loop_detach && !need_dm_detach
 534                             && !need_md_detach) {
 535                         log_info("All filesystems, swaps, loop devices, MD devices and DM devices detached.");
 536                         /* Yay, done */
 537                         break;
 538                 }
 539
 540                 if (!changed && !last_try && !can_initrd) {
 541                         /* There are things we cannot get rid of. Loop one more time in which we will log
 542                          * with higher priority to inform the user. Note that we don't need to do this if
 543                          * there is an initrd to switch to, because that one is likely to get rid of the
 544                          * remaining mounts. If not, it will log about them. */
 545                         last_try = true;
 546                         continue;
 547                 }
 548
 549                 /* If in this iteration we didn't manage to unmount/deactivate anything, we simply give up */
 550                 if (!changed) {
 551                         log_info("Cannot finalize remaining%s%s%s%s%s continuing.",
 552                                  need_umount ? " file systems," : "",
 553                                  need_swapoff ? " swap devices," : "",
 554                                  need_loop_detach ? " loop devices," : "",
 555                                  need_dm_detach ? " DM devices," : "",
 556                                  need_md_detach ? " MD devices," : "");
 557                         break;
 558                 }
 559
 560                 log_debug("Couldn't finalize remaining %s%s%s%s%s trying again.",
 561                           need_umount ? " file systems," : "",
 562                           need_swapoff ? " swap devices," : "",
 563                           need_loop_detach ? " loop devices," : "",
 564                           need_dm_detach ? " DM devices," : "",
 565                           need_md_detach ? " MD devices," : "");
 566         }
 567
 568         /* We're done with the watchdog. Note that the watchdog is explicitly not stopped here. It remains
 569          * active to guard against any issues during the rest of the shutdown sequence. */
 570         watchdog_free_device();
 571
 572         arguments[0] = NULL; /* Filled in by execute_directories(), when needed */
 573         arguments[1] = arg_verb;
 574         arguments[2] = NULL;
 575         (void) execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, arguments, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
 576
 577         (void) rlimit_nofile_safe();
 578
 579         if (can_initrd) {
 580                 r = switch_root_initramfs();
 581                 if (r >= 0) {
 582                         argv[0] = (char*) "/shutdown";
 583
 584                         (void) setsid();
 585                         (void) make_console_stdio();
 586
 587                         log_info("Successfully changed into root pivot.\n"
 588                                  "Returning to initrd...");
 589
 590                         execv("/shutdown", argv);
 591                         log_error_errno(errno, "Failed to execute shutdown binary: %m");
 592                 } else
 593                         log_error_errno(r, "Failed to switch root to \"/run/initramfs\": %m");
 594         }
 595
 596         if (need_umount || need_swapoff || need_loop_detach || need_dm_detach || need_md_detach)
 597                 log_error("Unable to finalize remaining%s%s%s%s%s ignoring.",
 598                           need_umount ? " file systems," : "",
 599                           need_swapoff ? " swap devices," : "",
 600                           need_loop_detach ? " loop devices," : "",
 601                           need_dm_detach ? " DM devices," : "",
 602                           need_md_detach ? " MD devices," : "");
 603
 604         /* The kernel will automatically flush ATA disks and suchlike on reboot(), but the file systems need
 605          * to be sync'ed explicitly in advance. So let's do this here, but not needlessly slow down
 606          * containers. Note that we sync'ed things already once above, but we did some more work since then
 607          * which might have caused IO, hence let's do it once more. Do not remove this sync, data corruption
 608          * will result. */
 609         if (!in_container)
 610                 sync_with_progress();
 611
 612         notify_supervisor();
 613
 614         if (streq(arg_verb, "exit")) {
 615                 if (in_container) {
 616                         log_info("Exiting container.");
 617                         return arg_exit_code;
 618                 }
 619
 620                 cmd = RB_POWER_OFF; /* We cannot exit() on the host, fallback on another method. */
 621         }
 622
 623         switch (cmd) {
 624
 625         case LINUX_REBOOT_CMD_KEXEC:
 626
 627                 if (!in_container) {
 628                         /* We cheat and exec kexec to avoid doing all its work */
 629                         log_info("Rebooting with kexec.");
 630
 631                         r = safe_fork("(sd-kexec)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_LOG|FORK_WAIT, NULL);
 632                         if (r == 0) {
 633                                 const char * const args[] = {
 634                                         KEXEC, "-e", NULL
 635                                 };
 636
 637                                 /* Child */
 638
 639                                 execv(args[0], (char * const *) args);
 640                                 log_debug_errno(errno, "Failed to execute '" KEXEC "' binary, proceeding with reboot(RB_KEXEC): %m");
 641
 642                                 /* execv failed (kexec binary missing?), so try simply reboot(RB_KEXEC) */
 643                                 (void) reboot(cmd);
 644                                 _exit(EXIT_FAILURE);
 645                         }
 646
 647                         /* If we are still running, then the kexec can't have worked, let's fall through */
 648                 }
 649
 650                 cmd = RB_AUTOBOOT;
 651                 _fallthrough_;
 652
 653         case RB_AUTOBOOT:
 654                 (void) reboot_with_parameter(REBOOT_LOG);
 655                 log_info("Rebooting.");
 656                 break;
 657
 658         case RB_POWER_OFF:
 659                 log_info("Powering off.");
 660                 break;
 661
 662         case RB_HALT_SYSTEM:
 663                 log_info("Halting system.");
 664                 break;
 665
 666         default:
 667                 assert_not_reached();
 668         }
 669
 670         (void) reboot(cmd);
 671         if (ERRNO_IS_PRIVILEGE(errno) && in_container) {
 672                 /* If we are in a container, and we lacked CAP_SYS_BOOT just exit, this will kill our
 673                  * container for good. */
 674                 log_info("Exiting container.");
 675                 return EXIT_SUCCESS;
 676         }
 677
 678         r = log_error_errno(errno, "Failed to invoke reboot(): %m");
 679
 680   error:
 681         log_struct_errno(LOG_EMERG, r,
 682                          LOG_MESSAGE("Critical error while doing system shutdown: %m"),
 683                          "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_ERROR_STR);
 684         freeze();
 685 }