Merge pull request #29272 from enr0n/coredump-container

coredump: support forwarding coredumps to containers

src/basic/cgroup-util.c

@@ -2268,6 +2268,37 @@ int cg_hybrid_unified(void) {
         return r == CGROUP_UNIFIED_SYSTEMD && !unified_systemd_v232;
 }
 
+int cg_is_delegated(const char *path) {
+        int r;
+
+        assert(path);
+
+        r = cg_get_xattr_bool(path, "trusted.delegate");
+        if (ERRNO_IS_NEG_XATTR_ABSENT(r)) {
+                /* If the trusted xattr isn't set (preferred), then check the
+                 * untrusted one. Under the assumption that whoever is trusted
+                 * enough to own the cgroup, is also trusted enough to decide
+                 * if it is delegated or not this should be safe. */
+                r = cg_get_xattr_bool(path, "user.delegate");
+                if (ERRNO_IS_NEG_XATTR_ABSENT(r))
+                        return false;
+        }
+
+        return r;
+}
+
+int cg_has_coredump_receive(const char *path) {
+        int r;
+
+        assert(path);
+
+        r = cg_get_xattr_bool(path, "user.coredump_receive");
+        if (ERRNO_IS_NEG_XATTR_ABSENT(r))
+                return false;
+
+        return r;
+}
+
 const uint64_t cgroup_io_limit_defaults[_CGROUP_IO_LIMIT_TYPE_MAX] = {
         [CGROUP_IO_RBPS_MAX]    = CGROUP_LIMIT_MAX,
         [CGROUP_IO_WBPS_MAX]    = CGROUP_LIMIT_MAX,

src/basic/cgroup-util.h

@@ -210,6 +210,10 @@ int cg_rmdir(const char *controller, const char *path);
 
 int cg_is_threaded(const char *path);
 
+int cg_is_delegated(const char *path);
+
+int cg_has_coredump_receive(const char *path);
+
 typedef enum  {
         CG_KEY_MODE_GRACEFUL = 1 << 0,
 } CGroupKeyMode;

src/basic/process-util.c

@@ -319,6 +319,33 @@ int container_get_leader(const char *machine, pid_t *pid) {
         return 0;
 }
 
+int namespace_get_leader(pid_t pid, NamespaceType type, pid_t *ret) {
+        int r;
+
+        assert(ret);
+
+        for (;;) {
+                pid_t ppid;
+
+                r = get_process_ppid(pid, &ppid);
+                if (r < 0)
+                        return r;
+
+                r = in_same_namespace(pid, ppid, type);
+                if (r < 0)
+                        return r;
+                if (r == 0) {
+                        /* If the parent and the child are not in the same
+                         * namespace, then the child is the leader we are
+                         * looking for. */
+                        *ret = pid;
+                        return 0;
+                }
+
+                pid = ppid;
+        }
+}
+
 int is_kernel_thread(pid_t pid) {
         _cleanup_free_ char *line = NULL;
         unsigned long long flags;

src/basic/process-util.h

@@ -14,6 +14,7 @@
 #include "alloc-util.h"
 #include "format-util.h"
 #include "macro.h"
+#include "namespace-util.h"
 #include "time-util.h"
 
 #define procfs_file_alloca(pid, field)                                  \
@@ -53,6 +54,8 @@ int get_process_umask(pid_t pid, mode_t *ret);
 
 int container_get_leader(const char *machine, pid_t *pid);
 
+int namespace_get_leader(pid_t pid, NamespaceType type, pid_t *ret);
+
 int wait_for_terminate(pid_t pid, siginfo_t *status);
 
 typedef enum WaitFlags {