Simplify execute_directory()

Remove the optional sepearate opening of the directory,
it would be just too complicated with the change to
multiple directories.

Move the middle of execute_directory() to a seperate
function to make it easier to grok.

1 files changed, 79 insertions, 84 deletions

diff --git a/src/shared/util.c b/src/shared/util.c
index 7d753e448a..06bd1b9f04 100644
--- a/src/shared/util.c
+++ b/src/shared/util.c
@@ -4037,117 +4037,112 @@ 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, usec_t timeout, char *argv[]) {
-        pid_t executor_pid;
-        int r;
+static int do_execute(const char *directory, usec_t timeout, char *argv[]) {
+        _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
+        _cleanup_closedir_ DIR *d;
+        struct dirent *de;
 
-        assert(directory);
+        /* We fork this all off from a child process so that we can
+         * somewhat cleanly make use of SIGALRM to set a time limit */
 
-        /* Executes all binaries in a directory in parallel and waits
-         * for them to finish. Optionally a timeout is applied. */
+        reset_all_signal_handlers();
+        reset_signal_mask();
 
-        executor_pid = fork();
-        if (executor_pid < 0) {
-                log_error_errno(errno, "Failed to fork: %m");
-                return;
+        assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
 
-        } else if (executor_pid == 0) {
-                _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
-                _cleanup_closedir_ DIR *_d = NULL;
-                struct dirent *de;
+        d = opendir(directory);
+        if (!d) {
+                if (errno == ENOENT)
+                        return 0;
 
-                /* We fork this all off from a child process so that
-                 * we can somewhat cleanly make use of SIGALRM to set
-                 * a time limit */
+                return log_error_errno(errno, "Failed to open directory %s: %m", directory);
+        }
 
-                reset_all_signal_handlers();
-                reset_signal_mask();
+        pids = hashmap_new(NULL);
+        if (!pids)
+                return log_oom();
 
-                assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
+        FOREACH_DIRENT(de, d, break) {
+                _cleanup_free_ char *path = NULL;
+                pid_t pid;
+                int r;
 
-                if (!d) {
-                        d = _d = opendir(directory);
-                        if (!d) {
-                                if (errno == ENOENT)
-                                        _exit(EXIT_SUCCESS);
+                if (!dirent_is_file(de))
+                        continue;
 
-                                log_error_errno(errno, "Failed to enumerate directory %s: %m", directory);
-                                _exit(EXIT_FAILURE);
-                        }
-                }
+                path = strjoin(directory, "/", de->d_name, NULL);
+                if (!path)
+                        return log_oom();
 
-                pids = hashmap_new(NULL);
-                if (!pids) {
-                        log_oom();
-                        _exit(EXIT_FAILURE);
-                }
+                pid = fork();
+                if (pid < 0) {
+                        log_error_errno(errno, "Failed to fork: %m");
+                        continue;
+                } else if (pid == 0) {
+                        char *_argv[2];
 
-                FOREACH_DIRENT(de, d, break) {
-                        _cleanup_free_ char *path = NULL;
-                        pid_t pid;
+                        assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
 
-                        if (!dirent_is_file(de))
-                                continue;
+                        if (!argv) {
+                                _argv[0] = path;
+                                _argv[1] = NULL;
+                                argv = _argv;
+                        } else
+                                argv[0] = path;
 
-                        path = strjoin(directory, "/", de->d_name, NULL);
-                        if (!path) {
-                                log_oom();
-                                _exit(EXIT_FAILURE);
-                        }
+                        execv(path, argv);
+                        return log_error_errno(errno, "Failed to execute %s: %m", path);
+                }
 
-                        pid = fork();
-                        if (pid < 0) {
-                                log_error_errno(errno, "Failed to fork: %m");
-                                continue;
-                        } else if (pid == 0) {
-                                char *_argv[2];
+                log_debug("Spawned %s as " PID_FMT ".", path, pid);
 
-                                assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
+                r = hashmap_put(pids, UINT_TO_PTR(pid), path);
+                if (r < 0)
+                        return log_oom();
 
-                                if (!argv) {
-                                        _argv[0] = path;
-                                        _argv[1] = NULL;
-                                        argv = _argv;
-                                } else
-                                        argv[0] = path;
+                path = NULL;
+        }
 
-                                execv(path, argv);
-                                log_error_errno(errno, "Failed to execute %s: %m", path);
-                                _exit(EXIT_FAILURE);
-                        }
+        /* Abort execution of this process after the timout. We simply
+         * rely on SIGALRM as default action terminating the process,
+         * and turn on alarm(). */
 
-                        log_debug("Spawned %s as " PID_FMT ".", path, pid);
+        if (timeout != USEC_INFINITY)
+                alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
 
-                        r = hashmap_put(pids, UINT_TO_PTR(pid), path);
-                        if (r < 0) {
-                                log_oom();
-                                _exit(EXIT_FAILURE);
-                        }
+        while (!hashmap_isempty(pids)) {
+                _cleanup_free_ char *path = NULL;
+                pid_t pid;
 
-                        path = NULL;
-                }
+                pid = PTR_TO_UINT(hashmap_first_key(pids));
+                assert(pid > 0);
+
+                path = hashmap_remove(pids, UINT_TO_PTR(pid));
+                assert(path);
 
-                /* Abort execution of this process after the
-                 * timout. We simply rely on SIGALRM as default action
-                 * terminating the process, and turn on alarm(). */
+                wait_for_terminate_and_warn(path, pid, true);
+        }
 
-                if (timeout != USEC_INFINITY)
-                        alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
+        return 0;
+}
 
-                while (!hashmap_isempty(pids)) {
-                        _cleanup_free_ char *path = NULL;
-                        pid_t pid;
+void execute_directory(const char *directory, usec_t timeout, char *argv[]) {
+        pid_t executor_pid;
+        int r;
 
-                        pid = PTR_TO_UINT(hashmap_first_key(pids));
-                        assert(pid > 0);
+        assert(directory);
 
-                        path = hashmap_remove(pids, UINT_TO_PTR(pid));
-                        assert(path);
+        /* Executes all binaries in the directory in parallel and waits
+         * for them to finish. Optionally a timeout is applied. */
 
-                        wait_for_terminate_and_warn(path, pid, true);
-                }
+        executor_pid = fork();
+        if (executor_pid < 0) {
+                log_error_errno(errno, "Failed to fork: %m");
+                return;
 
-                _exit(EXIT_SUCCESS);
+        } else if (executor_pid == 0) {
+                r = do_execute(directory, timeout, argv);
+                _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
         }
 
         wait_for_terminate_and_warn(directory, executor_pid, true);