mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-01 19:26:45 +07:00
84d737866e
Add a per pid_namespace child-reaper. This is needed so processes are reaped within the same pid space and do not spill over to the parent pid space. Its also needed so containers preserve existing semantic that pid == 1 would reap orphaned children. This is based on Eric Biederman's patch: http://lkml.org/lkml/2006/2/6/285 Signed-off-by: Sukadev Bhattiprolu <sukadev@us.ibm.com> Signed-off-by: Cedric Le Goater <clg@fr.ibm.com> Cc: Kirill Korotaev <dev@openvz.org> Cc: Eric W. Biederman <ebiederm@xmission.com> Cc: Herbert Poetzl <herbert@13thfloor.at> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
134 lines
3.7 KiB
C
134 lines
3.7 KiB
C
#ifndef _LINUX_PID_H
|
|
#define _LINUX_PID_H
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
enum pid_type
|
|
{
|
|
PIDTYPE_PID,
|
|
PIDTYPE_PGID,
|
|
PIDTYPE_SID,
|
|
PIDTYPE_MAX
|
|
};
|
|
|
|
/*
|
|
* 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
|
|
* 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.
|
|
*/
|
|
|
|
struct pid
|
|
{
|
|
atomic_t count;
|
|
/* Try to keep pid_chain in the same cacheline as nr for find_pid */
|
|
int nr;
|
|
struct hlist_node pid_chain;
|
|
/* lists of tasks that use this pid */
|
|
struct hlist_head tasks[PIDTYPE_MAX];
|
|
struct rcu_head rcu;
|
|
};
|
|
|
|
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;
|
|
}
|
|
|
|
extern void FASTCALL(put_pid(struct pid *pid));
|
|
extern struct task_struct *FASTCALL(pid_task(struct pid *pid, enum pid_type));
|
|
extern struct task_struct *FASTCALL(get_pid_task(struct pid *pid,
|
|
enum pid_type));
|
|
|
|
extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
|
|
|
|
/*
|
|
* attach_pid() and detach_pid() must be called with the tasklist_lock
|
|
* write-held.
|
|
*/
|
|
extern int FASTCALL(attach_pid(struct task_struct *task,
|
|
enum pid_type type, int nr));
|
|
|
|
extern void FASTCALL(detach_pid(struct task_struct *task, enum pid_type));
|
|
extern void FASTCALL(transfer_pid(struct task_struct *old,
|
|
struct task_struct *new, enum pid_type));
|
|
|
|
/*
|
|
* look up a PID in the hash table. Must be called with the tasklist_lock
|
|
* or rcu_read_lock() held.
|
|
*/
|
|
extern struct pid *FASTCALL(find_pid(int nr));
|
|
|
|
/*
|
|
* Lookup a PID in the hash table, and return with it's count elevated.
|
|
*/
|
|
extern struct pid *find_get_pid(int nr);
|
|
extern struct pid *find_ge_pid(int nr);
|
|
|
|
extern struct pid *alloc_pid(void);
|
|
extern void FASTCALL(free_pid(struct pid *pid));
|
|
|
|
static inline pid_t pid_nr(struct pid *pid)
|
|
{
|
|
pid_t nr = 0;
|
|
if (pid)
|
|
nr = pid->nr;
|
|
return nr;
|
|
}
|
|
|
|
|
|
#define do_each_task_pid(who, type, task) \
|
|
do { \
|
|
struct hlist_node *pos___; \
|
|
struct pid *pid___ = find_pid(who); \
|
|
if (pid___ != NULL) \
|
|
hlist_for_each_entry_rcu((task), pos___, \
|
|
&pid___->tasks[type], pids[type].node) {
|
|
|
|
#define while_each_task_pid(who, type, task) \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
#define do_each_pid_task(pid, type, task) \
|
|
do { \
|
|
struct hlist_node *pos___; \
|
|
if (pid != NULL) \
|
|
hlist_for_each_entry_rcu((task), pos___, \
|
|
&pid->tasks[type], pids[type].node) {
|
|
|
|
#define while_each_pid_task(pid, type, task) \
|
|
} \
|
|
} while (0)
|
|
|
|
#endif /* _LINUX_PID_H */
|