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) {
129 log_debug("Sleep mode \"%s\" is supported by the kernel.", *type
);
135 _cleanup_free_
char *t
= strv_join(types
, "/");
136 log_debug("Sleep mode %s not supported by the kernel, sorry.", strnull(t
));
141 int can_sleep_disk(char **types
) {
142 _cleanup_free_
char *p
= NULL
;
146 if (strv_isempty(types
))
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");
155 r
= read_one_line_file("/sys/power/disk", &p
);
157 log_debug_errno(r
, "Couldn't read /sys/power/disk: %m");
161 STRV_FOREACH(type
, types
) {
162 const char *word
, *state
;
166 FOREACH_WORD_SEPARATOR(word
, l
, p
, WHITESPACE
, state
) {
167 if (l
== k
&& memcmp(word
, *type
, l
) == 0)
172 memcmp(word
+ 1, *type
, l
- 2) == 0 &&
181 #define HIBERNATION_SWAP_THRESHOLD 0.98
183 SwapEntry
* swap_entry_free(SwapEntry
*se
) {
193 HibernateLocation
* hibernate_location_free(HibernateLocation
*hl
) {
197 swap_entry_free(hl
->swap
);
202 static int swap_device_to_device_id(const SwapEntry
*swap
, dev_t
*ret_dev
) {
207 assert(swap
->device
);
210 r
= stat(swap
->device
, &sb
);
214 if (streq(swap
->type
, "partition")) {
215 if (!S_ISBLK(sb
.st_mode
))
218 *ret_dev
= sb
.st_rdev
;
222 return get_block_device(swap
->device
, ret_dev
);
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.
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
;
236 assert(swap
->device
);
237 assert(streq(swap
->type
, "file"));
239 fd
= open(swap
->device
, O_RDONLY
|O_CLOEXEC
|O_NOCTTY
);
241 return log_debug_errno(errno
, "Failed to open swap file %s to determine on-disk offset: %m", swap
->device
);
243 if (fstat(fd
, &sb
) < 0)
244 return log_debug_errno(errno
, "Failed to stat %s: %m", swap
->device
);
246 btrfs
= btrfs_is_filesystem(fd
);
248 return log_debug_errno(btrfs
, "Error checking %s for Btrfs filesystem: %m", swap
->device
);
250 log_debug("%s: detection of swap file offset on Btrfs is not supported", swap
->device
);
251 *ret_offset
= UINT64_MAX
;
255 r
= read_fiemap(fd
, &fiemap
);
257 return log_debug_errno(r
, "Unable to read extent map for '%s': %m", swap
->device
);
259 *ret_offset
= fiemap
->fm_extents
[0].fe_physical
/ page_size();
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;
269 r
= read_one_line_file("/sys/power/resume", &resume_str
);
271 return log_debug_errno(r
, "Error reading /sys/power/resume: %m");
273 r
= parse_dev(resume_str
, &resume
);
275 return log_debug_errno(r
, "Error parsing /sys/power/resume device: %s: %m", resume_str
);
277 r
= read_one_line_file("/sys/power/resume_offset", &resume_offset_str
);
279 log_debug_errno(r
, "Kernel does not support resume_offset; swap file offset detection will be skipped.");
281 return log_debug_errno(r
, "Error reading /sys/power/resume_offset: %m");
283 r
= safe_atou64(resume_offset_str
, &resume_offset
);
285 return log_debug_errno(r
, "Failed to parse value in /sys/power/resume_offset \"%s\": %m", resume_offset_str
);
288 if (resume_offset
> 0 && resume
== 0)
289 log_debug("Warning: found /sys/power/resume_offset==%" PRIu64
", but /sys/power/resume unset. Misconfiguration?",
292 *ret_resume
= resume
;
293 *ret_resume_offset
= resume_offset
;
299 * Determine if the HibernateLocation matches the resume= (device) and resume_offset= (file).
301 static bool location_is_resume_device(const HibernateLocation
*location
, dev_t sys_resume
, uint64_t sys_offset
) {
305 return sys_resume
> 0 &&
306 sys_resume
== location
->devno
&&
307 (sys_offset
== location
->offset
|| (sys_offset
> 0 && location
->offset
== UINT64_MAX
));
311 * Attempt to find the hibernation location by parsing /proc/swaps, /sys/power/resume, and
312 * /sys/power/resume_offset.
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.
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.
321 * Negative value in the case of error.
323 int find_hibernate_location(HibernateLocation
**ret_hibernate_location
) {
324 _cleanup_fclose_
FILE *f
= NULL
;
325 _cleanup_(hibernate_location_freep
) HibernateLocation
*hibernate_location
= NULL
;
327 uint64_t sys_offset
= 0;
328 bool resume_match
= false;
331 /* read the /sys/power/resume & /sys/power/resume_offset values */
332 r
= read_resume_files(&sys_resume
, &sys_offset
);
336 f
= fopen("/proc/swaps", "re");
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 */
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;
348 swap
= new0(SwapEntry
, 1);
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
);
362 log_debug("Failed to parse /proc/swaps:%u, ignoring", i
);
366 if (streq(swap
->type
, "file")) {
367 if (endswith(swap
->device
, "\\040(deleted)")) {
368 log_debug("Ignoring deleted swap file '%s'.", swap
->device
);
372 r
= calculate_swap_file_offset(swap
, &swap_offset
);
376 } else if (streq(swap
->type
, "partition")) {
379 fn
= path_startswith(swap
->device
, "/dev/");
380 if (fn
&& startswith(fn
, "zram")) {
381 log_debug("%s: ignoring zram swap", swap
->device
);
386 log_debug("%s: swap type %s is unsupported for hibernation, ignoring", swap
->device
, swap
->type
);
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
);
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
);
403 r
= swap_device_to_device_id(swap
, &swap_device
);
405 return log_debug_errno(r
, "%s: failed to query device number: %m", swap
->device
);
407 hibernate_location
= hibernate_location_free(hibernate_location
);
408 hibernate_location
= new(HibernateLocation
, 1);
409 if (!hibernate_location
)
412 *hibernate_location
= (HibernateLocation
) {
413 .devno
= swap_device
,
414 .offset
= swap_offset
,
415 .swap
= TAKE_PTR(swap
),
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
);
425 log_debug("%s: is a candidate device.", hibernate_location
->swap
->device
);
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.");
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.");
438 if (hibernate_location
->offset
== UINT64_MAX
) {
440 return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS
), "Offset detection failed and /sys/power/resume_offset is not set.");
442 hibernate_location
->offset
= sys_offset
;
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
);
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
);
454 *ret_hibernate_location
= TAKE_PTR(hibernate_location
);
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;
468 if (getenv_bool("SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK") > 0)
471 r
= find_hibernate_location(&hibernate_location
);
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.
479 if (r
> 0 && !hibernate_location
) {
480 log_debug("Unable to determine remaining swap space; hibernation may fail");
484 if (!hibernate_location
)
487 r
= get_proc_field("/proc/meminfo", "Active(anon)", WHITESPACE
, &active
);
489 log_debug_errno(r
, "Failed to retrieve Active(anon) from /proc/meminfo: %m");
493 r
= safe_atollu(active
, &act
);
495 log_debug_errno(r
, "Failed to parse Active(anon) from /proc/meminfo: %s: %m", active
);
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
);
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
;
514 if (fstat(fd
, &statinfo
) < 0)
515 return log_debug_errno(errno
, "Cannot determine file size: %m");
516 if (!S_ISREG(statinfo
.st_mode
))
518 fiemap_length
= statinfo
.st_size
;
520 /* Zero this out in case we run on a file with no extents */
521 fiemap
= calloc(n_extra
, sizeof(struct fiemap_extent
));
525 result_fiemap
= malloc_multiply(n_extra
, sizeof(struct fiemap_extent
));
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
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
,
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");
545 /* Nothing to process */
546 if (fiemap
->fm_mapped_extents
== 0)
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
)))
555 fiemap
->fm_extent_count
= fiemap
->fm_mapped_extents
;
556 fiemap
->fm_mapped_extents
= 0;
558 if (ioctl(fd
, FS_IOC_FIEMAP
, fiemap
) < 0)
559 return log_debug_errno(errno
, "Failed to read extents: %m");
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
)))
566 memcpy(result_fiemap
->fm_extents
+ result_extents
,
568 sizeof(struct fiemap_extent
) * fiemap
->fm_mapped_extents
);
570 result_extents
+= fiemap
->fm_mapped_extents
;
572 /* Highly unlikely that it is zero */
573 if (_likely_(fiemap
->fm_mapped_extents
> 0)) {
574 uint32_t i
= fiemap
->fm_mapped_extents
- 1;
576 fiemap_start
= fiemap
->fm_extents
[i
].fe_logical
+
577 fiemap
->fm_extents
[i
].fe_length
;
579 if (fiemap
->fm_extents
[i
].fe_flags
& FIEMAP_EXTENT_LAST
)
584 memcpy(result_fiemap
, fiemap
, sizeof(struct fiemap
));
585 result_fiemap
->fm_mapped_extents
= result_extents
;
586 *ret
= TAKE_PTR(result_fiemap
);
590 static int can_sleep_internal(const char *verb
, bool check_allowed
, const SleepConfig
*sleep_config
);
592 static bool can_s2h(const SleepConfig
*sleep_config
) {
596 if (!clock_supported(CLOCK_BOOTTIME_ALARM
)) {
597 log_debug("CLOCK_BOOTTIME_ALARM is not supported.");
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
);
608 return log_debug_errno(r
, "Failed to check if %s is possible: %m", p
);
614 static int can_sleep_internal(const char *verb
, bool check_allowed
, const SleepConfig
*sleep_config
) {
616 char **modes
= NULL
, **states
= NULL
;
619 assert(STR_IN_SET(verb
, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
621 r
= sleep_settings(verb
, sleep_config
, &allow
, &modes
, &states
);
625 if (check_allowed
&& !allow
) {
626 log_debug("Sleep mode \"%s\" is disabled by configuration.", verb
);
630 if (streq(verb
, "suspend-then-hibernate"))
631 return can_s2h(sleep_config
);
633 if (!can_sleep_state(states
) || !can_sleep_disk(modes
))
636 if (streq(verb
, "suspend"))
639 if (!enough_swap_for_hibernation())
645 int can_sleep(const char *verb
) {
646 _cleanup_(free_sleep_configp
) SleepConfig
*sleep_config
= NULL
;
649 r
= parse_sleep_config(&sleep_config
);
653 return can_sleep_internal(verb
, true, sleep_config
);
656 int sleep_settings(const char *verb
, const SleepConfig
*sleep_config
, bool *ret_allow
, char ***ret_modes
, char ***ret_states
) {
659 assert(sleep_config
);
660 assert(STR_IN_SET(verb
, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
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
;
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
);
686 SleepConfig
* free_sleep_config(SleepConfig
*sc
) {
690 strv_free(sc
->suspend_modes
);
691 strv_free(sc
->suspend_states
);
693 strv_free(sc
->hibernate_modes
);
694 strv_free(sc
->hibernate_states
);
696 strv_free(sc
->hybrid_modes
);
697 strv_free(sc
->hybrid_states
);