HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/execute.c

114,975 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 78c34b4e092b80db503d10431609260c5b3d8f72

Lines 2001–3000 of 3,235

 
        void *id, *val;
        HASHMAP_FOREACH_KEY(val, id, c->syscall_filter) {
                _cleanup_free_ char *name = NULL;
                const char *e = NULL;
                char *s;
                int num = PTR_TO_INT(val);
 
                if (c->syscall_allow_list && num >= 0)
                        /* syscall with num >= 0 in allow-list is denied. */
                        continue;
 
                name = sym_seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1);
                if (!name)
                        continue;
 
                if (num >= 0) {
                        e = seccomp_errno_or_action_to_string(num);
                        if (e)
                                s = strjoin(name, ":", e);
                        else
                                s = asprintf_safe("%s:%d", name, num);
                        if (!s)
                                return NULL;
                } else
                        s = TAKE_PTR(name);
 
                if (strv_consume(&l, s) < 0)
                        return NULL;
        }
 
        strv_sort(l);
#endif
 
        return l ? TAKE_PTR(l) : strv_new(NULL);
}
 
char** exec_context_get_syscall_archs(const ExecContext *c) {
        _cleanup_strv_free_ char **l = NULL;
 
        assert(c);
 
#if HAVE_SECCOMP
        void *id;
        SET_FOREACH(id, c->syscall_archs) {
                const char *name;
 
                name = seccomp_arch_to_string(PTR_TO_UINT32(id) - 1);
                if (!name)
                        continue;
 
                if (strv_extend(&l, name) < 0)
                        return NULL;
        }
 
        strv_sort(l);
#endif
 
        return l ? TAKE_PTR(l) : strv_new(NULL);
}
 
char** exec_context_get_syscall_log(const ExecContext *c) {
        _cleanup_strv_free_ char **l = NULL;
 
        assert(c);
 
#if HAVE_SECCOMP
        if (dlopen_libseccomp(LOG_DEBUG) < 0)
                return strv_new(NULL);
 
        void *id, *val;
        HASHMAP_FOREACH_KEY(val, id, c->syscall_log) {
                char *name = NULL;
 
                name = sym_seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1);
                if (!name)
                        continue;
 
                if (strv_consume(&l, name) < 0)
                        return NULL;
        }
 
        strv_sort(l);
#endif
 
        return l ? TAKE_PTR(l) : strv_new(NULL);
}
 
char** exec_context_get_address_families(const ExecContext *c) {
        _cleanup_strv_free_ char **l = NULL;
        void *af;
 
        assert(c);
 
        SET_FOREACH(af, c->address_families) {
                const char *name;
 
                name = af_to_name(PTR_TO_INT(af));
                if (!name)
                        continue;
 
                if (strv_extend(&l, name) < 0)
                        return NULL;
        }
 
        strv_sort(l);
 
        return l ? TAKE_PTR(l) : strv_new(NULL);
}
 
char** exec_context_get_restrict_filesystems(const ExecContext *c) {
        assert(c);
 
#if HAVE_LIBBPF
        char **l = set_get_strv(c->restrict_filesystems);
        if (!l)
                return NULL;
 
        return strv_sort(l);
#else
        return strv_new(NULL);
#endif
}
 
bool exec_context_restrict_namespaces_set(const ExecContext *c) {
        assert(c);
 
        return (c->restrict_namespaces & NAMESPACE_FLAGS_ALL) != NAMESPACE_FLAGS_ALL;
}
 
bool exec_context_restrict_filesystems_set(const ExecContext *c) {
        assert(c);
 
        return c->restrict_filesystems_allow_list ||
          !set_isempty(c->restrict_filesystems);
}
 
bool exec_context_with_rootfs(const ExecContext *c) {
        assert(c);
 
        /* Checks if RootDirectory=, RootImage=, RootMStack= or RootDirectoryFileDescriptor= are used */
 
        return !empty_or_root(c->root_directory) || c->root_image || c->root_directory_as_fd || c->root_mstack;
}
 
