chiark / gitweb /
Do not print invalid UTF-8 in error messages
[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         _cleanup_strv_free_ char
35                 **suspend_mode = NULL, **suspend_state = NULL,
36                 **hibernate_mode = NULL, **hibernate_state = NULL,
37                 **hybrid_mode = NULL, **hybrid_state = NULL;
38         char **modes, **states;
39
40         const ConfigTableItem items[] = {
41                 { "Sleep",   "SuspendMode",      config_parse_strv,  0, &suspend_mode  },
42                 { "Sleep",   "SuspendState",     config_parse_strv,  0, &suspend_state },
43                 { "Sleep",   "HibernateMode",    config_parse_strv,  0, &hibernate_mode  },
44                 { "Sleep",   "HibernateState",   config_parse_strv,  0, &hibernate_state },
45                 { "Sleep",   "HybridSleepMode",  config_parse_strv,  0, &hybrid_mode  },
46                 { "Sleep",   "HybridSleepState", config_parse_strv,  0, &hybrid_state },
47                 {}};
48
49         int r;
50         FILE _cleanup_fclose_ *f;
51
52         f = fopen(PKGSYSCONFDIR "/sleep.conf", "re");
53         if (!f)
54                 log_full(errno == ENOENT ? LOG_DEBUG: LOG_WARNING,
55                          "Failed to open configuration file " PKGSYSCONFDIR "/sleep.conf: %m");
56         else {
57                 r = config_parse(NULL, PKGSYSCONFDIR "/sleep.conf", f, "Sleep\0",
58                                  config_item_table_lookup, (void*) items, false, false, NULL);
59                 if (r < 0)
60                         log_warning("Failed to parse configuration file: %s", strerror(-r));
61         }
62
63         if (streq(verb, "suspend")) {
64                 /* empty by default */
65                 USE(modes, suspend_mode);
66
67                 if (suspend_state)
68                         USE(states, suspend_state);
69                 else
70                         states = strv_new("mem", "standby", "freeze", NULL);
71
72         } else if (streq(verb, "hibernate")) {
73                 if (hibernate_mode)
74                         USE(modes, hibernate_mode);
75                 else
76                         modes = strv_new("platform", "shutdown", NULL);
77
78                 if (hibernate_state)
79                         USE(states, hibernate_state);
80                 else
81                         states = strv_new("disk", NULL);
82
83         } else if (streq(verb, "hybrid-sleep")) {
84                 if (hybrid_mode)
85                         USE(modes, hybrid_mode);
86                 else
87                         modes = strv_new("suspend", "platform", "shutdown", NULL);
88
89                 if (hybrid_state)
90                         USE(states, hybrid_state);
91                 else
92                         states = strv_new("disk", NULL);
93
94         } else
95                 assert_not_reached("what verb");
96
97         if ((!modes && !streq(verb, "suspend")) || !states) {
98                 strv_free(modes);
99                 strv_free(states);
100                 return log_oom();
101         }
102
103         *_modes = modes;
104         *_states = states;
105         return 0;
106 }
107
108 int can_sleep_state(char **types) {
109         char *w, *state, **type;
110         int r;
111         _cleanup_free_ char *p = NULL;
112
113         if (strv_isempty(types))
114                 return true;
115
116         /* If /sys is read-only we cannot sleep */
117         if (access("/sys/power/state", W_OK) < 0)
118                 return false;
119
120         r = read_one_line_file("/sys/power/state", &p);
121         if (r < 0)
122                 return false;
123
124         STRV_FOREACH(type, types) {
125                 size_t l, k;
126
127                 k = strlen(*type);
128                 FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
129                         if (l == k && memcmp(w, *type, l) == 0)
130                                 return true;
131         }
132
133         return false;
134 }
135
136 int can_sleep_disk(char **types) {
137         char *w, *state, **type;
138         int r;
139         _cleanup_free_ char *p = NULL;
140
141         if (strv_isempty(types))
142                 return true;
143
144         /* If /sys is read-only we cannot sleep */
145         if (access("/sys/power/disk", W_OK) < 0)
146                 return false;
147
148         r = read_one_line_file("/sys/power/disk", &p);
149         if (r < 0)
150                 return false;
151
152         STRV_FOREACH(type, types) {
153                 size_t l, k;
154
155                 k = strlen(*type);
156                 FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
157                         if (l == k && memcmp(w, *type, l) == 0)
158                                 return true;
159
160                         if (l == k + 2 && w[0] == '[' && memcmp(w + 1, *type, l - 2) == 0 && w[l-1] == ']')
161                                 return true;
162                 }
163         }
164
165         return false;
166 }
167
168 #define HIBERNATION_SWAP_THRESHOLD 0.98
169
170 static int hibernation_partition_size(size_t *size, size_t *used) {
171         _cleanup_fclose_ FILE *f;
172         int i;
173
174         assert(size);
175         assert(used);
176
177         f = fopen("/proc/swaps", "re");
178         if (!f) {
179                 log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
180                          "Failed to retrieve open /proc/swaps: %m");
181                 assert(errno > 0);
182                 return -errno;
183         }
184
185         (void) fscanf(f, "%*s %*s %*s %*s %*s\n");
186
187         for (i = 1;; i++) {
188                 _cleanup_free_ char *dev = NULL, *type = NULL;
189                 size_t size_field, used_field;
190                 int k;
191
192                 k = fscanf(f,
193                            "%ms "   /* device/file */
194                            "%ms "   /* type of swap */
195                            "%zd "   /* swap size */
196                            "%zd "   /* used */
197                            "%*i\n", /* priority */
198                            &dev, &type, &size_field, &used_field);
199                 if (k != 4) {
200                         if (k == EOF)
201                                 break;
202
203                         log_warning("Failed to parse /proc/swaps:%u", i);
204                         continue;
205                 }
206
207                 if (streq(type, "partition") && endswith(dev, "\\040(deleted)")) {
208                         log_warning("Ignoring deleted swapfile '%s'.", dev);
209                         continue;
210                 }
211
212                 *size = size_field;
213                 *used = used_field;
214                 return 0;
215         }
216
217         log_debug("No swap partitions were found.");
218         return -ENOSYS;
219 }
220
221 static bool enough_memory_for_hibernation(void) {
222         _cleanup_free_ char *active = NULL;
223         unsigned long long act = 0;
224         size_t size = 0, used = 0;
225         int r;
226
227         r = hibernation_partition_size(&size, &used);
228         if (r < 0)
229                 return false;
230
231         r = get_status_field("/proc/meminfo", "\nActive(anon):", &active);
232         if (r < 0) {
233                 log_error("Failed to retrieve Active(anon) from /proc/meminfo: %s", strerror(-r));
234                 return false;
235         }
236
237         r = safe_atollu(active, &act);
238         if (r < 0) {
239                 log_error("Failed to parse Active(anon) from /proc/meminfo: %s: %s",
240                           active, strerror(-r));
241                 return false;
242         }
243
244         r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
245         log_debug("Hibernation is %spossible, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
246                   r ? "" : "im", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
247
248         return r;
249 }
250
251 int can_sleep(const char *verb) {
252         _cleanup_strv_free_ char **modes = NULL, **states = NULL;
253         int r;
254
255         assert(streq(verb, "suspend") ||
256                streq(verb, "hibernate") ||
257                streq(verb, "hybrid-sleep"));
258
259         r = parse_sleep_config(verb, &modes, &states);
260         if (r < 0)
261                 return false;
262
263         if (!can_sleep_state(states) || !can_sleep_disk(modes))
264                 return false;
265
266         return streq(verb, "suspend") || enough_memory_for_hibernation();
267 }