***/
-#include "bus-common-errors.h"
-#include "bus-error.h"
-#include "bus-util.h"
#include "elogind-dbus.h"
-#include "fd-util.h"
#include "process-util.h"
#include "sd-messages.h"
#include "sleep.h"
-#include "sleep-config.h"
#include "string-util.h"
#include "strv.h"
#include "update-utmp.h"
-#include "user-util.h"
static int bus_manager_log_shutdown(
/* elogind specific helper to make HALT and REBOOT possible. */
static int run_helper(const char *helper) {
- int pid = fork();
- if (pid < 0) {
- return log_error_errno(errno, "Failed to fork: %m");
- }
+ int r = 0;
- if (pid == 0) {
- /* Child */
+ r = safe_fork_full(helper, NULL, 0, FORK_RESET_SIGNALS|FORK_REOPEN_LOG, NULL);
- close_all_fds(NULL, 0);
+ if (r < 0)
+ return log_error_errno(errno, "Failed to fork run %s: %m", helper);
+ if (0 == r) {
+ /* Child */
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);
+ return 0;
}
/* elogind specific executor */
switch (action) {
case HANDLE_POWEROFF:
- return run_helper(HALT);
+ return run_helper(POWEROFF);
case HANDLE_REBOOT:
return run_helper(REBOOT);
case HANDLE_HALT:
case HANDLE_KEXEC:
return run_helper(KEXEC);
case HANDLE_SUSPEND:
- return do_sleep("suspend", m->suspend_mode, m->suspend_state);
+ return do_sleep(m, "suspend");
case HANDLE_HIBERNATE:
- return do_sleep("hibernate", m->hibernate_mode, m->hibernate_state);
+ return do_sleep(m, "hibernate");
case HANDLE_HYBRID_SLEEP:
- return do_sleep("hybrid-sleep", m->hybrid_sleep_mode, m->hybrid_sleep_state);
+ return do_sleep(m, "hybrid-sleep");
+ case HANDLE_SUSPEND_THEN_HIBERNATE:
+ return do_sleep(m, "suspend-then-hibernate");
default:
return -EINVAL;
}
}
-static int execute_shutdown_or_sleep(
+int execute_shutdown_or_sleep(
Manager *m,
InhibitWhat w,
HandleAction action,
}
/* This comes from our patched update-utmp/update-utmp.c */
- update_utmp(2, argv_utmp, m->bus);
+ update_utmp(2, argv_utmp);
strv_free(argv_utmp);
}
* sleeping processes to wake up, we have to tell them all
* by ourselves. */
if (w == INHIBIT_SLEEP) {
- send_prepare_for(m, w, false);
+ (void) send_prepare_for(m, w, false);
m->action_what = 0;
} else
m->action_what = w;
return 0;
}
-int manager_dispatch_delayed(Manager *manager, bool timeout) {
-
- _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
- Inhibitor *offending = NULL;
- int r;
-
- assert(manager);
-
- if ( (0 == manager->action_what) || (HANDLE_IGNORE == manager->pending_action) )
- return 0;
-
- if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL, false, false, 0, &offending)) {
- _cleanup_free_ char *comm = NULL, *u = NULL;
-
- if (!timeout)
- return 0;
-
- (void) get_process_comm(offending->pid, &comm);
- u = uid_to_name(offending->uid);
-
- log_notice("Delay lock is active (UID "UID_FMT"/%s, PID "PID_FMT"/%s) but inhibitor timeout is reached.",
- offending->uid, strna(u),
- offending->pid, strna(comm));
- }
-
- /* Actually do the operation */
- r = execute_shutdown_or_sleep(manager, manager->action_what, manager->pending_action, &error);
- if (r < 0) {
- log_warning("Failed to send delayed message: %s", bus_error_message(&error, r));
-
- manager->pending_action = HANDLE_IGNORE;
- manager->action_what = 0;
- /* It is not a critical error for elogind if suspending fails */
- }
-
- return 1;
-}
-
-static int delay_shutdown_or_sleep(
- Manager *m,
- InhibitWhat w,
- HandleAction action) {
-
- int r;
- usec_t timeout_val;
-
- assert(m);
- assert(w >= 0);
- assert(w < _INHIBIT_WHAT_MAX);
-
- timeout_val = now(CLOCK_MONOTONIC) + m->inhibit_delay_max;
-
- if (m->inhibit_timeout_source) {
- r = sd_event_source_set_time(m->inhibit_timeout_source, timeout_val);
- if (r < 0)
- return log_error_errno(r, "sd_event_source_set_time() failed: %m");
-
- r = sd_event_source_set_enabled(m->inhibit_timeout_source, SD_EVENT_ONESHOT);
- if (r < 0)
- return log_error_errno(r, "sd_event_source_set_enabled() failed: %m");
- } else {
- r = sd_event_add_time(m->event, &m->inhibit_timeout_source, CLOCK_MONOTONIC,
- timeout_val, 0, manager_inhibit_timeout_handler, m);
- if (r < 0)
- return r;
- }
-
- m->pending_action = action;
- m->action_what = w;
-
- return 0;
-}
-
-int bus_manager_shutdown_or_sleep_now_or_later(
- Manager *m,
- HandleAction action,
- InhibitWhat w,
- sd_bus_error *error) {
-
- bool delayed;
- int r;
-
- assert(m);
- assert(w >= 0);
- assert(w <= _INHIBIT_WHAT_MAX);
-
- /* Tell everybody to prepare for shutdown/sleep */
- send_prepare_for(m, w, true);
-
- delayed =
- m->inhibit_delay_max > 0 &&
- manager_is_inhibited(m, w, INHIBIT_DELAY, NULL, false, false, 0, NULL);
-
- log_debug_elogind("%s called for %s (%sdelayed)", __FUNCTION__,
- handle_action_to_string(action),
- delayed ? "" : "NOT ");
-
- if (delayed)
- /* Shutdown is delayed, keep in mind what we
- * want to do, and start a timeout */
- r = delay_shutdown_or_sleep(m, w, action);
- else
- /* Shutdown is not delayed, execute it
- * immediately */
- r = execute_shutdown_or_sleep(m, w, action, error);
-
- return r;
-}
-
-static int method_do_shutdown_or_sleep(
- Manager *m,
- sd_bus_message *message,
- HandleAction sleep_action,
- InhibitWhat w,
- const char *action,
- const char *action_multiple_sessions,
- const char *action_ignore_inhibit,
- const char *sleep_verb,
- sd_bus_error *error) {
-
- int interactive, r;
-
- assert(m);
- assert(message);
- assert(w >= 0);
- assert(w <= _INHIBIT_WHAT_MAX);
-
- r = sd_bus_message_read(message, "b", &interactive);
- if (r < 0)
- return r;
-
- log_debug_elogind("%s called with action '%s', sleep '%s' (%sinteractive)",
- __FUNCTION__, action, sleep_verb,
- interactive ? "" : "NOT ");
-
- /* Don't allow multiple jobs being executed at the same time */
- if (m->action_what)
- return sd_bus_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS, "There's already a shutdown or sleep operation in progress");
-
- if (sleep_verb) {
- r = can_sleep(m, sleep_verb);
- if (r < 0)
- return r;
-
- if (r == 0)
- return sd_bus_error_setf(error, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, "Sleep verb not supported");
- }
-
- if (IN_SET(sleep_action, HANDLE_HALT, HANDLE_POWEROFF, HANDLE_REBOOT)) {
- r = verify_shutdown_creds(m, message, w, interactive, action, action_multiple_sessions,
- action_ignore_inhibit, error);
- log_debug_elogind("verify_shutdown_creds() returned %d", r);
- if (r != 0)
- return r;
- }
-
- r = bus_manager_shutdown_or_sleep_now_or_later(m, sleep_action, w, error);
- if (r < 0)
- return r;
-
- return sd_bus_reply_method_return(message, NULL);
-}
-
-int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
-
- log_debug_elogind("%s called", __FUNCTION__);
-
- return method_do_shutdown_or_sleep(
- m, message,
- HANDLE_POWEROFF,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.power-off",
- "org.freedesktop.login1.power-off-multiple-sessions",
- "org.freedesktop.login1.power-off-ignore-inhibit",
- NULL,
- error);
-}
-
-int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
-
- log_debug_elogind("%s called", __FUNCTION__);
-
- return method_do_shutdown_or_sleep(
- m, message,
- HANDLE_REBOOT,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.reboot",
- "org.freedesktop.login1.reboot-multiple-sessions",
- "org.freedesktop.login1.reboot-ignore-inhibit",
- NULL,
- error);
-}
-
-int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
-
- log_debug_elogind("%s called", __FUNCTION__);
-
- return method_do_shutdown_or_sleep(
- m, message,
- HANDLE_HALT,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.halt",
- "org.freedesktop.login1.halt-multiple-sessions",
- "org.freedesktop.login1.halt-ignore-inhibit",
- NULL,
- error);
-}
-
-int method_suspend(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
-
- log_debug_elogind("%s called", __FUNCTION__);
-
- return method_do_shutdown_or_sleep(
- m, message,
- HANDLE_SUSPEND,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.suspend",
- "org.freedesktop.login1.suspend-multiple-sessions",
- "org.freedesktop.login1.suspend-ignore-inhibit",
- "suspend",
- error);
-}
-
int manager_scheduled_shutdown_handler(
sd_event_source *s,
uint64_t usec,
else
action = HANDLE_REBOOT;
- r = execute_shutdown_or_sleep(m, 0, action, &error);
- if (r < 0)
- return log_error_errno(r, "Unable to execute transition to %s: %m", m->scheduled_shutdown_type);
+ /* Don't allow multiple jobs being executed at the same time */
+ if (m->action_what) {
+ r = -EALREADY;
+ log_error("Scheduled shutdown to %s failed: shutdown or sleep operation already in progress",
+ m->scheduled_shutdown_type);
+ goto error;
+ }
- return 0;
-}
+ if (m->shutdown_dry_run) {
+ /* We do not process delay inhibitors here. Otherwise, we
+ * would have to be considered "in progress" (like the check
+ * above) for some seconds after our admin has seen the final
+ * wall message. */
-int method_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ bus_manager_log_shutdown(m, INHIBIT_SHUTDOWN, action);
+ log_info("Running in dry run, suppressing action.");
+ reset_scheduled_shutdown(m);
- log_debug_elogind("%s called", __FUNCTION__);
-
- return method_do_shutdown_or_sleep(
- m, message,
- HANDLE_HIBERNATE,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.hibernate",
- "org.freedesktop.login1.hibernate-multiple-sessions",
- "org.freedesktop.login1.hibernate-ignore-inhibit",
- "hibernate",
- error);
-}
+ return 0;
+ }
-int method_hybrid_sleep(sd_bus_message *message, void *userdata, sd_bus_error *error) {
- Manager *m = userdata;
+ r = execute_shutdown_or_sleep(m, 0, action, &error);
+ if (r < 0) {
+ log_error_errno(r, "Scheduled shutdown to %s failed: %m",
+ m->scheduled_shutdown_type);
+ goto error;
+ }
- log_debug_elogind("%s called", __FUNCTION__);
-
- return method_do_shutdown_or_sleep(
- m, message,
- HANDLE_HYBRID_SLEEP,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.hibernate",
- "org.freedesktop.login1.hibernate-multiple-sessions",
- "org.freedesktop.login1.hibernate-ignore-inhibit",
- "hybrid-sleep",
- error);
+ return 0;
+
+error:
+ reset_scheduled_shutdown(m);
+ return r;
}
~ianmdlvl / elogind.git / blobdiff