X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flogin%2Flogind-action.c;h=9b2ec6e24258652fee94f4732886ba743e01b19f;hp=1928f43cd1c314191f872f21340466adac039734;hb=c73bfb05cb09992935ede3247a1cc4726e54a44d;hpb=94036de887ad5b0dc805abe38b5c1c58b57d9465 diff --git a/src/login/logind-action.c b/src/login/logind-action.c index 1928f43cd..9b2ec6e24 100644 --- a/src/login/logind-action.c +++ b/src/login/logind-action.c @@ -22,12 +22,18 @@ #include #include "sd-messages.h" +#include "util.h" +#include "strv.h" +#include "fileio.h" #include "conf-parser.h" -#include "special.h" +// #include "special.h" #include "sleep-config.h" -#include "bus-util.h" #include "bus-error.h" +#include "bus-util.h" #include "logind-action.h" +// #include "formats-util.h" +#include "process-util.h" +#include "terminal-util.h" int manager_handle_action( Manager *m, @@ -46,6 +52,8 @@ int manager_handle_action( [HANDLE_HYBRID_SLEEP] = "Hibernating and suspending..." }; +/// elogind does this itself. No target table required +#if 0 static const char * const target_table[_HANDLE_ACTION_MAX] = { [HANDLE_POWEROFF] = SPECIAL_POWEROFF_TARGET, [HANDLE_REBOOT] = SPECIAL_REBOOT_TARGET, @@ -55,6 +63,7 @@ int manager_handle_action( [HANDLE_HIBERNATE] = SPECIAL_HIBERNATE_TARGET, [HANDLE_HYBRID_SLEEP] = SPECIAL_HYBRID_SLEEP_TARGET }; +#endif // 0 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; InhibitWhat inhibit_operation; @@ -71,26 +80,6 @@ int manager_handle_action( } if (inhibit_key == INHIBIT_HANDLE_LID_SWITCH) { - int n; - - /* If we are docked don't react to lid closing */ - if (manager_is_docked(m)) { - log_debug("Ignoring lid switch request, system is docked."); - return 0; - } - - /* If we have more than one or no displays connected, - * don't react to lid closing. The no display case we - * treat like this under the assumption that there is - * no modern drm driver available. */ - n = manager_count_displays(m); - if (n < 0) - log_warning("Display counting failed: %s", strerror(-n)); - else if (n != 1) { - log_debug("Ignoring lid switch request, %i displays connected.", n); - return 0; - } - /* If the last system suspend or startup is too close, * let's not suspend for now, to give USB docking * stations some time to settle so that we can @@ -133,7 +122,7 @@ int manager_handle_action( if (!supported) { log_warning("Requested operation not supported, ignoring."); - return -ENOTSUP; + return -EOPNOTSUPP; } if (m->action_what) { @@ -153,25 +142,29 @@ int manager_handle_action( /* If this is just a recheck of the lid switch then don't warn about anything */ if (!is_edge) { - log_debug("Refusing operation, %s is inhibited by UID %lu/%s, PID %lu/%s.", + log_debug("Refusing operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.", inhibit_what_to_string(inhibit_operation), - (unsigned long) offending->uid, strna(u), - (unsigned long) offending->pid, strna(comm)); + offending->uid, strna(u), + offending->pid, strna(comm)); return 0; } - log_error("Refusing operation, %s is inhibited by UID %lu/%s, PID %lu/%s.", + log_error("Refusing operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.", inhibit_what_to_string(inhibit_operation), - (unsigned long) offending->uid, strna(u), - (unsigned long) offending->pid, strna(comm)); + offending->uid, strna(u), + offending->pid, strna(comm)); - warn_melody(); return -EPERM; } log_info("%s", message_table[handle]); +/// elogind uses its own variant, which can use the handle directly. +#if 0 r = bus_manager_shutdown_or_sleep_now_or_later(m, target_table[handle], inhibit_operation, &error); +#else + r = bus_manager_shutdown_or_sleep_now_or_later(m, handle, inhibit_operation, &error); +#endif // 0 if (r < 0) { log_error("Failed to execute operation: %s", bus_error_message(&error, r)); return r; @@ -180,6 +173,143 @@ int manager_handle_action( return 1; } +static int run_helper(const char *helper) { + int pid = fork(); + if (pid < 0) { + return log_error_errno(errno, "Failed to fork: %m"); + } + + if (pid == 0) { + /* Child */ + + close_all_fds(NULL, 0); + + execlp(helper, helper, NULL); + log_error_errno(errno, "Failed to execute %s: %m", helper); + _exit(EXIT_FAILURE); + } + + return wait_for_terminate_and_warn(helper, pid, true); +} + +static int write_mode(char **modes) { + int r = 0; + char **mode; + + STRV_FOREACH(mode, modes) { + int k; + + k = write_string_file("/sys/power/disk", *mode, 0); + if (k == 0) + return 0; + + log_debug_errno(k, "Failed to write '%s' to /sys/power/disk: %m", + *mode); + if (r == 0) + r = k; + } + + if (r < 0) + log_error_errno(r, "Failed to write mode to /sys/power/disk: %m"); + + return r; +} + +static int write_state(FILE **f, char **states) { + char **state; + int r = 0; + + STRV_FOREACH(state, states) { + int k; + + k = write_string_stream(*f, *state, true); + if (k == 0) + return 0; + log_debug_errno(k, "Failed to write '%s' to /sys/power/state: %m", + *state); + if (r == 0) + r = k; + + fclose(*f); + *f = fopen("/sys/power/state", "we"); + if (!*f) + return log_error_errno(errno, "Failed to open /sys/power/state: %m"); + } + + return r; +} + +static int do_sleep(const char *arg_verb, char **modes, char **states) { + char *arguments[] = { + NULL, + (char*) "pre", + (char*) arg_verb, + NULL + }; + static const char* const dirs[] = {SYSTEM_SLEEP_PATH, NULL}; + + int r; + _cleanup_fclose_ FILE *f = NULL; + + /* This file is opened first, so that if we hit an error, + * we can abort before modifying any state. */ + f = fopen("/sys/power/state", "we"); + if (!f) + return log_error_errno(errno, "Failed to open /sys/power/state: %m"); + + /* Configure the hibernation mode */ + r = write_mode(modes); + if (r < 0) + return r; + + execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments); + + log_struct(LOG_INFO, + LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_START), + LOG_MESSAGE("Suspending system..."), + "SLEEP=%s", arg_verb, + NULL); + + r = write_state(&f, states); + if (r < 0) + return r; + + log_struct(LOG_INFO, + LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP), + LOG_MESSAGE("System resumed."), + "SLEEP=%s", arg_verb, + NULL); + + arguments[1] = (char*) "post"; + execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments); + + return r; +} + +int shutdown_or_sleep(Manager *m, HandleAction action) { + + assert(m); + + switch (action) { + case HANDLE_POWEROFF: + return run_helper(HALT); + case HANDLE_REBOOT: + return run_helper(REBOOT); + case HANDLE_HALT: + return run_helper(HALT); + case HANDLE_KEXEC: + return run_helper(KEXEC); + case HANDLE_SUSPEND: + return do_sleep("suspend", m->suspend_mode, m->suspend_state); + case HANDLE_HIBERNATE: + return do_sleep("hibernate", m->hibernate_mode, m->hibernate_state); + case HANDLE_HYBRID_SLEEP: + return do_sleep("hybrid-sleep", m->hybrid_sleep_mode, m->hybrid_sleep_state); + default: + return -EINVAL; + } +} + static const char* const handle_action_table[_HANDLE_ACTION_MAX] = { [HANDLE_IGNORE] = "ignore", [HANDLE_POWEROFF] = "poweroff",