***/
-#include "bus-common-errors.h"
-#include "bus-error.h"
-#include "bus-util.h"
#include "elogind-dbus.h"
#include "process-util.h"
#include "sd-messages.h"
-#include "sleep-config.h"
+#include "sleep.h"
#include "string-util.h"
#include "strv.h"
#include "update-utmp.h"
-#include "user-util.h"
-int have_multiple_sessions(
- Manager *m,
- uid_t uid) {
-
- Session *session;
- Iterator i;
-
- assert(m);
-
- /* Check for other users' sessions. Greeter sessions do not
- * count, and non-login sessions do not count either. */
- HASHMAP_FOREACH(session, m->sessions, i)
- if (session->class == SESSION_USER &&
- session->user->uid != uid)
- return true;
-
- return false;
-}
-
static int bus_manager_log_shutdown(
Manager *m,
InhibitWhat w,
p = strjoina(p, " (", m->wall_message, ").");
return log_struct(LOG_NOTICE,
- LOG_MESSAGE_ID(SD_MESSAGE_SHUTDOWN),
+ "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR,
p,
q,
NULL);
}
-static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
+/* elogind specific helper to make HALT and REBOOT possible. */
+static int run_helper(const char *helper) {
+ int r = 0;
- static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
- [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
- [INHIBIT_SLEEP] = "PrepareForSleep"
- };
+ r = safe_fork_full(helper, NULL, 0, FORK_RESET_SIGNALS|FORK_REOPEN_LOG, NULL);
- int active = _active;
+ 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 0;
+}
+
+/* elogind specific executor */
+static int shutdown_or_sleep(Manager *m, HandleAction action) {
assert(m);
- assert(w >= 0);
- assert(w < _INHIBIT_WHAT_MAX);
- assert(signal_name[w]);
-
- return sd_bus_emit_signal(m->bus,
- "/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- signal_name[w],
- "b",
- active);
+
+ switch (action) {
+ case HANDLE_POWEROFF:
+ return run_helper(POWEROFF);
+ 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(m, "suspend");
+ case HANDLE_HIBERNATE:
+ return do_sleep(m, "hibernate");
+ case HANDLE_HYBRID_SLEEP:
+ 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 manager_inhibit_timeout_handler(
- sd_event_source *s,
- uint64_t usec,
- void *userdata) {
-
- Manager *manager = userdata;
- int r;
-
- assert(manager);
- assert(manager->inhibit_timeout_source == s);
-
- r = manager_dispatch_delayed(manager, true);
- return (r < 0) ? r : 0;
-}
-
-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;
-}
-
-int verify_shutdown_creds(
- Manager *m,
- sd_bus_message *message,
- InhibitWhat w,
- bool interactive,
- const char *action,
- const char *action_multiple_sessions,
- const char *action_ignore_inhibit,
- sd_bus_error *error) {
-
- _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
- bool multiple_sessions, blocked;
- uid_t uid;
- int r;
-
- assert(m);
- assert(message);
- assert(w >= 0);
- assert(w <= _INHIBIT_WHAT_MAX);
-
- r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
- if (r < 0)
- return r;
-
- r = sd_bus_creds_get_euid(creds, &uid);
- if (r < 0)
- return r;
-
- r = have_multiple_sessions(m, uid);
- if (r < 0)
- return r;
-
- multiple_sessions = r > 0;
- blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid, NULL);
-
- if (multiple_sessions && action_multiple_sessions) {
- r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action_multiple_sessions, NULL, interactive, UID_INVALID, &m->polkit_registry, error);
- if (r < 0)
- return r;
- if (r == 0)
- return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
- }
-
- if (blocked && action_ignore_inhibit) {
- r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action_ignore_inhibit, NULL, interactive, UID_INVALID, &m->polkit_registry, error);
- if (r < 0)
- return r;
- if (r == 0)
- return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
- }
-
- if (!multiple_sessions && !blocked && action) {
- r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action, NULL, interactive, UID_INVALID, &m->polkit_registry, error);
- if (r < 0)
- return r;
- if (r == 0)
- return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
- }
-
- return 0;
-}
-
-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_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