From 7bd1311e54a418b1532d3931b9af70f8aabf4ece Mon Sep 17 00:00:00 2001

From: Lennart Poettering <lennart@poettering.net>

Date: Thu, 6 Mar 2014 02:19:06 +0100

Subject: [PATCH] util: add timeout to generator execution

(cherry picked from commit aa62a8936f5983770e90b791083d55107659f7a1)

(cherry picked from commit d66226bce64620543d21675ae610ecfeb9395e2a

                and commit 5e2f14e62b43f713bade20dd9f55db525ac43859)

Conflicts:

	src/core/manager.c

---

 src/core/manager.c   |   5 +-

 src/core/shutdown.c  |   2 +-

 src/shared/hashmap.h |   8 +++

 src/shared/util.c    | 162 +++++++++++++++++++++++++++------------------------

 src/shared/util.h    |   2 +-

 src/sleep/sleep.c    |  14 +++--

 6 files changed, 108 insertions(+), 85 deletions(-)

diff --git a/src/core/manager.c b/src/core/manager.c

index 58c17ab..3a38fab 100644

--- a/src/core/manager.c

+++ b/src/core/manager.c

@@ -2661,9 +2661,8 @@ void manager_run_generators(Manager *m) {

         argv[3] = m->generator_unit_path_late;

         argv[4] = NULL;

-        RUN_WITH_UMASK(0022) {

-                execute_directory(generator_path, d, (char**) argv);

-        }

+        RUN_WITH_UMASK(0022)

+                execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);

         trim_generator_dir(m, &m->generator_unit_path);

         trim_generator_dir(m, &m->generator_unit_path_early);

diff --git a/src/core/shutdown.c b/src/core/shutdown.c

index 5e0f3ce..68960b1 100644

--- a/src/core/shutdown.c

+++ b/src/core/shutdown.c