bool exec_context_with_rootfs_strict(const ExecContext *c) {
        assert(c);
 
        /* just like exec_context_with_rootfs(), but doesn't suppress a root directory of "/", i.e. returns
         * true in more cases: when a root directory is explicitly configured, even if it's our usual
         * root. */
 
        return c->root_directory || c->root_image || c->root_directory_as_fd || c->root_mstack;
}
 
int exec_context_has_vpicked_extensions(const ExecContext *context) {
        int r;
 
        assert(context);
 
        FOREACH_ARRAY(mi, context->extension_images, context->n_extension_images) {
                r = path_uses_vpick(mi->source);
                if (r != 0)
                        return r;
        }
        STRV_FOREACH(ed, context->extension_directories) {
                r = path_uses_vpick(*ed);
                if (r != 0)
                        return r;
        }
 
        return 0;
}
 
void exec_status_start(ExecStatus *s, pid_t pid, const dual_timestamp *ts) {
        assert(s);
 
        *s = (ExecStatus) {
                .pid = pid,
        };
 
        if (ts)
                s->start_timestamp = *ts;
        else
                dual_timestamp_now(&s->start_timestamp);
}
 
void exec_status_exit(ExecStatus *s, const ExecContext *context, pid_t pid, int code, int status) {
        assert(s);
 
        if (s->pid != pid)
                *s = (ExecStatus) {
                        .pid = pid,
                };
 
        dual_timestamp_now(&s->exit_timestamp);
 
        s->code = code;
        s->status = status;
 
        if (context && context->utmp_id)
                (void) utmp_put_dead_process(context->utmp_id, pid, code, status);
}
 
void exec_status_handoff(ExecStatus *s, const struct ucred *ucred, const dual_timestamp *ts) {
        assert(s);
        assert(ucred);
        assert(ts);
 
        if (ucred->pid != s->pid)
                *s = (ExecStatus) {
                        .pid = ucred->pid,
                };
 
        s->handoff_timestamp = *ts;
}
 
void exec_status_reset(ExecStatus *s) {
        assert(s);
 
        *s = (ExecStatus) {};
}
 
void exec_status_dump(const ExecStatus *s, FILE *f, const char *prefix) {
        assert(s);
        assert(f);
 
        if (s->pid <= 0)
                return;
 
        prefix = strempty(prefix);
 
        fprintf(f,
                "%sPID: "PID_FMT"\n",
                prefix, s->pid);
 
        if (dual_timestamp_is_set(&s->start_timestamp))
                fprintf(f,
                        "%sStart Timestamp: %s\n",
                        prefix, FORMAT_TIMESTAMP_STYLE(s->start_timestamp.realtime, TIMESTAMP_US));
 
        if (dual_timestamp_is_set(&s->handoff_timestamp) && dual_timestamp_is_set(&s->start_timestamp) &&
            s->handoff_timestamp.monotonic > s->start_timestamp.monotonic)
                fprintf(f,
                        "%sHandoff Timestamp: %s since start\n",
                        prefix,
                        FORMAT_TIMESPAN(usec_sub_unsigned(s->handoff_timestamp.monotonic, s->start_timestamp.monotonic), 1));
        else
                fprintf(f,
                        "%sHandoff Timestamp: %s\n",
                        prefix, FORMAT_TIMESTAMP_STYLE(s->handoff_timestamp.realtime, TIMESTAMP_US));
 
        if (dual_timestamp_is_set(&s->exit_timestamp)) {
 
                if (dual_timestamp_is_set(&s->handoff_timestamp) && s->exit_timestamp.monotonic > s->handoff_timestamp.monotonic)
                        fprintf(f,
                                "%sExit Timestamp: %s since handoff\n",
                                prefix,
                                FORMAT_TIMESPAN(usec_sub_unsigned(s->exit_timestamp.monotonic, s->handoff_timestamp.monotonic), 1));
                else if (dual_timestamp_is_set(&s->start_timestamp) && s->exit_timestamp.monotonic > s->start_timestamp.monotonic)
                        fprintf(f,
                                "%sExit Timestamp: %s since start\n",
                                prefix,
                                FORMAT_TIMESPAN(usec_sub_unsigned(s->exit_timestamp.monotonic, s->start_timestamp.monotonic), 1));
                else
                        fprintf(f,
                                "%sExit Timestamp: %s\n",
                                prefix, FORMAT_TIMESTAMP_STYLE(s->exit_timestamp.realtime, TIMESTAMP_US));
 
                fprintf(f,
                        "%sExit Code: %s\n"
                        "%sExit Status: %i\n",
                        prefix, sigchld_code_to_string(s->code),
                        prefix, s->status);
        }
}
 
