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