2005-04-16 16:20:36 -06:00
|
|
|
#ifndef _LINUX_PID_H
|
|
|
|
|
#define _LINUX_PID_H
|
|
|
|
|
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
enum pid_type
|
|
|
|
|
{
|
|
|
|
|
PIDTYPE_PID,
|
|
|
|
|
PIDTYPE_PGID,
|
|
|
|
|
PIDTYPE_SID,
|
|
|
|
|
PIDTYPE_MAX
|
|
|
|
|
};
|
|
|
|
|
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
|
|
|
|
* Storing pid_t values in the kernel and refering to them later has a
|
|
|
|
|
* 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
|
2006-12-08 03:38:01 -07:00
|
|
|
* 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.
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
*/
|
|
|
|
|
|
2007-10-19 00:40:03 -06:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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 {
|
|
|
|
|
/* Try to keep pid_chain in the same cacheline as nr for find_pid */
|
|
|
|
|
int nr;
|
|
|
|
|
struct pid_namespace *ns;
|
|
|
|
|
struct hlist_node pid_chain;
|
|
|
|
|
};
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct pid
|
|
|
|
|
{
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
atomic_t count;
|
|
|
|
|
/* lists of tasks that use this pid */
|
|
|
|
|
struct hlist_head tasks[PIDTYPE_MAX];
|
|
|
|
|
struct rcu_head rcu;
|
2007-10-19 00:40:03 -06:00
|
|
|
int level;
|
|
|
|
|
struct upid numbers[1];
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
2007-05-10 23:23:00 -06:00
|
|
|
extern struct pid init_struct_pid;
|
|
|
|
|
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-13 16:03:15 -07:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-02 03:18:59 -06:00
|
|
|
extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
|
* attach_pid() and detach_pid() must be called with the tasklist_lock
|
|
|
|
|
* write-held.
|
|
|
|
|
*/
|
2008-02-13 16:03:15 -07:00
|
|
|
extern int attach_pid(struct task_struct *task, enum pid_type type,
|
|
|
|
|
struct pid *pid);
|
|
|
|
|
extern void detach_pid(struct task_struct *task, enum pid_type);
|
|
|
|
|
extern void transfer_pid(struct task_struct *old, struct task_struct *new,
|
|
|
|
|
enum pid_type);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-19 00:40:06 -06:00
|
|
|
struct pid_namespace;
|
|
|
|
|
extern struct pid_namespace init_pid_ns;
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
|
* look up a PID in the hash table. Must be called with the tasklist_lock
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
* or rcu_read_lock() held.
|
2007-10-19 00:40:06 -06:00
|
|
|
*
|
|
|
|
|
* find_pid_ns() finds the pid in the namespace specified
|
|
|
|
|
* find_pid() find the pid by its global id, i.e. in the init namespace
|
|
|
|
|
* find_vpid() finr the pid by its virtual id, i.e. in the current namespace
|
|
|
|
|
*
|
|
|
|
|
* see also find_task_by_pid() set in include/linux/sched.h
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
*/
|
2008-02-13 16:03:15 -07:00
|
|
|
extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns);
|
2007-10-19 00:40:19 -06:00
|
|
|
extern struct pid *find_vpid(int nr);
|
|
|
|
|
extern struct pid *find_pid(int nr);
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Lookup a PID in the hash table, and return with it's count elevated.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
[PATCH] pidhash: Refactor the pid hash table
Simplifies the code, reduces the need for 4 pid hash tables, and makes the
code more capable.
In the discussions I had with Oleg it was felt that to a large extent the
cleanup itself justified the work. With struct pid being dynamically
allocated meant we could create the hash table entry when the pid was
allocated and free the hash table entry when the pid was freed. Instead of
playing with the hash lists when ever a process would attach or detach to a
process.
For myself the fact that it gave what my previous task_ref patch gave for free
with simpler code was a big win. The problem is that if you hold a reference
to struct task_struct you lock in 10K of low memory. If you do that in a user
controllable way like /proc does, with an unprivileged but hostile user space
application with typical resource limits of 1000 fds and 100 processes I can
trigger the OOM killer by consuming all of low memory with task structs, on a
machine wight 1GB of low memory.
If I instead hold a reference to struct pid which holds a pointer to my
task_struct, I don't suffer from that problem because struct pid is 2 orders
of magnitude smaller. In fact struct pid is small enough that most other
kernel data structures dwarf it, so simply limiting the number of referring
data structures is enough to prevent exhaustion of low memory.
This splits the current struct pid into two structures, struct pid and struct
pid_link, and reduces our number of hash tables from PIDTYPE_MAX to just one.
struct pid_link is the per process linkage into the hash tables and lives in
struct task_struct. struct pid is given an indepedent lifetime, and holds
pointers to each of the pid types.
The independent life of struct pid simplifies attach_pid, and detach_pid,
because we are always manipulating the list of pids and not the hash table.
In addition in giving struct pid an indpendent life it makes the concept much
more powerful.
Kernel data structures can now embed a struct pid * instead of a pid_t and
not suffer from pid wrap around problems or from keeping unnecessarily
large amounts of memory allocated.
Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-31 03:31:42 -07:00
|
|
|
extern struct pid *find_get_pid(int nr);
|
2007-10-19 00:40:06 -06:00
|
|
|
extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
|
2008-02-08 05:18:24 -07:00
|
|
|
int next_pidmap(struct pid_namespace *pid_ns, int last);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-19 00:40:05 -06:00
|
|
|
extern struct pid *alloc_pid(struct pid_namespace *ns);
|
2008-02-13 16:03:15 -07:00
|
|
|
extern void free_pid(struct pid *pid);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-10-19 00:40:06 -06:00
|
|
|
/*
|
|
|
|
|
* 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;
|
2008-02-08 05:19:15 -07:00
|
|
|
* pid_vnr() : virtual id, i.e. the id seen from the pid namespace of
|
|
|
|
|
* current.
|
2007-10-19 00:40:06 -06:00
|
|
|
* pid_nr_ns() : id seen from the ns specified.
|
|
|
|
|
*
|
|
|
|
|
* see also task_xid_nr() etc in include/linux/sched.h
|
|
|
|
|
*/
|
|
|
|
|
|
2006-10-02 03:17:12 -06:00
|
|
|
static inline pid_t pid_nr(struct pid *pid)
|
|
|
|
|
{
|
|
|
|
|
pid_t nr = 0;
|
|
|
|
|
if (pid)
|
2007-10-19 00:40:06 -06:00
|
|
|
nr = pid->numbers[0].nr;
|
|
|
|
|
return nr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
|
2008-02-08 05:19:15 -07:00
|
|
|
pid_t pid_vnr(struct pid *pid);
|
2006-10-02 03:17:12 -06:00
|
|
|
|
2006-10-03 02:13:45 -06:00
|
|
|
#define do_each_pid_task(pid, type, task) \
|
|
|
|
|
do { \
|
|
|
|
|
struct hlist_node *pos___; \
|
|
|
|
|
if (pid != NULL) \
|
|
|
|
|
hlist_for_each_entry_rcu((task), pos___, \
|
2006-10-02 03:17:22 -06:00
|
|
|
&pid->tasks[type], pids[type].node) {
|
|
|
|
|
|
2008-02-08 05:19:19 -07:00
|
|
|
/*
|
|
|
|
|
* Both old and new leaders may be attached to
|
|
|
|
|
* the same pid in the middle of de_thread().
|
|
|
|
|
*/
|
2006-10-03 02:13:45 -06:00
|
|
|
#define while_each_pid_task(pid, type, task) \
|
2008-02-08 05:19:19 -07:00
|
|
|
if (type == PIDTYPE_PID) \
|
|
|
|
|
break; \
|
2006-10-03 02:13:45 -06:00
|
|
|
} \
|
2006-10-02 03:17:22 -06:00
|
|
|
} while (0)
|
2006-10-02 03:17:09 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* _LINUX_PID_H */
|
