[thirdparty/systemd.git] / src / shared / sleep-config.c

/* SPDX-License-Identifier: LGPL-2.1+ */
/***
  Copyright © 2018 Dell Inc.
***/

#include <errno.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <syslog.h>
#include <unistd.h>

#include "alloc-util.h"
#include "conf-parser.h"
#include "def.h"
#include "env-util.h"
#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "log.h"
#include "macro.h"
#include "parse-util.h"
#include "path-util.h"
#include "sleep-config.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"

int parse_sleep_config(SleepConfig **ret_sleep_config) {
        _cleanup_(free_sleep_configp) SleepConfig *sc;
        int allow_suspend = -1, allow_hibernate = -1,
            allow_s2h = -1, allow_hybrid_sleep = -1;

        sc = new0(SleepConfig, 1);
        if (!sc)
                return log_oom();

        const ConfigTableItem items[] = {
                { "Sleep", "AllowSuspend",              config_parse_tristate, 0, &allow_suspend },
                { "Sleep", "AllowHibernation",          config_parse_tristate, 0, &allow_hibernate },
                { "Sleep", "AllowSuspendThenHibernate", config_parse_tristate, 0, &allow_s2h },
                { "Sleep", "AllowHybridSleep",          config_parse_tristate, 0, &allow_hybrid_sleep },

                { "Sleep", "SuspendMode",               config_parse_strv, 0, &sc->suspend_modes  },
                { "Sleep", "SuspendState",              config_parse_strv, 0, &sc->suspend_states },
                { "Sleep", "HibernateMode",             config_parse_strv, 0, &sc->hibernate_modes  },
                { "Sleep", "HibernateState",            config_parse_strv, 0, &sc->hibernate_states },
                { "Sleep", "HybridSleepMode",           config_parse_strv, 0, &sc->hybrid_modes  },
                { "Sleep", "HybridSleepState",          config_parse_strv, 0, &sc->hybrid_states },

                { "Sleep", "HibernateDelaySec",         config_parse_sec,  0, &sc->hibernate_delay_sec},
                {}
        };

        (void) config_parse_many_nulstr(PKGSYSCONFDIR "/sleep.conf",
                                        CONF_PATHS_NULSTR("systemd/sleep.conf.d"),
                                        "Sleep\0", config_item_table_lookup, items,
                                        CONFIG_PARSE_WARN, NULL);

        /* use default values unless set */
        sc->allow_suspend = allow_suspend != 0;
        sc->allow_hibernate = allow_hibernate != 0;
        sc->allow_hybrid_sleep = allow_hybrid_sleep >= 0 ? allow_hybrid_sleep
                : (allow_suspend != 0 && allow_hibernate != 0);
        sc->allow_s2h = allow_s2h >= 0 ? allow_s2h
                : (allow_suspend != 0 && allow_hibernate != 0);

        if (!sc->suspend_states)
                sc->suspend_states = strv_new("mem", "standby", "freeze");
        if (!sc->hibernate_modes)
                sc->hibernate_modes = strv_new("platform", "shutdown");
        if (!sc->hibernate_states)
                sc->hibernate_states = strv_new("disk");
        if (!sc->hybrid_modes)
                sc->hybrid_modes = strv_new("suspend", "platform", "shutdown");
        if (!sc->hybrid_states)
                sc->hybrid_states = strv_new("disk");
        if (sc->hibernate_delay_sec == 0)
                sc->hibernate_delay_sec = 180 * USEC_PER_MINUTE;

        /* ensure values set for all required fields */
        if (!sc->suspend_states || !sc->hibernate_modes
            || !sc->hibernate_states || !sc->hybrid_modes || !sc->hybrid_states)
                return log_oom();

        *ret_sleep_config = TAKE_PTR(sc);

        return 0;
}

int can_sleep_state(char **types) {
        char **type;
        int r;
        _cleanup_free_ char *p = NULL;

        if (strv_isempty(types))
                return true;

        /* If /sys is read-only we cannot sleep */
        if (access("/sys/power/state", W_OK) < 0)
                return false;

        r = read_one_line_file("/sys/power/state", &p);
        if (r < 0)
                return false;

        STRV_FOREACH(type, types) {
                const char *word, *state;
                size_t l, k;

                k = strlen(*type);
                FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state)
                        if (l == k && memcmp(word, *type, l) == 0)
                                return true;
        }

        return false;
}

