pid.h 5.86 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
#ifndef _LINUX_PID_H
#define _LINUX_PID_H

4
5
#include <linux/rcupdate.h>

Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
enum pid_type
{
	PIDTYPE_PID,
	PIDTYPE_PGID,
	PIDTYPE_SID,
	PIDTYPE_MAX
};

14
15
16
17
18
19
20
21
22
23
/*
 * What is struct pid?
 *
 * A struct pid is the kernel's internal notion of a process identifier.
 * It refers to individual tasks, process groups, and sessions.  While
 * there are processes attached to it the struct pid lives in a hash
 * table, so it and then the processes that it refers to can be found
 * quickly from the numeric pid value.  The attached processes may be
 * quickly accessed by following pointers from struct pid.
 *
Lucas De Marchi's avatar
Lucas De Marchi committed
24
 * Storing pid_t values in the kernel and referring to them later has a
25
26
27
28
29
30
31
32
33
34
35
36
37
 * problem.  The process originally with that pid may have exited and the
 * pid allocator wrapped, and another process could have come along
 * and been assigned that pid.
 *
 * Referring to user space processes by holding a reference to struct
 * task_struct has a problem.  When the user space process exits
 * the now useless task_struct is still kept.  A task_struct plus a
 * stack consumes around 10K of low kernel memory.  More precisely
 * this is THREAD_SIZE + sizeof(struct task_struct).  By comparison
 * a struct pid is about 64 bytes.
 *
 * Holding a reference to struct pid solves both of these problems.
 * It is small so holding a reference does not consume a lot of
38
39
40
 * resources, and since a new struct pid is allocated when the numeric pid
 * value is reused (when pids wrap around) we don't mistakenly refer to new
 * processes.
41
42
 */

43
44
45
46
47
48
49
50

/*
 * struct upid is used to get the id of the struct pid, as it is
 * seen in particular namespace. Later the struct pid is found with
 * find_pid_ns() using the int nr and struct pid_namespace *ns.
 */

struct upid {
51
	/* Try to keep pid_chain in the same cacheline as nr for find_vpid */
52
53
54
55
56
	int nr;
	struct pid_namespace *ns;
	struct hlist_node pid_chain;
};

Linus Torvalds's avatar
Linus Torvalds committed
57
58
struct pid
{
59
	atomic_t count;
60
	unsigned int level;
61
62
63
	/* lists of tasks that use this pid */
	struct hlist_head tasks[PIDTYPE_MAX];
	struct rcu_head rcu;
64
	struct upid numbers[1];
Linus Torvalds's avatar
Linus Torvalds committed
65
66
};

67
68
extern struct pid init_struct_pid;

69
70
71
72
73
74
75
76
77
78
79
80
81
struct pid_link
{
	struct hlist_node node;
	struct pid *pid;
};

static inline struct pid *get_pid(struct pid *pid)
{
	if (pid)
		atomic_inc(&pid->count);
	return pid;
}

82
83
84
extern void put_pid(struct pid *pid);
extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
Linus Torvalds's avatar
Linus Torvalds committed
85

86
87
extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);

Linus Torvalds's avatar
Linus Torvalds committed
88
89
90
91
/*
 * attach_pid() and detach_pid() must be called with the tasklist_lock
 * write-held.
 */
92
93
extern void attach_pid(struct task_struct *task, enum pid_type type,
			struct pid *pid);
94
extern void detach_pid(struct task_struct *task, enum pid_type);
95
96
extern void change_pid(struct task_struct *task, enum pid_type,
			struct pid *pid);
97
98
extern void transfer_pid(struct task_struct *old, struct task_struct *new,
			 enum pid_type);
Linus Torvalds's avatar
Linus Torvalds committed
99

100
101
102
struct pid_namespace;
extern struct pid_namespace init_pid_ns;

Linus Torvalds's avatar
Linus Torvalds committed
103
104
/*
 * look up a PID in the hash table. Must be called with the tasklist_lock
105
 * or rcu_read_lock() held.
106
107
 *
 * find_pid_ns() finds the pid in the namespace specified
108
 * find_vpid() finds the pid by its virtual id, i.e. in the current namespace
109
 *
110
 * see also find_task_by_vpid() set in include/linux/sched.h
111
 */
