36f822c4bd
Special care is needed so that we get an error message if the file failed to parse, but not when it is missing. To avoid duplicating the same error check in every caller, add an additional 'warn' boolean to tell config_parse whether a message should be issued. This makes things both shorter and more robust wrt. to error reporting.
260 lines
8.2 KiB
C
260 lines
8.2 KiB
C
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2013 Zbigniew Jędrzejewski-Szmek
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "conf-parser.h"
|
|
#include "sleep-config.h"
|
|
#include "fileio.h"
|
|
#include "log.h"
|
|
#include "strv.h"
|
|
#include "util.h"
|
|
|
|
#define USE(x, y) do{ (x) = (y); (y) = NULL; } while(0)
|
|
|
|
int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
|
|
|
|
_cleanup_strv_free_ char
|
|
**suspend_mode = NULL, **suspend_state = NULL,
|
|
**hibernate_mode = NULL, **hibernate_state = NULL,
|
|
**hybrid_mode = NULL, **hybrid_state = NULL;
|
|
char **modes, **states;
|
|
|
|
const ConfigTableItem items[] = {
|
|
{ "Sleep", "SuspendMode", config_parse_strv, 0, &suspend_mode },
|
|
{ "Sleep", "SuspendState", config_parse_strv, 0, &suspend_state },
|
|
{ "Sleep", "HibernateMode", config_parse_strv, 0, &hibernate_mode },
|
|
{ "Sleep", "HibernateState", config_parse_strv, 0, &hibernate_state },
|
|
{ "Sleep", "HybridSleepMode", config_parse_strv, 0, &hybrid_mode },
|
|
{ "Sleep", "HybridSleepState", config_parse_strv, 0, &hybrid_state },
|
|
{}
|
|
};
|
|
|
|
config_parse(NULL, PKGSYSCONFDIR "/sleep.conf", NULL,
|
|
"Sleep\0",
|
|
config_item_table_lookup, items, false, false, true, NULL);
|
|
|
|
if (streq(verb, "suspend")) {
|
|
/* empty by default */
|
|
USE(modes, suspend_mode);
|
|
|
|
if (suspend_state)
|
|
USE(states, suspend_state);
|
|
else
|
|
states = strv_new("mem", "standby", "freeze", NULL);
|
|
|
|
} else if (streq(verb, "hibernate")) {
|
|
if (hibernate_mode)
|
|
USE(modes, hibernate_mode);
|
|
else
|
|
modes = strv_new("platform", "shutdown", NULL);
|
|
|
|
if (hibernate_state)
|
|
USE(states, hibernate_state);
|
|
else
|
|
states = strv_new("disk", NULL);
|
|
|
|
} else if (streq(verb, "hybrid-sleep")) {
|
|
if (hybrid_mode)
|
|
USE(modes, hybrid_mode);
|
|
else
|
|
modes = strv_new("suspend", "platform", "shutdown", NULL);
|
|
|
|
if (hybrid_state)
|
|
USE(states, hybrid_state);
|
|
else
|
|
states = strv_new("disk", NULL);
|
|
|
|
} else
|
|
assert_not_reached("what verb");
|
|
|
|
if ((!modes && !streq(verb, "suspend")) || !states) {
|
|
strv_free(modes);
|
|
strv_free(states);
|
|
return log_oom();
|
|
}
|
|
|
|
*_modes = modes;
|
|
*_states = states;
|
|
return 0;
|
|
}
|
|
|
|
int can_sleep_state(char **types) {
|
|
char *w, *state, **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) {
|
|
size_t l, k;
|
|
|
|
k = strlen(*type);
|
|
FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
|
|
if (l == k && memcmp(w, *type, l) == 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int can_sleep_disk(char **types) {
|
|
char *w, *state, **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)
|
|
return false;
|
|
|
|
r = read_one_line_file("/sys/power/disk", &p);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
STRV_FOREACH(type, types) {
|
|
size_t l, k;
|
|
|
|
k = strlen(*type);
|
|
FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
|
|
if (l == k && memcmp(w, *type, l) == 0)
|
|
return true;
|
|
|
|
if (l == k + 2 && w[0] == '[' && memcmp(w + 1, *type, l - 2) == 0 && w[l-1] == ']')
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#define HIBERNATION_SWAP_THRESHOLD 0.98
|
|
|
|
static int hibernation_partition_size(size_t *size, size_t *used) {
|
|
_cleanup_fclose_ FILE *f;
|
|
int i;
|
|
|
|
assert(size);
|
|
assert(used);
|
|
|
|
f = fopen("/proc/swaps", "re");
|
|
if (!f) {
|
|
log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
|
|
"Failed to retrieve open /proc/swaps: %m");
|
|
assert(errno > 0);
|
|
return -errno;
|
|
}
|
|
|
|
(void) fscanf(f, "%*s %*s %*s %*s %*s\n");
|
|
|
|
for (i = 1;; i++) {
|
|
_cleanup_free_ char *dev = NULL, *type = NULL;
|
|
size_t size_field, used_field;
|
|
int k;
|
|
|
|
k = fscanf(f,
|
|
"%ms " /* device/file */
|
|
"%ms " /* type of swap */
|
|
"%zd " /* swap size */
|
|
"%zd " /* used */
|
|
"%*i\n", /* priority */
|
|
&dev, &type, &size_field, &used_field);
|
|
if (k != 4) {
|
|
if (k == EOF)
|
|
break;
|
|
|
|
log_warning("Failed to parse /proc/swaps:%u", i);
|
|
continue;
|
|
}
|
|
|
|
if (streq(type, "partition") && endswith(dev, "\\040(deleted)")) {
|
|
log_warning("Ignoring deleted swapfile '%s'.", dev);
|
|
continue;
|
|
}
|
|
|
|
*size = size_field;
|
|
*used = used_field;
|
|
return 0;
|
|
}
|
|
|
|
log_debug("No swap partitions were found.");
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static bool enough_memory_for_hibernation(void) {
|
|
_cleanup_free_ char *active = NULL;
|
|
unsigned long long act = 0;
|
|
size_t size = 0, used = 0;
|
|
int r;
|
|
|
|
r = hibernation_partition_size(&size, &used);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
r = get_status_field("/proc/meminfo", "\nActive(anon):", &active);
|
|
if (r < 0) {
|
|
log_error("Failed to retrieve Active(anon) from /proc/meminfo: %s", strerror(-r));
|
|
return false;
|
|
}
|
|
|
|
r = safe_atollu(active, &act);
|
|
if (r < 0) {
|
|
log_error("Failed to parse Active(anon) from /proc/meminfo: %s: %s",
|
|
active, strerror(-r));
|
|
return false;
|
|
}
|
|
|
|
r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
|
|
log_debug("Hibernation is %spossible, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
|
|
r ? "" : "im", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
|
|
|
|
return r;
|
|
}
|
|
|
|
int can_sleep(const char *verb) {
|
|
_cleanup_strv_free_ char **modes = NULL, **states = NULL;
|
|
int r;
|
|
|
|
assert(streq(verb, "suspend") ||
|
|
streq(verb, "hibernate") ||
|
|
streq(verb, "hybrid-sleep"));
|
|
|
|
r = parse_sleep_config(verb, &modes, &states);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
if (!can_sleep_state(states) || !can_sleep_disk(modes))
|
|
return false;
|
|
|
|
return streq(verb, "suspend") || enough_memory_for_hibernation();
|
|
}
|