Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | #ifndef _LINUX_PID_H |
| 2 | #define _LINUX_PID_H |
| 3 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 4 | #include <linux/rcupdate.h> |
| 5 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | enum pid_type |
| 7 | { |
| 8 | PIDTYPE_PID, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | PIDTYPE_PGID, |
| 10 | PIDTYPE_SID, |
| 11 | PIDTYPE_MAX |
| 12 | }; |
| 13 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 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 |
Sukadev Bhattiprolu | 84d7378 | 2006-12-08 02:38:01 -0800 | [diff] [blame] | 38 | * resources, and since a new struct pid is allocated when the numeric pid |
| 39 | * value is reused (when pids wrap around) we don't mistakenly refer to new |
| 40 | * processes. |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 41 | */ |
| 42 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | struct pid |
| 44 | { |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 45 | atomic_t count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | /* Try to keep pid_chain in the same cacheline as nr for find_pid */ |
| 47 | int nr; |
| 48 | struct hlist_node pid_chain; |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 49 | /* lists of tasks that use this pid */ |
| 50 | struct hlist_head tasks[PIDTYPE_MAX]; |
| 51 | struct rcu_head rcu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | }; |
| 53 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 54 | struct pid_link |
| 55 | { |
| 56 | struct hlist_node node; |
| 57 | struct pid *pid; |
| 58 | }; |
| 59 | |
| 60 | static inline struct pid *get_pid(struct pid *pid) |
| 61 | { |
| 62 | if (pid) |
| 63 | atomic_inc(&pid->count); |
| 64 | return pid; |
| 65 | } |
| 66 | |
| 67 | extern void FASTCALL(put_pid(struct pid *pid)); |
| 68 | extern struct task_struct *FASTCALL(pid_task(struct pid *pid, enum pid_type)); |
| 69 | extern struct task_struct *FASTCALL(get_pid_task(struct pid *pid, |
| 70 | enum pid_type)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
Oleg Nesterov | 1a657f7 | 2006-10-02 02:18:59 -0700 | [diff] [blame] | 72 | extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type); |
| 73 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | /* |
| 75 | * attach_pid() and detach_pid() must be called with the tasklist_lock |
| 76 | * write-held. |
| 77 | */ |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 78 | extern int FASTCALL(attach_pid(struct task_struct *task, |
Sukadev Bhattiprolu | e713d0d | 2007-05-10 22:22:58 -0700 | [diff] [blame^] | 79 | enum pid_type type, struct pid *pid)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | extern void FASTCALL(detach_pid(struct task_struct *task, enum pid_type)); |
Eric W. Biederman | c18258c | 2006-09-27 01:51:06 -0700 | [diff] [blame] | 81 | extern void FASTCALL(transfer_pid(struct task_struct *old, |
| 82 | struct task_struct *new, enum pid_type)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | |
| 84 | /* |
| 85 | * 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] | 86 | * or rcu_read_lock() held. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | */ |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 88 | extern struct pid *FASTCALL(find_pid(int nr)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 90 | /* |
| 91 | * Lookup a PID in the hash table, and return with it's count elevated. |
| 92 | */ |
| 93 | extern struct pid *find_get_pid(int nr); |
Eric W. Biederman | 0804ef4 | 2006-10-02 02:17:04 -0700 | [diff] [blame] | 94 | extern struct pid *find_ge_pid(int nr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | |
Eric W. Biederman | 92476d7 | 2006-03-31 02:31:42 -0800 | [diff] [blame] | 96 | extern struct pid *alloc_pid(void); |
| 97 | extern void FASTCALL(free_pid(struct pid *pid)); |
| 98 | |
Eric W. Biederman | 5feb8f5 | 2006-10-02 02:17:12 -0700 | [diff] [blame] | 99 | static inline pid_t pid_nr(struct pid *pid) |
| 100 | { |
| 101 | pid_t nr = 0; |
| 102 | if (pid) |
| 103 | nr = pid->nr; |
| 104 | return nr; |
| 105 | } |
| 106 | |
Andrew Morton | 1d32849 | 2006-10-03 01:13:45 -0700 | [diff] [blame] | 107 | #define do_each_pid_task(pid, type, task) \ |
| 108 | do { \ |
| 109 | struct hlist_node *pos___; \ |
| 110 | if (pid != NULL) \ |
| 111 | hlist_for_each_entry_rcu((task), pos___, \ |
Oleg Nesterov | d387cae | 2006-10-02 02:17:22 -0700 | [diff] [blame] | 112 | &pid->tasks[type], pids[type].node) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | |
Andrew Morton | 1d32849 | 2006-10-03 01:13:45 -0700 | [diff] [blame] | 114 | #define while_each_pid_task(pid, type, task) \ |
| 115 | } \ |
Oleg Nesterov | d387cae | 2006-10-02 02:17:22 -0700 | [diff] [blame] | 116 | } while (0) |
Eric W. Biederman | 558cb32 | 2006-10-02 02:17:09 -0700 | [diff] [blame] | 117 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | #endif /* _LINUX_PID_H */ |