1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 Copyright © 2018 Dell Inc.
11 #include <sys/ioctl.h>
13 #include <sys/types.h>
17 #include "alloc-util.h"
18 #include "blockdev-util.h"
19 #include "btrfs-util.h"
20 #include "conf-parser.h"
23 #include "errno-util.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"
34 #include "time-util.h"
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;
41 sc
= new0(SleepConfig
, 1);
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
},
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
},
58 { "Sleep", "HibernateDelaySec", config_parse_sec
, 0, &sc
->hibernate_delay_sec
},
62 (void) config_parse_many_nulstr(
63 PKGSYSCONFDIR
"/sleep.conf",
64 CONF_PATHS_NULSTR("systemd/sleep.conf.d"),
66 config_item_table_lookup
, items
,
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);
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
;
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
)
97 *ret_sleep_config
= TAKE_PTR(sc
);
102 int can_sleep_state(char **types
) {
105 _cleanup_free_
char *p
= NULL
;
107 if (strv_isempty(types
))
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");
116 r
= read_one_line_file("/sys/power/state", &p
);
118 log_debug_errno(r
, "Failed to read /sys/power/state, cannot sleep: %m");
122 STRV_FOREACH(type
, types
) {
123 const char *word
, *state
;
127 FOREACH_WORD_SEPARATOR(word
, l
, p
, WHITESPACE
, state
)
128 if (l
== k
&& memcmp(word
, *type
, l
) == 0)
135 int can_sleep_disk(char **types
) {
136 _cleanup_free_
char *p
= NULL
;
140 if (strv_isempty(types
))
143 /* If /sys is read-only we cannot sleep */
144 if (access("/sys/power/disk", W_OK
) < 0) {
145 log_debug_errno(errno
, "/sys/power/disk is not writable: %m");
149 r
= read_one_line_file("/sys/power/disk", &p
);
151 log_debug_errno(r
, "Couldn't read /sys/power/disk: %m");
155 STRV_FOREACH(type
, types
) {
156 const char *word
, *state
;
160 FOREACH_WORD_SEPARATOR(word
, l
, p
, WHITESPACE
, state
) {
161 if (l
== k
&& memcmp(word
, *type
, l
) == 0)
166 memcmp(word
+ 1, *type
, l
- 2) == 0 &&
175 #define HIBERNATION_SWAP_THRESHOLD 0.98
177 SwapEntry
* swap_entry_free(SwapEntry
*se
) {
187 HibernateLocation
* hibernate_location_free(HibernateLocation
*hl
) {
191 swap_entry_free(hl
->swap
);
196 static int swap_device_to_device_id(const SwapEntry
*swap
, dev_t
*ret_dev
) {
201 assert(swap
->device
);
204 r
= stat(swap
->device
, &sb
);
208 if (streq(swap
->type
, "partition")) {
209 if (!S_ISBLK(sb
.st_mode
))
212 *ret_dev
= sb
.st_rdev
;
216 return get_block_device(swap
->device
, ret_dev
);
220 * Attempt to calculate the swap file offset on supported filesystems. On unsupported
221 * filesystems, a debug message is logged and ret_offset is set to UINT64_MAX.
223 static int calculate_swap_file_offset(const SwapEntry
*swap
, uint64_t *ret_offset
) {
224 _cleanup_close_
int fd
= -1;
225 _cleanup_free_
struct fiemap
*fiemap
= NULL
;
230 assert(swap
->device
);
231 assert(streq(swap
->type
, "file"));
233 fd
= open(swap
->device
, O_RDONLY
|O_CLOEXEC
|O_NOCTTY
);
235 return log_debug_errno(errno
, "Failed to open swap file %s to determine on-disk offset: %m", swap
->device
);
237 if (fstat(fd
, &sb
) < 0)
238 return log_debug_errno(errno
, "Failed to stat %s: %m", swap
->device
);
240 btrfs
= btrfs_is_filesystem(fd
);
242 return log_debug_errno(btrfs
, "Error checking %s for Btrfs filesystem: %m", swap
->device
);
244 log_debug("%s: detection of swap file offset on Btrfs is not supported", swap
->device
);
245 *ret_offset
= UINT64_MAX
;
249 r
= read_fiemap(fd
, &fiemap
);
251 return log_debug_errno(r
, "Unable to read extent map for '%s': %m", swap
->device
);
253 *ret_offset
= fiemap
->fm_extents
[0].fe_physical
/ page_size();
257 static int read_resume_files(dev_t
*ret_resume
, uint64_t *ret_resume_offset
) {
258 _cleanup_free_
char *resume_str
= NULL
, *resume_offset_str
= NULL
;
259 uint64_t resume_offset
= 0;
263 r
= read_one_line_file("/sys/power/resume", &resume_str
);
265 return log_debug_errno(r
, "Error reading /sys/power/resume: %m");
267 r
= parse_dev(resume_str
, &resume
);
269 return log_debug_errno(r
, "Error parsing /sys/power/resume device: %s: %m", resume_str
);
271 r
= read_one_line_file("/sys/power/resume_offset", &resume_offset_str
);
273 log_debug_errno(r
, "Kernel does not support resume_offset; swap file offset detection will be skipped.");
275 return log_debug_errno(r
, "Error reading /sys/power/resume_offset: %m");
277 r
= safe_atou64(resume_offset_str
, &resume_offset
);
279 return log_debug_errno(r
, "Failed to parse value in /sys/power/resume_offset \"%s\": %m", resume_offset_str
);
282 if (resume_offset
> 0 && resume
== 0)
283 log_debug("Warning: found /sys/power/resume_offset==%" PRIu64
", but /sys/power/resume unset. Misconfiguration?",
286 *ret_resume
= resume
;
287 *ret_resume_offset
= resume_offset
;
293 * Determine if the HibernateLocation matches the resume= (device) and resume_offset= (file).
295 static bool location_is_resume_device(const HibernateLocation
*location
, dev_t sys_resume
, uint64_t sys_offset
) {
299 return sys_resume
> 0 &&
300 sys_resume
== location
->devno
&&
301 (sys_offset
== location
->offset
|| (sys_offset
> 0 && location
->offset
== UINT64_MAX
));
305 * Attempt to find the hibernation location by parsing /proc/swaps, /sys/power/resume, and
306 * /sys/power/resume_offset.
309 * 1 - Values are set in /sys/power/resume and /sys/power/resume_offset.
310 * ret_hibernate_location will represent matching /proc/swap entry if identified or NULL if not.
312 * 0 - No values are set in /sys/power/resume and /sys/power/resume_offset.
313 ret_hibernate_location will represent the highest priority swap with most remaining space discovered in /proc/swaps.
315 * Negative value in the case of error.
317 int find_hibernate_location(HibernateLocation
**ret_hibernate_location
) {
318 _cleanup_fclose_
FILE *f
= NULL
;
319 _cleanup_(hibernate_location_freep
) HibernateLocation
*hibernate_location
= NULL
;
321 uint64_t sys_offset
= 0;
322 bool resume_match
= false;
325 /* read the /sys/power/resume & /sys/power/resume_offset values */
326 r
= read_resume_files(&sys_resume
, &sys_offset
);
330 f
= fopen("/proc/swaps", "re");
332 log_debug_errno(errno
, "Failed to open /proc/swaps: %m");
333 return errno
== ENOENT
? -EOPNOTSUPP
: -errno
; /* Convert swap not supported to a recognizable error */
336 (void) fscanf(f
, "%*s %*s %*s %*s %*s\n");
337 for (unsigned i
= 1;; i
++) {
338 _cleanup_(swap_entry_freep
) SwapEntry
*swap
= NULL
;
339 uint64_t swap_offset
= 0;
342 swap
= new0(SwapEntry
, 1);
347 "%ms " /* device/file */
348 "%ms " /* type of swap */
349 "%" PRIu64
/* swap size */
350 "%" PRIu64
/* used */
351 "%i\n", /* priority */
352 &swap
->device
, &swap
->type
, &swap
->size
, &swap
->used
, &swap
->priority
);
356 log_debug("Failed to parse /proc/swaps:%u, ignoring", i
);
360 if (streq(swap
->type
, "file")) {
361 if (endswith(swap
->device
, "\\040(deleted)")) {
362 log_debug("Ignoring deleted swap file '%s'.", swap
->device
);
366 r
= calculate_swap_file_offset(swap
, &swap_offset
);
370 } else if (streq(swap
->type
, "partition")) {
373 fn
= path_startswith(swap
->device
, "/dev/");
374 if (fn
&& startswith(fn
, "zram")) {
375 log_debug("%s: ignoring zram swap", swap
->device
);
380 log_debug("%s: swap type %s is unsupported for hibernation, ignoring", swap
->device
, swap
->type
);
384 /* prefer resume device or highest priority swap with most remaining space */
385 if (hibernate_location
&& swap
->priority
< hibernate_location
->swap
->priority
) {
386 log_debug("%s: ignoring device with lower priority", swap
->device
);
389 if (hibernate_location
&&
390 (swap
->priority
== hibernate_location
->swap
->priority
391 && swap
->size
- swap
->used
< hibernate_location
->swap
->size
- hibernate_location
->swap
->used
)) {
392 log_debug("%s: ignoring device with lower usable space", swap
->device
);
397 r
= swap_device_to_device_id(swap
, &swap_device
);
399 return log_debug_errno(r
, "%s: failed to query device number: %m", swap
->device
);
401 hibernate_location
= hibernate_location_free(hibernate_location
);
402 hibernate_location
= new(HibernateLocation
, 1);
403 if (!hibernate_location
)
406 *hibernate_location
= (HibernateLocation
) {
407 .devno
= swap_device
,
408 .offset
= swap_offset
,
409 .swap
= TAKE_PTR(swap
),
412 /* if the swap is the resume device, stop the loop */
413 if (location_is_resume_device(hibernate_location
, sys_resume
, sys_offset
)) {
414 log_debug("%s: device matches configured resume settings.", hibernate_location
->swap
->device
);
419 log_debug("%s: is a candidate device.", hibernate_location
->swap
->device
);
422 /* We found nothing at all */
423 if (!hibernate_location
)
424 return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS
),
425 "No possible swap partitions or files suitable for hibernation were found in /proc/swaps.");
427 /* resume= is set but a matching /proc/swaps entry was not found */
428 if (sys_resume
!= 0 && !resume_match
)
429 return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS
),
430 "No swap partitions or files matching resume config were found in /proc/swaps.");
432 if (hibernate_location
->offset
== UINT64_MAX
) {
434 return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS
), "Offset detection failed and /sys/power/resume_offset is not set.");
436 hibernate_location
->offset
= sys_offset
;
440 log_debug("Hibernation will attempt to use swap entry with path: %s, device: %u:%u, offset: %" PRIu64
", priority: %i",
441 hibernate_location
->swap
->device
, major(hibernate_location
->devno
), minor(hibernate_location
->devno
),
442 hibernate_location
->offset
, hibernate_location
->swap
->priority
);
444 log_debug("/sys/power/resume is not configured; attempting to hibernate with path: %s, device: %u:%u, offset: %" PRIu64
", priority: %i",
445 hibernate_location
->swap
->device
, major(hibernate_location
->devno
), minor(hibernate_location
->devno
),
446 hibernate_location
->offset
, hibernate_location
->swap
->priority
);
448 *ret_hibernate_location
= TAKE_PTR(hibernate_location
);
456 static bool enough_swap_for_hibernation(void) {
457 _cleanup_free_
char *active
= NULL
;
458 _cleanup_(hibernate_location_freep
) HibernateLocation
*hibernate_location
= NULL
;
459 unsigned long long act
= 0;
462 if (getenv_bool("SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK") > 0)
465 r
= find_hibernate_location(&hibernate_location
);
469 /* If /sys/power/{resume,resume_offset} is configured but a matching entry
470 * could not be identified in /proc/swaps, user is likely using Btrfs with a swapfile;
471 * return true and let the system attempt hibernation.
473 if (r
> 0 && !hibernate_location
) {
474 log_debug("Unable to determine remaining swap space; hibernation may fail");
478 if (!hibernate_location
)
481 r
= get_proc_field("/proc/meminfo", "Active(anon)", WHITESPACE
, &active
);
483 log_debug_errno(r
, "Failed to retrieve Active(anon) from /proc/meminfo: %m");
487 r
= safe_atollu(active
, &act
);
489 log_debug_errno(r
, "Failed to parse Active(anon) from /proc/meminfo: %s: %m", active
);
493 r
= act
<= (hibernate_location
->swap
->size
- hibernate_location
->swap
->used
) * HIBERNATION_SWAP_THRESHOLD
;
494 log_debug("%s swap for hibernation, Active(anon)=%llu kB, size=%" PRIu64
" kB, used=%" PRIu64
" kB, threshold=%.2g%%",
495 r
? "Enough" : "Not enough", act
, hibernate_location
->swap
->size
, hibernate_location
->swap
->used
, 100*HIBERNATION_SWAP_THRESHOLD
);
500 int read_fiemap(int fd
, struct fiemap
**ret
) {
501 _cleanup_free_
struct fiemap
*fiemap
= NULL
, *result_fiemap
= NULL
;
502 struct stat statinfo
;
503 uint32_t result_extents
= 0;
504 uint64_t fiemap_start
= 0, fiemap_length
;
505 const size_t n_extra
= DIV_ROUND_UP(sizeof(struct fiemap
), sizeof(struct fiemap_extent
));
506 size_t fiemap_allocated
= n_extra
, result_fiemap_allocated
= n_extra
;
508 if (fstat(fd
, &statinfo
) < 0)
509 return log_debug_errno(errno
, "Cannot determine file size: %m");
510 if (!S_ISREG(statinfo
.st_mode
))
512 fiemap_length
= statinfo
.st_size
;
514 /* Zero this out in case we run on a file with no extents */
515 fiemap
= calloc(n_extra
, sizeof(struct fiemap_extent
));
519 result_fiemap
= malloc_multiply(n_extra
, sizeof(struct fiemap_extent
));
523 /* XFS filesystem has incorrect implementation of fiemap ioctl and
524 * returns extents for only one block-group at a time, so we need
525 * to handle it manually, starting the next fiemap call from the end
528 while (fiemap_start
< fiemap_length
) {
529 *fiemap
= (struct fiemap
) {
530 .fm_start
= fiemap_start
,
531 .fm_length
= fiemap_length
,
532 .fm_flags
= FIEMAP_FLAG_SYNC
,
535 /* Find out how many extents there are */
536 if (ioctl(fd
, FS_IOC_FIEMAP
, fiemap
) < 0)
537 return log_debug_errno(errno
, "Failed to read extents: %m");
539 /* Nothing to process */
540 if (fiemap
->fm_mapped_extents
== 0)
543 /* Resize fiemap to allow us to read in the extents, result fiemap has to hold all
544 * the extents for the whole file. Add space for the initial struct fiemap. */
545 if (!greedy_realloc0((void**) &fiemap
, &fiemap_allocated
,
546 n_extra
+ fiemap
->fm_mapped_extents
, sizeof(struct fiemap_extent
)))
549 fiemap
->fm_extent_count
= fiemap
->fm_mapped_extents
;
550 fiemap
->fm_mapped_extents
= 0;
552 if (ioctl(fd
, FS_IOC_FIEMAP
, fiemap
) < 0)
553 return log_debug_errno(errno
, "Failed to read extents: %m");
555 /* Resize result_fiemap to allow us to copy in the extents */
556 if (!greedy_realloc((void**) &result_fiemap
, &result_fiemap_allocated
,
557 n_extra
+ result_extents
+ fiemap
->fm_mapped_extents
, sizeof(struct fiemap_extent
)))
560 memcpy(result_fiemap
->fm_extents
+ result_extents
,
562 sizeof(struct fiemap_extent
) * fiemap
->fm_mapped_extents
);
564 result_extents
+= fiemap
->fm_mapped_extents
;
566 /* Highly unlikely that it is zero */
567 if (_likely_(fiemap
->fm_mapped_extents
> 0)) {
568 uint32_t i
= fiemap
->fm_mapped_extents
- 1;
570 fiemap_start
= fiemap
->fm_extents
[i
].fe_logical
+
571 fiemap
->fm_extents
[i
].fe_length
;
573 if (fiemap
->fm_extents
[i
].fe_flags
& FIEMAP_EXTENT_LAST
)
578 memcpy(result_fiemap
, fiemap
, sizeof(struct fiemap
));
579 result_fiemap
->fm_mapped_extents
= result_extents
;
580 *ret
= TAKE_PTR(result_fiemap
);
584 static int can_sleep_internal(const char *verb
, bool check_allowed
, const SleepConfig
*sleep_config
);
586 static bool can_s2h(const SleepConfig
*sleep_config
) {
590 if (!clock_supported(CLOCK_BOOTTIME_ALARM
)) {
591 log_debug("CLOCK_BOOTTIME_ALARM is not supported.");
595 FOREACH_STRING(p
, "suspend", "hibernate") {
596 r
= can_sleep_internal(p
, false, sleep_config
);
597 if (IN_SET(r
, 0, -ENOSPC
, -EADV
)) {
598 log_debug("Unable to %s system.", p
);
602 return log_debug_errno(r
, "Failed to check if %s is possible: %m", p
);
608 static int can_sleep_internal(const char *verb
, bool check_allowed
, const SleepConfig
*sleep_config
) {
610 char **modes
= NULL
, **states
= NULL
;
613 assert(STR_IN_SET(verb
, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
615 r
= sleep_settings(verb
, sleep_config
, &allow
, &modes
, &states
);
619 if (check_allowed
&& !allow
) {
620 log_debug("Sleep mode \"%s\" is disabled by configuration.", verb
);
624 if (streq(verb
, "suspend-then-hibernate"))
625 return can_s2h(sleep_config
);
627 if (!can_sleep_state(states
) || !can_sleep_disk(modes
))
630 if (streq(verb
, "suspend"))
633 if (!enough_swap_for_hibernation())
639 int can_sleep(const char *verb
) {
640 _cleanup_(free_sleep_configp
) SleepConfig
*sleep_config
= NULL
;
643 r
= parse_sleep_config(&sleep_config
);
647 return can_sleep_internal(verb
, true, sleep_config
);
650 int sleep_settings(const char *verb
, const SleepConfig
*sleep_config
, bool *ret_allow
, char ***ret_modes
, char ***ret_states
) {
653 assert(sleep_config
);
654 assert(STR_IN_SET(verb
, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
656 if (streq(verb
, "suspend")) {
657 *ret_allow
= sleep_config
->allow_suspend
;
658 *ret_modes
= sleep_config
->suspend_modes
;
659 *ret_states
= sleep_config
->suspend_states
;
660 } else if (streq(verb
, "hibernate")) {
661 *ret_allow
= sleep_config
->allow_hibernate
;
662 *ret_modes
= sleep_config
->hibernate_modes
;
663 *ret_states
= sleep_config
->hibernate_states
;
664 } else if (streq(verb
, "hybrid-sleep")) {
665 *ret_allow
= sleep_config
->allow_hybrid_sleep
;
666 *ret_modes
= sleep_config
->hybrid_modes
;
667 *ret_states
= sleep_config
->hybrid_states
;
668 } else if (streq(verb
, "suspend-then-hibernate")) {
669 *ret_allow
= sleep_config
->allow_s2h
;
670 *ret_modes
= *ret_states
= NULL
;
673 /* suspend modes empty by default */
674 if ((!ret_modes
&& !streq(verb
, "suspend")) || !ret_states
)
675 return log_error_errno(SYNTHETIC_ERRNO(EINVAL
), "No modes or states set for %s; Check sleep.conf", verb
);
680 SleepConfig
* free_sleep_config(SleepConfig
*sc
) {
684 strv_free(sc
->suspend_modes
);
685 strv_free(sc
->suspend_states
);
687 strv_free(sc
->hibernate_modes
);
688 strv_free(sc
->hibernate_states
);
690 strv_free(sc
->hybrid_modes
);
691 strv_free(sc
->hybrid_states
);