int can_sleep_disk(char **types) {
        char **type;
        int r;
        _cleanup_free_ char *p = NULL;

        if (strv_isempty(types))
                return true;

        /* If /sys is read-only we cannot sleep */
        if (access("/sys/power/disk", W_OK) < 0) {
                log_debug_errno(errno, "/sys/power/disk is not writable: %m");
                return false;
        }

        r = read_one_line_file("/sys/power/disk", &p);
        if (r < 0) {
                log_debug_errno(r, "Couldn't read /sys/power/disk: %m");
                return false;
        }

        STRV_FOREACH(type, types) {
                const char *word, *state;
                size_t l, k;

                k = strlen(*type);
                FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state) {
                        if (l == k && memcmp(word, *type, l) == 0)
                                return true;

                        if (l == k + 2 &&
                            word[0] == '[' &&
                            memcmp(word + 1, *type, l - 2) == 0 &&
                            word[l-1] == ']')
                                return true;
                }
        }

        return false;
}

#define HIBERNATION_SWAP_THRESHOLD 0.98

int find_hibernate_location(char **device, char **type, size_t *size, size_t *used) {
        _cleanup_fclose_ FILE *f;
        unsigned i;

        f = fopen("/proc/swaps", "re");
        if (!f) {
                log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
                         "Failed to retrieve open /proc/swaps: %m");
                return negative_errno();
        }

        (void) fscanf(f, "%*s %*s %*s %*s %*s\n");

        // TODO: sort swaps in priority order rather than using first successful option
        for (i = 1;; i++) {
                _cleanup_free_ char *dev_field = NULL, *type_field = NULL;
                size_t size_field, used_field;
                int k;

                k = fscanf(f,
                           "%ms "   /* device/file */
                           "%ms "   /* type of swap */
                           "%zu "   /* swap size */
                           "%zu "   /* used */
                           "%*i\n", /* priority */
                           &dev_field, &type_field, &size_field, &used_field);
                if (k == EOF)
                        break;
                if (k != 4) {
                        log_warning("Failed to parse /proc/swaps:%u", i);
                        continue;
                }

                if (streq(type_field, "file")) {

                        if (endswith(dev_field, "\\040(deleted)")) {
                                log_warning("Ignoring deleted swap file '%s'.", dev_field);
                                continue;
                        }

                } else if (streq(type_field, "partition")) {
                        const char *fn;

                        fn = path_startswith(dev_field, "/dev/");
                        if (fn && startswith(fn, "zram")) {
                                log_debug("Ignoring compressed RAM swap device '%s'.", dev_field);
                                continue;
                        }
                }

                if (device)
                        *device = TAKE_PTR(dev_field);
                if (type)
                        *type = TAKE_PTR(type_field);
                if (size)
                        *size = size_field;
                if (used)
                        *used = used_field;
                return 0;
        }

        return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS),
                               "No swap partitions were found.");
}

static bool enough_swap_for_hibernation(void) {
        _cleanup_free_ char *active = NULL;
        unsigned long long act = 0;
        size_t size = 0, used = 0;
        int r;

        if (getenv_bool("SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK") > 0)
                return true;

        r = find_hibernate_location(NULL, NULL, &size, &used);
        if (r < 0)
                return false;

        r = get_proc_field("/proc/meminfo", "Active(anon)", WHITESPACE, &active);
        if (r < 0) {
                log_debug_errno(r, "Failed to retrieve Active(anon) from /proc/meminfo: %m");
                return false;
        }

        r = safe_atollu(active, &act);
        if (r < 0) {
                log_debug_errno(r, "Failed to parse Active(anon) from /proc/meminfo: %s: %m", active);
                return false;
        }

        r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
        log_debug("%s swap for hibernation, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
                  r ? "Enough" : "Not enough", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);

        return r;
}

