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, char **modes, char **states) {
 244         char *arguments[] = {
 245                 NULL,
 246                 (char*) "pre",
 247                 (char*) arg_verb,
 248                 NULL
 249         };
 250         static const char* const dirs[] = {SYSTEM_SLEEP_PATH, NULL};
 251
 252         int r;
 253         _cleanup_fclose_ FILE *f = NULL;
 254
 255         /* This file is opened first, so that if we hit an error,
 256          * we can abort before modifying any state. */
 257         f = fopen("/sys/power/state", "we");
 258         if (!f)
 259                 return log_error_errno(errno, "Failed to open /sys/power/state: %m");
 260
 261         /* Configure the hibernation mode */
 262         r = write_mode(modes);
 263         if (r < 0)
 264                 return r;
 265
 266         execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments);
 267
 268         log_struct(LOG_INFO,
 269                    LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_START),
 270                    LOG_MESSAGE("Suspending system..."),
 271                    "SLEEP=%s", arg_verb,
 272                    NULL);
 273
 274         r = write_state(&f, states);
 275         if (r < 0)
 276                 return r;
 277
 278         log_struct(LOG_INFO,
 279                    LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP),
 280                    LOG_MESSAGE("System resumed."),
 281                    "SLEEP=%s", arg_verb,
 282                    NULL);
 283
 284         arguments[1] = (char*) "post";
 285         execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments);
 286
 287         return r;
 288 }
 289
 290 int shutdown_or_sleep(Manager *m, HandleAction action) {
 291
 292         assert(m);
 293
 294         switch (action) {
 295         case HANDLE_POWEROFF:
 296                 return run_helper(HALT);
 297         case HANDLE_REBOOT:
 298                 return run_helper(REBOOT);
 299         case HANDLE_HALT:
 300                 return run_helper(HALT);
 301         case HANDLE_KEXEC:
 302                 return run_helper(KEXEC);
 303         case HANDLE_SUSPEND:
 304                 return do_sleep("suspend", m->suspend_mode, m->suspend_state);
 305         case HANDLE_HIBERNATE:
 306                 return do_sleep("hibernate", m->hibernate_mode, m->hibernate_state);
 307         case HANDLE_HYBRID_SLEEP:
 308                 return do_sleep("hybrid-sleep", m->hybrid_sleep_mode, m->hybrid_sleep_state);
 309         default:
 310                 return -EINVAL;
 311         }
 312 }
 313
 314 static const char* const handle_action_table[_HANDLE_ACTION_MAX] = {
 315         [HANDLE_IGNORE] = "ignore",
 316         [HANDLE_POWEROFF] = "poweroff",
 317         [HANDLE_REBOOT] = "reboot",
 318         [HANDLE_HALT] = "halt",
 319         [HANDLE_KEXEC] = "kexec",
 320         [HANDLE_SUSPEND] = "suspend",
 321         [HANDLE_HIBERNATE] = "hibernate",
 322         [HANDLE_HYBRID_SLEEP] = "hybrid-sleep",
 323         [HANDLE_LOCK] = "lock"
 324 };
 325
 326 DEFINE_STRING_TABLE_LOOKUP(handle_action, HandleAction);
 327 DEFINE_CONFIG_PARSE_ENUM(config_parse_handle_action, handle_action, HandleAction, "Failed to parse handle action setting");