112
extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns);
113
extern struct pid *find_vpid(int nr);
114
115
116

/*
 * Lookup a PID in the hash table, and return with it's count elevated.
Linus Torvalds's avatar
Linus Torvalds committed
117
 */
118
extern struct pid *find_get_pid(int nr);
119
extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
120
int next_pidmap(struct pid_namespace *pid_ns, unsigned int last);
Linus Torvalds's avatar
Linus Torvalds committed
121

122
extern struct pid *alloc_pid(struct pid_namespace *ns);
123
extern void free_pid(struct pid *pid);
124
extern void disable_pid_allocation(struct pid_namespace *ns);
Linus Torvalds's avatar
Linus Torvalds committed
125

Eric W. Biederman's avatar
Eric W. Biederman committed
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/*
 * ns_of_pid() returns the pid namespace in which the specified pid was
 * allocated.
 *
 * NOTE:
 * 	ns_of_pid() is expected to be called for a process (task) that has
 * 	an attached 'struct pid' (see attach_pid(), detach_pid()) i.e @pid
 * 	is expected to be non-NULL. If @pid is NULL, caller should handle
 * 	the resulting NULL pid-ns.
 */
static inline struct pid_namespace *ns_of_pid(struct pid *pid)
{
	struct pid_namespace *ns = NULL;
	if (pid)
		ns = pid->numbers[pid->level].ns;
	return ns;
}

144
145
146
147
148
149
150
151
152
153
154
/*
 * is_child_reaper returns true if the pid is the init process
 * of the current namespace. As this one could be checked before
 * pid_ns->child_reaper is assigned in copy_process, we check
 * with the pid number.
 */
static inline bool is_child_reaper(struct pid *pid)
{
	return pid->numbers[pid->level].nr == 1;
}

155
156
157
158
/*
 * the helpers to get the pid's id seen from different namespaces
 *
 * pid_nr()    : global id, i.e. the id seen from the init namespace;
Eric W. Biederman's avatar
Eric W. Biederman committed
159
160
 * pid_vnr()   : virtual id, i.e. the id seen from the pid namespace of
 *               current.
161
162
163
164
165
 * pid_nr_ns() : id seen from the ns specified.
 *
 * see also task_xid_nr() etc in include/linux/sched.h
 */

166
167
168
169
static inline pid_t pid_nr(struct pid *pid)
{
	pid_t nr = 0;
	if (pid)
170
171
172
173
174
		nr = pid->numbers[0].nr;
	return nr;
}

pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
Eric W. Biederman's avatar
Eric W. Biederman committed
175
pid_t pid_vnr(struct pid *pid);
176

Andrew Morton's avatar
Andrew Morton committed
177
178
179
#define do_each_pid_task(pid, type, task)				\
	do {								\
		struct hlist_node *pos___;				\
180
		if ((pid) != NULL)					\
Andrew Morton's avatar
Andrew Morton committed
181
			hlist_for_each_entry_rcu((task), pos___,	\
182
				&(pid)->tasks[type], pids[type].node) {
183

184
185
186
187
			/*
			 * Both old and new leaders may be attached to
			 * the same pid in the middle of de_thread().
			 */
Andrew Morton's avatar
Andrew Morton committed
188
#define while_each_pid_task(pid, type, task)				\
189
190
				if (type == PIDTYPE_PID)		\
					break;				\
Andrew Morton's avatar
Andrew Morton committed
191
			}						\
192
	} while (0)
193

194
195
196
197
198
199
200
201
202
#define do_each_pid_thread(pid, type, task)				\
	do_each_pid_task(pid, type, task) {				\
		struct task_struct *tg___ = task;			\
		do {

#define while_each_pid_thread(pid, type, task)				\
		} while_each_thread(tg___, task);			\
		task = tg___;						\
	} while_each_pid_task(pid, type, task)
Linus Torvalds's avatar
Linus Torvalds committed
203
#endif /* _LINUX_PID_H */