void exec_command_dump(ExecCommand *c, FILE *f, const char *prefix) {
        _cleanup_free_ char *cmd = NULL;
        const char *prefix2;
 
        assert(c);
        assert(f);
 
        prefix = strempty(prefix);
        prefix2 = strjoina(prefix, "\t");
 
        cmd = quote_command_line(c->argv, SHELL_ESCAPE_EMPTY);
 
        fprintf(f,
                "%sCommand Line: %s\n",
                prefix, strnull(cmd));
 
        exec_status_dump(&c->exec_status, f, prefix2);
}
 
void exec_command_dump_list(ExecCommand *c, FILE *f, const char *prefix) {
        assert(f);
 
        prefix = strempty(prefix);
 
        LIST_FOREACH(command, i, c)
                exec_command_dump(i, f, prefix);
}
 
void exec_command_append_list(ExecCommand **l, ExecCommand *e) {
        ExecCommand *end;
 
        assert(l);
        assert(e);
 
        if (*l) {
                /* It's kind of important, that we keep the order here */
                end = LIST_FIND_TAIL(command, *l);
                LIST_INSERT_AFTER(command, *l, end, e);
        } else
                *l = e;
}
 
int exec_command_set(ExecCommand *c, const char *path, ...) {
        va_list ap;
        char **l, *p;
 
        assert(c);
        assert(path);
 
        va_start(ap, path);
        l = strv_new_ap(path, ap);
        va_end(ap);
 
        if (!l)
                return -ENOMEM;
 
        p = strdup(path);
        if (!p) {
                strv_free(l);
                return -ENOMEM;
        }
 
        free_and_replace(c->path, p);
 
        return strv_free_and_replace(c->argv, l);
}
 
int exec_command_append(ExecCommand *c, const char *path, ...) {
        char **l;
        va_list ap;
        int r;
 
        assert(c);
        assert(path);
 
        va_start(ap, path);
        l = strv_new_ap(path, ap);
        va_end(ap);
 
        if (!l)
                return -ENOMEM;
 
        r = strv_extend_strv_consume(&c->argv, l, /* filter_duplicates= */ false);
        if (r < 0)
                return r;
 
        return 0;
}
 
static char *destroy_tree(char *path) {
        if (!path)
                return NULL;
 
        if (!path_equal(path, RUN_SYSTEMD_EMPTY)) {
                log_debug("Spawning process to nuke '%s'", path);
 
                (void) asynchronous_rm_rf(path, REMOVE_ROOT|REMOVE_SUBVOLUME|REMOVE_PHYSICAL);
        }
 
        return mfree(path);
}
 
void exec_shared_runtime_done(ExecSharedRuntime *rt) {
        assert(rt);
 
        if (rt->manager)
                (void) hashmap_remove(rt->manager->exec_shared_runtime_by_id, rt->id);
 
        rt->id = mfree(rt->id);
        rt->tmp_dir = mfree(rt->tmp_dir);
        rt->var_tmp_dir = mfree(rt->var_tmp_dir);
        safe_close_pair(rt->userns_storage_socket);
        safe_close_pair(rt->netns_storage_socket);
        safe_close_pair(rt->ipcns_storage_socket);
}
 
