Handle suspend/hibernate/hybrid-suspend/shutdown/reboot directly

* configure.ac: Get paths of halt and reboot.
* Makefile.am (systemsleepdir, systemshutdowndir): New variables.  Look
  in them for hooks to run.

* src/login/logind-action.c: Inline the salient bits from systemd's
  system-sleep.c here.

* src/login/logind-dbus.c (execute_shutdown_or_sleep): Call our own
  shutdown_or_sleep helper instead of invoking a systemd method.

* src/login/logind.h: Declare shutdown_or_sleep.

3 files changed, 150 insertions, 23 deletions

diff --git a/src/login/logind-action.c b/src/login/logind-action.c
index ce7f681040..b0ff774dfd 100644
--- a/src/login/logind-action.c
+++ b/src/login/logind-action.c
@@ -20,12 +20,20 @@
 ***/
 
 #include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
 
+#include "sd-messages.h"
+#include "log.h"
+#include "util.h"
+#include "strv.h"
+#include "fileio.h"
+#include "build.h"
+#include "def.h"
 #include "conf-parser.h"
-#include "special.h"
 #include "sleep-config.h"
-#include "bus-util.h"
 #include "bus-error.h"
+#include "bus-util.h"
 #include "logind-action.h"
 
 int manager_handle_action(
@@ -149,6 +157,144 @@ 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);
+                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);
+                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) {
+        _cleanup_strv_free_ char **modes = NULL, **states = NULL;
+        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;
+
+        r = parse_sleep_config(arg_verb, &modes, &states);
+        if (r < 0)
+                return r;
+
+        /* 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(HandleAction action) {
+        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");
+        case HANDLE_HIBERNATE:
+                return do_sleep("hibernate");
+        case HANDLE_HYBRID_SLEEP:
+                return do_sleep("hybrid-sleep");
+        default:
+                return -EINVAL;
+        }
+}
+
 static const char* const handle_action_table[_HANDLE_ACTION_MAX] = {
         [HANDLE_IGNORE] = "ignore",
         [HANDLE_POWEROFF] = "poweroff",
diff --git a/src/login/logind-dbus.c b/src/login/logind-dbus.c
index b735366fe1..301c4de2fe 100644
--- a/src/login/logind-dbus.c
+++ b/src/login/logind-dbus.c
@@ -1422,10 +1422,6 @@ static int execute_shutdown_or_sleep(
                 InhibitWhat w,
                 HandleAction action,
                 sd_bus_error *error) {
-
-        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
-        const char *p;
-        char *c;
         int r;
 
         assert(m);
@@ -1436,26 +1432,10 @@ static int execute_shutdown_or_sleep(
 
         /* FIXME: here do the thing.  */
 
-        r = sd_bus_call_method(
-                        m->bus,
-                        "org.freedesktop.systemd1",
-                        "/org/freedesktop/systemd1",
-                        "org.freedesktop.systemd1.Manager",
-                        "StartUnit",
-                        error,
-                        &reply,
-                        "ss", NULL, "replace-irreversibly");
+        r = shutdown_or_sleep(action);
         if (r < 0)
                 return r;
 
-        r = sd_bus_message_read(reply, "o", &p);
-        if (r < 0)
-                return r;
-
-        c = strdup(p);
-        if (!c)
-                return -ENOMEM;
-
         /* Make sure the lid switch is ignored for a while (?) */
         manager_set_lid_switch_ignore(m, now(CLOCK_MONOTONIC) + m->holdoff_timeout_usec);
 
diff --git a/src/login/logind.h b/src/login/logind.h
index f2e9d38af9..5af01cb79a 100644
--- a/src/login/logind.h
+++ b/src/login/logind.h
@@ -145,6 +145,7 @@ bool manager_is_docked_or_multiple_displays(Manager *m);
 extern const sd_bus_vtable manager_vtable[];
 
 int bus_manager_shutdown_or_sleep_now_or_later(Manager *m, HandleAction action, InhibitWhat w, sd_bus_error *error);
+int shutdown_or_sleep(HandleAction action);
 
 int manager_send_changed(Manager *manager, const char *property, ...) _sentinel_;