@@ -294,7 +294,7 @@ int main(int argc, char *argv[]) {

         arguments[0] = NULL;

         arguments[1] = argv[1];

         arguments[2] = NULL;

-        execute_directory(SYSTEM_SHUTDOWN_PATH, NULL, arguments);

+        execute_directory(SYSTEM_SHUTDOWN_PATH, NULL, DEFAULT_TIMEOUT_USEC, arguments);

         if (!in_container && !in_initrd() &&

             access("/run/initramfs/shutdown", X_OK) == 0) {

diff --git a/src/shared/hashmap.h b/src/shared/hashmap.h

index 3d4f672..b912af8 100644

--- a/src/shared/hashmap.h

+++ b/src/shared/hashmap.h

@@ -24,6 +24,7 @@

 #include <stdbool.h>

 #include "macro.h"

+#include "util.h"

 /* Pretty straightforward hash table implementation. As a minor

  * optimization a NULL hashmap object will be treated as empty hashmap

@@ -104,3 +105,10 @@ char **hashmap_get_strv(Hashmap *h);

 #define HASHMAP_FOREACH_BACKWARDS(e, h, i) \

         for ((i) = ITERATOR_LAST, (e) = hashmap_iterate_backwards((h), &(i), NULL); (e); (e) = hashmap_iterate_backwards((h), &(i), NULL))

+

+DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free);

+DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free_free);

+DEFINE_TRIVIAL_CLEANUP_FUNC(Hashmap*, hashmap_free_free_free);

+#define _cleanup_hashmap_free_ _cleanup_(hashmap_freep)

+#define _cleanup_hashmap_free_free_ _cleanup_(hashmap_free_freep)

+#define _cleanup_hashmap_free_free_free_ _cleanup_(hashmap_free_free_freep)

diff --git a/src/shared/util.c b/src/shared/util.c

index 1329854..bec339b 100644

--- a/src/shared/util.c

+++ b/src/shared/util.c

@@ -3740,111 +3740,123 @@ bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {

         return endswith(de->d_name, suffix);

 }

-void execute_directory(const char *directory, DIR *d, char *argv[]) {

-        DIR *_d = NULL;

-        struct dirent *de;

-        Hashmap *pids = NULL;

+void execute_directory(const char *directory, DIR *d, usec_t timeout, char *argv[]) {

+        pid_t executor_pid;

+        int r;

         assert(directory);

-        /* Executes all binaries in a directory in parallel and

-         * waits for them to finish. */

+        /* Executes all binaries in a directory in parallel and waits

+         * for them to finish. Optionally a timeout is applied. */

-        if (!d) {

-                if (!(_d = opendir(directory))) {

+        executor_pid = fork();

+        if (executor_pid < 0) {

+                log_error("Failed to fork: %m");

+                return;

-                        if (errno == ENOENT)

-                                return;

+        } else if (executor_pid == 0) {

+                _cleanup_hashmap_free_free_ Hashmap *pids = NULL;

+                _cleanup_closedir_ DIR *_d = NULL;

+                struct dirent *de;

+                sigset_t ss;

-                        log_error("Failed to enumerate directory %s: %m", directory);

-                        return;

-                }

+                /* We fork this all off from a child process so that

+                 * we can somewhat cleanly make use of SIGALRM to set

+                 * a time limit */

-                d = _d;

-        }

+                reset_all_signal_handlers();

-        if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {

-                log_error("Failed to allocate set.");

-                goto finish;

-        }

+                assert_se(sigemptyset(&ss) == 0);

+                assert_se(sigprocmask(SIG_SETMASK, &ss, NULL) == 0);

-        while ((de = readdir(d))) {

-                char *path;

-                pid_t pid;

-                int k;

+                assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);

-                if (!dirent_is_file(de))

-                        continue;

+                if (!d) {

+                        d = _d = opendir(directory);

+                        if (!d) {

+                                if (errno == ENOENT)

+                                        _exit(EXIT_SUCCESS);

-                if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {

-                        log_oom();

-                        continue;

+                                log_error("Failed to enumerate directory %s: %m", directory);

+                                _exit(EXIT_FAILURE);

+                        }

                 }

-                if ((pid = fork()) < 0) {

-                        log_error("Failed to fork: %m");

-                        free(path);

-                        continue;

+                pids = hashmap_new(NULL, NULL);

+                if (!pids) {

+                        log_oom();

+                        _exit(EXIT_FAILURE);

                 }

-                if (pid == 0) {

-                        char *_argv[2];

-                        /* Child */

+                FOREACH_DIRENT(de, d, break) {

+                        _cleanup_free_ char *path = NULL;

+                        pid_t pid;

-                        if (!argv) {

-                                _argv[0] = path;

-                                _argv[1] = NULL;

-                                argv = _argv;

-                        } else

-                                argv[0] = path;

+                        if (!dirent_is_file(de))

+                                continue;

-                        execv(path, argv);

+                        if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {

+                                log_oom();

+                                _exit(EXIT_FAILURE);

+                        }

-                        log_error("Failed to execute %s: %m", path);

-                        _exit(EXIT_FAILURE);

-                }

+                        pid = fork();

+                        if (pid < 0) {

+                                log_error("Failed to fork: %m");

+                                continue;

+                        } else if (pid == 0) {

+                                char *_argv[2];

-                log_debug("Spawned %s as %lu", path, (unsigned long) pid);

+                                assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);

-                if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {

-                        log_error("Failed to add PID to set: %s", strerror(-k));

-                        free(path);

-                }

-        }

+                                if (!argv) {

+                                        _argv[0] = path;

+                                        _argv[1] = NULL;

+                                        argv = _argv;

+                                } else

+                                        argv[0] = path;

-        while (!hashmap_isempty(pids)) {

-                pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));

-                siginfo_t si = {};

-                char *path;

+                                execv(path, argv);

+                                log_error("Failed to execute %s: %m", path);

+                                _exit(EXIT_FAILURE);

+                        }

-                if (waitid(P_PID, pid, &si, WEXITED) < 0) {

-                        if (errno == EINTR)

-                                continue;

+                        log_debug("Spawned %s as %lu.", path, (long unsigned) pid);

-                        log_error("waitid() failed: %m");

-                        goto finish;

+                        r = hashmap_put(pids, UINT_TO_PTR(pid), path);

+                        if (r < 0) {

+                                log_oom();

+                                _exit(EXIT_FAILURE);

+                        }

+

+                        path = NULL;

                 }

-                if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {

-                        if (!is_clean_exit(si.si_code, si.si_status, NULL)) {

-                                if (si.si_code == CLD_EXITED)

-                                        log_error("%s exited with exit status %i.", path, si.si_status);

-                                else

-                                        log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));

-                        } else

-                                log_debug("%s exited successfully.", path);

+                /* Abort execution of this process after the

+                 * timout. We simply rely on SIGALRM as default action

+                 * terminating the process, and turn on alarm(). */

+

+                if (timeout != (usec_t) -1)

+                        alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);

+

+                while (!hashmap_isempty(pids)) {

+                        _cleanup_free_ char *path = NULL;

+                        pid_t pid;

+

+                        pid = PTR_TO_UINT(hashmap_first_key(pids));

+                        assert(pid > 0);

-                        free(path);

+                        path = hashmap_remove(pids, UINT_TO_PTR(pid));

+                        assert(path);

+

+                        wait_for_terminate_and_warn(path, pid);

                 }

-        }