static ExecSharedRuntime* exec_shared_runtime_free(ExecSharedRuntime *rt) {
        if (!rt)
                return NULL;
 
        exec_shared_runtime_done(rt);
        return mfree(rt);
}
 
DEFINE_TRIVIAL_UNREF_FUNC(ExecSharedRuntime, exec_shared_runtime, exec_shared_runtime_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(ExecSharedRuntime*, exec_shared_runtime_free);
 
ExecSharedRuntime* exec_shared_runtime_destroy(ExecSharedRuntime *rt) {
        if (!rt)
                return NULL;
 
        assert(rt->n_ref > 0);
        rt->n_ref--;
 
        if (rt->n_ref > 0)
                return NULL;
 
        rt->tmp_dir = destroy_tree(rt->tmp_dir);
        rt->var_tmp_dir = destroy_tree(rt->var_tmp_dir);
 
        return exec_shared_runtime_free(rt);
}
 
static int exec_shared_runtime_allocate(ExecSharedRuntime **ret, const char *id) {
        _cleanup_free_ char *id_copy = NULL;
        ExecSharedRuntime *n;
 
        assert(ret);
 
        id_copy = strdup(id);
        if (!id_copy)
                return -ENOMEM;
 
        n = new(ExecSharedRuntime, 1);
        if (!n)
                return -ENOMEM;
 
        *n = (ExecSharedRuntime) {
                .id = TAKE_PTR(id_copy),
                .userns_storage_socket = EBADF_PAIR,
                .netns_storage_socket = EBADF_PAIR,
                .ipcns_storage_socket = EBADF_PAIR,
        };
 
        *ret = n;
        return 0;
}
 
static int exec_shared_runtime_add(
                Manager *m,
                const char *id,
                char **tmp_dir,
                char **var_tmp_dir,
                int userns_storage_socket[2],
                int netns_storage_socket[2],
                int ipcns_storage_socket[2],
                ExecSharedRuntime **ret) {
 
        _cleanup_(exec_shared_runtime_freep) ExecSharedRuntime *rt = NULL;
        int r;
 
        assert(m);
        assert(id);
        assert(tmp_dir);
        assert(var_tmp_dir);
 
        /* tmp_dir, var_tmp_dir, {net,ipc}ns_storage_socket fds are donated on success */
 
        r = exec_shared_runtime_allocate(&rt, id);
        if (r < 0)
                return r;
 
        r = hashmap_ensure_put(&m->exec_shared_runtime_by_id, &string_hash_ops, rt->id, rt);
        if (r < 0)
                return r;
 
        rt->tmp_dir = TAKE_PTR(*tmp_dir);
        rt->var_tmp_dir = TAKE_PTR(*var_tmp_dir);
 
        if (userns_storage_socket) {
                rt->userns_storage_socket[0] = TAKE_FD(userns_storage_socket[0]);
                rt->userns_storage_socket[1] = TAKE_FD(userns_storage_socket[1]);
        }
 
        if (netns_storage_socket) {
                rt->netns_storage_socket[0] = TAKE_FD(netns_storage_socket[0]);
                rt->netns_storage_socket[1] = TAKE_FD(netns_storage_socket[1]);
        }
 
        if (ipcns_storage_socket) {
                rt->ipcns_storage_socket[0] = TAKE_FD(ipcns_storage_socket[0]);
                rt->ipcns_storage_socket[1] = TAKE_FD(ipcns_storage_socket[1]);
        }
 
        rt->manager = m;
 
        if (ret)
                *ret = rt;
        /* do not remove created ExecSharedRuntime object when the operation succeeds. */
        TAKE_PTR(rt);
        return 0;
}
 
static int exec_shared_runtime_make(
                Manager *m,
                const ExecContext *c,
                const char *id,
                ExecSharedRuntime **ret) {
 
        _cleanup_(namespace_cleanup_tmpdirp) char *tmp_dir = NULL, *var_tmp_dir = NULL;
        _cleanup_close_pair_ int userns_storage_socket[2] = EBADF_PAIR, netns_storage_socket[2] = EBADF_PAIR, ipcns_storage_socket[2] = EBADF_PAIR;
        int r;
 
        assert(m);
        assert(c);
        assert(id);
        assert(ret);
 
        /* It is not necessary to create ExecSharedRuntime object. */
        if (!c->user_namespace_path && !exec_needs_network_namespace(c) && !exec_needs_ipc_namespace(c) &&
            c->private_tmp != PRIVATE_TMP_CONNECTED && c->private_var_tmp != PRIVATE_TMP_CONNECTED) {
                *ret = NULL;
                return 0;
        }
 
        if (c->private_tmp == PRIVATE_TMP_CONNECTED &&
            !prefixed_path_strv_contains(c->inaccessible_paths, "/tmp")) {
 
                r = setup_tmp_dir_one(id, "/tmp", &tmp_dir);
                if (r < 0)
                        return r;
        }
 
        if (c->private_var_tmp == PRIVATE_TMP_CONNECTED &&
            !prefixed_path_strv_contains(c->inaccessible_paths, "/var/tmp") &&
            !prefixed_path_strv_contains(c->inaccessible_paths, "/var")) {
 
                r = setup_tmp_dir_one(id, "/var/tmp", &var_tmp_dir);
                if (r < 0)
                        return r;
        }
 
        if (c->user_namespace_path)
                if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, userns_storage_socket) < 0)
                        return -errno;
 
        if (exec_needs_network_namespace(c))
                if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, netns_storage_socket) < 0)
                        return -errno;
 
        if (exec_needs_ipc_namespace(c))
                if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, ipcns_storage_socket) < 0)
                        return -errno;
 
        r = exec_shared_runtime_add(m, id, &tmp_dir, &var_tmp_dir, userns_storage_socket, netns_storage_socket, ipcns_storage_socket, ret);
        if (r < 0)
                return r;
 
        return 1;
}
 
