src/login/logind-action.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2012 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <unistd.h>
  23
  24 #include "sd-messages.h"
  25 #include "util.h"
  26 #include "strv.h"
  27 #include "fileio.h"
  28 #include "conf-parser.h"
  29 // #include "special.h"
  30 #include "sleep-config.h"
  31 #include "bus-error.h"
  32 #include "bus-util.h"
  33 #include "logind-action.h"
  34 // #include "formats-util.h"
  35 #include "process-util.h"
  36 #include "terminal-util.h"
  37
  38 int manager_handle_action(
  39                 Manager *m,
  40                 InhibitWhat inhibit_key,
  41                 HandleAction handle,
  42                 bool ignore_inhibited,
  43                 bool is_edge) {
  44
  45         static const char * const message_table[_HANDLE_ACTION_MAX] = {
  46                 [HANDLE_POWEROFF] = "Powering Off...",
  47                 [HANDLE_REBOOT] = "Rebooting...",
  48                 [HANDLE_HALT] = "Halting...",
  49                 [HANDLE_KEXEC] = "Rebooting via kexec...",
  50                 [HANDLE_SUSPEND] = "Suspending...",
  51                 [HANDLE_HIBERNATE] = "Hibernating...",
  52                 [HANDLE_HYBRID_SLEEP] = "Hibernating and suspending..."
  53         };
  54
  55 /// elogind does this itself. No target table required
  56 #if 0
  57         static const char * const target_table[_HANDLE_ACTION_MAX] = {
  58                 [HANDLE_POWEROFF] = SPECIAL_POWEROFF_TARGET,
  59                 [HANDLE_REBOOT] = SPECIAL_REBOOT_TARGET,
  60                 [HANDLE_HALT] = SPECIAL_HALT_TARGET,
  61                 [HANDLE_KEXEC] = SPECIAL_KEXEC_TARGET,
  62                 [HANDLE_SUSPEND] = SPECIAL_SUSPEND_TARGET,
  63                 [HANDLE_HIBERNATE] = SPECIAL_HIBERNATE_TARGET,
  64                 [HANDLE_HYBRID_SLEEP] = SPECIAL_HYBRID_SLEEP_TARGET
  65         };
  66 #endif // 0
  67
  68         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
  69         InhibitWhat inhibit_operation;
  70         Inhibitor *offending = NULL;
  71         bool supported;
  72         int r;
  73
  74         assert(m);
  75
  76         /* If the key handling is turned off, don't do anything */
  77         if (handle == HANDLE_IGNORE) {
  78                 log_debug("Refusing operation, as it is turned off.");
  79                 return 0;
  80         }
  81
  82         if (inhibit_key == INHIBIT_HANDLE_LID_SWITCH) {
  83                 /* If the last system suspend or startup is too close,
  84                  * let's not suspend for now, to give USB docking
  85                  * stations some time to settle so that we can
  86                  * properly watch its displays. */
  87                 if (m->lid_switch_ignore_event_source) {
  88                         log_debug("Ignoring lid switch request, system startup or resume too close.");
  89                         return 0;
  90                 }
  91         }
  92
  93         /* If the key handling is inhibited, don't do anything */
  94         if (inhibit_key > 0) {
  95                 if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0, NULL)) {
  96                         log_debug("Refusing operation, %s is inhibited.", inhibit_what_to_string(inhibit_key));
  97                         return 0;
  98                 }
  99         }
 100
 101         /* Locking is handled differently from the rest. */
 102         if (handle == HANDLE_LOCK) {
 103
 104                 if (!is_edge)
 105                         return 0;
 106
 107                 log_info("Locking sessions...");
 108                 session_send_lock_all(m, true);
 109                 return 1;
 110         }
 111
 112         if (handle == HANDLE_SUSPEND)
 113                 supported = can_sleep("suspend") > 0;
 114         else if (handle == HANDLE_HIBERNATE)
 115                 supported = can_sleep("hibernate") > 0;
 116         else if (handle == HANDLE_HYBRID_SLEEP)
 117                 supported = can_sleep("hybrid-sleep") > 0;
 118         else if (handle == HANDLE_KEXEC)
 119                 supported = access(KEXEC, X_OK) >= 0;
 120         else
 121                 supported = true;
 122
 123         if (!supported) {
 124                 log_warning("Requested operation not supported, ignoring.");
 125                 return -EOPNOTSUPP;
 126         }
 127
 128         if (m->action_what) {
 129                 log_debug("Action already in progress, ignoring.");
 130                 return -EALREADY;
 131         }
 132
 133         inhibit_operation = handle == HANDLE_SUSPEND || handle == HANDLE_HIBERNATE || handle == HANDLE_HYBRID_SLEEP ? INHIBIT_SLEEP : INHIBIT_SHUTDOWN;
 134
 135         /* If the actual operation is inhibited, warn and fail */
 136         if (!ignore_inhibited &&
 137             manager_is_inhibited(m, inhibit_operation, INHIBIT_BLOCK, NULL, false, false, 0, &offending)) {
 138                 _cleanup_free_ char *comm = NULL, *u = NULL;
 139
 140                 get_process_comm(offending->pid, &comm);
 141                 u = uid_to_name(offending->uid);
 142
 143                 /* If this is just a recheck of the lid switch then don't warn about anything */
 144                 if (!is_edge) {
 145                         log_debug("Refusing operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.",
 146                                   inhibit_what_to_string(inhibit_operation),
 147                                   offending->uid, strna(u),
 148                                   offending->pid, strna(comm));
 149                         return 0;
 150                 }
 151
 152                 log_error("Refusing operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.",
 153                           inhibit_what_to_string(inhibit_operation),
 154                           offending->uid, strna(u),
 155                           offending->pid, strna(comm));
 156
 157                 warn_melody();
 158                 return -EPERM;
 159         }
 160
 161         log_info("%s", message_table[handle]);
 162
 163 /// elogind uses its own variant, which can use the handle directly.
 164 #if 0
 165         r = bus_manager_shutdown_or_sleep_now_or_later(m, target_table[handle], inhibit_operation, &error);
 166 #else
 167         r = bus_manager_shutdown_or_sleep_now_or_later(m, handle, inhibit_operation, &error);
 168 #endif // 0
 169         if (r < 0) {
 170                 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
 171                 return r;
 172         }
 173
 174         return 1;
 175 }
 176
 177 static int run_helper(const char *helper) {
 178         int pid = fork();
 179         if (pid < 0) {
 180                 return log_error_errno(errno, "Failed to fork: %m");
 181         }
 182
 183         if (pid == 0) {
 184                 /* Child */
 185
 186                 close_all_fds(NULL, 0);
 187
 188                 execlp(helper, helper, NULL);
 189                 log_error_errno(errno, "Failed to execute %s: %m", helper);
 190                 _exit(EXIT_FAILURE);
 191         }
 192
 193         return wait_for_terminate_and_warn(helper, pid, true);
 194 }
 195
 196 static int write_mode(char **modes) {
 197         int r = 0;
 198         char **mode;
 199
 200         STRV_FOREACH(mode, modes) {
 201                 int k;
 202
 203                 k = write_string_file("/sys/power/disk", *mode, 0);
 204                 if (k == 0)
 205                         return 0;
 206
 207                 log_debug_errno(k, "Failed to write '%s' to /sys/power/disk: %m",
 208                                 *mode);
 209                 if (r == 0)
 210                         r = k;
 211         }
 212
 213         if (r < 0)
 214                 log_error_errno(r, "Failed to write mode to /sys/power/disk: %m");
 215
 216         return r;
 217 }
 218
 219 static int write_state(FILE **f, char **states) {
 220         char **state;
 221         int r = 0;
 222
 223         STRV_FOREACH(state, states) {
 224                 int k;
 225
 226                 k = write_string_stream(*f, *state, true);
 227                 if (k == 0)
 228                         return 0;
 229                 log_debug_errno(k, "Failed to write '%s' to /sys/power/state: %m",
 230                                 *state);
 231                 if (r == 0)
 232                         r = k;
 233
 234                 fclose(*f);
 235                 *f = fopen("/sys/power/state", "we");
 236                 if (!*f)
 237                         return log_error_errno(errno, "Failed to open /sys/power/state: %m");
 238         }
 239
 240         return r;
 241 }
 242
 243 static int do_sleep(const char *arg_verb) {
 244         _cleanup_strv_free_ char **modes = NULL, **states = NULL;
 245         char *arguments[] = {
 246                 NULL,
 247                 (char*) "pre",
 248                 (char*) arg_verb,
 249                 NULL
 250         };
 251         static const char* const dirs[] = {SYSTEM_SLEEP_PATH, NULL};
 252
 253         int r;
 254         _cleanup_fclose_ FILE *f = NULL;
 255
 256         /* This file is opened first, so that if we hit an error,
 257          * we can abort before modifying any state. */
 258         f = fopen("/sys/power/state", "we");
 259         if (!f)
 260                 return log_error_errno(errno, "Failed to open /sys/power/state: %m");
 261
 262         /* Configure the hibernation mode */
 263         r = write_mode(modes);
 264         if (r < 0)
 265                 return r;
 266
 267         execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments);
 268
 269         log_struct(LOG_INFO,
 270                    LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_START),
 271                    LOG_MESSAGE("Suspending system..."),
 272                    "SLEEP=%s", arg_verb,
 273                    NULL);
 274
 275         r = write_state(&f, states);
 276         if (r < 0)
 277                 return r;
 278
 279         log_struct(LOG_INFO,
 280                    LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP),
 281                    LOG_MESSAGE("System resumed."),
 282                    "SLEEP=%s", arg_verb,
 283                    NULL);
 284
 285         arguments[1] = (char*) "post";
 286         execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments);
 287
 288         return r;
 289 }
 290
 291 int shutdown_or_sleep(HandleAction action) {
 292         switch (action) {
 293         case HANDLE_POWEROFF:
 294                 return run_helper(HALT);
 295         case HANDLE_REBOOT:
 296                 return run_helper(REBOOT);
 297         case HANDLE_HALT:
 298                 return run_helper(HALT);
 299         case HANDLE_KEXEC:
 300                 return run_helper(KEXEC);
 301         case HANDLE_SUSPEND:
 302                 return do_sleep("suspend");
 303         case HANDLE_HIBERNATE:
 304                 return do_sleep("hibernate");
 305         case HANDLE_HYBRID_SLEEP:
 306                 return do_sleep("hybrid-sleep");
 307         default:
 308                 return -EINVAL;
 309         }
 310 }
 311
 312 static const char* const handle_action_table[_HANDLE_ACTION_MAX] = {
 313         [HANDLE_IGNORE] = "ignore",
 314         [HANDLE_POWEROFF] = "poweroff",
 315         [HANDLE_REBOOT] = "reboot",
 316         [HANDLE_HALT] = "halt",
 317         [HANDLE_KEXEC] = "kexec",
 318         [HANDLE_SUSPEND] = "suspend",
 319         [HANDLE_HIBERNATE] = "hibernate",
 320         [HANDLE_HYBRID_SLEEP] = "hybrid-sleep",
 321         [HANDLE_LOCK] = "lock"
 322 };
 323
 324 DEFINE_STRING_TABLE_LOOKUP(handle_action, HandleAction);
 325 DEFINE_CONFIG_PARSE_ENUM(config_parse_handle_action, handle_action, HandleAction, "Failed to parse handle action setting");