src/shared/sleep-config.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <unistd.h>
   4
   5 #include "alloc-util.h"
   6 #include "conf-parser.h"
   7 #include "constants.h"
   8 #include "device-util.h"
   9 #include "devnum-util.h"
  10 #include "errno-util.h"
  11 #include "fd-util.h"
  12 #include "fileio.h"
  13 #include "hibernate-util.h"
  14 #include "log.h"
  15 #include "macro.h"
  16 #include "path-util.h"
  17 #include "sleep-config.h"
  18 #include "stat-util.h"
  19 #include "stdio-util.h"
  20 #include "string-table.h"
  21 #include "string-util.h"
  22 #include "strv.h"
  23 #include "time-util.h"
  24
  25 #define DEFAULT_SUSPEND_ESTIMATION_USEC (1 * USEC_PER_HOUR)
  26
  27 static const char* const sleep_operation_table[_SLEEP_OPERATION_MAX] = {
  28         [SLEEP_SUSPEND]                = "suspend",
  29         [SLEEP_HIBERNATE]              = "hibernate",
  30         [SLEEP_HYBRID_SLEEP]           = "hybrid-sleep",
  31         [SLEEP_SUSPEND_THEN_HIBERNATE] = "suspend-then-hibernate",
  32 };
  33
  34 DEFINE_STRING_TABLE_LOOKUP(sleep_operation, SleepOperation);
  35
  36 static char* const* const sleep_default_state_table[_SLEEP_OPERATION_CONFIG_MAX] = {
  37         [SLEEP_SUSPEND]      = STRV_MAKE("mem", "standby", "freeze"),
  38         [SLEEP_HIBERNATE]    = STRV_MAKE("disk"),
  39         [SLEEP_HYBRID_SLEEP] = STRV_MAKE("disk"),
  40 };
  41
  42 static char* const* const sleep_default_mode_table[_SLEEP_OPERATION_CONFIG_MAX] = {
  43         /* Not used by SLEEP_SUSPEND */
  44         [SLEEP_HIBERNATE]    = STRV_MAKE("platform", "shutdown"),
  45         [SLEEP_HYBRID_SLEEP] = STRV_MAKE("suspend"),
  46 };
  47
  48 SleepConfig* sleep_config_free(SleepConfig *sc) {
  49         if (!sc)
  50                 return NULL;
  51
  52         for (SleepOperation i = 0; i < _SLEEP_OPERATION_CONFIG_MAX; i++) {
  53                 strv_free(sc->states[i]);
  54                 strv_free(sc->modes[i]);
  55         }
  56
  57         strv_free(sc->mem_modes);
  58
  59         return mfree(sc);
  60 }
  61
  62 static int config_parse_sleep_mode(
  63                 const char *unit,
  64                 const char *filename,
  65                 unsigned line,
  66                 const char *section,
  67                 unsigned section_line,
  68                 const char *lvalue,
  69                 int ltype,
  70                 const char *rvalue,
  71                 void *data,
  72                 void *userdata) {
  73
  74         char ***sv = ASSERT_PTR(data);
  75         _cleanup_strv_free_ char **modes = NULL;
  76         int r;
  77
  78         assert(filename);
  79         assert(lvalue);
  80         assert(rvalue);
  81
  82         if (isempty(rvalue)) {
  83                 modes = strv_new(NULL);
  84                 if (!modes)
  85                         return log_oom();
  86         } else {
  87                 r = strv_split_full(&modes, rvalue, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
  88                 if (r < 0)
  89                         return log_oom();
  90         }
  91
  92         return strv_free_and_replace(*sv, modes);
  93 }
  94
  95 static void sleep_config_validate_state_and_mode(SleepConfig *sc) {
  96         assert(sc);
  97
  98         /* So we should really not allow setting SuspendState= to 'disk', which means hibernation. We have
  99          * SLEEP_HIBERNATE for proper hibernation support, which includes checks for resume support (through
 100          * EFI variable or resume= kernel command line option). It's simply not sensible to call the suspend
 101          * operation but eventually do an unsafe hibernation. */
 102         if (strv_contains(sc->states[SLEEP_SUSPEND], "disk")) {
 103                 strv_remove(sc->states[SLEEP_SUSPEND], "disk");
 104                 log_warning("Sleep state 'disk' is not supported by operation %s, ignoring.",
 105                             sleep_operation_to_string(SLEEP_SUSPEND));
 106         }
 107         assert(!sc->modes[SLEEP_SUSPEND]);
 108
 109         /* People should use hybrid-sleep instead of setting HibernateMode=suspend. Warn about it but don't
 110          * drop it in this case. */
 111         if (strv_contains(sc->modes[SLEEP_HIBERNATE], "suspend"))
 112                 log_warning("Sleep mode 'suspend' should not be used by operation %s. Please use %s instead.",
 113                             sleep_operation_to_string(SLEEP_HIBERNATE), sleep_operation_to_string(SLEEP_HYBRID_SLEEP));
 114 }
 115
 116 int parse_sleep_config(SleepConfig **ret) {
 117         _cleanup_(sleep_config_freep) SleepConfig *sc = NULL;
 118         int allow_suspend = -1, allow_hibernate = -1, allow_s2h = -1, allow_hybrid_sleep = -1;
 119
 120         assert(ret);
 121
 122         sc = new(SleepConfig, 1);
 123         if (!sc)
 124                 return log_oom();
 125
 126         *sc = (SleepConfig) {
 127                 .hibernate_delay_usec = USEC_INFINITY,
 128         };
 129
 130         const ConfigTableItem items[] = {
 131                 { "Sleep", "AllowSuspend",              config_parse_tristate,    0,               &allow_suspend               },
 132                 { "Sleep", "AllowHibernation",          config_parse_tristate,    0,               &allow_hibernate             },
 133                 { "Sleep", "AllowSuspendThenHibernate", config_parse_tristate,    0,               &allow_s2h                   },
 134                 { "Sleep", "AllowHybridSleep",          config_parse_tristate,    0,               &allow_hybrid_sleep          },
 135
 136                 { "Sleep", "SuspendState",              config_parse_strv,        0,               sc->states + SLEEP_SUSPEND   },
 137                 { "Sleep", "SuspendMode",               config_parse_warn_compat, DISABLED_LEGACY, NULL                         },
 138
 139                 { "Sleep", "HibernateState",            config_parse_warn_compat, DISABLED_LEGACY, NULL                         },
 140                 { "Sleep", "HibernateMode",             config_parse_sleep_mode,  0,               sc->modes + SLEEP_HIBERNATE  },
 141
 142                 { "Sleep", "HybridSleepState",          config_parse_warn_compat, DISABLED_LEGACY, NULL                         },
 143                 { "Sleep", "HybridSleepMode",           config_parse_warn_compat, DISABLED_LEGACY, NULL                         },
 144
 145                 { "Sleep", "MemorySleepMode",           config_parse_sleep_mode,  0,               &sc->mem_modes               },
 146
 147                 { "Sleep", "HibernateDelaySec",         config_parse_sec,         0,               &sc->hibernate_delay_usec    },
 148                 { "Sleep", "SuspendEstimationSec",      config_parse_sec,         0,               &sc->suspend_estimation_usec },
 149                 {}
 150         };
 151
 152         (void) config_parse_standard_file_with_dropins(
 153                         "systemd/sleep.conf",
 154                         "Sleep\0",
 155                         config_item_table_lookup, items,
 156                         CONFIG_PARSE_WARN,
 157                         /* userdata= */ NULL);
 158
 159         /* use default values unless set */
 160         sc->allow[SLEEP_SUSPEND] = allow_suspend != 0;
 161         sc->allow[SLEEP_HIBERNATE] = allow_hibernate != 0;
 162         sc->allow[SLEEP_HYBRID_SLEEP] = allow_hybrid_sleep >= 0 ? allow_hybrid_sleep
 163                 : (allow_suspend != 0 && allow_hibernate != 0);
 164         sc->allow[SLEEP_SUSPEND_THEN_HIBERNATE] = allow_s2h >= 0 ? allow_s2h
 165                 : (allow_suspend != 0 && allow_hibernate != 0);
 166
 167         for (SleepOperation i = 0; i < _SLEEP_OPERATION_CONFIG_MAX; i++) {
 168                 if (!sc->states[i] && sleep_default_state_table[i]) {
 169                         sc->states[i] = strv_copy(sleep_default_state_table[i]);
 170                         if (!sc->states[i])
 171                                 return log_oom();
 172                 }
 173
 174                 if (!sc->modes[i] && sleep_default_mode_table[i]) {
 175                         sc->modes[i] = strv_copy(sleep_default_mode_table[i]);
 176                         if (!sc->modes[i])
 177                                 return log_oom();
 178                 }
 179         }
 180
 181         if (sc->suspend_estimation_usec == 0)
 182                 sc->suspend_estimation_usec = DEFAULT_SUSPEND_ESTIMATION_USEC;
 183
 184         sleep_config_validate_state_and_mode(sc);
 185
 186         *ret = TAKE_PTR(sc);
 187         return 0;
 188 }
 189
 190 int sleep_state_supported(char * const *states) {
 191         _cleanup_free_ char *supported_sysfs = NULL;
 192         const char *found;
 193         int r;
 194
 195         if (strv_isempty(states))
 196                 return log_debug_errno(SYNTHETIC_ERRNO(ENOMSG), "No sleep state configured.");
 197
 198         if (access("/sys/power/state", W_OK) < 0)
 199                 return log_debug_errno(errno, "/sys/power/state is not writable: %m");
 200
 201         r = read_one_line_file("/sys/power/state", &supported_sysfs);
 202         if (r < 0)
 203                 return log_debug_errno(r, "Failed to read /sys/power/state: %m");
 204
 205         r = string_contains_word_strv(supported_sysfs, NULL, states, &found);
 206         if (r < 0)
 207                 return log_debug_errno(r, "Failed to parse /sys/power/state: %m");
 208         if (r > 0) {
 209                 log_debug("Sleep state '%s' is supported by kernel.", found);
 210                 return true;
 211         }
 212
 213         if (DEBUG_LOGGING) {
 214                 _cleanup_free_ char *joined = strv_join(states, " ");
 215                 log_debug("None of the configured sleep states are supported by kernel: %s", strnull(joined));
 216         }
 217         return false;
 218 }
 219
 220 int sleep_mode_supported(const char *path, char * const *modes) {
 221         _cleanup_free_ char *supported_sysfs = NULL;
 222         int r;
 223
 224         assert(path);
 225
 226         /* Unlike state, kernel has its own default choice if not configured */
 227         if (strv_isempty(modes)) {
 228                 log_debug("No sleep mode configured, using kernel default for %s.", path);
 229                 return true;
 230         }
 231
 232         if (access(path, W_OK) < 0)
 233                 return log_debug_errno(errno, "%s is not writable: %m", path);
 234
 235         r = read_one_line_file(path, &supported_sysfs);
 236         if (r < 0)
 237                 return log_debug_errno(r, "Failed to read %s: %m", path);
 238
 239         for (const char *p = supported_sysfs;;) {
 240                 _cleanup_free_ char *word = NULL;
 241                 char *mode;
 242                 size_t l;
 243
 244                 r = extract_first_word(&p, &word, NULL, 0);
 245                 if (r < 0)
 246                         return log_debug_errno(r, "Failed to parse %s: %m", path);
 247                 if (r == 0)
 248                         break;
 249
 250                 mode = word;
 251                 l = strlen(word);
 252
 253                 if (mode[0] == '[' && mode[l - 1] == ']') {
 254                         mode[l - 1] = '\0';
 255                         mode++;
 256                 }
 257
 258                 if (strv_contains(modes, mode)) {
 259                         log_debug("Sleep mode '%s' is supported by kernel (%s).", mode, path);
 260                         return true;
 261                 }
 262         }
 263
 264         if (DEBUG_LOGGING) {
 265                 _cleanup_free_ char *joined = strv_join(modes, " ");
 266                 log_debug("None of the configured modes are supported by kernel (%s): %s",
 267                           path, strnull(joined));
 268         }
 269         return false;
 270 }
 271
 272 static int sleep_supported_internal(
 273                 const SleepConfig *sleep_config,
 274                 SleepOperation operation,
 275                 bool check_allowed,
 276                 SleepSupport *ret_support);
 277
 278 static int s2h_supported(const SleepConfig *sleep_config, SleepSupport *ret_support) {
 279
 280         static const SleepOperation operations[] = {
 281                 SLEEP_SUSPEND,
 282                 SLEEP_HIBERNATE,
 283         };
 284
 285         SleepSupport support;
 286         int r;
 287
 288         assert(sleep_config);
 289         assert(ret_support);
 290
 291         if (!clock_supported(CLOCK_BOOTTIME_ALARM)) {
 292                 log_debug("CLOCK_BOOTTIME_ALARM is not supported, can't perform %s.", sleep_operation_to_string(SLEEP_SUSPEND_THEN_HIBERNATE));
 293                 *ret_support = SLEEP_ALARM_NOT_SUPPORTED;
 294                 return false;
 295         }
 296
 297         FOREACH_ELEMENT(i, operations) {
 298                 r = sleep_supported_internal(sleep_config, *i, /* check_allowed = */ false, &support);
 299                 if (r < 0)
 300                         return r;
 301                 if (r == 0) {
 302                         log_debug("Sleep operation %s is not supported, can't perform %s.",
 303                                   sleep_operation_to_string(*i), sleep_operation_to_string(SLEEP_SUSPEND_THEN_HIBERNATE));
 304                         *ret_support = support;
 305                         return false;
 306                 }
 307         }
 308
 309         assert(support == SLEEP_SUPPORTED);
 310         *ret_support = support;
 311
 312         return true;
 313 }
 314
 315 static int sleep_supported_internal(
 316                 const SleepConfig *sleep_config,
 317                 SleepOperation operation,
 318                 bool check_allowed,
 319                 SleepSupport *ret_support) {
 320
 321         int r;
 322
 323         assert(sleep_config);
 324         assert(operation >= 0);
 325         assert(operation < _SLEEP_OPERATION_MAX);
 326         assert(ret_support);
 327
 328         if (check_allowed && !sleep_config->allow[operation]) {
 329                 log_debug("Sleep operation %s is disabled by configuration.", sleep_operation_to_string(operation));
 330                 *ret_support = SLEEP_DISABLED;
 331                 return false;
 332         }
 333
 334         if (operation == SLEEP_SUSPEND_THEN_HIBERNATE)
 335                 return s2h_supported(sleep_config, ret_support);
 336
 337         assert(operation < _SLEEP_OPERATION_CONFIG_MAX);
 338
 339         r = sleep_state_supported(sleep_config->states[operation]);
 340         if (r == -ENOMSG) {
 341                 *ret_support = SLEEP_NOT_CONFIGURED;
 342                 return false;
 343         }
 344         if (r < 0)
 345                 return r;
 346         if (r == 0) {
 347                 *ret_support = SLEEP_STATE_OR_MODE_NOT_SUPPORTED;
 348                 return false;
 349         }
 350
 351         if (SLEEP_NEEDS_MEM_SLEEP(sleep_config, operation)) {
 352                 r = sleep_mode_supported("/sys/power/mem_sleep", sleep_config->mem_modes);
 353                 if (r < 0)
 354                         return r;
 355                 if (r == 0) {
 356                         *ret_support = SLEEP_STATE_OR_MODE_NOT_SUPPORTED;
 357                         return false;
 358                 }
 359         }
 360
 361         if (SLEEP_OPERATION_IS_HIBERNATION(operation)) {
 362                 r = sleep_mode_supported("/sys/power/disk", sleep_config->modes[operation]);
 363                 if (r < 0)
 364                         return r;
 365                 if (r == 0) {
 366                         *ret_support = SLEEP_STATE_OR_MODE_NOT_SUPPORTED;
 367                         return false;
 368                 }
 369
 370                 r = hibernation_is_safe();
 371                 if (r == -ENOTRECOVERABLE) {
 372                         *ret_support = SLEEP_RESUME_NOT_SUPPORTED;
 373                         return false;
 374                 }
 375                 if (r == -ENOSPC) {
 376                         *ret_support = SLEEP_NOT_ENOUGH_SWAP_SPACE;
 377                         return false;
 378                 }
 379                 if (r < 0)
 380                         return r;
 381         } else
 382                 assert(!sleep_config->modes[operation]);
 383
 384         *ret_support = SLEEP_SUPPORTED;
 385         return true;
 386 }
 387
 388 int sleep_supported_full(SleepOperation operation, SleepSupport *ret_support) {
 389         _cleanup_(sleep_config_freep) SleepConfig *sleep_config = NULL;
 390         SleepSupport support;
 391         int r;
 392
 393         assert(operation >= 0);
 394         assert(operation < _SLEEP_OPERATION_MAX);
 395
 396         r = parse_sleep_config(&sleep_config);
 397         if (r < 0)
 398                 return r;
 399
 400         r = sleep_supported_internal(sleep_config, operation, /* check_allowed = */ true, &support);
 401         if (r < 0)
 402                 return r;
 403
 404         assert((r > 0) == (support == SLEEP_SUPPORTED));
 405
 406         if (ret_support)
 407                 *ret_support = support;
 408
 409         return r;
 410 }