]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | #ifndef _LINUX_PID_H |
2 | #define _LINUX_PID_H | |
3 | ||
92476d7f EB |
4 | #include <linux/rcupdate.h> |
5 | ||
1da177e4 LT |
6 | enum pid_type |
7 | { | |
8 | PIDTYPE_PID, | |
1da177e4 LT |
9 | PIDTYPE_PGID, |
10 | PIDTYPE_SID, | |
11 | PIDTYPE_MAX | |
12 | }; | |
13 | ||
92476d7f EB |
14 | /* |
15 | * What is struct pid? | |
16 | * | |
17 | * A struct pid is the kernel's internal notion of a process identifier. | |
18 | * It refers to individual tasks, process groups, and sessions. While | |
19 | * there are processes attached to it the struct pid lives in a hash | |
20 | * table, so it and then the processes that it refers to can be found | |
21 | * quickly from the numeric pid value. The attached processes may be | |
22 | * quickly accessed by following pointers from struct pid. | |
23 | * | |
24 | * Storing pid_t values in the kernel and refering to them later has a | |
25 | * problem. The process originally with that pid may have exited and the | |
26 | * pid allocator wrapped, and another process could have come along | |
27 | * and been assigned that pid. | |
28 | * | |
29 | * Referring to user space processes by holding a reference to struct | |
30 | * task_struct has a problem. When the user space process exits | |
31 | * the now useless task_struct is still kept. A task_struct plus a | |
32 | * stack consumes around 10K of low kernel memory. More precisely | |
33 | * this is THREAD_SIZE + sizeof(struct task_struct). By comparison | |
34 | * a struct pid is about 64 bytes. | |
35 | * | |
36 | * Holding a reference to struct pid solves both of these problems. | |
37 | * It is small so holding a reference does not consume a lot of | |
38 | * resources, and since a new struct pid is allocated when the numeric | |
39 | * pid value is reused we don't mistakenly refer to new processes. | |
40 | */ | |
41 | ||
1da177e4 LT |
42 | struct pid |
43 | { | |
92476d7f | 44 | atomic_t count; |
1da177e4 LT |
45 | /* Try to keep pid_chain in the same cacheline as nr for find_pid */ |
46 | int nr; | |
47 | struct hlist_node pid_chain; | |
92476d7f EB |
48 | /* lists of tasks that use this pid */ |
49 | struct hlist_head tasks[PIDTYPE_MAX]; | |
50 | struct rcu_head rcu; | |
1da177e4 LT |
51 | }; |
52 | ||
92476d7f EB |
53 | struct pid_link |
54 | { | |
55 | struct hlist_node node; | |
56 | struct pid *pid; | |
57 | }; | |
58 | ||
59 | static inline struct pid *get_pid(struct pid *pid) | |
60 | { | |
61 | if (pid) | |
62 | atomic_inc(&pid->count); | |
63 | return pid; | |
64 | } | |
65 | ||
66 | extern void FASTCALL(put_pid(struct pid *pid)); | |
67 | extern struct task_struct *FASTCALL(pid_task(struct pid *pid, enum pid_type)); | |
68 | extern struct task_struct *FASTCALL(get_pid_task(struct pid *pid, | |
69 | enum pid_type)); | |
1da177e4 LT |
70 | |
71 | /* | |
72 | * attach_pid() and detach_pid() must be called with the tasklist_lock | |
73 | * write-held. | |
74 | */ | |
92476d7f EB |
75 | extern int FASTCALL(attach_pid(struct task_struct *task, |
76 | enum pid_type type, int nr)); | |
1da177e4 LT |
77 | |
78 | extern void FASTCALL(detach_pid(struct task_struct *task, enum pid_type)); | |
c18258c6 EB |
79 | extern void FASTCALL(transfer_pid(struct task_struct *old, |
80 | struct task_struct *new, enum pid_type)); | |
1da177e4 LT |
81 | |
82 | /* | |
83 | * look up a PID in the hash table. Must be called with the tasklist_lock | |
92476d7f EB |
84 | * or rcu_read_lock() held. |
85 | */ | |
86 | extern struct pid *FASTCALL(find_pid(int nr)); | |
87 | ||
88 | /* | |
89 | * Lookup a PID in the hash table, and return with it's count elevated. | |
1da177e4 | 90 | */ |
92476d7f | 91 | extern struct pid *find_get_pid(int nr); |
0804ef4b | 92 | extern struct pid *find_ge_pid(int nr); |
1da177e4 | 93 | |
92476d7f EB |
94 | extern struct pid *alloc_pid(void); |
95 | extern void FASTCALL(free_pid(struct pid *pid)); | |
1da177e4 | 96 | |
92476d7f EB |
97 | #define pid_next(task, type) \ |
98 | ((task)->pids[(type)].node.next) | |
99 | ||
100 | #define pid_next_task(task, type) \ | |
101 | hlist_entry(pid_next(task, type), struct task_struct, \ | |
102 | pids[(type)].node) | |
103 | ||
104 | ||
105 | /* We could use hlist_for_each_entry_rcu here but it takes more arguments | |
106 | * than the do_each_task_pid/while_each_task_pid. So we roll our own | |
107 | * to preserve the existing interface. | |
108 | */ | |
1da177e4 LT |
109 | #define do_each_task_pid(who, type, task) \ |
110 | if ((task = find_task_by_pid_type(type, who))) { \ | |
92476d7f | 111 | prefetch(pid_next(task, type)); \ |
1da177e4 LT |
112 | do { |
113 | ||
114 | #define while_each_task_pid(who, type, task) \ | |
92476d7f EB |
115 | } while (pid_next(task, type) && ({ \ |
116 | task = pid_next_task(task, type); \ | |
117 | rcu_dereference(task); \ | |
118 | prefetch(pid_next(task, type)); \ | |
119 | 1; }) ); \ | |
120 | } | |
1da177e4 | 121 | |
558cb325 EB |
122 | #define do_each_pid_task(pid, type, task) \ |
123 | if ((task = pid_task(pid, type))) { \ | |
124 | prefetch(pid_next(task, type)); \ | |
125 | do { | |
126 | ||
127 | #define while_each_pid_task(pid, type, task) \ | |
128 | } while (pid_next(task, type) && ({ \ | |
129 | task = pid_next_task(task, type); \ | |
130 | rcu_dereference(task); \ | |
131 | prefetch(pid_next(task, type)); \ | |
132 | 1; }) ); \ | |
133 | } | |
134 | ||
1da177e4 | 135 | #endif /* _LINUX_PID_H */ |