include/linux/pid.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_PID_H
   3 #define _LINUX_PID_H
   4
   5 #include <linux/pid_types.h>
   6 #include <linux/rculist.h>
   7 #include <linux/rcupdate.h>
   8 #include <linux/refcount.h>
   9 #include <linux/sched.h>
  10 #include <linux/wait.h>
  11
  12 /*
  13  * What is struct pid?
  14  *
  15  * A struct pid is the kernel's internal notion of a process identifier.
  16  * It refers to individual tasks, process groups, and sessions.  While
  17  * there are processes attached to it the struct pid lives in a hash
  18  * table, so it and then the processes that it refers to can be found
  19  * quickly from the numeric pid value.  The attached processes may be
  20  * quickly accessed by following pointers from struct pid.
  21  *
  22  * Storing pid_t values in the kernel and referring to them later has a
  23  * problem.  The process originally with that pid may have exited and the
  24  * pid allocator wrapped, and another process could have come along
  25  * and been assigned that pid.
  26  *
  27  * Referring to user space processes by holding a reference to struct
  28  * task_struct has a problem.  When the user space process exits
  29  * the now useless task_struct is still kept.  A task_struct plus a
  30  * stack consumes around 10K of low kernel memory.  More precisely
  31  * this is THREAD_SIZE + sizeof(struct task_struct).  By comparison
  32  * a struct pid is about 64 bytes.
  33  *
  34  * Holding a reference to struct pid solves both of these problems.
  35  * It is small so holding a reference does not consume a lot of
  36  * resources, and since a new struct pid is allocated when the numeric pid
  37  * value is reused (when pids wrap around) we don't mistakenly refer to new
  38  * processes.
  39  */
  40
  41
  42 /*
  43  * struct upid is used to get the id of the struct pid, as it is
  44  * seen in particular namespace. Later the struct pid is found with
  45  * find_pid_ns() using the int nr and struct pid_namespace *ns.
  46  */
  47
  48 struct upid {
  49         int nr;
  50         struct pid_namespace *ns;
  51 };
  52
  53 struct pid
  54 {
  55         refcount_t count;
  56         unsigned int level;
  57         spinlock_t lock;
  58         /* lists of tasks that use this pid */
  59         struct hlist_head tasks[PIDTYPE_MAX];
  60         struct hlist_head inodes;
  61         /* wait queue for pidfd notifications */
  62         wait_queue_head_t wait_pidfd;
  63         struct rcu_head rcu;
  64         struct upid numbers[];
  65 };
  66
  67 extern struct pid init_struct_pid;
  68
  69 extern const struct file_operations pidfd_fops;
  70
  71 struct file;
  72
  73 extern struct pid *pidfd_pid(const struct file *file);
  74 struct pid *pidfd_get_pid(unsigned int fd, unsigned int *flags);
  75 struct task_struct *pidfd_get_task(int pidfd, unsigned int *flags);
  76 int pidfd_create(struct pid *pid, unsigned int flags);
  77 int pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret);
  78
  79 static inline struct pid *get_pid(struct pid *pid)
  80 {
  81         if (pid)
  82                 refcount_inc(&pid->count);
  83         return pid;
  84 }
  85
  86 extern void put_pid(struct pid *pid);
  87 extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
  88 static inline bool pid_has_task(struct pid *pid, enum pid_type type)
  89 {
  90         return !hlist_empty(&pid->tasks[type]);
  91 }
  92 extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
  93
  94 extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
  95
  96 /*
  97  * these helpers must be called with the tasklist_lock write-held.
  98  */
  99 extern void attach_pid(struct task_struct *task, enum pid_type);
 100 extern void detach_pid(struct task_struct *task, enum pid_type);
 101 extern void change_pid(struct task_struct *task, enum pid_type,
 102                         struct pid *pid);
 103 extern void exchange_tids(struct task_struct *task, struct task_struct *old);
 104 extern void transfer_pid(struct task_struct *old, struct task_struct *new,
 105                          enum pid_type);
 106
 107 extern int pid_max;
 108 extern int pid_max_min, pid_max_max;
 109
 110 /*
 111  * look up a PID in the hash table. Must be called with the tasklist_lock
 112  * or rcu_read_lock() held.
 113  *
 114  * find_pid_ns() finds the pid in the namespace specified
 115  * find_vpid() finds the pid by its virtual id, i.e. in the current namespace
 116  *
 117  * see also find_task_by_vpid() set in include/linux/sched.h
 118  */
 119 extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns);
 120 extern struct pid *find_vpid(int nr);
 121
 122 /*
 123  * Lookup a PID in the hash table, and return with it's count elevated.
 124  */
 125 extern struct pid *find_get_pid(int nr);
 126 extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
 127
 128 extern struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid,
 129                              size_t set_tid_size);
 130 extern void free_pid(struct pid *pid);
 131 extern void disable_pid_allocation(struct pid_namespace *ns);
 132
 133 /*
 134  * ns_of_pid() returns the pid namespace in which the specified pid was
 135  * allocated.
 136  *
 137  * NOTE:
 138  *      ns_of_pid() is expected to be called for a process (task) that has
 139  *      an attached 'struct pid' (see attach_pid(), detach_pid()) i.e @pid
 140  *      is expected to be non-NULL. If @pid is NULL, caller should handle
 141  *      the resulting NULL pid-ns.
 142  */
 143 static inline struct pid_namespace *ns_of_pid(struct pid *pid)
 144 {
 145         struct pid_namespace *ns = NULL;
 146         if (pid)
 147                 ns = pid->numbers[pid->level].ns;
 148         return ns;
 149 }
 150
 151 /*
 152  * is_child_reaper returns true if the pid is the init process
 153  * of the current namespace. As this one could be checked before
 154  * pid_ns->child_reaper is assigned in copy_process, we check
 155  * with the pid number.
 156  */
 157 static inline bool is_child_reaper(struct pid *pid)
 158 {
 159         return pid->numbers[pid->level].nr == 1;
 160 }
 161
 162 /*
 163  * the helpers to get the pid's id seen from different namespaces
 164  *
 165  * pid_nr()    : global id, i.e. the id seen from the init namespace;
 166  * pid_vnr()   : virtual id, i.e. the id seen from the pid namespace of
 167  *               current.
 168  * pid_nr_ns() : id seen from the ns specified.
 169  *
 170  * see also task_xid_nr() etc in include/linux/sched.h
 171  */
 172
 173 static inline pid_t pid_nr(struct pid *pid)
 174 {
 175         pid_t nr = 0;
 176         if (pid)
 177                 nr = pid->numbers[0].nr;
 178         return nr;
 179 }
 180
 181 pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
 182 pid_t pid_vnr(struct pid *pid);
 183
 184 #define do_each_pid_task(pid, type, task)                               \
 185         do {                                                            \
 186                 if ((pid) != NULL)                                      \
 187                         hlist_for_each_entry_rcu((task),                \
 188                                 &(pid)->tasks[type], pid_links[type]) {
 189
 190                         /*
 191                          * Both old and new leaders may be attached to
 192                          * the same pid in the middle of de_thread().
 193                          */
 194 #define while_each_pid_task(pid, type, task)                            \
 195                                 if (type == PIDTYPE_PID)                \
 196                                         break;                          \
 197                         }                                               \
 198         } while (0)
 199
 200 #define do_each_pid_thread(pid, type, task)                             \
 201         do_each_pid_task(pid, type, task) {                             \
 202                 struct task_struct *tg___ = task;                       \
 203                 for_each_thread(tg___, task) {
 204
 205 #define while_each_pid_thread(pid, type, task)                          \
 206                 }                                                       \
 207                 task = tg___;                                           \
 208         } while_each_pid_task(pid, type, task)
 209
 210 static inline struct pid *task_pid(struct task_struct *task)
 211 {
 212         return task->thread_pid;
 213 }
 214
 215 /*
 216  * the helpers to get the task's different pids as they are seen
 217  * from various namespaces
 218  *
 219  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
 220  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
 221  *                     current.
 222  * task_xid_nr_ns()  : id seen from the ns specified;
 223  *
 224  * see also pid_nr() etc in include/linux/pid.h
 225  */
 226 pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type, struct pid_namespace *ns);
 227
 228 static inline pid_t task_pid_nr(struct task_struct *tsk)
 229 {
 230         return tsk->pid;
 231 }
 232
 233 static inline pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 234 {
 235         return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
 236 }
 237
 238 static inline pid_t task_pid_vnr(struct task_struct *tsk)
 239 {
 240         return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
 241 }
 242
 243
 244 static inline pid_t task_tgid_nr(struct task_struct *tsk)
 245 {
 246         return tsk->tgid;
 247 }
 248
 249 /**
 250  * pid_alive - check that a task structure is not stale
 251  * @p: Task structure to be checked.
 252  *
 253  * Test if a process is not yet dead (at most zombie state)
 254  * If pid_alive fails, then pointers within the task structure
 255  * can be stale and must not be dereferenced.
 256  *
 257  * Return: 1 if the process is alive. 0 otherwise.
 258  */
 259 static inline int pid_alive(const struct task_struct *p)
 260 {
 261         return p->thread_pid != NULL;
 262 }
 263
 264 static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 265 {
 266         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
 267 }
 268
 269 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
 270 {
 271         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
 272 }
 273
 274
 275 static inline pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 276 {
 277         return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
 278 }
 279
 280 static inline pid_t task_session_vnr(struct task_struct *tsk)
 281 {
 282         return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
 283 }
 284
 285 static inline pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 286 {
 287         return __task_pid_nr_ns(tsk, PIDTYPE_TGID, ns);
 288 }
 289
 290 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
 291 {
 292         return __task_pid_nr_ns(tsk, PIDTYPE_TGID, NULL);
 293 }
 294
 295 static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
 296 {
 297         pid_t pid = 0;
 298
 299         rcu_read_lock();
 300         if (pid_alive(tsk))
 301                 pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns);
 302         rcu_read_unlock();
 303
 304         return pid;
 305 }
 306
 307 static inline pid_t task_ppid_nr(const struct task_struct *tsk)
 308 {
 309         return task_ppid_nr_ns(tsk, &init_pid_ns);
 310 }
 311
 312 /* Obsolete, do not use: */
 313 static inline pid_t task_pgrp_nr(struct task_struct *tsk)
 314 {
 315         return task_pgrp_nr_ns(tsk, &init_pid_ns);
 316 }
 317
 318 /**
 319  * is_global_init - check if a task structure is init. Since init
 320  * is free to have sub-threads we need to check tgid.
 321  * @tsk: Task structure to be checked.
 322  *
 323  * Check if a task structure is the first user space task the kernel created.
 324  *
 325  * Return: 1 if the task structure is init. 0 otherwise.
 326  */
 327 static inline int is_global_init(struct task_struct *tsk)
 328 {
 329         return task_tgid_nr(tsk) == 1;
 330 }
 331
 332 #endif /* _LINUX_PID_H */