int read_fiemap(int fd, struct fiemap **ret) {
        _cleanup_free_ struct fiemap *fiemap = NULL, *result_fiemap = NULL;
        struct stat statinfo;
        uint32_t result_extents = 0;
        uint64_t fiemap_start = 0, fiemap_length;
        const size_t n_extra = DIV_ROUND_UP(sizeof(struct fiemap), sizeof(struct fiemap_extent));
        size_t fiemap_allocated = n_extra, result_fiemap_allocated = n_extra;

        if (fstat(fd, &statinfo) < 0)
                return log_debug_errno(errno, "Cannot determine file size: %m");
        if (!S_ISREG(statinfo.st_mode))
                return -ENOTTY;
        fiemap_length = statinfo.st_size;

        /* Zero this out in case we run on a file with no extents */
        fiemap = calloc(n_extra, sizeof(struct fiemap_extent));
        if (!fiemap)
                return -ENOMEM;

        result_fiemap = malloc_multiply(n_extra, sizeof(struct fiemap_extent));
        if (!result_fiemap)
                return -ENOMEM;

        /*  XFS filesystem has incorrect implementation of fiemap ioctl and
         *  returns extents for only one block-group at a time, so we need
         *  to handle it manually, starting the next fiemap call from the end
         *  of the last extent
         */
        while (fiemap_start < fiemap_length) {
                *fiemap = (struct fiemap) {
                        .fm_start = fiemap_start,
                        .fm_length = fiemap_length,
                        .fm_flags = FIEMAP_FLAG_SYNC,
                };

                /* Find out how many extents there are */
                if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0)
                        return log_debug_errno(errno, "Failed to read extents: %m");

                /* Nothing to process */
                if (fiemap->fm_mapped_extents == 0)
                        break;

                /* Resize fiemap to allow us to read in the extents, result fiemap has to hold all
                 * the extents for the whole file. Add space for the initial struct fiemap. */
                if (!greedy_realloc0((void**) &fiemap, &fiemap_allocated,
                                     n_extra + fiemap->fm_mapped_extents, sizeof(struct fiemap_extent)))
                        return -ENOMEM;

                fiemap->fm_extent_count = fiemap->fm_mapped_extents;
                fiemap->fm_mapped_extents = 0;

                if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0)
                        return log_debug_errno(errno, "Failed to read extents: %m");

                /* Resize result_fiemap to allow us to copy in the extents */
                if (!greedy_realloc((void**) &result_fiemap, &result_fiemap_allocated,
                                    n_extra + result_extents + fiemap->fm_mapped_extents, sizeof(struct fiemap_extent)))
                        return -ENOMEM;

                memcpy(result_fiemap->fm_extents + result_extents,
                       fiemap->fm_extents,
                       sizeof(struct fiemap_extent) * fiemap->fm_mapped_extents);

                result_extents += fiemap->fm_mapped_extents;

                /* Highly unlikely that it is zero */
                if (_likely_(fiemap->fm_mapped_extents > 0)) {
                        uint32_t i = fiemap->fm_mapped_extents - 1;

                        fiemap_start = fiemap->fm_extents[i].fe_logical +
                                       fiemap->fm_extents[i].fe_length;

                        if (fiemap->fm_extents[i].fe_flags & FIEMAP_EXTENT_LAST)
                                break;
                }
        }

        memcpy(result_fiemap, fiemap, sizeof(struct fiemap));
        result_fiemap->fm_mapped_extents = result_extents;
        *ret = TAKE_PTR(result_fiemap);
        return 0;
}

static int can_sleep_internal(const char *verb, bool check_allowed, const SleepConfig *sleep_config);

static bool can_s2h(const SleepConfig *sleep_config) {
        const char *p;
        int r;

        if (!clock_supported(CLOCK_BOOTTIME_ALARM)) {
                log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
                         "CLOCK_BOOTTIME_ALARM is not supported");
                return false;
        }

        FOREACH_STRING(p, "suspend", "hibernate") {
                r = can_sleep_internal(p, false, sleep_config);
                if (IN_SET(r, 0, -ENOSPC, -EADV)) {
                        log_debug("Unable to %s system.", p);
                        return false;
                }
                if (r < 0)
                        return log_debug_errno(r, "Failed to check if %s is possible: %m", p);
        }

        return true;
}

static int can_sleep_internal(const char *verb, bool check_allowed, const SleepConfig *sleep_config) {
        bool allow;
        char **modes = NULL, **states = NULL;
        int r;

        assert(STR_IN_SET(verb, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));

        r = sleep_settings(verb, sleep_config, &allow, &modes, &states);
        if (r < 0)
                return false;

        if (check_allowed && !allow) {
                log_debug("Sleep mode \"%s\" is disabled by configuration.", verb);
                return false;
        }

        if (streq(verb, "suspend-then-hibernate"))
                return can_s2h(sleep_config);

        if (!can_sleep_state(states) || !can_sleep_disk(modes))
                return false;

        if (streq(verb, "suspend"))
                return true;

        if (!enough_swap_for_hibernation())
                return -ENOSPC;

        return true;
}

int can_sleep(const char *verb) {
        _cleanup_(free_sleep_configp) SleepConfig *sleep_config = NULL;
        int r;

        r = parse_sleep_config(&sleep_config);
        if (r < 0)
                return r;

        return can_sleep_internal(verb, true, sleep_config);
}