int exec_shared_runtime_acquire(Manager *m, const ExecContext *c, const char *id, bool create, ExecSharedRuntime **ret) {
        ExecSharedRuntime *rt;
        int r;
 
        assert(m);
        assert(id);
        assert(ret);
 
        rt = hashmap_get(m->exec_shared_runtime_by_id, id);
        if (rt)
                /* We already have an ExecSharedRuntime object, let's increase the ref count and reuse it */
                goto ref;
 
        if (!create) {
                *ret = NULL;
                return 0;
        }
 
        /* If not found, then create a new object. */
        r = exec_shared_runtime_make(m, c, id, &rt);
        if (r < 0)
                return r;
        if (r == 0) {
                /* When r == 0, it is not necessary to create ExecSharedRuntime object. */
                *ret = NULL;
                return 0;
        }
 
ref:
        /* increment reference counter. */
        rt->n_ref++;
        *ret = rt;
        return 1;
}
 
int exec_shared_runtime_serialize(const Manager *m, FILE *f, FDSet *fds) {
        ExecSharedRuntime *rt;
 
        assert(m);
        assert(f);
        assert(fds);
 
        HASHMAP_FOREACH(rt, m->exec_shared_runtime_by_id) {
                fprintf(f, "exec-runtime=%s", rt->id);
 
                if (rt->tmp_dir)
                        fprintf(f, " tmp-dir=%s", rt->tmp_dir);
 
                if (rt->var_tmp_dir)
                        fprintf(f, " var-tmp-dir=%s", rt->var_tmp_dir);
 
                if (rt->userns_storage_socket[0] >= 0) {
                        int copy;
 
                        copy = fdset_put_dup(fds, rt->userns_storage_socket[0]);
                        if (copy < 0)
                                return copy;
 
                        fprintf(f, " userns-socket-0=%i", copy);
                }
 
                if (rt->userns_storage_socket[1] >= 0) {
                        int copy;
 
                        copy = fdset_put_dup(fds, rt->userns_storage_socket[1]);
                        if (copy < 0)
                                return copy;
 
                        fprintf(f, " userns-socket-1=%i", copy);
                }
 
                if (rt->netns_storage_socket[0] >= 0) {
                        int copy;
 
                        copy = fdset_put_dup(fds, rt->netns_storage_socket[0]);
                        if (copy < 0)
                                return copy;
 
                        fprintf(f, " netns-socket-0=%i", copy);
                }
 
                if (rt->netns_storage_socket[1] >= 0) {
                        int copy;
 
                        copy = fdset_put_dup(fds, rt->netns_storage_socket[1]);
                        if (copy < 0)
                                return copy;
 
                        fprintf(f, " netns-socket-1=%i", copy);
                }
 
                if (rt->ipcns_storage_socket[0] >= 0) {
                        int copy;
 
                        copy = fdset_put_dup(fds, rt->ipcns_storage_socket[0]);
                        if (copy < 0)
                                return copy;
 
                        fprintf(f, " ipcns-socket-0=%i", copy);
                }
 
                if (rt->ipcns_storage_socket[1] >= 0) {
                        int copy;
 
                        copy = fdset_put_dup(fds, rt->ipcns_storage_socket[1]);
                        if (copy < 0)
                                return copy;
 
                        fprintf(f, " ipcns-socket-1=%i", copy);
                }
 
                fputc('\n', f);
        }
 
        return 0;
}
 
