src/sleep/sleep.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2010-2017 Canonical
   4   Copyright © 2018 Dell Inc.
   5 ***/
   6
   7 #include <fcntl.h>
   8 #include <getopt.h>
   9 #include <poll.h>
  10 #include <stdlib.h>
  11 #include <sys/timerfd.h>
  12 #include <sys/utsname.h>
  13
  14 #include "sd-bus.h"
  15 #include "sd-device.h"
  16 #include "sd-id128.h"
  17 #include "sd-json.h"
  18 #include "sd-messages.h"
  19
  20 #include "alloc-util.h"
  21 #include "battery-capacity.h"
  22 #include "battery-util.h"
  23 #include "blockdev-util.h"
  24 #include "build.h"
  25 #include "bus-error.h"
  26 #include "bus-locator.h"
  27 #include "bus-unit-util.h"
  28 #include "bus-util.h"
  29 #include "constants.h"
  30 #include "efivars.h"
  31 #include "env-util.h"
  32 #include "errno-util.h"
  33 #include "exec-util.h"
  34 #include "fd-util.h"
  35 #include "fileio.h"
  36 #include "hibernate-util.h"
  37 #include "io-util.h"
  38 #include "log.h"
  39 #include "main-func.h"
  40 #include "os-util.h"
  41 #include "pretty-print.h"
  42 #include "sleep-config.h"
  43 #include "special.h"
  44 #include "strv.h"
  45 #include "time-util.h"
  46
  47 #define DEFAULT_HIBERNATE_DELAY_USEC_NO_BATTERY (2 * USEC_PER_HOUR)
  48
  49 static SleepOperation arg_operation = _SLEEP_OPERATION_INVALID;
  50
  51 #if ENABLE_EFI
  52 static int determine_auto_swap(sd_device *device) {
  53         _cleanup_(sd_device_unrefp) sd_device *origin = NULL;
  54         const char *part_designator;
  55         int r;
  56
  57         /* Check if the selected hibernation device is the "auto" one. Specifically, trace to the partition
  58          * block device and check if ID_DISSECT_PART_DESIGNATOR property is set to "swap" by udev
  59          * dissect_image builtin. Later hibernate-resume-generator will generate cryptsetup unit based on
  60          * this info. */
  61
  62         assert(device);
  63
  64         r = block_device_get_originating(device, &origin);
  65         if (r < 0 && r != -ENOENT)
  66                 return r;
  67         if (r >= 0)
  68                 device = origin;
  69
  70         r = sd_device_get_property_value(device, "ID_DISSECT_PART_DESIGNATOR", &part_designator);
  71         if (r == -ENOENT)
  72                 return false;
  73         if (r < 0)
  74                 return r;
  75
  76         return streq(part_designator, "swap");
  77 }
  78 #endif
  79
  80 static int write_efi_hibernate_location(const HibernationDevice *hibernation_device, bool required) {
  81         int log_level = required ? LOG_ERR : LOG_DEBUG;
  82
  83 #if ENABLE_EFI
  84         _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
  85         _cleanup_free_ char *formatted = NULL, *id = NULL, *image_id = NULL,
  86                        *version_id = NULL, *image_version = NULL;
  87         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
  88         const char *uuid_str;
  89         sd_id128_t uuid;
  90         struct utsname uts = {};
  91         int r, auto_swap, log_level_ignore = required ? LOG_WARNING : LOG_DEBUG;
  92
  93         assert(hibernation_device);
  94
  95         if (!is_efi_boot())
  96                 return log_full_errno(log_level, SYNTHETIC_ERRNO(EOPNOTSUPP),
  97                                       "Not an EFI boot, passing HibernateLocation via EFI variable is not possible.");
  98
  99         r = sd_device_new_from_devnum(&device, 'b', hibernation_device->devno);
 100         if (r < 0)
 101                 return log_full_errno(log_level, r, "Failed to create sd-device object for '%s': %m",
 102                                       hibernation_device->path);
 103
 104         r = sd_device_get_property_value(device, "ID_FS_UUID", &uuid_str);
 105         if (r < 0)
 106                 return log_full_errno(log_level, r, "Failed to get filesystem UUID for device '%s': %m",
 107                                       hibernation_device->path);
 108
 109         r = sd_id128_from_string(uuid_str, &uuid);
 110         if (r < 0)
 111                 return log_full_errno(log_level, r, "Failed to parse ID_FS_UUID '%s' for device '%s': %m",
 112                                       uuid_str, hibernation_device->path);
 113
 114         auto_swap = determine_auto_swap(device);
 115         if (auto_swap < 0)
 116                 log_full_errno(log_level_ignore, auto_swap,
 117                                "Failed to get partition designator of '%s', ignoring: %m", hibernation_device->path);
 118
 119         if (uname(&uts) < 0)
 120                 log_full_errno(log_level_ignore, errno, "Failed to get kernel info, ignoring: %m");
 121
 122         r = parse_os_release(NULL,
 123                              "ID", &id,
 124                              "IMAGE_ID", &image_id,
 125                              "VERSION_ID", &version_id,
 126                              "IMAGE_VERSION", &image_version);
 127         if (r < 0)
 128                 log_full_errno(log_level_ignore, r, "Failed to parse os-release, ignoring: %m");
 129
 130         r = sd_json_buildo(
 131                         &v,
 132                         SD_JSON_BUILD_PAIR_UUID("uuid", uuid),
 133                         SD_JSON_BUILD_PAIR_UNSIGNED("offset", hibernation_device->offset),
 134                         SD_JSON_BUILD_PAIR_CONDITION(auto_swap >= 0, "autoSwap", SD_JSON_BUILD_BOOLEAN(auto_swap)),
 135                         SD_JSON_BUILD_PAIR_CONDITION(!isempty(uts.release), "kernelVersion", SD_JSON_BUILD_STRING(uts.release)),
 136                         SD_JSON_BUILD_PAIR_CONDITION(!!id, "osReleaseId", SD_JSON_BUILD_STRING(id)),
 137                         SD_JSON_BUILD_PAIR_CONDITION(!!image_id, "osReleaseImageId", SD_JSON_BUILD_STRING(image_id)),
 138                         SD_JSON_BUILD_PAIR_CONDITION(!!version_id, "osReleaseVersionId", SD_JSON_BUILD_STRING(version_id)),
 139                         SD_JSON_BUILD_PAIR_CONDITION(!!image_version, "osReleaseImageVersion", SD_JSON_BUILD_STRING(image_version)));
 140         if (r < 0)
 141                 return log_full_errno(log_level, r, "Failed to build JSON object: %m");
 142
 143         r = sd_json_variant_format(v, 0, &formatted);
 144         if (r < 0)
 145                 return log_full_errno(log_level, r, "Failed to format JSON object: %m");
 146
 147         r = efi_set_variable_string(EFI_SYSTEMD_VARIABLE_STR("HibernateLocation"), formatted);
 148         if (r < 0)
 149                 return log_full_errno(log_level, r, "Failed to set EFI variable HibernateLocation: %m");
 150
 151         log_debug("Set EFI variable HibernateLocation to '%s'.", formatted);
 152         return 0;
 153 #else
 154         return log_full_errno(log_level, SYNTHETIC_ERRNO(EOPNOTSUPP),
 155                               "EFI support not enabled, passing HibernateLocation via EFI variable is not possible.");
 156 #endif
 157 }
 158
 159 static int write_state(int fd, char * const *states) {
 160         int r = 0;
 161
 162         assert(fd >= 0);
 163         assert(states);
 164
 165         STRV_FOREACH(state, states) {
 166                 _cleanup_fclose_ FILE *f = NULL;
 167                 int k;
 168
 169                 k = fdopen_independent(fd, "we", &f);
 170                 if (k < 0)
 171                         return RET_GATHER(r, k);
 172
 173                 k = write_string_stream(f, *state, WRITE_STRING_FILE_DISABLE_BUFFER);
 174                 if (k >= 0) {
 175                         log_debug("Using sleep state '%s'.", *state);
 176                         return 0;
 177                 }
 178
 179                 RET_GATHER(r, log_debug_errno(k, "Failed to write '%s' to /sys/power/state: %m", *state));
 180         }
 181
 182         return r;
 183 }
 184
 185 static int write_mode(const char *path, char * const *modes) {
 186         int r, ret = 0;
 187
 188         assert(path);
 189
 190         STRV_FOREACH(mode, modes) {
 191                 r = write_string_file(path, *mode, WRITE_STRING_FILE_DISABLE_BUFFER);
 192                 if (r >= 0) {
 193                         log_debug("Using sleep mode '%s' for %s.", *mode, path);
 194                         return 0;
 195                 }
 196
 197                 RET_GATHER(ret, log_debug_errno(r, "Failed to write '%s' to %s: %m", *mode, path));
 198         }
 199
 200         return ret;
 201 }
 202
 203 static int lock_all_homes(void) {
 204         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 205         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 206         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 207         int r;
 208
 209         /* Let's synchronously lock all home directories managed by homed that have been marked for it. This
 210          * way the key material required to access these volumes is hopefully removed from memory. */
 211
 212         r = sd_bus_open_system(&bus);
 213         if (r < 0)
 214                 return log_error_errno(r, "Failed to connect to system bus: %m");
 215
 216         r = bus_message_new_method_call(bus, &m, bus_home_mgr, "LockAllHomes");
 217         if (r < 0)
 218                 return bus_log_create_error(r);
 219
 220         /* If homed is not running it can't have any home directories active either. */
 221         r = sd_bus_message_set_auto_start(m, false);
 222         if (r < 0)
 223                 return log_error_errno(r, "Failed to disable auto-start of LockAllHomes() message: %m");
 224
 225         r = sd_bus_call(bus, m, DEFAULT_TIMEOUT_USEC, &error, NULL);
 226         if (r < 0) {
 227                 if (!bus_error_is_unknown_service(&error))
 228                         return log_error_errno(r, "Failed to lock home directories: %s", bus_error_message(&error, r));
 229
 230                 log_debug("systemd-homed is not running, locking of home directories skipped.");
 231         } else
 232                 log_debug("Successfully requested locking of all home directories.");
 233         return 0;
 234 }
 235
 236 static int execute(
 237                 const SleepConfig *sleep_config,
 238                 SleepOperation operation,
 239                 const char *action) {
 240
 241         const char *arguments[] = {
 242                 NULL,
 243                 "pre",
 244                 /* NB: we use 'arg_operation' instead of 'operation' here, as we want to communicate the overall
 245                  * operation here, not the specific one, in case of s2h. */
 246                 sleep_operation_to_string(arg_operation),
 247                 NULL
 248         };
 249         static const char* const dirs[] = {
 250                 SYSTEM_SLEEP_PATH,
 251                 NULL
 252         };
 253
 254         _cleanup_close_ int state_fd = -EBADF;
 255         int r;
 256
 257         assert(sleep_config);
 258         assert(operation >= 0);
 259         assert(operation < _SLEEP_OPERATION_CONFIG_MAX); /* Others are handled by execute_s2h() instead */
 260
 261         if (strv_isempty(sleep_config->states[operation]))
 262                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 263                                        "No sleep states configured for sleep operation %s, can't sleep.",
 264                                        sleep_operation_to_string(operation));
 265
 266         /* This file is opened first, so that if we hit an error, we can abort before modifying any state. */
 267         state_fd = open("/sys/power/state", O_WRONLY|O_CLOEXEC);
 268         if (state_fd < 0)
 269                 return log_error_errno(errno, "Failed to open %s: %m", "/sys/power/state");
 270
 271         if (sleep_needs_mem_sleep(sleep_config, operation)) {
 272                 r = write_mode("/sys/power/mem_sleep", sleep_config->mem_modes);
 273                 if (r < 0)
 274                         return log_error_errno(r, "Failed to write mode to /sys/power/mem_sleep: %m");
 275         }
 276
 277         /* Configure hibernation settings if we are supposed to hibernate */
 278         if (SLEEP_OPERATION_IS_HIBERNATION(operation)) {
 279                 _cleanup_(hibernation_device_done) HibernationDevice hibernation_device = {};
 280                 bool resume_set;
 281
 282                 r = find_suitable_hibernation_device(&hibernation_device);
 283                 if (r < 0)
 284                         return log_error_errno(r, "Failed to find location to hibernate to: %m");
 285                 resume_set = r > 0;
 286
 287                 r = write_efi_hibernate_location(&hibernation_device, !resume_set);
 288                 if (!resume_set) {
 289                         if (r == -EOPNOTSUPP)
 290                                 return log_error_errno(r, "No valid 'resume=' option found, refusing to hibernate.");
 291                         if (r < 0)
 292                                 return r;
 293
 294                         r = write_resume_config(hibernation_device.devno, hibernation_device.offset, hibernation_device.path);
 295                         if (r < 0)
 296                                 goto fail;
 297                 }
 298
 299                 r = write_mode("/sys/power/disk", sleep_config->modes[operation]);
 300                 if (r < 0) {
 301                         log_error_errno(r, "Failed to write mode to /sys/power/disk: %m");
 302                         goto fail;
 303                 }
 304         }
 305
 306         /* Pass an action string to the call-outs. This is mostly our operation string, except if the
 307          * hibernate step of s-t-h fails, in which case we communicate that with a separate action. */
 308         if (!action)
 309                 action = sleep_operation_to_string(operation);
 310
 311         if (setenv("SYSTEMD_SLEEP_ACTION", action, /* overwrite = */ 1) < 0)
 312                 log_warning_errno(errno, "Failed to set SYSTEMD_SLEEP_ACTION=%s, ignoring: %m", action);
 313
 314         (void) execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, (char **) arguments, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
 315         (void) lock_all_homes();
 316
 317         log_struct(LOG_INFO,
 318                    LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_START_STR),
 319                    LOG_MESSAGE("Performing sleep operation '%s'...", sleep_operation_to_string(operation)),
 320                    LOG_ITEM("SLEEP=%s", sleep_operation_to_string(arg_operation)));
 321
 322         r = write_state(state_fd, sleep_config->states[operation]);
 323         if (r < 0)
 324                 log_struct_errno(LOG_ERR, r,
 325                                  LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP_STR),
 326                                  LOG_MESSAGE("Failed to put system to sleep. System resumed again: %m"),
 327                                  LOG_ITEM("SLEEP=%s", sleep_operation_to_string(arg_operation)));
 328         else
 329                 log_struct(LOG_INFO,
 330                            LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP_STR),
 331                            LOG_MESSAGE("System returned from sleep operation '%s'.", sleep_operation_to_string(arg_operation)),
 332                            LOG_ITEM("SLEEP=%s", sleep_operation_to_string(arg_operation)));
 333
 334         arguments[1] = "post";
 335         (void) execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, (char **) arguments, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
 336
 337         if (r >= 0)
 338                 return 0;
 339
 340 fail:
 341         if (SLEEP_OPERATION_IS_HIBERNATION(operation))
 342                 (void) clear_efi_hibernate_location_and_warn();
 343
 344         return r;
 345 }
 346
 347 /* Return true if wakeup type is APM timer */
 348 static int check_wakeup_type(void) {
 349         static const char dmi_object_path[] = "/sys/firmware/dmi/entries/1-0/raw";
 350         uint8_t wakeup_type_byte, tablesize;
 351         _cleanup_free_ char *buf = NULL;
 352         size_t bufsize;
 353         int r;
 354
 355         /* implementation via dmi/entries */
 356         r = read_full_virtual_file(dmi_object_path, &buf, &bufsize);
 357         if (r < 0)
 358                 return log_debug_errno(r, "Unable to read %s: %m", dmi_object_path);
 359         if (bufsize < 25)
 360                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
 361                                        "Only read %zu bytes from %s (expected 25)",
 362                                        bufsize, dmi_object_path);
 363
 364         /* index 1 stores the size of table */
 365         tablesize = (uint8_t) buf[1];
 366         if (tablesize < 25)
 367                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
 368                                        "Table size less than the index[0x18] where waketype byte is available.");
 369
 370         wakeup_type_byte = (uint8_t) buf[24];
 371         /* 0 is Reserved and 8 is AC Power Restored. As per table 12 in
 372          * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.4.0.pdf */
 373         if (wakeup_type_byte >= 128)
 374                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Expected value in range 0-127");
 375
 376         if (wakeup_type_byte == 3) {
 377                 log_debug("DMI BIOS System Information indicates wakeup type is APM Timer");
 378                 return true;
 379         }
 380
 381         return false;
 382 }
 383
 384 static int custom_timer_suspend(const SleepConfig *sleep_config) {
 385         usec_t hibernate_timestamp;
 386         int r;
 387
 388         assert(sleep_config);
 389
 390         hibernate_timestamp = usec_add(now(CLOCK_BOOTTIME), sleep_config->hibernate_delay_usec);
 391
 392         while (battery_is_discharging_and_low() == 0) {
 393                 _cleanup_hashmap_free_ Hashmap *last_capacity = NULL, *current_capacity = NULL;
 394                 _cleanup_close_ int tfd = -EBADF;
 395                 struct itimerspec ts = {};
 396                 usec_t suspend_interval;
 397                 bool woken_by_timer;
 398
 399                 tfd = timerfd_create(CLOCK_BOOTTIME_ALARM, TFD_NONBLOCK|TFD_CLOEXEC);
 400                 if (tfd < 0)
 401                         return log_error_errno(errno, "Error creating timerfd: %m");
 402
 403                 /* Store current battery capacity before suspension */
 404                 r = fetch_batteries_capacity_by_name(&last_capacity);
 405                 if (r < 0)
 406                         return log_error_errno(r, "Error fetching battery capacity percentage: %m");
 407
 408                 if (hashmap_isempty(last_capacity))
 409                         /* In case of no battery, system suspend interval will be set to HibernateDelaySec= or 2 hours. */
 410                         suspend_interval = timestamp_is_set(hibernate_timestamp)
 411                                            ? sleep_config->hibernate_delay_usec : DEFAULT_HIBERNATE_DELAY_USEC_NO_BATTERY;
 412                 else {
 413                         r = get_total_suspend_interval(last_capacity, &suspend_interval);
 414                         if (r < 0) {
 415                                 log_debug_errno(r, "Failed to estimate suspend interval using previous discharge rate, ignoring: %m");
 416                                 /* In case of any errors, especially when we do not know the battery
 417                                  * discharging rate, system suspend interval will be set to
 418                                  * SuspendEstimationSec=. */
 419                                 suspend_interval = sleep_config->suspend_estimation_usec;
 420                         }
 421                 }
 422
 423                 /* Do not suspend more than HibernateDelaySec= unless HibernateOnACPower=no and currently on AC power */
 424                 if (!sleep_config->hibernate_on_ac_power) {
 425                         /* Do not allow "decay" to suspend if the system has no battery. */
 426                         if (hashmap_isempty(last_capacity))
 427                                 log_once(LOG_WARNING, "HibernateOnACPower=no was ignored because the system does not have a battery.");
 428                         else if (on_ac_power() > 0)
 429                                 hibernate_timestamp = usec_add(now(CLOCK_BOOTTIME), sleep_config->hibernate_delay_usec);
 430                 }
 431
 432                 usec_t before_timestamp = now(CLOCK_BOOTTIME);
 433                 suspend_interval = MIN(suspend_interval, usec_sub_unsigned(hibernate_timestamp, before_timestamp));
 434                 if (suspend_interval <= 0)
 435                         break; /* system should hibernate */
 436
 437                 log_debug("Set timerfd wake alarm for %s", FORMAT_TIMESPAN(suspend_interval, USEC_PER_SEC));
 438                 /* Wake alarm for system with or without battery to hibernate or estimate discharge rate whichever is applicable */
 439                 timespec_store(&ts.it_value, suspend_interval);
 440
 441                 if (timerfd_settime(tfd, 0, &ts, NULL) < 0)
 442                         return log_error_errno(errno, "Error setting battery estimate timer: %m");
 443
 444                 r = execute(sleep_config, SLEEP_SUSPEND, NULL);
 445                 if (r < 0)
 446                         return r;
 447
 448                 r = fd_wait_for_event(tfd, POLLIN, 0);
 449                 if (r < 0)
 450                         return log_error_errno(r, "Error polling timerfd: %m");
 451                 /* Store fd_wait status */
 452                 woken_by_timer = FLAGS_SET(r, POLLIN);
 453
 454                 r = fetch_batteries_capacity_by_name(&current_capacity);
 455                 if (r < 0 || hashmap_isempty(current_capacity)) {
 456                         /* In case of no battery or error while getting charge level, no need to measure
 457                          * discharge rate. Instead the system should wake up if it is manual wakeup or
 458                          * hibernate if this is a timer wakeup. */
 459                         if (r < 0)
 460                                 log_debug_errno(r, "Battery capacity percentage unavailable, cannot estimate discharge rate: %m");
 461                         else
 462                                 log_debug("No battery found.");
 463                         if (!woken_by_timer)
 464                                 return 0;
 465                         break;
 466                 }
 467
 468                 usec_t after_timestamp = now(CLOCK_BOOTTIME);
 469                 log_debug("Attempting to estimate battery discharge rate after wakeup from %s sleep",
 470                           FORMAT_TIMESPAN(after_timestamp - before_timestamp, USEC_PER_HOUR));
 471
 472                 if (after_timestamp != before_timestamp) {
 473                         r = estimate_battery_discharge_rate_per_hour(last_capacity, current_capacity, before_timestamp, after_timestamp);
 474                         if (r < 0)
 475                                 log_warning_errno(r, "Failed to estimate and update battery discharge rate, ignoring: %m");
 476                 } else
 477                         log_debug("System woke up too early to estimate discharge rate.");
 478
 479                 if (!woken_by_timer)
 480                         /* Return as manual wakeup done. This also will return in case battery was charged during suspension */
 481                         return 0;
 482
 483                 r = check_wakeup_type();
 484                 if (r > 0) {
 485                         log_debug("wakeup type is APM timer");
 486                         /* system should hibernate */
 487                         break;
 488                 }
 489         }
 490
 491         return 1;
 492 }
 493
 494 static int execute_s2h(const SleepConfig *sleep_config) {
 495         int r;
 496
 497         assert(sleep_config);
 498
 499         /* Only check if we have automated battery alarms if HibernateDelaySec= is not set, as in that case
 500          * we'll busy poll for the configured interval instead */
 501         if (!timestamp_is_set(sleep_config->hibernate_delay_usec)) {
 502                 r = check_wakeup_type();
 503                 if (r < 0)
 504                         log_warning_errno(r, "Failed to check hardware wakeup type, ignoring: %m");
 505                 else {
 506                         r = battery_trip_point_alarm_exists();
 507                         if (r < 0)
 508                                 log_warning_errno(r, "Failed to check whether acpi_btp support is enabled or not, ignoring: %m");
 509                 }
 510         } else
 511                 r = 0;  /* Force fallback path */
 512
 513         if (r > 0) { /* If we have both wakeup alarms and battery trip point support, use them */
 514                 log_debug("Attempting to suspend...");
 515                 r = execute(sleep_config, SLEEP_SUSPEND, NULL);
 516                 if (r < 0)
 517                         return r;
 518
 519                 r = check_wakeup_type();
 520                 if (r < 0)
 521                         return log_error_errno(r, "Failed to check hardware wakeup type: %m");
 522
 523                 if (r == 0)
 524                         /* For APM Timer wakeup, system should hibernate else wakeup */
 525                         return 0;
 526         } else {
 527                 r = custom_timer_suspend(sleep_config);
 528                 if (r < 0)
 529                         return log_debug_errno(r, "Suspend cycle with manual battery discharge rate estimation failed: %m");
 530                 if (r == 0)
 531                         /* manual wakeup */
 532                         return 0;
 533         }
 534         /* For above custom timer, if 1 is returned, system will directly hibernate */
 535
 536         log_debug("Attempting to hibernate");
 537         r = execute(sleep_config, SLEEP_HIBERNATE, NULL);
 538         if (r < 0) {
 539                 log_notice("Couldn't hibernate, will try to suspend again.");
 540
 541                 r = execute(sleep_config, SLEEP_SUSPEND, "suspend-after-failed-hibernate");
 542                 if (r < 0)
 543                         return r;
 544         }
 545
 546         return 0;
 547 }
 548
 549 static int help(void) {
 550         _cleanup_free_ char *link = NULL;
 551         int r;
 552
 553         r = terminal_urlify_man("systemd-suspend.service", "8", &link);
 554         if (r < 0)
 555                 return log_oom();
 556
 557         printf("%s COMMAND\n\n"
 558                "Suspend the system, hibernate the system, or both.\n\n"
 559                "  -h --help              Show this help and exit\n"
 560                "  --version              Print version string and exit\n"
 561                "\nCommands:\n"
 562                "  suspend                Suspend the system\n"
 563                "  hibernate              Hibernate the system\n"
 564                "  hybrid-sleep           Both hibernate and suspend the system\n"
 565                "  suspend-then-hibernate Initially suspend and then hibernate\n"
 566                "                         the system after a fixed period of time or\n"
 567                "                         when battery is low\n"
 568                "\nSee the %s for details.\n",
 569                program_invocation_short_name,
 570                link);
 571
 572         return 0;
 573 }
 574
 575 static int parse_argv(int argc, char *argv[]) {
 576
 577         enum {
 578                 ARG_VERSION = 0x100,
 579         };
 580
 581         static const struct option options[] = {
 582                 { "help",         no_argument,       NULL, 'h'           },
 583                 { "version",      no_argument,       NULL, ARG_VERSION   },
 584                 {}
 585         };
 586
 587         int c;
 588
 589         assert(argc >= 0);
 590         assert(argv);
 591
 592         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 593                 switch (c) {
 594
 595                 case 'h':
 596                         return help();
 597
 598                 case ARG_VERSION:
 599                         return version();
 600
 601                 case '?':
 602                         return -EINVAL;
 603
 604                 default:
 605                         assert_not_reached();
 606
 607                 }
 608
 609         if (argc - optind != 1)
 610                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 611                                        "Usage: %s COMMAND",
 612                                        program_invocation_short_name);
 613
 614         arg_operation = sleep_operation_from_string(argv[optind]);
 615         if (arg_operation < 0)
 616                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown command '%s'.", argv[optind]);
 617
 618         return 1 /* work to do */;
 619 }
 620
 621 static int run(int argc, char *argv[]) {
 622         _cleanup_(unit_freezer_freep) UnitFreezer *user_slice_freezer = NULL;
 623         _cleanup_(sleep_config_freep) SleepConfig *sleep_config = NULL;
 624         int r;
 625
 626         log_setup();
 627
 628         r = parse_argv(argc, argv);
 629         if (r <= 0)
 630                 return r;
 631
 632         r = parse_sleep_config(&sleep_config);
 633         if (r < 0)
 634                 return r;
 635
 636         if (!sleep_config->allow[arg_operation])
 637                 return log_error_errno(SYNTHETIC_ERRNO(EACCES),
 638                                        "Sleep operation \"%s\" is disabled by configuration, refusing.",
 639                                        sleep_operation_to_string(arg_operation));
 640
 641         /* Freeze the user sessions */
 642         r = getenv_bool("SYSTEMD_SLEEP_FREEZE_USER_SESSIONS");
 643         if (r < 0 && r != -ENXIO)
 644                 log_warning_errno(r, "Cannot parse value of $SYSTEMD_SLEEP_FREEZE_USER_SESSIONS, ignoring: %m");
 645         if (r != 0) {
 646                 r = unit_freezer_new(SPECIAL_USER_SLICE, &user_slice_freezer);
 647                 if (r < 0)
 648                         return r;
 649
 650                 (void) unit_freezer_freeze(user_slice_freezer);
 651         } else
 652                 log_notice("User sessions remain unfrozen on explicit request ($SYSTEMD_SLEEP_FREEZE_USER_SESSIONS=0).\n"
 653                            "This is not recommended, and might result in unexpected behavior, particularly\n"
 654                            "in suspend-then-hibernate operations or setups with encrypted home directories.");
 655
 656         switch (arg_operation) {
 657
 658         case SLEEP_SUSPEND_THEN_HIBERNATE:
 659                 r = execute_s2h(sleep_config);
 660                 break;
 661
 662         case SLEEP_HYBRID_SLEEP:
 663                 r = execute(sleep_config, SLEEP_HYBRID_SLEEP, NULL);
 664                 if (r < 0) {
 665                         /* If we can't hybrid sleep, then let's try to suspend at least. After all, the user
 666                          * asked us to do both: suspend + hibernate, and it's almost certainly the
 667                          * hibernation that failed, hence still do the other thing, the suspend. */
 668
 669                         log_notice_errno(r, "Couldn't hybrid sleep, will try to suspend instead: %m");
 670
 671                         r = execute(sleep_config, SLEEP_SUSPEND, "suspend-after-failed-hybrid-sleep");
 672                 }
 673
 674                 break;
 675
 676         case SLEEP_SUSPEND:
 677         case SLEEP_HIBERNATE:
 678                 r = execute(sleep_config, arg_operation, NULL);
 679                 break;
 680
 681         default:
 682                 assert_not_reached();
 683         }
 684
 685         if (user_slice_freezer)
 686                 RET_GATHER(r, unit_freezer_thaw(user_slice_freezer));
 687
 688         return r;
 689 }
 690
 691 DEFINE_MAIN_FUNCTION(run);