-finish:

-        if (_d)

-                closedir(_d);

+                _exit(EXIT_SUCCESS);

+        }

-        if (pids)

-                hashmap_free_free(pids);

+        wait_for_terminate_and_warn(directory, executor_pid);

 }

 int kill_and_sigcont(pid_t pid, int sig) {

diff --git a/src/shared/util.h b/src/shared/util.h

index 02621a7..47a3dc9 100644

--- a/src/shared/util.h

+++ b/src/shared/util.h

@@ -432,7 +432,7 @@ bool tty_is_console(const char *tty) _pure_;

 int vtnr_from_tty(const char *tty);

 const char *default_term_for_tty(const char *tty);

-void execute_directory(const char *directory, DIR *_d, char *argv[]);

+void execute_directory(const char *directory, DIR *_d, usec_t timeout, char *argv[]);

 int kill_and_sigcont(pid_t pid, int sig);

diff --git a/src/sleep/sleep.c b/src/sleep/sleep.c

index c228cb6..8e847db 100644

--- a/src/sleep/sleep.c

+++ b/src/sleep/sleep.c

@@ -25,14 +25,15 @@

 #include <string.h>

 #include <getopt.h>

-#include "systemd/sd-id128.h"

-#include "systemd/sd-messages.h"

+#include "sd-id128.h"

+#include "sd-messages.h"

 #include "log.h"

 #include "util.h"

 #include "strv.h"

 #include "fileio.h"

 #include "build.h"

 #include "sleep-config.h"

+#include "def.h"

 static char* arg_verb = NULL;

@@ -41,9 +42,12 @@ static int write_mode(char **modes) {

         char **mode;

         STRV_FOREACH(mode, modes) {

-                int k = write_string_file("/sys/power/disk", *mode);

+                int k;

+

+                k = write_string_file("/sys/power/disk", *mode);

                 if (k == 0)

                         return 0;

+

                 log_debug("Failed to write '%s' to /sys/power/disk: %s",

                           *mode, strerror(-k));

                 if (r == 0)

@@ -106,7 +110,7 @@ static int execute(char **modes, char **states) {

         arguments[1] = (char*) "pre";

         arguments[2] = arg_verb;

         arguments[3] = NULL;

-        execute_directory(SYSTEM_SLEEP_PATH, NULL, arguments);

+        execute_directory(SYSTEM_SLEEP_PATH, NULL, DEFAULT_TIMEOUT_USEC, arguments);

         log_struct(LOG_INFO,

                    MESSAGE_ID(SD_MESSAGE_SLEEP_START),

@@ -125,7 +129,7 @@ static int execute(char **modes, char **states) {

                    NULL);

         arguments[1] = (char*) "post";

-        execute_directory(SYSTEM_SLEEP_PATH, NULL, arguments);

+        execute_directory(SYSTEM_SLEEP_PATH, NULL, DEFAULT_TIMEOUT_USEC, arguments);

         return r;

 }