int exec_shared_runtime_deserialize_compat(Unit *u, const char *key, const char *value, FDSet *fds) {
        _cleanup_(exec_shared_runtime_freep) ExecSharedRuntime *rt_create = NULL;
        ExecSharedRuntime *rt = NULL;
        int r;
 
        /* This is for the migration from old (v237 or earlier) deserialization text.
         * Due to the bug #7790, this may not work with the units that use JoinsNamespaceOf=.
         * Even if the ExecSharedRuntime object originally created by the other unit, we cannot judge
         * so or not from the serialized text, then we always creates a new object owned by this. */
 
        assert(u);
        assert(key);
        assert(value);
 
        /* Manager manages ExecSharedRuntime objects by the unit id.
         * So, we omit the serialized text when the unit does not have id (yet?)... */
        if (isempty(u->id)) {
                log_unit_debug(u, "Invocation ID not found. Dropping runtime parameter.");
                return 0;
        }
 
        if (u->manager) {
                if (hashmap_ensure_allocated(&u->manager->exec_shared_runtime_by_id, &string_hash_ops) < 0)
                        return log_oom();
 
                rt = hashmap_get(u->manager->exec_shared_runtime_by_id, u->id);
        }
        if (!rt) {
                if (exec_shared_runtime_allocate(&rt_create, u->id) < 0)
                        return log_oom();
 
                rt = rt_create;
        }
 
        if (streq(key, "tmp-dir")) {
                if (free_and_strdup_warn(&rt->tmp_dir, value) < 0)
                        return -ENOMEM;
 
        } else if (streq(key, "var-tmp-dir")) {
                if (free_and_strdup_warn(&rt->var_tmp_dir, value) < 0)
                        return -ENOMEM;
 
        } else if (streq(key, "netns-socket-0")) {
 
                safe_close(rt->netns_storage_socket[0]);
                rt->netns_storage_socket[0] = deserialize_fd(fds, value);
                if (rt->netns_storage_socket[0] < 0)
                        return 0;
 
        } else if (streq(key, "netns-socket-1")) {
 
                safe_close(rt->netns_storage_socket[1]);
                rt->netns_storage_socket[1] = deserialize_fd(fds, value);
                if (rt->netns_storage_socket[1] < 0)
                        return 0;
        } else
                return 0;
 
        /* If the object is newly created, then put it to the hashmap which manages ExecSharedRuntime objects. */
        if (rt_create && u->manager) {
                r = hashmap_put(u->manager->exec_shared_runtime_by_id, rt_create->id, rt_create);
                if (r < 0) {
                        log_unit_debug_errno(u, r, "Failed to put runtime parameter to manager's storage: %m");
                        return 0;
                }
 
                rt_create->manager = u->manager;
 
                /* Avoid cleanup */
                TAKE_PTR(rt_create);
        }
 
        return 1;
}
 