int sleep_settings(const char *verb, const SleepConfig *sleep_config, bool *ret_allow, char ***ret_modes, char ***ret_states) {

        assert(verb);
        assert(sleep_config);
        assert(STR_IN_SET(verb, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));

        if (streq(verb, "suspend")) {
                *ret_allow = sleep_config->allow_suspend;
                *ret_modes = sleep_config->suspend_modes;
                *ret_states = sleep_config->suspend_states;
        } else if (streq(verb, "hibernate")) {
                *ret_allow = sleep_config->allow_hibernate;
                *ret_modes = sleep_config->hibernate_modes;
                *ret_states = sleep_config->hibernate_states;
        } else if (streq(verb, "hybrid-sleep")) {
                *ret_allow = sleep_config->allow_hybrid_sleep;
                *ret_modes = sleep_config->hybrid_modes;
                *ret_states = sleep_config->hybrid_states;
        } else if (streq(verb, "suspend-then-hibernate")) {
                *ret_allow = sleep_config->allow_s2h;
                *ret_modes = *ret_states = NULL;
        }

        /* suspend modes empty by default */
        if ((!ret_modes && !streq(verb, "suspend")) || !ret_states)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No modes or states set for %s; Check sleep.conf", verb);

        return 0;
}

void free_sleep_config(SleepConfig *sc) {
        if (!sc)
                return;

        strv_free(sc->suspend_modes);
        strv_free(sc->suspend_states);

        strv_free(sc->hibernate_modes);
        strv_free(sc->hibernate_states);

        strv_free(sc->hybrid_modes);
        strv_free(sc->hybrid_states);

        free(sc);
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
19adb8a3	2	/***
96b2fb93	3	Copyright © 2018 Dell Inc.
19adb8a3 ZJS	4	***/
19adb8a3 ZJS	5
a8fbdf54	6	#include <errno.h>
ca78ad1d	7	#include <fcntl.h>
17c40b3a	8	#include <linux/fs.h>
a8fbdf54 TA	9	#include <stdbool.h>
a8fbdf54 TA	10	#include <stddef.h>
19adb8a3	11	#include <stdio.h>
a8fbdf54	12	#include <string.h>
36dd5ffd	13	#include <sys/ioctl.h>
ca78ad1d ZJS	14	#include <sys/stat.h>
ca78ad1d ZJS	15	#include <sys/types.h>
a8fbdf54 TA	16	#include <syslog.h>
a8fbdf54 TA	17	#include <unistd.h>
19adb8a3	18
b5efdb8a	19	#include "alloc-util.h"
19adb8a3	20	#include "conf-parser.h"
a0f29c76	21	#include "def.h"
490d20e6	22	#include "env-util.h"
427646ea	23	#include "errno-util.h"
3ffd4af2	24	#include "fd-util.h"
19adb8a3 ZJS	25	#include "fileio.h"
19adb8a3 ZJS	26	#include "log.h"
a8fbdf54	27	#include "macro.h"
a0f29c76	28	#include "parse-util.h"
411ae92b	29	#include "path-util.h"
3ffd4af2	30	#include "sleep-config.h"
07630cea	31	#include "string-util.h"
19adb8a3	32	#include "strv.h"
1bbbefe7	33	#include "time-util.h"
19adb8a3	34
28ca9c24 ZS	35	int parse_sleep_config(SleepConfig **ret_sleep_config) {
28ca9c24 ZS	36	_cleanup_(free_sleep_configp) SleepConfig *sc;
e8f1d00d ZJS	37	int allow_suspend = -1, allow_hibernate = -1,
e8f1d00d ZJS	38	allow_s2h = -1, allow_hybrid_sleep = -1;
28ca9c24 ZS	39
	40	sc = new0(SleepConfig, 1);
	41	if (!sc)
	42	return log_oom();
19adb8a3 ZJS	43
19adb8a3 ZJS	44	const ConfigTableItem items[] = {
e8f1d00d ZJS	45	{ "Sleep", "AllowSuspend", config_parse_tristate, 0, &allow_suspend },
	46	{ "Sleep", "AllowHibernation", config_parse_tristate, 0, &allow_hibernate },
	47	{ "Sleep", "AllowSuspendThenHibernate", config_parse_tristate, 0, &allow_s2h },
	48	{ "Sleep", "AllowHybridSleep", config_parse_tristate, 0, &allow_hybrid_sleep },
	49
28ca9c24 ZS	50	{ "Sleep", "SuspendMode", config_parse_strv, 0, &sc->suspend_modes },
	51	{ "Sleep", "SuspendState", config_parse_strv, 0, &sc->suspend_states },
	52	{ "Sleep", "HibernateMode", config_parse_strv, 0, &sc->hibernate_modes },
	53	{ "Sleep", "HibernateState", config_parse_strv, 0, &sc->hibernate_states },
	54	{ "Sleep", "HybridSleepMode", config_parse_strv, 0, &sc->hybrid_modes },
	55	{ "Sleep", "HybridSleepState", config_parse_strv, 0, &sc->hybrid_states },
e8f1d00d	56
28ca9c24	57	{ "Sleep", "HibernateDelaySec", config_parse_sec, 0, &sc->hibernate_delay_sec},
34c10968 LP	58	{}
34c10968 LP	59	};
19adb8a3	60
bcde742e LP	61	(void) config_parse_many_nulstr(PKGSYSCONFDIR "/sleep.conf",
	62	CONF_PATHS_NULSTR("systemd/sleep.conf.d"),
	63	"Sleep\0", config_item_table_lookup, items,
	64	CONFIG_PARSE_WARN, NULL);
19adb8a3	65
28ca9c24 ZS	66	/* use default values unless set */
	67	sc->allow_suspend = allow_suspend != 0;
	68	sc->allow_hibernate = allow_hibernate != 0;
7874583d ZS	69	sc->allow_hybrid_sleep = allow_hybrid_sleep >= 0 ? allow_hybrid_sleep
	70	: (allow_suspend != 0 && allow_hibernate != 0);
	71	sc->allow_s2h = allow_s2h >= 0 ? allow_s2h
	72	: (allow_suspend != 0 && allow_hibernate != 0);
28ca9c24 ZS	73
	74	if (!sc->suspend_states)
	75	sc->suspend_states = strv_new("mem", "standby", "freeze");
	76	if (!sc->hibernate_modes)
	77	sc->hibernate_modes = strv_new("platform", "shutdown");
	78	if (!sc->hibernate_states)
	79	sc->hibernate_states = strv_new("disk");
	80	if (!sc->hybrid_modes)
	81	sc->hybrid_modes = strv_new("suspend", "platform", "shutdown");
	82	if (!sc->hybrid_states)
	83	sc->hybrid_states = strv_new("disk");
	84	if (sc->hibernate_delay_sec == 0)
	85	sc->hibernate_delay_sec = 180 * USEC_PER_MINUTE;
	86
	87	/* ensure values set for all required fields */
	88	if (!sc->suspend_states \|\| !sc->hibernate_modes
	89	\|\| !sc->hibernate_states \|\| !sc->hybrid_modes \|\| !sc->hybrid_states)
19adb8a3	90	return log_oom();
19adb8a3	91
28ca9c24	92	*ret_sleep_config = TAKE_PTR(sc);
c58493c0	93
19adb8a3 ZJS	94	return 0;
	95	}
	96
	97	int can_sleep_state(char **types) {
a2a5291b	98	char **type;
19adb8a3 ZJS	99	int r;
	100	_cleanup_free_ char *p = NULL;
	101
	102	if (strv_isempty(types))
	103	return true;
	104
	105	/* If /sys is read-only we cannot sleep */
	106	if (access("/sys/power/state", W_OK) < 0)
	107	return false;
	108
	109	r = read_one_line_file("/sys/power/state", &p);
	110	if (r < 0)
	111	return false;
	112
	113	STRV_FOREACH(type, types) {
a2a5291b	114	const char word, state;
19adb8a3 ZJS	115	size_t l, k;
	116
	117	k = strlen(*type);
a2a5291b ZJS	118	FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state)
a2a5291b ZJS	119	if (l == k && memcmp(word, *type, l) == 0)
19adb8a3 ZJS	120	return true;
	121	}
	122
	123	return false;
	124	}
	125
	126	int can_sleep_disk(char **types) {
a2a5291b	127	char **type;
19adb8a3 ZJS	128	int r;
	129	_cleanup_free_ char *p = NULL;
	130
	131	if (strv_isempty(types))
	132	return true;
	133
	134	/* If /sys is read-only we cannot sleep */
7474f15b LP	135	if (access("/sys/power/disk", W_OK) < 0) {
7474f15b LP	136	log_debug_errno(errno, "/sys/power/disk is not writable: %m");
19adb8a3	137	return false;
7474f15b	138	}
19adb8a3 ZJS	139
19adb8a3 ZJS	140	r = read_one_line_file("/sys/power/disk", &p);
7474f15b LP	141	if (r < 0) {
7474f15b LP	142	log_debug_errno(r, "Couldn't read /sys/power/disk: %m");
19adb8a3	143	return false;
7474f15b	144	}
19adb8a3 ZJS	145
19adb8a3 ZJS	146	STRV_FOREACH(type, types) {
a2a5291b	147	const char word, state;
19adb8a3 ZJS	148	size_t l, k;
	149
	150	k = strlen(*type);
a2a5291b ZJS	151	FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state) {
a2a5291b ZJS	152	if (l == k && memcmp(word, *type, l) == 0)
19adb8a3 ZJS	153	return true;
19adb8a3 ZJS	154
a2a5291b ZJS	155	if (l == k + 2 &&
	156	word[0] == '[' &&
	157	memcmp(word + 1, *type, l - 2) == 0 &&
	158	word[l-1] == ']')
19adb8a3 ZJS	159	return true;
	160	}
	161	}
	162
	163	return false;
	164	}
	165
