Re: [PATCH 01/10] pid: add helpers to operate on a struct pid array

---
 fs/pidfs.c                   | 16 +++++++++++++
 include/linux/pid.h          | 53 ++++++++++++++++++++++++++++++++++++++++++++
 include/linux/pid_types.h    |  8 +++++++
 include/linux/pidfs.h        |  5 +++++
 include/linux/sched/signal.h | 18 +++++++++++++++
 5 files changed, 100 insertions(+)

diff --git a/fs/pidfs.c b/fs/pidfs.c
index a6a643f15d08..586af2e5811c 100644
--- a/fs/pidfs.c
+++ b/fs/pidfs.c

@@ -1070,6 +1070,22 @@ int pidfs_register_pid_gfp(struct pid *pid, gfp_t gfp)
        return 0;
 }

+/* Register the pids up to pid type @last of @pids in pidfs. */
+int __pidfs_register_pids(struct pid *const *pids, enum pid_type last)
+{
+       if (WARN_ON_ONCE(last >= PIDTYPE_MAX))
+               return -EINVAL;
+
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++) {
+               int ret = pidfs_register_pid(pids[type]);
+
+               if (unlikely(ret))
+                       return ret;
+       }
+
+       return 0;
+}
+
 static struct dentry *pidfs_stash_dentry(struct dentry **stashed,
                                         struct dentry *dentry)
 {

diff --git a/include/linux/pid.h b/include/linux/pid.h
index ddaef0bbc8ba..87635d0cc1f7 100644
--- a/include/linux/pid.h
+++ b/include/linux/pid.h

@@ -2,6 +2,9 @@
 #ifndef _LINUX_PID_H
 #define _LINUX_PID_H

+#include <linux/array_size.h>
+#include <linux/build_bug.h>
+#include <linux/minmax.h>
 #include <linux/pid_types.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>

@@ -92,6 +95,56 @@ static inline struct pid *get_pid(struct pid *pid)
 }

 extern void put_pid(struct pid *pid);
+
+/*
+ * Helpers for arrays of struct pid indexed by pid type declared with
+ * DECLARE_PIDS(). The array covers PIDTYPE_PID up to the pid type it
+ * was declared with and the helpers take that bound from the array.
+ */
+static inline void __get_pids(struct pid **dst, struct pid *const *src,
+                             enum pid_type last)
+{
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++)
+               dst[type] = get_pid(src[type]);
+}
+
+static inline void __put_pids(struct pid **pids, enum pid_type last)
+{
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++) {
+               put_pid(pids[type]);
+               pids[type] = NULL;
+       }
+}
+
+static inline void __swap_pids(struct pid **a, struct pid **b,
+                              enum pid_type last)
+{
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++)
+               swap(a[type], b[type]);
+}
+
+static inline bool __pids_equal(struct pid *const *a, struct pid *const *b,
+                               enum pid_type last)
+{
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++)
+               if (a[type] != b[type])
+                       return false;
+       return true;
+}
+
+/* The last pid type an array declared with DECLARE_PIDS() covers. */
+#define pids_last(pids)                                                        \
+       ((enum pid_type)(ARRAY_SIZE(pids) - 1 +                         \
+                        BUILD_BUG_ON_ZERO(ARRAY_SIZE(pids) > PIDTYPE_MAX)))
+
+#define __pids_last2(a, b)                                             \
+       (pids_last(a) + BUILD_BUG_ON_ZERO(ARRAY_SIZE(a) != ARRAY_SIZE(b)))
+
+#define get_pids(dst, src)     __get_pids(dst, src, __pids_last2(dst, src))
+#define put_pids(pids)         __put_pids(pids, pids_last(pids))
+#define swap_pids(a, b)                __swap_pids(a, b, __pids_last2(a, b))
+#define pids_equal(a, b)       __pids_equal(a, b, __pids_last2(a, b))
+
 extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
 static inline bool pid_has_task(struct pid *pid, enum pid_type type)
 {

diff --git a/include/linux/pid_types.h b/include/linux/pid_types.h
index c2aee1d91dcf..3302690a2a28 100644
--- a/include/linux/pid_types.h
+++ b/include/linux/pid_types.h

@@ -2,6 +2,8 @@
 #ifndef _LINUX_PID_TYPES_H
 #define _LINUX_PID_TYPES_H

+#include <linux/build_bug.h>
+
 enum pid_type {
        PIDTYPE_PID,
        PIDTYPE_TGID,

@@ -10,6 +12,12 @@ enum pid_type {
        PIDTYPE_MAX,
 };

+struct pid;
+
+/* An array of struct pid indexed by pid type, PIDTYPE_PID up to @last. */
+#define DECLARE_PIDS(name, last)                                       \
+       struct pid *name[(last) + 1 + BUILD_BUG_ON_ZERO((last) >= PIDTYPE_MAX)]
+
 struct pid_namespace;
 extern struct pid_namespace init_pid_ns;

diff --git a/include/linux/pidfs.h b/include/linux/pidfs.h
index 0abf7da9ab23..3c1e82f1a369 100644
--- a/include/linux/pidfs.h
+++ b/include/linux/pidfs.h

@@ -3,6 +3,7 @@
 #define _LINUX_PID_FS_H

 #include <linux/gfp_types.h>
+#include <linux/pid.h>

 struct coredump_params;

@@ -32,5 +33,9 @@ static inline int pidfs_register_pid(struct pid *pid)
 }

 void pidfs_free_pid(struct pid *pid);
+int __pidfs_register_pids(struct pid *const *pids, enum pid_type last);
+
+/* Register the pids of an array declared with DECLARE_PIDS(). */
+#define pidfs_register_pids(pids)      __pidfs_register_pids(pids, pids_last(pids))

 #endif /* _LINUX_PID_FS_H */

diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
index 584ae88b435e..9444b47789a0 100644
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h

@@ -677,6 +677,24 @@ struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
        return pid;
 }

+/* Fill @pids with the pid types of @task up to @last, without references. */
+static inline void __task_pids(struct pid **pids, enum pid_type last,
+                              struct task_struct *task)
+{
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++)
+               pids[type] = task_pid_type(task, type);
+}
+
+static inline void __get_task_pids(struct pid **pids, enum pid_type last,
+                                  struct task_struct *task)
+{
+       for (enum pid_type type = PIDTYPE_PID; type <= last; type++)
+               pids[type] = get_pid(task_pid_type(task, type));
+}
+
+#define task_pids(pids, task)          __task_pids(pids, pids_last(pids), task)
+#define get_task_pids(pids, task)      __get_task_pids(pids, pids_last(pids), task)
+
 static inline struct pid *task_tgid(struct task_struct *task)
 {
        return task->signal->pids[PIDTYPE_TGID];

--

2.53.0