int exec_shared_runtime_deserialize_one(Manager *m, const char *value, FDSet *fds) {
        _cleanup_free_ char *tmp_dir = NULL, *var_tmp_dir = NULL;
        char *id = NULL;
        _cleanup_close_pair_ int userns_fdpair[] = EBADF_PAIR, netns_fdpair[] = EBADF_PAIR, ipcns_fdpair[] = EBADF_PAIR;
        int r;
        const char *p, *v = ASSERT_PTR(value);
        size_t n;
 
        assert(m);
        assert(fds);
 
        n = strcspn(v, " ");
        id = strndupa_safe(v, n);
        if (v[n] != ' ')
                goto finalize;
        p = v + n + 1;
 
        v = startswith(p, "tmp-dir=");
        if (v) {
                n = strcspn(v, " ");
                tmp_dir = strndup(v, n);
                if (!tmp_dir)
                        return log_oom();
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "var-tmp-dir=");
        if (v) {
                n = strcspn(v, " ");
                var_tmp_dir = strndup(v, n);
                if (!var_tmp_dir)
                        return log_oom();
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "userns-socket-0=");
        if (v) {
                char *buf;
 
                n = strcspn(v, " ");
                buf = strndupa_safe(v, n);
 
                userns_fdpair[0] = deserialize_fd(fds, buf);
                if (userns_fdpair[0] < 0)
                        return userns_fdpair[0];
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "userns-socket-1=");
        if (v) {
                char *buf;
 
                n = strcspn(v, " ");
                buf = strndupa_safe(v, n);
 
                userns_fdpair[1] = deserialize_fd(fds, buf);
                if (userns_fdpair[1] < 0)
                        return userns_fdpair[1];
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "netns-socket-0=");
        if (v) {
                char *buf;
 
                n = strcspn(v, " ");
                buf = strndupa_safe(v, n);
 
                netns_fdpair[0] = deserialize_fd(fds, buf);
                if (netns_fdpair[0] < 0)
                        return netns_fdpair[0];
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "netns-socket-1=");
        if (v) {
                char *buf;
 
                n = strcspn(v, " ");
                buf = strndupa_safe(v, n);
 
                netns_fdpair[1] = deserialize_fd(fds, buf);
                if (netns_fdpair[1] < 0)
                        return netns_fdpair[1];
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "ipcns-socket-0=");
        if (v) {
                char *buf;
 
                n = strcspn(v, " ");
                buf = strndupa_safe(v, n);
 
                ipcns_fdpair[0] = deserialize_fd(fds, buf);
                if (ipcns_fdpair[0] < 0)
                        return ipcns_fdpair[0];
                if (v[n] != ' ')
                        goto finalize;
                p = v + n + 1;
        }
 
        v = startswith(p, "ipcns-socket-1=");
        if (v) {
                char *buf;
 
                n = strcspn(v, " ");
                buf = strndupa_safe(v, n);
 
                ipcns_fdpair[1] = deserialize_fd(fds, buf);
                if (ipcns_fdpair[1] < 0)
                        return ipcns_fdpair[1];
        }
 
finalize:
        r = exec_shared_runtime_add(m, id, &tmp_dir, &var_tmp_dir, userns_fdpair, netns_fdpair, ipcns_fdpair, NULL);
        if (r < 0)
                return log_debug_errno(r, "Failed to add exec-runtime: %m");
        return 0;
}
 