69ab8088 ZJS	166	#define HIBERNATION_SWAP_THRESHOLD 0.98
69ab8088 ZJS	167
17c40b3a	168	int find_hibernate_location(char device, char type, size_t size, size_t used) {
9fb3675e	169	_cleanup_fclose_ FILE *f;
1fa2f38f	170	unsigned i;
9fb3675e	171
c8a202b7	172	f = fopen("/proc/swaps", "re");
9fb3675e ZJS	173	if (!f) {
	174	log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
	175	"Failed to retrieve open /proc/swaps: %m");
427646ea	176	return negative_errno();
9fb3675e	177	}
69ab8088	178
9fb3675e ZJS	179	(void) fscanf(f, "%s %s %s %s %*s\n");
9fb3675e ZJS	180
2002d8cd	181	// TODO: sort swaps in priority order rather than using first successful option
9fb3675e	182	for (i = 1;; i++) {
17c40b3a	183	_cleanup_free_ char dev_field = NULL, type_field = NULL;
9fb3675e ZJS	184	size_t size_field, used_field;
	185	int k;
	186
	187	k = fscanf(f,
	188	"%ms " /* device/file */
	189	"%ms " /* type of swap */
1fa2f38f ZJS	190	"%zu " /* swap size */
1fa2f38f ZJS	191	"%zu " /* used */
9fb3675e	192	"%i\n", / priority */
17c40b3a	193	&dev_field, &type_field, &size_field, &used_field);
3dea6886 LP	194	if (k == EOF)
3dea6886 LP	195	break;
9fb3675e	196	if (k != 4) {
9fb3675e ZJS	197	log_warning("Failed to parse /proc/swaps:%u", i);
	198	continue;
	199	}
	200
3dea6886 LP	201	if (streq(type_field, "file")) {
3dea6886 LP	202
411ae92b	203	if (endswith(dev_field, "\\040(deleted)")) {
3dea6886	204	log_warning("Ignoring deleted swap file '%s'.", dev_field);
411ae92b AJ	205	continue;
	206	}
	207
3dea6886	208	} else if (streq(type_field, "partition")) {
411ae92b	209	const char *fn;
3dea6886	210
411ae92b AJ	211	fn = path_startswith(dev_field, "/dev/");
411ae92b AJ	212	if (fn && startswith(fn, "zram")) {
3dea6886	213	log_debug("Ignoring compressed RAM swap device '%s'.", dev_field);
411ae92b AJ	214	continue;
411ae92b AJ	215	}
9fb3675e	216	}
3dea6886	217
17c40b3a ML	218	if (device)
	219	*device = TAKE_PTR(dev_field);
	220	if (type)
	221	*type = TAKE_PTR(type_field);
	222	if (size)
	223	*size = size_field;
	224	if (used)
	225	*used = used_field;
9fb3675e	226	return 0;
69ab8088 ZJS	227	}
69ab8088 ZJS	228
baaa35ad ZJS	229	return log_debug_errno(SYNTHETIC_ERRNO(ENOSYS),
baaa35ad ZJS	230	"No swap partitions were found.");
9fb3675e ZJS	231	}
9fb3675e ZJS	232
4638cd39	233	static bool enough_swap_for_hibernation(void) {
9fb3675e	234	_cleanup_free_ char *active = NULL;
39883f62 LP	235	unsigned long long act = 0;
39883f62 LP	236	size_t size = 0, used = 0;
9fb3675e ZJS	237	int r;
9fb3675e ZJS	238
490d20e6 VV	239	if (getenv_bool("SYSTEMD_BYPASS_HIBERNATION_MEMORY_CHECK") > 0)
	240	return true;
	241
17c40b3a	242	r = find_hibernate_location(NULL, NULL, &size, &used);
9fb3675e	243	if (r < 0)
69ab8088	244	return false;
69ab8088	245
c4cd1d4d	246	r = get_proc_field("/proc/meminfo", "Active(anon)", WHITESPACE, &active);
69ab8088	247	if (r < 0) {
904865b8	248	log_debug_errno(r, "Failed to retrieve Active(anon) from /proc/meminfo: %m");
69ab8088 ZJS	249	return false;
	250	}
	251
	252	r = safe_atollu(active, &act);
	253	if (r < 0) {
904865b8	254	log_debug_errno(r, "Failed to parse Active(anon) from /proc/meminfo: %s: %m", active);
69ab8088 ZJS	255	return false;
	256	}
	257
9fb3675e	258	r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
5fdf2d51 ZJS	259	log_debug("%s swap for hibernation, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
5fdf2d51 ZJS	260	r ? "Enough" : "Not enough", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
69ab8088 ZJS	261
	262	return r;
	263	}
	264
17c40b3a ML	265	int read_fiemap(int fd, struct fiemap **ret) {
17c40b3a ML	266	_cleanup_free_ struct fiemap fiemap = NULL, result_fiemap = NULL;
17c40b3a ML	267	struct stat statinfo;
	268	uint32_t result_extents = 0;
	269	uint64_t fiemap_start = 0, fiemap_length;
6524f1a8 ZJS	270	const size_t n_extra = DIV_ROUND_UP(sizeof(struct fiemap), sizeof(struct fiemap_extent));
6524f1a8 ZJS	271	size_t fiemap_allocated = n_extra, result_fiemap_allocated = n_extra;
17c40b3a ML	272
	273	if (fstat(fd, &statinfo) < 0)
	274	return log_debug_errno(errno, "Cannot determine file size: %m");
	275	if (!S_ISREG(statinfo.st_mode))
	276	return -ENOTTY;
	277	fiemap_length = statinfo.st_size;
	278
6524f1a8 ZJS	279	/* Zero this out in case we run on a file with no extents */
6524f1a8 ZJS	280	fiemap = calloc(n_extra, sizeof(struct fiemap_extent));
17c40b3a ML	281	if (!fiemap)
	282	return -ENOMEM;
	283
6524f1a8	284	result_fiemap = malloc_multiply(n_extra, sizeof(struct fiemap_extent));
17c40b3a ML	285	if (!result_fiemap)
	286	return -ENOMEM;
	287
	288	/* XFS filesystem has incorrect implementation of fiemap ioctl and
	289	* returns extents for only one block-group at a time, so we need
	290	* to handle it manually, starting the next fiemap call from the end
	291	* of the last extent
	292	*/
	293	while (fiemap_start < fiemap_length) {
	294	*fiemap = (struct fiemap) {
	295	.fm_start = fiemap_start,
	296	.fm_length = fiemap_length,
	297	.fm_flags = FIEMAP_FLAG_SYNC,
	298	};
	299
	300	/* Find out how many extents there are */
	301	if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0)
	302	return log_debug_errno(errno, "Failed to read extents: %m");
	303
	304	/* Nothing to process */
	305	if (fiemap->fm_mapped_extents == 0)
	306	break;
	307
6524f1a8 ZJS	308	/* Resize fiemap to allow us to read in the extents, result fiemap has to hold all
	309	* the extents for the whole file. Add space for the initial struct fiemap. */
	310	if (!greedy_realloc0((void**) &fiemap, &fiemap_allocated,
	311	n_extra + fiemap->fm_mapped_extents, sizeof(struct fiemap_extent)))
17c40b3a ML	312	return -ENOMEM;
	313
	314	fiemap->fm_extent_count = fiemap->fm_mapped_extents;
	315	fiemap->fm_mapped_extents = 0;
	316
	317	if (ioctl(fd, FS_IOC_FIEMAP, fiemap) < 0)
	318	return log_debug_errno(errno, "Failed to read extents: %m");
	319
6524f1a8 ZJS	320	/* Resize result_fiemap to allow us to copy in the extents */
	321	if (!greedy_realloc((void**) &result_fiemap, &result_fiemap_allocated,
	322	n_extra + result_extents + fiemap->fm_mapped_extents, sizeof(struct fiemap_extent)))
17c40b3a ML	323	return -ENOMEM;
	324
	325	memcpy(result_fiemap->fm_extents + result_extents,
	326	fiemap->fm_extents,
	327	sizeof(struct fiemap_extent) * fiemap->fm_mapped_extents);
	328
	329	result_extents += fiemap->fm_mapped_extents;
	330
	331	/* Highly unlikely that it is zero */
6524f1a8	332	if (_likely_(fiemap->fm_mapped_extents > 0)) {
17c40b3a ML	333	uint32_t i = fiemap->fm_mapped_extents - 1;
	334
	335	fiemap_start = fiemap->fm_extents[i].fe_logical +
	336	fiemap->fm_extents[i].fe_length;
	337
	338	if (fiemap->fm_extents[i].fe_flags & FIEMAP_EXTENT_LAST)
	339	break;
	340	}
	341	}
	342
	343	memcpy(result_fiemap, fiemap, sizeof(struct fiemap));
	344	result_fiemap->fm_mapped_extents = result_extents;
	345	*ret = TAKE_PTR(result_fiemap);
	346	return 0;
	347	}
	348
