chiark / gitweb /
util: do not strip /dev prefix twice
[elogind.git] / src / shared / sleep-config.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2013 Zbigniew JÄ™drzejewski-Szmek
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdio.h>
23
24 #include "conf-parser.h"
25 #include "sleep-config.h"
26 #include "fileio.h"
27 #include "log.h"
28 #include "strv.h"
29 #include "util.h"
30
31 #define USE(x, y) do{ (x) = (y); (y) = NULL; } while(0)
32
33 int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
34
35         _cleanup_strv_free_ char
36                 **suspend_mode = NULL, **suspend_state = NULL,
37                 **hibernate_mode = NULL, **hibernate_state = NULL,
38                 **hybrid_mode = NULL, **hybrid_state = NULL;
39         char **modes, **states;
40
41         const ConfigTableItem items[] = {
42                 { "Sleep",   "SuspendMode",      config_parse_strv,  0, &suspend_mode  },
43                 { "Sleep",   "SuspendState",     config_parse_strv,  0, &suspend_state },
44                 { "Sleep",   "HibernateMode",    config_parse_strv,  0, &hibernate_mode  },
45                 { "Sleep",   "HibernateState",   config_parse_strv,  0, &hibernate_state },
46                 { "Sleep",   "HybridSleepMode",  config_parse_strv,  0, &hybrid_mode  },
47                 { "Sleep",   "HybridSleepState", config_parse_strv,  0, &hybrid_state },
48                 {}
49         };
50
51         int r;
52         FILE _cleanup_fclose_ *f;
53
54         f = fopen(PKGSYSCONFDIR "/sleep.conf", "re");
55         if (!f)
56                 log_full(errno == ENOENT ? LOG_DEBUG: LOG_WARNING,
57                          "Failed to open configuration file " PKGSYSCONFDIR "/sleep.conf: %m");
58         else {
59                 r = config_parse(NULL, PKGSYSCONFDIR "/sleep.conf", f, "Sleep\0",
60                                  config_item_table_lookup, (void*) items, false, false, NULL);
61                 if (r < 0)
62                         log_warning("Failed to parse configuration file: %s", strerror(-r));
63         }
64
65         if (streq(verb, "suspend")) {
66                 /* empty by default */
67                 USE(modes, suspend_mode);
68
69                 if (suspend_state)
70                         USE(states, suspend_state);
71                 else
72                         states = strv_new("mem", "standby", "freeze", NULL);
73
74         } else if (streq(verb, "hibernate")) {
75                 if (hibernate_mode)
76                         USE(modes, hibernate_mode);
77                 else
78                         modes = strv_new("platform", "shutdown", NULL);
79
80                 if (hibernate_state)
81                         USE(states, hibernate_state);
82                 else
83                         states = strv_new("disk", NULL);
84
85         } else if (streq(verb, "hybrid-sleep")) {
86                 if (hybrid_mode)
87                         USE(modes, hybrid_mode);
88                 else
89                         modes = strv_new("suspend", "platform", "shutdown", NULL);
90
91                 if (hybrid_state)
92                         USE(states, hybrid_state);
93                 else
94                         states = strv_new("disk", NULL);
95
96         } else
97                 assert_not_reached("what verb");
98
99         if ((!modes && !streq(verb, "suspend")) || !states) {
100                 strv_free(modes);
101                 strv_free(states);
102                 return log_oom();
103         }
104
105         *_modes = modes;
106         *_states = states;
107         return 0;
108 }
109
110 int can_sleep_state(char **types) {
111         char *w, *state, **type;
112         int r;
113         _cleanup_free_ char *p = NULL;
114
115         if (strv_isempty(types))
116                 return true;
117
118         /* If /sys is read-only we cannot sleep */
119         if (access("/sys/power/state", W_OK) < 0)
120                 return false;
121
122         r = read_one_line_file("/sys/power/state", &p);
123         if (r < 0)
124                 return false;
125
126         STRV_FOREACH(type, types) {
127                 size_t l, k;
128
129                 k = strlen(*type);
130                 FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
131                         if (l == k && memcmp(w, *type, l) == 0)
132                                 return true;
133         }
134
135         return false;
136 }
137
138 int can_sleep_disk(char **types) {
139         char *w, *state, **type;
140         int r;
141         _cleanup_free_ char *p = NULL;
142
143         if (strv_isempty(types))
144                 return true;
145
146         /* If /sys is read-only we cannot sleep */
147         if (access("/sys/power/disk", W_OK) < 0)
148                 return false;
149
150         r = read_one_line_file("/sys/power/disk", &p);
151         if (r < 0)
152                 return false;
153
154         STRV_FOREACH(type, types) {
155                 size_t l, k;
156
157                 k = strlen(*type);
158                 FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
159                         if (l == k && memcmp(w, *type, l) == 0)
160                                 return true;
161
162                         if (l == k + 2 && w[0] == '[' && memcmp(w + 1, *type, l - 2) == 0 && w[l-1] == ']')
163                                 return true;
164                 }
165         }
166
167         return false;
168 }
169
170 #define HIBERNATION_SWAP_THRESHOLD 0.98
171
172 static int hibernation_partition_size(size_t *size, size_t *used) {
173         _cleanup_fclose_ FILE *f;
174         int i;
175
176         assert(size);
177         assert(used);
178
179         f = fopen("/proc/swaps", "re");
180         if (!f) {
181                 log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
182                          "Failed to retrieve open /proc/swaps: %m");
183                 assert(errno > 0);
184                 return -errno;
185         }
186
187         (void) fscanf(f, "%*s %*s %*s %*s %*s\n");
188
189         for (i = 1;; i++) {
190                 _cleanup_free_ char *dev = NULL, *type = NULL;
191                 size_t size_field, used_field;
192                 int k;
193
194                 k = fscanf(f,
195                            "%ms "   /* device/file */
196                            "%ms "   /* type of swap */
197                            "%zd "   /* swap size */
198                            "%zd "   /* used */
199                            "%*i\n", /* priority */
200                            &dev, &type, &size_field, &used_field);
201                 if (k != 4) {
202                         if (k == EOF)
203                                 break;
204
205                         log_warning("Failed to parse /proc/swaps:%u", i);
206                         continue;
207                 }
208
209                 if (streq(type, "partition") && endswith(dev, "\\040(deleted)")) {
210                         log_warning("Ignoring deleted swapfile '%s'.", dev);
211                         continue;
212                 }
213
214                 *size = size_field;
215                 *used = used_field;
216                 return 0;
217         }
218
219         log_debug("No swap partitions were found.");
220         return -ENOSYS;
221 }
222
223 static bool enough_memory_for_hibernation(void) {
224         _cleanup_free_ char *active = NULL;
225         unsigned long long act = 0;
226         size_t size = 0, used = 0;
227         int r;
228
229         r = hibernation_partition_size(&size, &used);
230         if (r < 0)
231                 return false;
232
233         r = get_status_field("/proc/meminfo", "\nActive(anon):", &active);
234         if (r < 0) {
235                 log_error("Failed to retrieve Active(anon) from /proc/meminfo: %s", strerror(-r));
236                 return false;
237         }
238
239         r = safe_atollu(active, &act);
240         if (r < 0) {
241                 log_error("Failed to parse Active(anon) from /proc/meminfo: %s: %s",
242                           active, strerror(-r));
243                 return false;
244         }
245
246         r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
247         log_debug("Hibernation is %spossible, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
248                   r ? "" : "im", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
249
250         return r;
251 }
252
253 int can_sleep(const char *verb) {
254         _cleanup_strv_free_ char **modes = NULL, **states = NULL;
255         int r;
256
257         assert(streq(verb, "suspend") ||
258                streq(verb, "hibernate") ||
259                streq(verb, "hybrid-sleep"));
260
261         r = parse_sleep_config(verb, &modes, &states);
262         if (r < 0)
263                 return false;
264
265         if (!can_sleep_state(states) || !can_sleep_disk(modes))
266                 return false;
267
268         return streq(verb, "suspend") || enough_memory_for_hibernation();
269 }