void exec_shared_runtime_vacuum(Manager *m) {
        ExecSharedRuntime *rt;
 
        assert(m);
 
        /* Free unreferenced ExecSharedRuntime objects. This is used after manager deserialization process. */
 
        HASHMAP_FOREACH(rt, m->exec_shared_runtime_by_id) {
                if (rt->n_ref > 0)
                        continue;
 
                (void) exec_shared_runtime_free(rt);
        }
}
 
int exec_runtime_make(
                const Unit *unit,
                const ExecContext *context,
                ExecSharedRuntime *shared,
                DynamicCreds *creds,
                ExecRuntime **ret) {
        _cleanup_close_pair_ int ephemeral_storage_socket[2] = EBADF_PAIR;
        _cleanup_free_ char *ephemeral = NULL;
        _cleanup_(exec_runtime_freep) ExecRuntime *rt = NULL;
        int r;
 
        assert(unit);
        assert(context);
        assert(ret);
 
        if (!shared && !creds && !exec_needs_ephemeral(context)) {
                *ret = NULL;
                return 0;
        }
 
        if (exec_needs_ephemeral(context)) {
                r = mkdir_p("/var/lib/systemd/ephemeral-trees", 0755);
                if (r < 0)
                        return r;
 
                r = tempfn_random_child("/var/lib/systemd/ephemeral-trees", unit->id, &ephemeral);
                if (r < 0)
                        return r;
 
                if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, ephemeral_storage_socket) < 0)
                        return -errno;
        }
 
        rt = new(ExecRuntime, 1);
        if (!rt)
                return -ENOMEM;
 
        *rt = (ExecRuntime) {
                .shared = shared,
                .dynamic_creds = creds,
                .ephemeral_copy = TAKE_PTR(ephemeral),
                .ephemeral_storage_socket[0] = TAKE_FD(ephemeral_storage_socket[0]),
                .ephemeral_storage_socket[1] = TAKE_FD(ephemeral_storage_socket[1]),
        };
 
        *ret = TAKE_PTR(rt);
        return 1;
}
 
ExecRuntime* exec_runtime_free(ExecRuntime *rt) {
        if (!rt)
                return NULL;
 
        exec_shared_runtime_unref(rt->shared);
        dynamic_creds_unref(rt->dynamic_creds);
 
        rt->ephemeral_copy = destroy_tree(rt->ephemeral_copy);
 
        safe_close_pair(rt->ephemeral_storage_socket);
        return mfree(rt);
}
 
ExecRuntime* exec_runtime_destroy(ExecRuntime *rt) {
        if (!rt)
                return NULL;
 
        rt->shared = exec_shared_runtime_destroy(rt->shared);
        rt->dynamic_creds = dynamic_creds_destroy(rt->dynamic_creds);
        return exec_runtime_free(rt);
}
 
void exec_runtime_clear(ExecRuntime *rt) {
        if (!rt)
                return;
 
        safe_close_pair(rt->ephemeral_storage_socket);
        rt->ephemeral_copy = mfree(rt->ephemeral_copy);
}
 
void exec_params_shallow_clear(ExecParameters *p) {
        if (!p)
                return;
 
        /* This is called on the PID1 side, as many of the struct's FDs are only borrowed, and actually
         * owned by the manager or other objects, and reused across multiple units. */
 
        p->environment = strv_free(p->environment);
        p->fd_names = strv_free(p->fd_names);
        p->files_env = strv_free(p->files_env);
        p->fds = mfree(p->fds);
        p->root_directory_fd = safe_close(p->root_directory_fd);
        p->exec_fd = safe_close(p->exec_fd);
        p->user_lookup_fd = -EBADF;
        p->bpf_restrict_fs_map_fd = -EBADF;
        p->unit_id = mfree(p->unit_id);
        p->invocation_id = SD_ID128_NULL;
        p->invocation_id_string[0] = '\0';
        p->confirm_spawn = mfree(p->confirm_spawn);
}
 
void exec_params_deep_clear(ExecParameters *p) {
        if (!p)