28ca9c24	349	static int can_sleep_internal(const char verb, bool check_allowed, const SleepConfig sleep_config);
e8f1d00d	350
28ca9c24	351	static bool can_s2h(const SleepConfig *sleep_config) {
c863dc05	352	const char *p;
c58493c0 ML	353	int r;
c58493c0 ML	354
1bbbefe7	355	if (!clock_supported(CLOCK_BOOTTIME_ALARM)) {
c58493c0	356	log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
1bbbefe7	357	"CLOCK_BOOTTIME_ALARM is not supported");
c58493c0 ML	358	return false;
	359	}
	360
c863dc05	361	FOREACH_STRING(p, "suspend", "hibernate") {
28ca9c24	362	r = can_sleep_internal(p, false, sleep_config);
8340b762	363	if (IN_SET(r, 0, -ENOSPC, -EADV)) {
c863dc05 ZJS	364	log_debug("Unable to %s system.", p);
	365	return false;
	366	}
b71c9758 ZJS	367	if (r < 0)
b71c9758 ZJS	368	return log_debug_errno(r, "Failed to check if %s is possible: %m", p);
c58493c0 ML	369	}
	370
	371	return true;
	372	}
	373
28ca9c24	374	static int can_sleep_internal(const char verb, bool check_allowed, const SleepConfig sleep_config) {
e8f1d00d	375	bool allow;
28ca9c24	376	char modes = NULL, states = NULL;
19adb8a3 ZJS	377	int r;
19adb8a3 ZJS	378
e68c79db	379	assert(STR_IN_SET(verb, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
c58493c0	380
28ca9c24	381	r = sleep_settings(verb, sleep_config, &allow, &modes, &states);
19adb8a3 ZJS	382	if (r < 0)
	383	return false;
	384
e8f1d00d ZJS	385	if (check_allowed && !allow) {
	386	log_debug("Sleep mode \"%s\" is disabled by configuration.", verb);
	387	return false;
	388	}
	389
	390	if (streq(verb, "suspend-then-hibernate"))
28ca9c24	391	return can_s2h(sleep_config);
e8f1d00d	392
69ab8088 ZJS	393	if (!can_sleep_state(states) \|\| !can_sleep_disk(modes))
	394	return false;
	395
b71c9758 ZJS	396	if (streq(verb, "suspend"))
	397	return true;
	398
4638cd39	399	if (!enough_swap_for_hibernation())
b71c9758 ZJS	400	return -ENOSPC;
	401
	402	return true;
19adb8a3	403	}
e8f1d00d ZJS	404
e8f1d00d ZJS	405	int can_sleep(const char *verb) {
28ca9c24 ZS	406	_cleanup_(free_sleep_configp) SleepConfig *sleep_config = NULL;
	407	int r;
	408
	409	r = parse_sleep_config(&sleep_config);
	410	if (r < 0)
	411	return r;
	412
	413	return can_sleep_internal(verb, true, sleep_config);
	414	}
	415
	416	int sleep_settings(const char verb, const SleepConfig sleep_config, bool ret_allow, char ret_modes, char *ret_states) {
	417
	418	assert(verb);
	419	assert(sleep_config);
	420	assert(STR_IN_SET(verb, "suspend", "hibernate", "hybrid-sleep", "suspend-then-hibernate"));
	421
	422	if (streq(verb, "suspend")) {
	423	*ret_allow = sleep_config->allow_suspend;
	424	*ret_modes = sleep_config->suspend_modes;
	425	*ret_states = sleep_config->suspend_states;
	426	} else if (streq(verb, "hibernate")) {
	427	*ret_allow = sleep_config->allow_hibernate;
	428	*ret_modes = sleep_config->hibernate_modes;
	429	*ret_states = sleep_config->hibernate_states;
	430	} else if (streq(verb, "hybrid-sleep")) {
	431	*ret_allow = sleep_config->allow_hybrid_sleep;
	432	*ret_modes = sleep_config->hybrid_modes;
	433	*ret_states = sleep_config->hybrid_states;
	434	} else if (streq(verb, "suspend-then-hibernate")) {
	435	*ret_allow = sleep_config->allow_s2h;
	436	ret_modes = ret_states = NULL;
	437	}
	438
	439	/* suspend modes empty by default */
	440	if ((!ret_modes && !streq(verb, "suspend")) \|\| !ret_states)
	441	return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "No modes or states set for %s; Check sleep.conf", verb);
	442
	443	return 0;
	444	}
	445
	446	void free_sleep_config(SleepConfig *sc) {
	447	if (!sc)
	448	return;
	449
	450	strv_free(sc->suspend_modes);
	451	strv_free(sc->suspend_states);
	452
	453	strv_free(sc->hibernate_modes);
	454	strv_free(sc->hibernate_states);
	455
	456	strv_free(sc->hybrid_modes);
	457	strv_free(sc->hybrid_states);
	458
	459	free(sc);
e8f1d00d	460	}