src/shared/sleep-config.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2018 Dell Inc.
   4 ***/
   5
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <linux/fs.h>
   9 #include <stdbool.h>
  10 #include <stddef.h>
  11 #include <sys/ioctl.h>
  12 #include <sys/stat.h>
  13 #include <sys/types.h>
  14 #include <syslog.h>
  15 #include <unistd.h>
  16
  17 #include "alloc-util.h"
  18 #include "blockdev-util.h"
  19 #include "btrfs-util.h"
  20 #include "conf-parser.h"
  21 #include "def.h"
  22 #include "env-util.h"
  23 #include "errno-util.h"
  24 #include "fd-util.h"
  25 #include "fileio.h"
  26 #include "log.h"
  27 #include "macro.h"
  28 #include "parse-util.h"
  29 #include "path-util.h"
  30 #include "sleep-config.h"
  31 #include "stdio-util.h"
  32 #include "string-util.h"
  33 #include "strv.h"
  34 #include "time-util.h"
  35
  36 int parse_sleep_config(SleepConfig **ret_sleep_config) {
  37         _cleanup_(free_sleep_configp) SleepConfig *sc;
  38         int allow_suspend = -1, allow_hibernate = -1,
  39             allow_s2h = -1, allow_hybrid_sleep = -1;
  40
  41         sc = new0(SleepConfig, 1);
  42         if (!sc)
  43                 return log_oom();
  44
  45         const ConfigTableItem items[] = {
  46                 { "Sleep", "AllowSuspend",              config_parse_tristate, 0, &allow_suspend },
  47                 { "Sleep", "AllowHibernation",          config_parse_tristate, 0, &allow_hibernate },
  48                 { "Sleep", "AllowSuspendThenHibernate", config_parse_tristate, 0, &allow_s2h },
  49                 { "Sleep", "AllowHybridSleep",          config_parse_tristate, 0, &allow_hybrid_sleep },
  50
  51                 { "Sleep", "SuspendMode",               config_parse_strv, 0, &sc->suspend_modes  },
  52                 { "Sleep", "SuspendState",              config_parse_strv, 0, &sc->suspend_states },
  53                 { "Sleep", "HibernateMode",             config_parse_strv, 0, &sc->hibernate_modes  },
  54                 { "Sleep", "HibernateState",            config_parse_strv, 0, &sc->hibernate_states },
  55                 { "Sleep", "HybridSleepMode",           config_parse_strv, 0, &sc->hybrid_modes  },
  56                 { "Sleep", "HybridSleepState",          config_parse_strv, 0, &sc->hybrid_states },
  57
  58                 { "Sleep", "HibernateDelaySec",         config_parse_sec,  0, &sc->hibernate_delay_sec},
  59                 {}
  60         };
  61
  62         (void) config_parse_many_nulstr(
  63                         PKGSYSCONFDIR "/sleep.conf",
  64                         CONF_PATHS_NULSTR("systemd/sleep.conf.d"),
  65                         "Sleep\0",
  66                         config_item_table_lookup, items,
  67                         CONFIG_PARSE_WARN,
  68                         NULL,
  69                         NULL);
  70
  71         /* use default values unless set */
  72         sc->allow_suspend = allow_suspend != 0;
  73         sc->allow_hibernate = allow_hibernate != 0;
  74         sc->allow_hybrid_sleep = allow_hybrid_sleep >= 0 ? allow_hybrid_sleep
  75                 : (allow_suspend != 0 && allow_hibernate != 0);
  76         sc->allow_s2h = allow_s2h >= 0 ? allow_s2h
  77                 : (allow_suspend != 0 && allow_hibernate != 0);
  78
  79         if (!sc->suspend_states)
  80                 sc->suspend_states = strv_new("mem", "standby", "freeze");
  81         if (!sc->hibernate_modes)
  82                 sc->hibernate_modes = strv_new("platform", "shutdown");
  83         if (!sc->hibernate_states)
  84                 sc->hibernate_states = strv_new("disk");
  85         if (!sc->hybrid_modes)
  86                 sc->hybrid_modes = strv_new("suspend", "platform", "shutdown");
  87         if (!sc->hybrid_states)
  88                 sc->hybrid_states = strv_new("disk");
  89         if (sc->hibernate_delay_sec == 0)
  90                 sc->hibernate_delay_sec = 2 * USEC_PER_HOUR;
  91
  92         /* ensure values set for all required fields */
  93         if (!sc->suspend_states || !sc->hibernate_modes
  94             || !sc->hibernate_states || !sc->hybrid_modes || !sc->hybrid_states)
  95                 return log_oom();
  96
  97         *ret_sleep_config = TAKE_PTR(sc);
  98
  99         return 0;
 100 }
 101
 102 int can_sleep_state(char **types) {
 103         char **type;
 104         int r;
 105         _cleanup_free_ char *p = NULL;
 106
 107         if (strv_isempty(types))
 108                 return true;
 109
 110         /* If /sys is read-only we cannot sleep */
 111         if (access("/sys/power/state", W_OK) < 0) {
 112                 log_debug_errno(errno, "/sys/power/state is not writable, cannot sleep: %m");
 113                 return false;
 114         }
 115
 116         r = read_one_line_file("/sys/power/state", &p);
 117         if (r < 0) {
 118                 log_debug_errno(r, "Failed to read /sys/power/state, cannot sleep: %m");
 119                 return false;
 120         }
 121
 122         STRV_FOREACH(type, types) {
 123                 const char *word, *state;
 124                 size_t l, k;
 125
 126                 k = strlen(*type);
 127                 FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state)
 128                         if (l == k && memcmp(word, *type, l) == 0) {
 129                                 log_debug("Sleep mode \"%s\" is supported by the kernel.", *type);
 130                                 return true;
 131                         }
 132         }
 133
 134         if (DEBUG_LOGGING) {
 135                 _cleanup_free_ char *t = strv_join(types, "/");
 136                 log_debug("Sleep mode %s not supported by the kernel, sorry.", strnull(t));
 137         }
 138         return false;
 139 }
 140
 141 int can_sleep_disk(char **types) {
 142         _cleanup_free_ char *p = NULL;
 143         char **type;
 144         int r;
 145
 146         if (strv_isempty(types))
 147                 return true;
 148
 149         /* If /sys is read-only we cannot sleep */
 150         if (access("/sys/power/disk", W_OK) < 0) {
 151                 log_debug_errno(errno, "/sys/power/disk is not writable: %m");
 152                 return false;
 153         }
 154
 155         r = read_one_line_file("/sys/power/disk", &p);
 156         if (r < 0) {
 157                 log_debug_errno(r, "Couldn't read /sys/power/disk: %m");
 158                 return false;
 159         }
 160
 161         STRV_FOREACH(type, types) {
 162                 const char *word, *state;
 163                 size_t l, k;
 164
 165                 k = strlen(*type);
 166                 FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state) {
 167                         if (l == k && memcmp(word, *type, l) == 0)
 168                                 return true;
 169
 170                         if (l == k + 2 &&
 171                             word[0] == '[' &&
 172                             memcmp(word + 1, *type, l - 2) == 0 &&
 173                             word[l-1] == ']')
 174                                 return true;
 175                 }
 176         }
 177
 178         return false;
 179 }
 180
 181 #define HIBERNATION_SWAP_THRESHOLD 0.98
 182
 183 SwapEntry* swap_entry_free(SwapEntry *se) {
 184         if (!se)
 185                 return NULL;
 186
 187         free(se->device);
 188         free(se->type);
 189
 190         return mfree(se);
 191 }
 192
 193 HibernateLocation* hibernate_location_free(HibernateLocation *hl) {
 194         if (!hl)
 195                 return NULL;
 196
 197         swap_entry_free(hl->swap);
 198
 199         return mfree(hl);
 200 }
 201
 202 static int swap_device_to_device_id(const SwapEntry *swap, dev_t *ret_dev) {
 203         struct stat sb;
 204         int r;
 205
 206         assert(swap);
 207         assert(swap->device);
 208         assert(swap->type);
 209
 210         r = stat(swap->device, &sb);
 211         if (r < 0)
 212                 return -errno;
 213
 214         if (streq(swap->type, "partition")) {
 215                 if (!S_ISBLK(sb.st_mode))
 216                         return -ENOTBLK;
 217
 218                 *ret_dev = sb.st_rdev;
 219                 return 0;
 220         }
 221
 222         return get_block_device(swap->device, ret_dev);
 223 }
 224
 225 /*
 226  * Attempt to calculate the swap file offset on supported filesystems. On unsupported
 227  * filesystems, a debug message is logged and ret_offset is set to UINT64_MAX.
 228  */
 229 static int calculate_swap_file_offset(const SwapEntry *swap, uint64_t *ret_offset) {
 230         _cleanup_close_ int fd = -1;
 231         _cleanup_free_ struct fiemap *fiemap = NULL;
 232         struct stat sb;
 233         int r, btrfs;
 234
 235         assert(swap);
 236         assert(swap->device);
 237         assert(streq(swap->type, "file"));
 238
 239         fd = open(swap->device, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 240         if (fd < 0)
 241                 return log_debug_errno(errno, "Failed to open swap file %s to determine on-disk offset: %m", swap->device);
 242
 243         if (fstat(fd, &sb) < 0)
 244                 return log_debug_errno(errno, "Failed to stat %s: %m", swap->device);
 245
 246         btrfs = btrfs_is_filesystem(fd);
 247         if (btrfs < 0)
 248                 return log_debug_errno(btrfs, "Error checking %s for Btrfs filesystem: %m", swap->device);
 249         if (btrfs > 0) {
 250                 log_debug("%s: detection of swap file offset on Btrfs is not supported", swap->device);
 251                 *ret_offset = UINT64_MAX;
 252                 return 0;
 253         }
 254
 255         r = read_fiemap(fd, &fiemap);
 256         if (r < 0)
 257                 return log_debug_errno(r, "Unable to read extent map for '%s': %m", swap->device);
 258
 259         *ret_offset = fiemap->fm_extents[0].fe_physical / page_size();
 260         return 0;
 261 }
 262
 263 static int read_resume_files(dev_t *ret_resume, uint64_t *ret_resume_offset) {
 264         _cleanup_free_ char *resume_str = NULL, *resume_offset_str = NULL;
 265         uint64_t resume_offset = 0;
 266         dev_t resume;
 267         int r;
 268
 269         r = read_one_line_file("/sys/power/resume", &resume_str);
 270         if (r < 0)
 271                 return log_debug_errno(r, "Error reading /sys/power/resume: %m");
 272
 273         r = parse_dev(resume_str, &resume);
 274         if (r < 0)
 275                 return log_debug_errno(r, "Error parsing /sys/power/resume device: %s: %m", resume_str);
 276
 277         r = read_one_line_file("/sys/power/resume_offset", &resume_offset_str);
 278         if (r == -ENOENT)
 279                 log_debug_errno(r, "Kernel does not support resume_offset; swap file offset detection will be skipped.");
 280         else if (r < 0)
 281                 return log_debug_errno(r, "Error reading /sys/power/resume_offset: %m");
 282         else {
 283                 r = safe_atou64(resume_offset_str, &resume_offset);
 284                 if (r < 0)
 285                         return log_debug_errno(r, "Failed to parse value in /sys/power/resume_offset \"%s\": %m", resume_offset_str);
 286         }
 287
 288         if (resume_offset > 0 && resume == 0)
 289                 log_debug("Warning: found /sys/power/resume_offset==%" PRIu64 ", but /sys/power/resume unset. Misconfiguration?",
 290                           resume_offset);
 291
 292         *ret_resume = resume;
 293         *ret_resume_offset = resume_offset;
 294
 295         return 0;
 296 }
 297
 298 /*
 299  * Determine if the HibernateLocation matches the resume= (device) and resume_offset= (file).
 300  */
 301 static bool location_is_resume_device(const HibernateLocation *location, dev_t sys_resume, uint64_t sys_offset) {
 302         if (!location)
 303                 return false;
 304
 305         return  sys_resume > 0 &&
 306                 sys_resume == location->devno &&
 307                 (sys_offset == location->offset || (sys_offset > 0 && location->offset == UINT64_MAX));
 308 }
 309
 310 /*
 311  * Attempt to find the hibernation location by parsing /proc/swaps, /sys/power/resume, and
 312  * /sys/power/resume_offset.
 313  *
 314  * Returns:
 315  *  1 - Values are set in /sys/power/resume and /sys/power/resume_offset.
 316  *      ret_hibernate_location will represent matching /proc/swap entry if identified or NULL if not.
 317  *
 318  *  0 - No values are set in /sys/power/resume and /sys/power/resume_offset.
 319         ret_hibernate_location will represent the highest priority swap with most remaining space discovered in /proc/swaps.
 320  *
 321  *  Negative value in the case of error.
 322  */
 323 int find_hibernate_location(HibernateLocation **ret_hibernate_location) {
 324         _cleanup_fclose_ FILE *f = NULL;
 325         _cleanup_(hibernate_location_freep) HibernateLocation *hibernate_location = NULL;
 326         dev_t sys_resume;
 327         uint64_t sys_offset = 0;
 328         bool resume_match = false;
 329         int r;
 330
 331         /* read the /sys/power/resume & /sys/power/resume_offset values */
 332         r = read_resume_files(&sys_resume, &sys_offset);
 333         if (r < 0)
 334                 return r;
 335
 336         f = fopen("/proc/swaps", "re");
 337         if (!f) {
 338                 log_debug_errno(errno, "Failed to open /proc/swaps: %m");
 339                 return errno == ENOENT ? -EOPNOTSUPP : -errno; /* Convert swap not supported to a recognizable error */
 340         }
 341
 342         (void) fscanf(f, "%*s %*s %*s %*s %*s\n");
 343         for (unsigned i = 1;; i++) {
 344                 _cleanup_(swap_entry_freep) SwapEntry *swap = NULL;
 345                 uint64_t swap_offset = 0;
 346                 int k;
 347
 348                 swap = new0(SwapEntry, 1);
 349                 if (!swap)
 350                         return -ENOMEM;
 351
 352                 k = fscanf(f,
 353                            "%ms "       /* device/file */
 354                            "%ms "       /* type of swap */
 355                            "%" PRIu64   /* swap size */
 356                            "%" PRIu64   /* used */
 357                            "%i\n",      /* priority */
 358                            &swap->device, &swap->type, &swap->size, &swap->used, &swap->priority);
 359                 if (k == EOF)
 360                         break;
 361                 if (k != 5) {
 362                         log_debug("Failed to parse /proc/swaps:%u, ignoring", i);
 363                         continue;
 364                 }
 365
 366                 if (streq(swap->type, "file")) {
 367                         if (endswith(swap->device, "\\040(deleted)")) {
 368                                 log_debug("Ignoring deleted swap file '%s'.", swap->device);
 369                                 continue;
 370                         }
 371
 372                         r = calculate_swap_file_offset(swap, &swap_offset);
 373                         if (r < 0)
 374                                 return r;
 375
 376                 } else if (streq(swap->type, "partition")) {
 377                         const char *fn;
 378
 379                         fn = path_startswith(swap->device, "/dev/");
 380                         if (fn && startswith(fn, "zram")) {
 381                                 log_debug("%s: ignoring zram swap", swap->device);
 382                                 continue;
 383                         }
 384
 385                 } else {
 386                         log_debug("%s: swap type %s is unsupported for hibernation, ignoring", swap->device, swap->type);
 387                         continue;
 388                 }
 389
 390                 /* prefer resume device or highest priority swap with most remaining space */
 391                 if (hibernate_location && swap->priority < hibernate_location->swap->priority) {
 392                         log_debug("%s: ignoring device with lower priority", swap->device);
 393                         continue;
 394                 }
 395                 if (hibernate_location &&
 396                     (swap->priority == hibernate_location->swap->priority
 397                      && swap->size - swap->used < hibernate_location->swap->size - hibernate_location->swap->used)) {
 398                         log_debug("%s: ignoring device with lower usable space", swap->device);
 399                         continue;
 400                 }
 401
 402                 dev_t swap_device;
 403                 r = swap_device_to_device_id(swap, &swap_device);
 404                 if (r < 0)
 405                         return log_debug_errno(r, "%s: failed to query device number: %m", swap->device);
 406
 407                 hibernate_location = hibernate_location_free(hibernate_location);
 408                 hibernate_location = new(HibernateLocation, 1);
 409                 if (!hibernate_location)
 410                         return -ENOMEM;
 411
 412                 *hibernate_location = (HibernateLocation) {
 413                         .devno = swap_device,
 414                         .offset = swap_offset,
 415                         .swap = TAKE_PTR(swap),
 416                 };
 417
 418                 /* if the swap is the resume device, stop the loop */
 419                 if (location_is_resume_device(hibernate_location, sys_resume, sys_offset)) {
 420                         log_debug("%s: device matches configured resume settings.", hibernate_location->swap->device);
 421                         resume_match = true;
 422                         break;
 423                 }
 424
 425                 log_debug("%s: is a candidate device.", hibernate_location->swap->device);
 426         }
 427
 428         /* We found nothing at all */
 429         if (!hibernate_location)
 430                 return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS),
 431                                        "No possible swap partitions or files suitable for hibernation were found in /proc/swaps.");
 432
 433         /* resume= is set but a matching /proc/swaps entry was not found */
 434         if (sys_resume != 0 && !resume_match)
 435                 return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS),
 436                                        "No swap partitions or files matching resume config were found in /proc/swaps.");
 437
 438         if (hibernate_location->offset == UINT64_MAX) {
 439                 if (sys_offset == 0)
 440                         return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS), "Offset detection failed and /sys/power/resume_offset is not set.");
 441
 442                 hibernate_location->offset = sys_offset;
 443         }
 444
 445         if (resume_match)
 446                 log_debug("Hibernation will attempt to use swap entry with path: %s, device: %u:%u, offset: %" PRIu64 ", priority: %i",
 447                           hibernate_location->swap->device, major(hibernate_location->devno), minor(hibernate_location->devno),
 448                           hibernate_location->offset, hibernate_location->swap->priority);
 449         else
 450                 log_debug("/sys/power/resume is not configured; attempting to hibernate with path: %s, device: %u:%u, offset: %" PRIu64 ", priority: %i",
 451                           hibernate_location->swap->device, major(hibernate_location->devno), minor(hibernate_location->devno),
 452                           hibernate_location->offset, hibernate_location->swap->priority);
 453
 454         *ret_hibernate_location = TAKE_PTR(hibernate_location);
 455
 456         if (resume_match)
 457                 return 1;
 458
 459         return 0;
 460 }
 461
 462 static bool enough_swap_for_hibernation(void) {
 463         _cleanup_free_ char *active = NULL;
 464         _cleanup_(hibernate_location_freep) HibernateLocation *hibernate_location = NULL;
 465         unsigned long long act = 0;
 466         int r;
 467
 468         if (getenv_bool("SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK") > 0)
 469                 return true;
 470
 471         r = find_hibernate_location(&hibernate_location);
 472         if (r < 0)
 473                 return false;
 474
 475         /* If /sys/power/{resume,resume_offset} is configured but a matching entry
 476          * could not be identified in /proc/swaps, user is likely using Btrfs with a swapfile;
 477          * return true and let the system attempt hibernation.
 478          */
 479         if (r > 0 && !hibernate_location) {
 480                 log_debug("Unable to determine remaining swap space; hibernation may fail");
 481                 return true;
 482         }
 483
 484         if (!hibernate_location)
 485                 return false;
 486
 487         r = get_proc_field("/proc/meminfo", "Active(anon)", WHITESPACE, &active);
 488         if (r < 0) {
 489                 log_debug_errno(r, "Failed to retrieve Active(anon) from /proc/meminfo: %m");
 490                 return false;
 491         }
 492
 493         r = safe_atollu(active, &act);
 494         if (r < 0) {
 495                 log_debug_errno(r, "Failed to parse Active(anon) from /proc/meminfo: %s: %m", active);
 496                 return false;
 497         }
 498
 499         r = act <= (hibernate_location->swap->size - hibernate_location->swap->used) * HIBERNATION_SWAP_THRESHOLD;
 500         log_debug("%s swap for hibernation, Active(anon)=%llu kB, size=%" PRIu64 " kB, used=%" PRIu64 " kB, threshold=%.2g%%",
 501                   r ? "Enough" : "Not enough", act, hibernate_location->swap->size, hibernate_location->swap->used, 100*HIBERNATION_SWAP_THRESHOLD);
 502
 503         return r;
 504 }
 505
 506 int read_fiemap(int fd, struct fiemap **ret) {
 507         _cleanup_free_ struct fiemap *fiemap = NULL, *result_fiemap = NULL;
 508         struct stat statinfo;
 509         uint32_t result_extents = 0;
 510         uint64_t fiemap_start = 0, fiemap_length;
 511         const size_t n_extra = DIV_ROUND_UP(sizeof(struct fiemap), sizeof(struct fiemap_extent));
 512         size_t fiemap_allocated = n_extra, result_fiemap_allocated = n_extra;
 513
 514         if (fstat(fd, &statinfo) < 0)
 515                 return log_debug_errno(errno, "Cannot determine file size: %m");
 516         if (!S_ISREG(statinfo.st_mode))
 517                 return -ENOTTY;
 518         fiemap_length = statinfo.st_size;
 519
 520         /* Zero this out in case we run on a file with no extents */
 521         fiemap = calloc(n_extra, sizeof(struct fiemap_extent));
 522         if (!fiemap)
 523                 return -ENOMEM;
 524
 525         result_fiemap = malloc_multiply(n_extra, sizeof(struct fiemap_extent));
 526         if (!result_fiemap)
 527                 return -ENOMEM;
 528
 529         /*  XFS filesystem has incorrect implementation of fiemap ioctl and
 530          *  returns extents for only one block-group at a time, so we need
 531          *  to handle it manually, starting the next fiemap call from the end
 532          *  of the last extent
 533          */
 534         while (fiemap_start < fiemap_length) {
 535                 *fiemap = (struct fiemap) {
 536                         .fm_start = fiemap_start,
 537                         .fm_length = fiemap_length,
 538                         .fm_flags = FIEMAP_FLAG_SYNC,
 539                 };
 540
 541                 /* Find out how many extents there are */
 542                 if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0)
 543                         return log_debug_errno(errno, "Failed to read extents: %m");
 544
 545                 /* Nothing to process */
 546                 if (fiemap->fm_mapped_extents == 0)
 547                         break;
 548
 549                 /* Resize fiemap to allow us to read in the extents, result fiemap has to hold all
 550                  * the extents for the whole file. Add space for the initial struct fiemap. */
 551                 if (!greedy_realloc0((void**) &fiemap, &fiemap_allocated,
 552                                      n_extra + fiemap->fm_mapped_extents, sizeof(struct fiemap_extent)))
 553                         return -ENOMEM;
 554
 555                 fiemap->fm_extent_count = fiemap->fm_mapped_extents;
 556                 fiemap->fm_mapped_extents = 0;
 557
 558                 if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0)
 559                         return log_debug_errno(errno, "Failed to read extents: %m");
 560
 561                 /* Resize result_fiemap to allow us to copy in the extents */
 562                 if (!greedy_realloc((void**) &result_fiemap, &result_fiemap_allocated,
 563                                     n_extra + result_extents + fiemap->fm_mapped_extents, sizeof(struct fiemap_extent)))
 564                         return -ENOMEM;
 565
 566                 memcpy(result_fiemap->fm_extents + result_extents,
 567                        fiemap->fm_extents,
 568                        sizeof(struct fiemap_extent) * fiemap->fm_mapped_extents);
 569
 570                 result_extents += fiemap->fm_mapped_extents;
 571
 572                 /* Highly unlikely that it is zero */
 573                 if (_likely_(fiemap->fm_mapped_extents > 0)) {
 574                         uint32_t i = fiemap->fm_mapped_extents - 1;
 575
 576                         fiemap_start = fiemap->fm_extents[i].fe_logical +
 577                                        fiemap->fm_extents[i].fe_length;
 578
 579                         if (fiemap->fm_extents[i].fe_flags & FIEMAP_EXTENT_LAST)
 580                                 break;
 581                 }
 582         }
 583
 584         memcpy(result_fiemap, fiemap, sizeof(struct fiemap));
 585         result_fiemap->fm_mapped_extents = result_extents;
 586         *ret = TAKE_PTR(result_fiemap);
 587         return 0;
 588 }
 589
 590 static int can_sleep_internal(const char *verb, bool check_allowed, const SleepConfig *sleep_config);
 591
 592 static bool can_s2h(const SleepConfig *sleep_config) {
 593         const char *p;
 594         int r;
 595
 596         if (!clock_supported(CLOCK_BOOTTIME_ALARM)) {
 597                 log_debug("CLOCK_BOOTTIME_ALARM is not supported.");
 598                 return false;
 599         }
 600
 601         FOREACH_STRING(p, "suspend", "hibernate") {
 602                 r = can_sleep_internal(p, false, sleep_config);
 603                 if (IN_SET(r, 0, -ENOSPC, -EADV)) {
 604                         log_debug("Unable to %s system.", p);
 605                         return false;
 606                 }
 607                 if (r < 0)
 608                         return log_debug_errno(r, "Failed to check if %s is possible: %m", p);
 609         }
 610
 611         return true;
 612 }
 613
 614 static int can_sleep_internal(const char *verb, bool check_allowed, const SleepConfig *sleep_config) {
 615         bool allow;
 616         char **modes = NULL, **states = NULL;
 617         int r;
 618
 619         assert(STR_IN_SET(verb, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
 620
 621         r = sleep_settings(verb, sleep_config, &allow, &modes, &states);
 622         if (r < 0)
 623                 return false;
 624
 625         if (check_allowed && !allow) {
 626                 log_debug("Sleep mode \"%s\" is disabled by configuration.", verb);
 627                 return false;
 628         }
 629
 630         if (streq(verb, "suspend-then-hibernate"))
 631                 return can_s2h(sleep_config);
 632
 633         if (!can_sleep_state(states) || !can_sleep_disk(modes))
 634                 return false;
 635
 636         if (streq(verb, "suspend"))
 637                 return true;
 638
 639         if (!enough_swap_for_hibernation())
 640                 return -ENOSPC;
 641
 642         return true;
 643 }
 644
 645 int can_sleep(const char *verb) {
 646         _cleanup_(free_sleep_configp) SleepConfig *sleep_config = NULL;
 647         int r;
 648
 649         r = parse_sleep_config(&sleep_config);
 650         if (r < 0)
 651                 return r;
 652
 653         return can_sleep_internal(verb, true, sleep_config);
 654 }
 655
 656 int sleep_settings(const char *verb, const SleepConfig *sleep_config, bool *ret_allow, char ***ret_modes, char ***ret_states) {
 657
 658         assert(verb);
 659         assert(sleep_config);
 660         assert(STR_IN_SET(verb, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
 661
 662         if (streq(verb, "suspend")) {
 663                 *ret_allow = sleep_config->allow_suspend;
 664                 *ret_modes = sleep_config->suspend_modes;
 665                 *ret_states = sleep_config->suspend_states;
 666         } else if (streq(verb, "hibernate")) {
 667                 *ret_allow = sleep_config->allow_hibernate;
 668                 *ret_modes = sleep_config->hibernate_modes;
 669                 *ret_states = sleep_config->hibernate_states;
 670         } else if (streq(verb, "hybrid-sleep")) {
 671                 *ret_allow = sleep_config->allow_hybrid_sleep;
 672                 *ret_modes = sleep_config->hybrid_modes;
 673                 *ret_states = sleep_config->hybrid_states;
 674         } else if (streq(verb, "suspend-then-hibernate")) {
 675                 *ret_allow = sleep_config->allow_s2h;
 676                 *ret_modes = *ret_states = NULL;
 677         }
 678
 679         /* suspend modes empty by default */
 680         if ((!ret_modes && !streq(verb, "suspend")) || !ret_states)
 681                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No modes or states set for %s; Check sleep.conf", verb);
 682
 683         return 0;
 684 }
 685
 686 SleepConfig* free_sleep_config(SleepConfig *sc) {
 687         if (!sc)
 688                 return NULL;
 689
 690         strv_free(sc->suspend_modes);
 691         strv_free(sc->suspend_states);
 692
 693         strv_free(sc->hibernate_modes);
 694         strv_free(sc->hibernate_states);
 695
 696         strv_free(sc->hybrid_modes);
 697         strv_free(sc->hybrid_states);
 698
 699         return mfree(sc);
 700 }