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 <linux/fiemap.h>
  11 #include <poll.h>
  12 #include <sys/stat.h>
  13 #include <sys/types.h>
  14 #include <sys/timerfd.h>
  15 #include <unistd.h>
  16
  17 #include "sd-bus.h"
  18 #include "sd-messages.h"
  19
  20 #include "battery-util.h"
  21 #include "btrfs-util.h"
  22 #include "build.h"
  23 #include "bus-error.h"
  24 #include "bus-locator.h"
  25 #include "bus-util.h"
  26 #include "constants.h"
  27 #include "devnum-util.h"
  28 #include "exec-util.h"
  29 #include "fd-util.h"
  30 #include "fileio.h"
  31 #include "format-util.h"
  32 #include "io-util.h"
  33 #include "log.h"
  34 #include "main-func.h"
  35 #include "parse-util.h"
  36 #include "pretty-print.h"
  37 #include "sleep-util.h"
  38 #include "special.h"
  39 #include "stdio-util.h"
  40 #include "string-util.h"
  41 #include "strv.h"
  42 #include "time-util.h"
  43
  44 #define DEFAULT_HIBERNATE_DELAY_USEC_NO_BATTERY (2 * USEC_PER_HOUR)
  45
  46 static SleepOperation arg_operation = _SLEEP_OPERATION_INVALID;
  47
  48 static int write_hibernate_location_info(const HibernateLocation *hibernate_location) {
  49         char offset_str[DECIMAL_STR_MAX(uint64_t)];
  50         const char *resume_str;
  51         int r;
  52
  53         assert(hibernate_location);
  54         assert(hibernate_location->swap);
  55
  56         resume_str = FORMAT_DEVNUM(hibernate_location->devno);
  57
  58         r = write_string_file("/sys/power/resume", resume_str, WRITE_STRING_FILE_DISABLE_BUFFER);
  59         if (r < 0)
  60                 return log_debug_errno(r, "Failed to write partition device to /sys/power/resume for '%s': '%s': %m",
  61                                        hibernate_location->swap->path, resume_str);
  62
  63         log_debug("Wrote resume= value for %s to /sys/power/resume: %s", hibernate_location->swap->path, resume_str);
  64
  65         /* if it's a swap partition, we're done */
  66         if (hibernate_location->swap->type == SWAP_BLOCK)
  67                 return 0;
  68
  69         assert(hibernate_location->swap->type == SWAP_FILE);
  70
  71         /* Only available in 4.17+ */
  72         if (hibernate_location->offset > 0 && access("/sys/power/resume_offset", W_OK) < 0) {
  73                 if (errno == ENOENT) {
  74                         log_debug("Kernel too old, can't configure resume_offset for %s, ignoring: %" PRIu64,
  75                                   hibernate_location->swap->path, hibernate_location->offset);
  76                         return 0;
  77                 }
  78
  79                 return log_debug_errno(errno, "/sys/power/resume_offset not writable: %m");
  80         }
  81
  82         xsprintf(offset_str, "%" PRIu64, hibernate_location->offset);
  83         r = write_string_file("/sys/power/resume_offset", offset_str, WRITE_STRING_FILE_DISABLE_BUFFER);
  84         if (r < 0)
  85                 return log_debug_errno(r, "Failed to write swap file offset to /sys/power/resume_offset for '%s': '%s': %m",
  86                                        hibernate_location->swap->path, offset_str);
  87
  88         log_debug("Wrote resume_offset= value for %s to /sys/power/resume_offset: %s", hibernate_location->swap->path, offset_str);
  89
  90         return 0;
  91 }
  92
  93 static int write_mode(char **modes) {
  94         int r = 0;
  95
  96         STRV_FOREACH(mode, modes) {
  97                 int k;
  98
  99                 k = write_string_file("/sys/power/disk", *mode, WRITE_STRING_FILE_DISABLE_BUFFER);
 100                 if (k >= 0)
 101                         return 0;
 102
 103                 log_debug_errno(k, "Failed to write '%s' to /sys/power/disk: %m", *mode);
 104                 if (r >= 0)
 105                         r = k;
 106         }
 107
 108         return r;
 109 }
 110
 111 static int write_state(FILE **f, char **states) {
 112         int r = 0;
 113
 114         assert(f);
 115         assert(*f);
 116
 117         STRV_FOREACH(state, states) {
 118                 int k;
 119
 120                 k = write_string_stream(*f, *state, WRITE_STRING_FILE_DISABLE_BUFFER);
 121                 if (k >= 0)
 122                         return 0;
 123                 log_debug_errno(k, "Failed to write '%s' to /sys/power/state: %m", *state);
 124                 if (r >= 0)
 125                         r = k;
 126
 127                 fclose(*f);
 128                 *f = fopen("/sys/power/state", "we");
 129                 if (!*f)
 130                         return -errno;
 131         }
 132
 133         return r;
 134 }
 135
 136 static int lock_all_homes(void) {
 137         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 138         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 139         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 140         int r;
 141
 142         /* Let's synchronously lock all home directories managed by homed that have been marked for it. This
 143          * way the key material required to access these volumes is hopefully removed from memory. */
 144
 145         r = sd_bus_open_system(&bus);
 146         if (r < 0)
 147                 return log_warning_errno(r, "Failed to connect to system bus, ignoring: %m");
 148
 149         r = bus_message_new_method_call(bus, &m, bus_home_mgr, "LockAllHomes");
 150         if (r < 0)
 151                 return bus_log_create_error(r);
 152
 153         /* If homed is not running it can't have any home directories active either. */
 154         r = sd_bus_message_set_auto_start(m, false);
 155         if (r < 0)
 156                 return log_error_errno(r, "Failed to disable auto-start of LockAllHomes() message: %m");
 157
 158         r = sd_bus_call(bus, m, DEFAULT_TIMEOUT_USEC, &error, NULL);
 159         if (r < 0) {
 160                 if (!bus_error_is_unknown_service(&error))
 161                         return log_error_errno(r, "Failed to lock home directories: %s", bus_error_message(&error, r));
 162
 163                 log_debug("systemd-homed is not running, locking of home directories skipped.");
 164         } else
 165                 log_debug("Successfully requested locking of all home directories.");
 166         return 0;
 167 }
 168
 169 static int execute(
 170                 const SleepConfig *sleep_config,
 171                 SleepOperation operation,
 172                 const char *action) {
 173
 174         char *arguments[] = {
 175                 NULL,
 176                 (char*) "pre",
 177                 /* NB: we use 'arg_operation' instead of 'operation' here, as we want to communicate the overall
 178                  * operation here, not the specific one, in case of s2h. */
 179                 (char*) sleep_operation_to_string(arg_operation),
 180                 NULL
 181         };
 182         static const char* const dirs[] = {
 183                 SYSTEM_SLEEP_PATH,
 184                 NULL
 185         };
 186
 187         _cleanup_(hibernate_location_freep) HibernateLocation *hibernate_location = NULL;
 188         _cleanup_fclose_ FILE *f = NULL;
 189         char **modes, **states;
 190         int r;
 191
 192         assert(sleep_config);
 193         assert(operation >= 0);
 194         assert(operation < _SLEEP_OPERATION_MAX);
 195         assert(operation != SLEEP_SUSPEND_THEN_HIBERNATE); /* Handled by execute_s2h() instead */
 196
 197         states = sleep_config->states[operation];
 198         modes = sleep_config->modes[operation];
 199
 200         if (strv_isempty(states))
 201                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 202                                        "No sleep states configured for sleep operation %s, can't sleep.",
 203                                        sleep_operation_to_string(operation));
 204
 205         /* This file is opened first, so that if we hit an error,
 206          * we can abort before modifying any state. */
 207         f = fopen("/sys/power/state", "we");
 208         if (!f)
 209                 return log_error_errno(errno, "Failed to open /sys/power/state: %m");
 210
 211         setvbuf(f, NULL, _IONBF, 0);
 212
 213         /* Configure hibernation settings if we are supposed to hibernate */
 214         if (!strv_isempty(modes)) {
 215                 r = find_hibernate_location(&hibernate_location);
 216                 if (r < 0)
 217                         return log_error_errno(r, "Failed to find location to hibernate to: %m");
 218                 if (r == 0) { /* 0 means: no hibernation location was configured in the kernel so far, let's
 219                                * do it ourselves then. > 0 means: kernel already had a configured hibernation
 220                                * location which we shouldn't touch. */
 221                         r = write_hibernate_location_info(hibernate_location);
 222                         if (r < 0)
 223                                 return log_error_errno(r, "Failed to prepare for hibernation: %m");
 224                 }
 225
 226                 r = write_mode(modes);
 227                 if (r < 0)
 228                         return log_error_errno(r, "Failed to write mode to /sys/power/disk: %m");
 229         }
 230
 231         /* Pass an action string to the call-outs. This is mostly our operation string, except if the
 232          * hibernate step of s-t-h fails, in which case we communicate that with a separate action. */
 233         if (!action)
 234                 action = sleep_operation_to_string(operation);
 235
 236         r = setenv("SYSTEMD_SLEEP_ACTION", action, 1);
 237         if (r != 0)
 238                 log_warning_errno(errno, "Error setting SYSTEMD_SLEEP_ACTION=%s, ignoring: %m", action);
 239
 240         (void) execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, arguments, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
 241         (void) lock_all_homes();
 242
 243         log_struct(LOG_INFO,
 244                    "MESSAGE_ID=" SD_MESSAGE_SLEEP_START_STR,
 245                    LOG_MESSAGE("Entering sleep state '%s'...", sleep_operation_to_string(operation)),
 246                    "SLEEP=%s", sleep_operation_to_string(arg_operation));
 247
 248         r = write_state(&f, states);
 249         if (r < 0)
 250                 log_struct_errno(LOG_ERR, r,
 251                                  "MESSAGE_ID=" SD_MESSAGE_SLEEP_STOP_STR,
 252                                  LOG_MESSAGE("Failed to put system to sleep. System resumed again: %m"),
 253                                  "SLEEP=%s", sleep_operation_to_string(arg_operation));
 254         else
 255                 log_struct(LOG_INFO,
 256                            "MESSAGE_ID=" SD_MESSAGE_SLEEP_STOP_STR,
 257                            LOG_MESSAGE("System returned from sleep state."),
 258                            "SLEEP=%s", sleep_operation_to_string(arg_operation));
 259
 260         arguments[1] = (char*) "post";
 261         (void) execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, arguments, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
 262
 263         return r;
 264 }
 265
 266 static int custom_timer_suspend(const SleepConfig *sleep_config) {
 267         usec_t hibernate_timestamp;
 268         int r;
 269
 270         assert(sleep_config);
 271
 272         hibernate_timestamp = usec_add(now(CLOCK_BOOTTIME), sleep_config->hibernate_delay_usec);
 273
 274         while (battery_is_discharging_and_low() == 0) {
 275                 _cleanup_hashmap_free_ Hashmap *last_capacity = NULL, *current_capacity = NULL;
 276                 _cleanup_close_ int tfd = -EBADF;
 277                 struct itimerspec ts = {};
 278                 usec_t suspend_interval;
 279                 bool woken_by_timer;
 280
 281                 tfd = timerfd_create(CLOCK_BOOTTIME_ALARM, TFD_NONBLOCK|TFD_CLOEXEC);
 282                 if (tfd < 0)
 283                         return log_error_errno(errno, "Error creating timerfd: %m");
 284
 285                 /* Store current battery capacity before suspension */
 286                 r = fetch_batteries_capacity_by_name(&last_capacity);
 287                 if (r < 0)
 288                         return log_error_errno(r, "Error fetching battery capacity percentage: %m");
 289
 290                 if (hashmap_isempty(last_capacity))
 291                         /* In case of no battery, system suspend interval will be set to HibernateDelaySec= or 2 hours. */
 292                         suspend_interval = timestamp_is_set(hibernate_timestamp)
 293                                            ? sleep_config->hibernate_delay_usec : DEFAULT_HIBERNATE_DELAY_USEC_NO_BATTERY;
 294                 else {
 295                         r = get_total_suspend_interval(last_capacity, &suspend_interval);
 296                         if (r < 0) {
 297                                 log_debug_errno(r, "Failed to estimate suspend interval using previous discharge rate, ignoring: %m");
 298                                 /* In case of any errors, especially when we do not know the battery
 299                                  * discharging rate, system suspend interval will be set to
 300                                  * SuspendEstimationSec=. */
 301                                 suspend_interval = sleep_config->suspend_estimation_usec;
 302                         }
 303                 }
 304
 305                 /* Do not suspend more than HibernateDelaySec= */
 306                 usec_t before_timestamp = now(CLOCK_BOOTTIME);
 307                 suspend_interval = MIN(suspend_interval, usec_sub_unsigned(hibernate_timestamp, before_timestamp));
 308                 if (suspend_interval <= 0)
 309                         break; /* system should hibernate */
 310
 311                 log_debug("Set timerfd wake alarm for %s", FORMAT_TIMESPAN(suspend_interval, USEC_PER_SEC));
 312                 /* Wake alarm for system with or without battery to hibernate or estimate discharge rate whichever is applicable */
 313                 timespec_store(&ts.it_value, suspend_interval);
 314
 315                 if (timerfd_settime(tfd, 0, &ts, NULL) < 0)
 316                         return log_error_errno(errno, "Error setting battery estimate timer: %m");
 317
 318                 r = execute(sleep_config, SLEEP_SUSPEND, NULL);
 319                 if (r < 0)
 320                         return r;
 321
 322                 r = fd_wait_for_event(tfd, POLLIN, 0);
 323                 if (r < 0)
 324                         return log_error_errno(r, "Error polling timerfd: %m");
 325                 /* Store fd_wait status */
 326                 woken_by_timer = FLAGS_SET(r, POLLIN);
 327
 328                 r = fetch_batteries_capacity_by_name(&current_capacity);
 329                 if (r < 0 || hashmap_isempty(current_capacity)) {
 330                         /* In case of no battery or error while getting charge level, no need to measure
 331                          * discharge rate. Instead the system should wake up if it is manual wakeup or
 332                          * hibernate if this is a timer wakeup. */
 333                         if (r < 0)
 334                                 log_debug_errno(r, "Battery capacity percentage unavailable, cannot estimate discharge rate: %m");
 335                         else
 336                                 log_debug("No battery found.");
 337                         if (!woken_by_timer)
 338                                 return 0;
 339                         break;
 340                 }
 341
 342                 usec_t after_timestamp = now(CLOCK_BOOTTIME);
 343                 log_debug("Attempting to estimate battery discharge rate after wakeup from %s sleep",
 344                           FORMAT_TIMESPAN(after_timestamp - before_timestamp, USEC_PER_HOUR));
 345
 346                 if (after_timestamp != before_timestamp) {
 347                         r = estimate_battery_discharge_rate_per_hour(last_capacity, current_capacity, before_timestamp, after_timestamp);
 348                         if (r < 0)
 349                                 log_warning_errno(r, "Failed to estimate and update battery discharge rate, ignoring: %m");
 350                 } else
 351                         log_debug("System woke up too early to estimate discharge rate");
 352
 353                 if (!woken_by_timer)
 354                         /* Return as manual wakeup done. This also will return in case battery was charged during suspension */
 355                         return 0;
 356
 357                 r = check_wakeup_type();
 358                 if (r < 0)
 359                         log_debug_errno(r, "Failed to check hardware wakeup type, ignoring: %m");
 360                 if (r > 0) {
 361                         log_debug("wakeup type is APM timer");
 362                         /* system should hibernate */
 363                         break;
 364                 }
 365         }
 366
 367         return 1;
 368 }
 369
 370 /* Freeze when invoked and thaw on cleanup */
 371 static int freeze_thaw_user_slice(const char **method) {
 372         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 373         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
 374         int r;
 375
 376         if (!method || !*method)
 377                 return 0;
 378
 379         r = bus_connect_system_systemd(&bus);
 380         if (r < 0)
 381                 return log_debug_errno(r, "Failed to open connection to systemd: %m");
 382
 383         (void) sd_bus_set_method_call_timeout(bus, FREEZE_TIMEOUT);
 384
 385         r = bus_call_method(bus, bus_systemd_mgr, *method, &error, NULL, "s", SPECIAL_USER_SLICE);
 386         if (r < 0)
 387                 return log_debug_errno(r, "Failed to execute operation: %s", bus_error_message(&error, r));
 388
 389         return 1;
 390 }
 391
 392 static int execute_s2h(const SleepConfig *sleep_config) {
 393         _unused_ _cleanup_(freeze_thaw_user_slice) const char *auto_method_thaw = "ThawUnit";
 394         int r;
 395
 396         assert(sleep_config);
 397
 398         r = freeze_thaw_user_slice(&(const char*) { "FreezeUnit" });
 399         if (r < 0)
 400                 log_debug_errno(r, "Failed to freeze unit user.slice, ignoring: %m");
 401
 402         /* Only check if we have automated battery alarms if HibernateDelaySec= is not set, as in that case
 403          * we'll busy poll for the configured interval instead */
 404         if (!timestamp_is_set(sleep_config->hibernate_delay_usec)) {
 405                 r = check_wakeup_type();
 406                 if (r < 0)
 407                         log_debug_errno(r, "Failed to check hardware wakeup type, ignoring: %m");
 408                 else {
 409                         r = battery_trip_point_alarm_exists();
 410                         if (r < 0)
 411                                 log_debug_errno(r, "Failed to check whether acpi_btp support is enabled or not, ignoring: %m");
 412                 }
 413         } else
 414                 r = 0;  /* Force fallback path */
 415
 416         if (r > 0) { /* If we have both wakeup alarms and battery trip point support, use them */
 417                 log_debug("Attempting to suspend...");
 418                 r = execute(sleep_config, SLEEP_SUSPEND, NULL);
 419                 if (r < 0)
 420                         return r;
 421
 422                 r = check_wakeup_type();
 423                 if (r < 0)
 424                         return log_debug_errno(r, "Failed to check hardware wakeup type: %m");
 425
 426                 if (r == 0)
 427                         /* For APM Timer wakeup, system should hibernate else wakeup */
 428                         return 0;
 429         } else {
 430                 r = custom_timer_suspend(sleep_config);
 431                 if (r < 0)
 432                         return log_debug_errno(r, "Suspend cycle with manual battery discharge rate estimation failed: %m");
 433                 if (r == 0)
 434                         /* manual wakeup */
 435                         return 0;
 436         }
 437         /* For above custom timer, if 1 is returned, system will directly hibernate */
 438
 439         log_debug("Attempting to hibernate");
 440         r = execute(sleep_config, SLEEP_HIBERNATE, NULL);
 441         if (r < 0) {
 442                 log_notice("Couldn't hibernate, will try to suspend again.");
 443
 444                 r = execute(sleep_config, SLEEP_SUSPEND, "suspend-after-failed-hibernate");
 445                 if (r < 0)
 446                         return r;
 447         }
 448
 449         return 0;
 450 }
 451
 452 static int help(void) {
 453         _cleanup_free_ char *link = NULL;
 454         int r;
 455
 456         r = terminal_urlify_man("systemd-suspend.service", "8", &link);
 457         if (r < 0)
 458                 return log_oom();
 459
 460         printf("%s COMMAND\n\n"
 461                "Suspend the system, hibernate the system, or both.\n\n"
 462                "  -h --help              Show this help and exit\n"
 463                "  --version              Print version string and exit\n"
 464                "\nCommands:\n"
 465                "  suspend                Suspend the system\n"
 466                "  hibernate              Hibernate the system\n"
 467                "  hybrid-sleep           Both hibernate and suspend the system\n"
 468                "  suspend-then-hibernate Initially suspend and then hibernate\n"
 469                "                         the system after a fixed period of time\n"
 470                "\nSee the %s for details.\n",
 471                program_invocation_short_name,
 472                link);
 473
 474         return 0;
 475 }
 476
 477 static int parse_argv(int argc, char *argv[]) {
 478         enum {
 479                 ARG_VERSION = 0x100,
 480         };
 481
 482         static const struct option options[] = {
 483                 { "help",         no_argument,       NULL, 'h'           },
 484                 { "version",      no_argument,       NULL, ARG_VERSION   },
 485                 {}
 486         };
 487
 488         int c;
 489
 490         assert(argc >= 0);
 491         assert(argv);
 492
 493         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
 494                 switch (c) {
 495                 case 'h':
 496                         return help();
 497
 498                 case ARG_VERSION:
 499                         return version();
 500
 501                 case '?':
 502                         return -EINVAL;
 503
 504                 default:
 505                         assert_not_reached();
 506                 }
 507
 508         if (argc - optind != 1)
 509                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 510                                        "Usage: %s COMMAND",
 511                                        program_invocation_short_name);
 512
 513         arg_operation = sleep_operation_from_string(argv[optind]);
 514         if (arg_operation < 0)
 515                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown command '%s'.", argv[optind]);
 516
 517         return 1 /* work to do */;
 518 }
 519
 520 static int run(int argc, char *argv[]) {
 521         _cleanup_(free_sleep_configp) SleepConfig *sleep_config = NULL;
 522         int r;
 523
 524         log_setup();
 525
 526         r = parse_argv(argc, argv);
 527         if (r <= 0)
 528                 return r;
 529
 530         r = parse_sleep_config(&sleep_config);
 531         if (r < 0)
 532                 return r;
 533
 534         if (!sleep_config->allow[arg_operation])
 535                 return log_error_errno(SYNTHETIC_ERRNO(EACCES),
 536                                        "Sleep operation \"%s\" is disabled by configuration, refusing.",
 537                                        sleep_operation_to_string(arg_operation));
 538
 539         switch (arg_operation) {
 540
 541         case SLEEP_SUSPEND_THEN_HIBERNATE:
 542                 r = execute_s2h(sleep_config);
 543                 break;
 544
 545         case SLEEP_HYBRID_SLEEP:
 546                 r = execute(sleep_config, SLEEP_HYBRID_SLEEP, NULL);
 547                 if (r < 0) {
 548                         /* If we can't hybrid sleep, then let's try to suspend at least. After all, the user
 549                          * asked us to do both: suspend + hibernate, and it's almost certainly the
 550                          * hibernation that failed, hence still do the other thing, the suspend. */
 551
 552                         log_notice("Couldn't hybrid sleep, will try to suspend instead.");
 553
 554                         r = execute(sleep_config, SLEEP_SUSPEND, "suspend-after-failed-hybrid-sleep");
 555                 }
 556
 557                 break;
 558
 559         default:
 560                 r = execute(sleep_config, arg_operation, NULL);
 561                 break;
 562         }
 563
 564         return r;
 565 }
 566
 567 DEFINE_MAIN_FUNCTION(run);