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 #define RESERVED_PIDS 300
  49
  50 struct upid {
  51         int nr;
  52         struct pid_namespace *ns;
  53 };
  54
  55 struct pid
  56 {
  57         refcount_t count;
  58         unsigned int level;
  59         spinlock_t lock;
  60         struct dentry *stashed;
  61         u64 ino;
  62         /* lists of tasks that use this pid */
  63         struct hlist_head tasks[PIDTYPE_MAX];
  64         struct hlist_head inodes;
  65         /* wait queue for pidfd notifications */
  66         wait_queue_head_t wait_pidfd;
  67         struct rcu_head rcu;
  68         struct upid numbers[];
  69 };
  70
  71 extern struct pid init_struct_pid;
  72
  73 struct file;
  74
  75 struct pid *pidfd_pid(const struct file *file);
  76 struct pid *pidfd_get_pid(unsigned int fd, unsigned int *flags);
  77 struct task_struct *pidfd_get_task(int pidfd, unsigned int *flags);
  78 int pidfd_prepare(struct pid *pid, unsigned int flags, struct file **ret);
  79 void do_notify_pidfd(struct task_struct *task);
  80
  81 static inline struct pid *get_pid(struct pid *pid)
  82 {
  83         if (pid)
  84                 refcount_inc(&pid->count);
  85         return pid;
  86 }
  87
  88 extern void put_pid(struct pid *pid);
  89 extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
  90 static inline bool pid_has_task(struct pid *pid, enum pid_type type)
  91 {
  92         return !hlist_empty(&pid->tasks[type]);
  93 }
  94 extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
  95
  96 extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
  97
  98 /*
  99  * these helpers must be called with the tasklist_lock write-held.
 100  */
 101 extern void attach_pid(struct task_struct *task, enum pid_type);
 102 extern void detach_pid(struct task_struct *task, enum pid_type);
 103 extern void change_pid(struct task_struct *task, enum pid_type,
 104                         struct pid *pid);
 105 extern void exchange_tids(struct task_struct *task, struct task_struct *old);
 106 extern void transfer_pid(struct task_struct *old, struct task_struct *new,
 107                          enum pid_type);
 108
 109 extern int pid_max;
 110 extern int pid_max_min, pid_max_max;
 111
 112 /*
 113  * look up a PID in the hash table. Must be called with the tasklist_lock
 114  * or rcu_read_lock() held.
 115  *
 116  * find_pid_ns() finds the pid in the namespace specified
 117  * find_vpid() finds the pid by its virtual id, i.e. in the current namespace
 118  *
 119  * see also find_task_by_vpid() set in include/linux/sched.h
 120  */
 121 extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns);
 122 extern struct pid *find_vpid(int nr);
 123
 124 /*
 125  * Lookup a PID in the hash table, and return with it's count elevated.
 126  */
 127 extern struct pid *find_get_pid(int nr);
 128 extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
 129
 130 extern struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid,
 131                              size_t set_tid_size);
 132 extern void free_pid(struct pid *pid);
 133 extern void disable_pid_allocation(struct pid_namespace *ns);
 134
 135 /*
 136  * ns_of_pid() returns the pid namespace in which the specified pid was
 137  * allocated.
 138  *
 139  * NOTE:
 140  *      ns_of_pid() is expected to be called for a process (task) that has
 141  *      an attached 'struct pid' (see attach_pid(), detach_pid()) i.e @pid
 142  *      is expected to be non-NULL. If @pid is NULL, caller should handle
 143  *      the resulting NULL pid-ns.
 144  */
 145 static inline struct pid_namespace *ns_of_pid(struct pid *pid)
 146 {
 147         struct pid_namespace *ns = NULL;
 148         if (pid)
 149                 ns = pid->numbers[pid->level].ns;
 150         return ns;
 151 }
 152
 153 /*
 154  * is_child_reaper returns true if the pid is the init process
 155  * of the current namespace. As this one could be checked before
 156  * pid_ns->child_reaper is assigned in copy_process, we check
 157  * with the pid number.
 158  */
 159 static inline bool is_child_reaper(struct pid *pid)
 160 {
 161         return pid->numbers[pid->level].nr == 1;
 162 }
 163
 164 /*
 165  * the helpers to get the pid's id seen from different namespaces
 166  *
 167  * pid_nr()    : global id, i.e. the id seen from the init namespace;
 168  * pid_vnr()   : virtual id, i.e. the id seen from the pid namespace of
 169  *               current.
 170  * pid_nr_ns() : id seen from the ns specified.
 171  *
 172  * see also task_xid_nr() etc in include/linux/sched.h
 173  */
 174
 175 static inline pid_t pid_nr(struct pid *pid)
 176 {
 177         pid_t nr = 0;
 178         if (pid)
 179                 nr = pid->numbers[0].nr;
 180         return nr;
 181 }
 182
 183 pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
 184 pid_t pid_vnr(struct pid *pid);
 185
 186 #define do_each_pid_task(pid, type, task)                               \
 187         do {                                                            \
 188                 if ((pid) != NULL)                                      \
 189                         hlist_for_each_entry_rcu((task),                \
 190                                 &(pid)->tasks[type], pid_links[type]) {
 191
 192                         /*
 193                          * Both old and new leaders may be attached to
 194                          * the same pid in the middle of de_thread().
 195                          */
 196 #define while_each_pid_task(pid, type, task)                            \
 197                                 if (type == PIDTYPE_PID)                \
 198                                         break;                          \
 199                         }                                               \
 200         } while (0)
 201
 202 #define do_each_pid_thread(pid, type, task)                             \
 203         do_each_pid_task(pid, type, task) {                             \
 204                 struct task_struct *tg___ = task;                       \
 205                 for_each_thread(tg___, task) {
 206
 207 #define while_each_pid_thread(pid, type, task)                          \
 208                 }                                                       \
 209                 task = tg___;                                           \
 210         } while_each_pid_task(pid, type, task)
 211
 212 static inline struct pid *task_pid(struct task_struct *task)
 213 {
 214         return task->thread_pid;
 215 }
 216
 217 /*
 218  * the helpers to get the task's different pids as they are seen
 219  * from various namespaces
 220  *
 221  * task_xid_nr()     : global id, i.e. the id seen from the init namespace;
 222  * task_xid_vnr()    : virtual id, i.e. the id seen from the pid namespace of
 223  *                     current.
 224  * task_xid_nr_ns()  : id seen from the ns specified;
 225  *
 226  * see also pid_nr() etc in include/linux/pid.h
 227  */
 228 pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type, struct pid_namespace *ns);
 229
 230 static inline pid_t task_pid_nr(struct task_struct *tsk)
 231 {
 232         return tsk->pid;
 233 }
 234
 235 static inline pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 236 {
 237         return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
 238 }
 239
 240 static inline pid_t task_pid_vnr(struct task_struct *tsk)
 241 {
 242         return __task_pid_nr_ns(tsk, PIDTYPE_PID, NULL);
 243 }
 244
 245
 246 static inline pid_t task_tgid_nr(struct task_struct *tsk)
 247 {
 248         return tsk->tgid;
 249 }
 250
 251 /**
 252  * pid_alive - check that a task structure is not stale
 253  * @p: Task structure to be checked.
 254  *
 255  * Test if a process is not yet dead (at most zombie state)
 256  * If pid_alive fails, then pointers within the task structure
 257  * can be stale and must not be dereferenced.
 258  *
 259  * Return: 1 if the process is alive. 0 otherwise.
 260  */
 261 static inline int pid_alive(const struct task_struct *p)
 262 {
 263         return p->thread_pid != NULL;
 264 }
 265
 266 static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 267 {
 268         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
 269 }
 270
 271 static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
 272 {
 273         return __task_pid_nr_ns(tsk, PIDTYPE_PGID, NULL);
 274 }
 275
 276
 277 static inline pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 278 {
 279         return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
 280 }
 281
 282 static inline pid_t task_session_vnr(struct task_struct *tsk)
 283 {
 284         return __task_pid_nr_ns(tsk, PIDTYPE_SID, NULL);
 285 }
 286
 287 static inline pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 288 {
 289         return __task_pid_nr_ns(tsk, PIDTYPE_TGID, ns);
 290 }
 291
 292 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
 293 {
 294         return __task_pid_nr_ns(tsk, PIDTYPE_TGID, NULL);
 295 }
 296
 297 static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
 298 {
 299         pid_t pid = 0;
 300
 301         rcu_read_lock();
 302         if (pid_alive(tsk))
 303                 pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns);
 304         rcu_read_unlock();
 305
 306         return pid;
 307 }
 308
 309 static inline pid_t task_ppid_nr(const struct task_struct *tsk)
 310 {
 311         return task_ppid_nr_ns(tsk, &init_pid_ns);
 312 }
 313
 314 /* Obsolete, do not use: */
 315 static inline pid_t task_pgrp_nr(struct task_struct *tsk)
 316 {
 317         return task_pgrp_nr_ns(tsk, &init_pid_ns);
 318 }
 319
 320 /**
 321  * is_global_init - check if a task structure is init. Since init
 322  * is free to have sub-threads we need to check tgid.
 323  * @tsk: Task structure to be checked.
 324  *
 325  * Check if a task structure is the first user space task the kernel created.
 326  *
 327  * Return: 1 if the task structure is init. 0 otherwise.
 328  */
 329 static inline int is_global_init(struct task_struct *tsk)
 330 {
 331         return task_tgid_nr(tsk) == 1;
 332 }
 333
 334 #endif /* _LINUX_PID_H */