Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | #ifndef _LINUX_PID_H |
| 3 | #define _LINUX_PID_H |
| 4 | |
Ingo Molnar | b2d0910 | 2017-02-04 01:27:20 +0100 | [diff] [blame] | 5 | #include <linux/rculist.h> |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 6 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | enum pid_type |
| 8 | { |
| 9 | PIDTYPE_PID, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | PIDTYPE_PGID, |
| 11 | PIDTYPE_SID, |
Oleg Nesterov | dd1c1f2 | 2017-08-21 17:35:02 +0200 | [diff] [blame] | 12 | PIDTYPE_MAX, |
| 13 | /* only valid to __task_pid_nr_ns() */ |
| 14 | __PIDTYPE_TGID |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | }; |
| 16 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 17 | /* |
| 18 | * What is struct pid? |
| 19 | * |
| 20 | * A struct pid is the kernel's internal notion of a process identifier. |
| 21 | * It refers to individual tasks, process groups, and sessions. While |
| 22 | * there are processes attached to it the struct pid lives in a hash |
| 23 | * table, so it and then the processes that it refers to can be found |
| 24 | * quickly from the numeric pid value. The attached processes may be |
| 25 | * quickly accessed by following pointers from struct pid. |
| 26 | * |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 27 | * Storing pid_t values in the kernel and referring to them later has a |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 28 | * problem. The process originally with that pid may have exited and the |
| 29 | * pid allocator wrapped, and another process could have come along |
| 30 | * and been assigned that pid. |
| 31 | * |
| 32 | * Referring to user space processes by holding a reference to struct |
| 33 | * task_struct has a problem. When the user space process exits |
| 34 | * the now useless task_struct is still kept. A task_struct plus a |
| 35 | * stack consumes around 10K of low kernel memory. More precisely |
| 36 | * this is THREAD_SIZE + sizeof(struct task_struct). By comparison |
| 37 | * a struct pid is about 64 bytes. |
| 38 | * |
| 39 | * Holding a reference to struct pid solves both of these problems. |
| 40 | * It is small so holding a reference does not consume a lot of |
Sukadev Bhattiprolu | 84d7378 | 2006-12-08 02:38:01 -0800 | [diff] [blame] | 41 | * resources, and since a new struct pid is allocated when the numeric pid |
| 42 | * value is reused (when pids wrap around) we don't mistakenly refer to new |
| 43 | * processes. |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 44 | */ |
| 45 | |
Sukadev Bhattiprolu | 4c3f2ea | 2007-10-18 23:40:03 -0700 | [diff] [blame] | 46 | |
| 47 | /* |
| 48 | * struct upid is used to get the id of the struct pid, as it is |
| 49 | * seen in particular namespace. Later the struct pid is found with |
| 50 | * find_pid_ns() using the int nr and struct pid_namespace *ns. |
| 51 | */ |
| 52 | |
| 53 | struct upid { |
Pavel Emelyanov | e49859e | 2008-07-25 01:48:36 -0700 | [diff] [blame] | 54 | /* Try to keep pid_chain in the same cacheline as nr for find_vpid */ |
Sukadev Bhattiprolu | 4c3f2ea | 2007-10-18 23:40:03 -0700 | [diff] [blame] | 55 | int nr; |
| 56 | struct pid_namespace *ns; |
| 57 | struct hlist_node pid_chain; |
| 58 | }; |
| 59 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | struct pid |
| 61 | { |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 62 | atomic_t count; |
Richard Kennedy | 33166b1 | 2008-07-25 01:48:35 -0700 | [diff] [blame] | 63 | unsigned int level; |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 64 | /* lists of tasks that use this pid */ |
| 65 | struct hlist_head tasks[PIDTYPE_MAX]; |
| 66 | struct rcu_head rcu; |
Sukadev Bhattiprolu | 4c3f2ea | 2007-10-18 23:40:03 -0700 | [diff] [blame] | 67 | struct upid numbers[1]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | }; |
| 69 | |
Sukadev Bhattiprolu | 820e45d | 2007-05-10 22:23:00 -0700 | [diff] [blame] | 70 | extern struct pid init_struct_pid; |
| 71 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 72 | struct pid_link |
| 73 | { |
| 74 | struct hlist_node node; |
| 75 | struct pid *pid; |
| 76 | }; |
| 77 | |
| 78 | static inline struct pid *get_pid(struct pid *pid) |
| 79 | { |
| 80 | if (pid) |
| 81 | atomic_inc(&pid->count); |
| 82 | return pid; |
| 83 | } |
| 84 | |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 85 | extern void put_pid(struct pid *pid); |
| 86 | extern struct task_struct *pid_task(struct pid *pid, enum pid_type); |
| 87 | extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | |
Oleg Nesterov | 1a657f78 | 2006-10-02 02:18:59 -0700 | [diff] [blame] | 89 | extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type); |
| 90 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | /* |
Oleg Nesterov | 8190773 | 2013-07-03 15:08:31 -0700 | [diff] [blame] | 92 | * these helpers must be called with the tasklist_lock write-held. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | */ |
Oleg Nesterov | 8190773 | 2013-07-03 15:08:31 -0700 | [diff] [blame] | 94 | extern void attach_pid(struct task_struct *task, enum pid_type); |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 95 | extern void detach_pid(struct task_struct *task, enum pid_type); |
Oleg Nesterov | 24336ea | 2008-04-30 00:54:26 -0700 | [diff] [blame] | 96 | extern void change_pid(struct task_struct *task, enum pid_type, |
| 97 | struct pid *pid); |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 98 | extern void transfer_pid(struct task_struct *old, struct task_struct *new, |
| 99 | enum pid_type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | |
Pavel Emelyanov | 198fe21 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 101 | struct pid_namespace; |
| 102 | extern struct pid_namespace init_pid_ns; |
| 103 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | /* |
| 105 | * look up a PID in the hash table. Must be called with the tasklist_lock |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 106 | * or rcu_read_lock() held. |
Pavel Emelyanov | 198fe21 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 107 | * |
| 108 | * find_pid_ns() finds the pid in the namespace specified |
Sisir Koppaka | 26498e8 | 2011-05-26 16:25:57 -0700 | [diff] [blame] | 109 | * find_vpid() finds the pid by its virtual id, i.e. in the current namespace |
Pavel Emelyanov | 198fe21 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 110 | * |
Pavel Emelyanov | dbda0de | 2008-07-25 01:48:37 -0700 | [diff] [blame] | 111 | * see also find_task_by_vpid() set in include/linux/sched.h |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | */ |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 113 | extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns); |
Pavel Emelyanov | 8990571 | 2007-10-18 23:40:19 -0700 | [diff] [blame] | 114 | extern struct pid *find_vpid(int nr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 116 | /* |
| 117 | * Lookup a PID in the hash table, and return with it's count elevated. |
| 118 | */ |
| 119 | extern struct pid *find_get_pid(int nr); |
Pavel Emelyanov | 198fe21 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 120 | extern struct pid *find_ge_pid(int nr, struct pid_namespace *); |
Linus Torvalds | c78193e | 2011-04-18 10:35:30 -0700 | [diff] [blame] | 121 | int next_pidmap(struct pid_namespace *pid_ns, unsigned int last); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | |
Pavel Emelyanov | 8ef047a | 2007-10-18 23:40:05 -0700 | [diff] [blame] | 123 | extern struct pid *alloc_pid(struct pid_namespace *ns); |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 124 | extern void free_pid(struct pid *pid); |
Eric W. Biederman | c876ad76 | 2012-12-21 20:27:12 -0800 | [diff] [blame] | 125 | extern void disable_pid_allocation(struct pid_namespace *ns); |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 126 | |
Pavel Emelyanov | 7af5729 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 127 | /* |
Eric W. Biederman | f9fb860 | 2009-01-07 18:08:46 -0800 | [diff] [blame] | 128 | * ns_of_pid() returns the pid namespace in which the specified pid was |
| 129 | * allocated. |
| 130 | * |
| 131 | * NOTE: |
| 132 | * ns_of_pid() is expected to be called for a process (task) that has |
| 133 | * an attached 'struct pid' (see attach_pid(), detach_pid()) i.e @pid |
| 134 | * is expected to be non-NULL. If @pid is NULL, caller should handle |
| 135 | * the resulting NULL pid-ns. |
| 136 | */ |
| 137 | static inline struct pid_namespace *ns_of_pid(struct pid *pid) |
| 138 | { |
| 139 | struct pid_namespace *ns = NULL; |
| 140 | if (pid) |
| 141 | ns = pid->numbers[pid->level].ns; |
| 142 | return ns; |
| 143 | } |
| 144 | |
| 145 | /* |
Eric W. Biederman | 45a6862 | 2011-03-23 16:43:12 -0700 | [diff] [blame] | 146 | * is_child_reaper returns true if the pid is the init process |
| 147 | * of the current namespace. As this one could be checked before |
| 148 | * pid_ns->child_reaper is assigned in copy_process, we check |
| 149 | * with the pid number. |
| 150 | */ |
| 151 | static inline bool is_child_reaper(struct pid *pid) |
| 152 | { |
| 153 | return pid->numbers[pid->level].nr == 1; |
| 154 | } |
| 155 | |
| 156 | /* |
Pavel Emelyanov | 7af5729 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 157 | * the helpers to get the pid's id seen from different namespaces |
| 158 | * |
| 159 | * pid_nr() : global id, i.e. the id seen from the init namespace; |
Eric W. Biederman | 44c4e1b | 2008-02-08 04:19:15 -0800 | [diff] [blame] | 160 | * pid_vnr() : virtual id, i.e. the id seen from the pid namespace of |
| 161 | * current. |
Pavel Emelyanov | 7af5729 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 162 | * pid_nr_ns() : id seen from the ns specified. |
| 163 | * |
| 164 | * see also task_xid_nr() etc in include/linux/sched.h |
| 165 | */ |
| 166 | |
Eric W. Biederman | 5feb8f5 | 2006-10-02 02:17:12 -0700 | [diff] [blame] | 167 | static inline pid_t pid_nr(struct pid *pid) |
| 168 | { |
| 169 | pid_t nr = 0; |
| 170 | if (pid) |
Pavel Emelyanov | 7af5729 | 2007-10-18 23:40:06 -0700 | [diff] [blame] | 171 | nr = pid->numbers[0].nr; |
| 172 | return nr; |
| 173 | } |
| 174 | |
| 175 | pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns); |
Eric W. Biederman | 44c4e1b | 2008-02-08 04:19:15 -0800 | [diff] [blame] | 176 | pid_t pid_vnr(struct pid *pid); |
Eric W. Biederman | 5feb8f5 | 2006-10-02 02:17:12 -0700 | [diff] [blame] | 177 | |
Andrew Morton | 1d32849 | 2006-10-03 01:13:45 -0700 | [diff] [blame] | 178 | #define do_each_pid_task(pid, type, task) \ |
| 179 | do { \ |
Steven Rostedt | 5ef6476 | 2008-12-04 00:26:39 -0500 | [diff] [blame] | 180 | if ((pid) != NULL) \ |
Sasha Levin | b67bfe0 | 2013-02-27 17:06:00 -0800 | [diff] [blame] | 181 | hlist_for_each_entry_rcu((task), \ |
Steven Rostedt | 5ef6476 | 2008-12-04 00:26:39 -0500 | [diff] [blame] | 182 | &(pid)->tasks[type], pids[type].node) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | |
Oleg Nesterov | 46f382d | 2008-02-08 04:19:19 -0800 | [diff] [blame] | 184 | /* |
| 185 | * Both old and new leaders may be attached to |
| 186 | * the same pid in the middle of de_thread(). |
| 187 | */ |
Andrew Morton | 1d32849 | 2006-10-03 01:13:45 -0700 | [diff] [blame] | 188 | #define while_each_pid_task(pid, type, task) \ |
Oleg Nesterov | 46f382d | 2008-02-08 04:19:19 -0800 | [diff] [blame] | 189 | if (type == PIDTYPE_PID) \ |
| 190 | break; \ |
Andrew Morton | 1d32849 | 2006-10-03 01:13:45 -0700 | [diff] [blame] | 191 | } \ |
Oleg Nesterov | d387cae | 2006-10-02 02:17:22 -0700 | [diff] [blame] | 192 | } while (0) |
Eric W. Biederman | 558cb32 | 2006-10-02 02:17:09 -0700 | [diff] [blame] | 193 | |
Ken Chen | 2d70b68 | 2008-08-20 14:09:17 -0700 | [diff] [blame] | 194 | #define do_each_pid_thread(pid, type, task) \ |
| 195 | do_each_pid_task(pid, type, task) { \ |
| 196 | struct task_struct *tg___ = task; \ |
Tetsuo Handa | e3b5a34 | 2017-02-27 14:27:37 -0800 | [diff] [blame] | 197 | for_each_thread(tg___, task) { |
Ken Chen | 2d70b68 | 2008-08-20 14:09:17 -0700 | [diff] [blame] | 198 | |
| 199 | #define while_each_pid_thread(pid, type, task) \ |
Tetsuo Handa | e3b5a34 | 2017-02-27 14:27:37 -0800 | [diff] [blame] | 200 | } \ |
Ken Chen | 2d70b68 | 2008-08-20 14:09:17 -0700 | [diff] [blame] | 201 | task = tg___; \ |
| 202 | } while_each_pid_task(pid, type, task) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | #endif /* _LINUX_PID_H */ |