Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
1: #ifndef _LINUX_PID_H 2: #define _LINUX_PID_H 3: 4: #include <linux/rcupdate.h> 5: 6: enum pid_type 7: { 8: PIDTYPE_PID, 9: PIDTYPE_PGID, 10: PIDTYPE_SID, 11: PIDTYPE_MAX 12: }; 13: 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 referring 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 pid 39: * value is reused (when pids wrap around) we don't mistakenly refer to new 40: * processes. 41: */ 42: 43: 44: /* 45: * struct upid is used to get the id of the struct pid, as it is 46: * seen in particular namespace. Later the struct pid is found with 47: * find_pid_ns() using the int nr and struct pid_namespace *ns. 48: */ 49: 50: struct upid { 51: /* Try to keep pid_chain in the same cacheline as nr for find_vpid */ 52: int nr; 53: struct pid_namespace *ns; 54: struct hlist_node pid_chain; 55: }; 56: 57: struct pid 58: { 59: atomic_t count; 60: unsigned int level; 61: /* lists of tasks that use this pid */ 62: struct hlist_head tasks[PIDTYPE_MAX]; 63: struct rcu_head rcu; 64: struct upid numbers[1]; 65: }; 66: 67: extern struct pid init_struct_pid; 68: 69: struct pid_link 70: { 71: struct hlist_node node; 72: struct pid *pid; 73: }; 74: 75: static inline struct pid *get_pid(struct pid *pid) 76: { 77: if (pid) 78: atomic_inc(&pid->count); 79: return pid; 80: } 81: 82: extern void put_pid(struct pid *pid); 83: extern struct task_struct *pid_task(struct pid *pid, enum pid_type); 84: extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type); 85: 86: extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type); 87: 88: /* 89: * these helpers must be called with the tasklist_lock write-held. 90: */ 91: extern void attach_pid(struct task_struct *task, enum pid_type); 92: extern void detach_pid(struct task_struct *task, enum pid_type); 93: extern void change_pid(struct task_struct *task, enum pid_type, 94: struct pid *pid); 95: extern void transfer_pid(struct task_struct *old, struct task_struct *new, 96: enum pid_type); 97: 98: struct pid_namespace; 99: extern struct pid_namespace init_pid_ns; 100: 101: /* 102: * look up a PID in the hash table. Must be called with the tasklist_lock 103: * or rcu_read_lock() held. 104: * 105: * find_pid_ns() finds the pid in the namespace specified 106: * find_vpid() finds the pid by its virtual id, i.e. in the current namespace 107: * 108: * see also find_task_by_vpid() set in include/linux/sched.h 109: */ 110: extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns); 111: extern struct pid *find_vpid(int nr); 112: 113: /* 114: * Lookup a PID in the hash table, and return with it's count elevated. 115: */ 116: extern struct pid *find_get_pid(int nr); 117: extern struct pid *find_ge_pid(int nr, struct pid_namespace *); 118: int next_pidmap(struct pid_namespace *pid_ns, unsigned int last); 119: 120: extern struct pid *alloc_pid(struct pid_namespace *ns); 121: extern void free_pid(struct pid *pid); 122: extern void disable_pid_allocation(struct pid_namespace *ns); 123: 124: /* 125: * ns_of_pid() returns the pid namespace in which the specified pid was 126: * allocated. 127: * 128: * NOTE: 129: * ns_of_pid() is expected to be called for a process (task) that has 130: * an attached 'struct pid' (see attach_pid(), detach_pid()) i.e @pid 131: * is expected to be non-NULL. If @pid is NULL, caller should handle 132: * the resulting NULL pid-ns. 133: */ 134: static inline struct pid_namespace *ns_of_pid(struct pid *pid) 135: { 136: struct pid_namespace *ns = NULL; 137: if (pid) 138: ns = pid->numbers[pid->level].ns; 139: return ns; 140: } 141: 142: /* 143: * is_child_reaper returns true if the pid is the init process 144: * of the current namespace. As this one could be checked before 145: * pid_ns->child_reaper is assigned in copy_process, we check 146: * with the pid number. 147: */ 148: static inline bool is_child_reaper(struct pid *pid) 149: { 150: return pid->numbers[pid->level].nr == 1; 151: } 152: 153: /* 154: * the helpers to get the pid's id seen from different namespaces 155: * 156: * pid_nr() : global id, i.e. the id seen from the init namespace; 157: * pid_vnr() : virtual id, i.e. the id seen from the pid namespace of 158: * current. 159: * pid_nr_ns() : id seen from the ns specified. 160: * 161: * see also task_xid_nr() etc in include/linux/sched.h 162: */ 163: 164: static inline pid_t pid_nr(struct pid *pid) 165: { 166: pid_t nr = 0; 167: if (pid) 168: nr = pid->numbers[0].nr; 169: return nr; 170: } 171: 172: pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns); 173: pid_t pid_vnr(struct pid *pid); 174: 175: #define do_each_pid_task(pid, type, task) \ 176: do { \ 177: if ((pid) != NULL) \ 178: hlist_for_each_entry_rcu((task), \ 179: &(pid)->tasks[type], pids[type].node) { 180: 181: /* 182: * Both old and new leaders may be attached to 183: * the same pid in the middle of de_thread(). 184: */ 185: #define while_each_pid_task(pid, type, task) \ 186: if (type == PIDTYPE_PID) \ 187: break; \ 188: } \ 189: } while (0) 190: 191: #define do_each_pid_thread(pid, type, task) \ 192: do_each_pid_task(pid, type, task) { \ 193: struct task_struct *tg___ = task; \ 194: do { 195: 196: #define while_each_pid_thread(pid, type, task) \ 197: } while_each_thread(tg___, task); \ 198: task = tg___; \ 199: } while_each_pid_task(pid, type, task) 200: #endif /* _LINUX_PID_H */ 201: