进程控制和通信(四) · PCB介绍

1
2
3

pid_t				pid;                            // 进程id
pid_t				tgid;                           // 线程group id
struct task_struct		*group_leader;              // 线程group leader

1
2
3
4
5
6

DECLARE_PER_CPU(struct task_struct *, current_task);
static __always_inline struct task_struct *get_current(void)
{
	return this_cpu_read_stable(current_task);
}
#define current get_current()

1
2
3
4

SYSCALL_DEFINE0(getpid)
{
	return task_tgid_vnr(current);
}

1
2
3
4

SYSCALL_DEFINE0(gettid)
{
	return task_pid_vnr(current);
}

1
2
3
4
5
6
7
8

SYSCALL_DEFINE0(getppid)
{
	int pid;
	rcu_read_lock();
	pid = task_tgid_vnr(rcu_dereference(current->real_parent));
	rcu_read_unlock();
	return pid;
}

1
2
3
4
5
6
7

/* Real parent process: */
struct task_struct __rcu	*real_parent;
/* Recipient of SIGCHLD, wait4() reports: */
struct task_struct __rcu	*parent;
/* Children/sibling form the list of natural children: */
struct list_head		children;
struct list_head		sibling;

1
2
3
4
5
6
7
8

/* CLONE_PARENT re-uses the old parent */
if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
    p->real_parent = current->real_parent;
    p->parent_exec_id = current->parent_exec_id;
} else {
    p->real_parent = current;
    p->parent_exec_id = current->self_exec_id;
}

1
2
3
4
5
6
7
8

void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
		   const struct cred *ptracer_cred)
{
	BUG_ON(!list_empty(&child->ptrace_entry));
	list_add(&child->ptrace_entry, &new_parent->ptraced);
	child->parent = new_parent;
	child->ptracer_cred = get_cred(ptracer_cred);
}

1
2
3
4
5

/* -1 unrunnable, 0 runnable, >0 stopped: */
volatile long			state;
/* Per task flags (PF_*), defined further below: */
unsigned int			flags;
int				exit_state;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/* Used in tsk->state: */
#define TASK_RUNNING			0x0000
#define TASK_INTERRUPTIBLE		0x0001
#define TASK_UNINTERRUPTIBLE	0x0002
#define __TASK_STOPPED			0x0004
#define __TASK_TRACED			0x0008
/* Used in tsk->exit_state: */
#define EXIT_DEAD				0x0010
#define EXIT_ZOMBIE				0x0020
#define EXIT_TRACE				(EXIT_ZOMBIE | EXIT_DEAD)
/* Used in tsk->state again: */
#define TASK_PARKED				0x0040
#define TASK_DEAD				0x0080
#define TASK_WAKEKILL			0x0100
#define TASK_WAKING				0x0200
#define TASK_NOLOAD				0x0400
#define TASK_NEW				0x0800
#define TASK_STATE_MAX			0x1000
/* Convenience macros for the sake of set_current_state: */
#define TASK_KILLABLE			(TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
#define TASK_STOPPED			(TASK_WAKEKILL | __TASK_STOPPED)
#define TASK_TRACED				(TASK_WAKEKILL | __TASK_TRACED)
#define TASK_IDLE				(TASK_UNINTERRUPTIBLE | TASK_NOLOAD)
/* Convenience macros for the sake of wake_up(): */
#define TASK_NORMAL				(TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
/* get_task_state(): */
#define TASK_REPORT				(TASK_RUNNING | TASK_INTERRUPTIBLE | \
					 			TASK_UNINTERRUPTIBLE | __TASK_STOPPED | \
					 			__TASK_TRACED | EXIT_DEAD | EXIT_ZOMBIE | \
					 			TASK_PARKED)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/*
 * Called when a process ceases being the active-running process involuntarily
 * due, typically, to expiring its time slice (this may also be called when
 * switching to the idle task).  Now we can calculate how long we ran.
 * Also, if the process is still in the TASK_RUNNING state, call
 * sched_info_queued() to mark that it has now again started waiting on
 * the runqueue.
 */
static inline void sched_info_depart(struct rq *rq, struct task_struct *t)
{
	unsigned long long delta = rq_clock(rq) - t->sched_info.last_arrival;
	rq_sched_info_depart(rq, delta);
	if (t->state == TASK_RUNNING)
		sched_info_queued(rq, t);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/*
 * Per process flags
 */
#define PF_IDLE				0x00000002	/* I am an IDLE thread */
#define PF_EXITING			0x00000004	/* Getting shut down */
#define PF_EXITPIDONE		0x00000008	/* PI exit done on shut down */
#define PF_VCPU				0x00000010	/* I'm a virtual CPU */
#define PF_WQ_WORKER		0x00000020	/* I'm a workqueue worker */
#define PF_FORKNOEXEC		0x00000040	/* Forked but didn't exec */
#define PF_MCE_PROCESS		0x00000080  /* Process policy on mce errors */
#define PF_SUPERPRIV		0x00000100	/* Used super-user privileges */
#define PF_DUMPCORE			0x00000200	/* Dumped core */
#define PF_SIGNALED			0x00000400	/* Killed by a signal */
#define PF_MEMALLOC			0x00000800	/* Allocating memory */
#define PF_NPROC_EXCEEDED	0x00001000	/* set_user() noticed that RLIMIT_NPROC was exceeded */
#define PF_USED_MATH		0x00002000	/* If unset the fpu must be initialized before use */
#define PF_USED_ASYNC		0x00004000	/* Used async_schedule*(), used by module init */
#define PF_NOFREEZE			0x00008000	/* This thread should not be frozen */
#define PF_FROZEN			0x00010000	/* Frozen for system suspend */
#define PF_KSWAPD			0x00020000	/* I am kswapd */
#define PF_MEMALLOC_NOFS	0x00040000	/* All allocation requests will inherit GFP_NOFS */
#define PF_MEMALLOC_NOIO	0x00080000	/* All allocation requests will inherit GFP_NOIO */
#define PF_LESS_THROTTLE	0x00100000	/* Throttle me less: I clean memory */
#define PF_KTHREAD			0x00200000	/* I am a kernel thread */
#define PF_RANDOMIZE		0x00400000	/* Randomize virtual address space */
#define PF_SWAPWRITE		0x00800000	/* Allowed to write to swap */
#define PF_MEMSTALL			0x01000000	/* Stalled due to lack of memory */
#define PF_UMH				0x02000000	/* I'm an Usermodehelper process */
#define PF_NO_SETAFFINITY	0x04000000	/* Userland is not allowed to meddle with cpus_allowed */
#define PF_MCE_EARLY		0x08000000  /* Early kill for mce process policy */
#define PF_MEMALLOC_NOCMA	0x10000000	/* All allocation request will have _GFP_MOVABLE cleared */
#define PF_FREEZER_SKIP		0x40000000	/* Freezer should not count it as freezable */
#define PF_SUSPEND_TASK		0x80000000  /* This thread called freeze_processes() and should not be frozen */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/*
 * Only the _current_ task can read/write to tsk->flags, but other
 * tasks can access tsk->flags in readonly mode for example
 * with tsk_used_math (like during threaded core dumping).
 * There is however an exception to this rule during ptrace
 * or during fork: the ptracer task is allowed to write to the
 * child->flags of its traced child (same goes for fork, the parent
 * can write to the child->flags), because we're guaranteed the
 * child is not running and in turn not changing child->flags
 * at the same time the parent does it.
 */

1
2
3
4
5
6
7

/* Process credentials: */
/* Tracer's credentials at attach: */
const struct cred __rcu		*ptracer_cred;
/* Objective and real subjective task credentials (COW): */
const struct cred __rcu		*real_cred;
/* Effective (overridable) subjective task credentials (COW): */
const struct cred __rcu		*cred;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct cred {
	atomic_t	usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
	atomic_t	subscribers;	/* number of processes subscribed */
	void		*put_addr;
	unsigned	magic;
#define CRED_MAGIC	0x43736564
#define CRED_MAGIC_DEAD	0x44656144
#endif
	kuid_t		uid;		/* real UID of the task */
	kgid_t		gid;		/* real GID of the task */
	kuid_t		suid;		/* saved UID of the task */
	kgid_t		sgid;		/* saved GID of the task */
	kuid_t		euid;		/* effective UID of the task */
	kgid_t		egid;		/* effective GID of the task */
	kuid_t		fsuid;		/* UID for VFS ops */
	kgid_t		fsgid;		/* GID for VFS ops */
	// .......
	kernel_cap_t	cap_inheritable; /* caps our children can inherit */
	kernel_cap_t	cap_permitted;	 /* caps we're permitted */
	kernel_cap_t	cap_effective;	 /* caps we can actually use */
	kernel_cap_t	cap_bset;		 /* capability bounding set */
	kernel_cap_t	cap_ambient;	 /* Ambient capability set */
	// .......
} __randomize_layout;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/*
 * The security context of a task
 *
 * The parts of the context break down into two categories:
 *
 *  (1) The objective context of a task.  These parts are used when some other
 *	task is attempting to affect this one.
 *
 *  (2) The subjective context.  These details are used when the task is acting
 *	upon another object, be that a file, a task, a key or whatever.
 *
 * Note that some members of this structure belong to both categories - the
 * LSM security pointer for instance.
 *
 * A task has two security pointers.  task->real_cred points to the objective
 * context that defines that task's actual details.  The objective part of this
 * context is used whenever that task is acted upon.
 *
 * task->cred points to the subjective context that defines the details of how
 * that task is going to act upon another object.  This may be overridden
 * temporarily to point to another security context, but normally points to the
 * same context as task->real_cred.
 */

1
2
3
4
5
6
7
8
9

u64				utime;				//用户态消耗的CPU时间
u64				stime;				//内核态消耗的CPU时间
/* Context switch counts: */
unsigned long			nvcsw;		//自愿的上下文切换计数
unsigned long			nivcsw;		//非自愿的上下文切换计数
/* Monotonic time in nsecs: */
u64				start_time;			//进程启动时间, 不包含睡眠时间
/* Boot based time in nsecs: */
u64				real_start_time;	//进程启动时间, 包含睡眠时间

1
2
3
4
5
6
7

int							prio;
int							static_prio;
int							normal_prio;
unsigned int				rt_priority;
const struct sched_class	*sched_class;
struct sched_entity			se;
struct sched_rt_entity		rt;

1
2
3
4
5
6
7

#define MAX_NICE	19
#define MIN_NICE	-20

#define MAX_USER_RT_PRIO	100
#define MAX_RT_PRIO			MAX_USER_RT_PRIO				// 100
#define MAX_PRIO			(MAX_RT_PRIO + NICE_WIDTH)		// 140
#define DEFAULT_PRIO		(MAX_RT_PRIO + NICE_WIDTH / 2)  // 120

1
2

#define NICE_TO_PRIO(nice)	((nice) + DEFAULT_PRIO)
#define PRIO_TO_NICE(prio)	((prio) - DEFAULT_PRIO)

1
2
3

$ ps -la
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
4 S  1000 16697  8335  0  80   0 - 537617 futex_ pts/4   00:01:19 hugo

1
2
3

$ renice -n 20 -p 16697 && ps -la | grep hugo
16697 (process ID) old priority 0, new priority 19
4 S  1000 16697  8335  0  99  19 - 537617 ep_pol pts/4   00:01:20 hugo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/* Signal handlers: */
struct signal_struct		*signal;
struct sighand_struct		*sighand;
sigset_t					blocked;
sigset_t					real_blocked;
/* Restored if set_restore_sigmask() was used: */
sigset_t					saved_sigmask;
struct sigpending			pending;
unsigned long				sas_ss_sp;
size_t						sas_ss_size;
unsigned int				sas_ss_flags;

1
2
3

// bool get_signal(struct ksignal *ksig)
struct sighand_struct *sighand = current->sighand;
struct signal_struct *signal = current->signal;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

$ kill -l
 1) SIGHUP	 	 2) SIGINT		 3) SIGQUIT		 4) SIGILL	 	5) SIGTRAP
 2) SIGABRT	 	 7) SIGBUS		 8) SIGFPE		 9) SIGKILL		10) SIGUSR1
1)  SIGSEGV		12) SIGUSR2		13) SIGPIPE		14) SIGALRM		15) SIGTERM
2)  SIGSTKFLT	17) SIGCHLD		18) SIGCONT		19) SIGSTOP		20) SIGTSTP
3)  SIGTTIN		22) SIGTTOU		23) SIGURG		24) SIGXCPU		25) SIGXFSZ
4)  SIGVTALRM	27) SIGPROF		28) SIGWINCH	29) SIGIO		30) SIGPWR
5)  SIGSYS		34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
6)  SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
7)  SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
8)  SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
9)  SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
10) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
11) SIGRTMAX-1	64) SIGRTMAX

1
2

struct mm_struct		*mm;
struct mm_struct		*active_mm;

1
2
3

unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;

1
2
3
4

/* Filesystem information: */
struct fs_struct		*fs;
/* Open file information: */
struct files_struct		*files;

1
2
3
4
5
6
7
8

struct fs_struct {
	int users;
	spinlock_t lock;
	seqcount_t seq;
	int umask;
	int in_exec;
	struct path root, pwd;
} __randomize_layout;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

/*
 * Open file table structure
 */
struct files_struct {
/* read mostly part */
	atomic_t count;
	bool resize_in_progress;
	wait_queue_head_t resize_wait;
	struct fdtable __rcu *fdt;
	struct fdtable fdtab;
/* written part on a separate cache line in SMP */
	spinlock_t file_lock ____cacheline_aligned_in_smp;
	unsigned int next_fd;
	unsigned long close_on_exec_init[1];
	unsigned long open_fds_init[1];
	unsigned long full_fds_bits_init[1];
	struct file __rcu * fd_array[NR_OPEN_DEFAULT];
};

1

#define INR_OPEN_MAX 4096	/* Hard limit for nfile rlimits */

1
2
3
4
5
6
7
8

struct fdtable {
	unsigned int max_fds;
	struct file __rcu **fd;      /* current fd array */
	unsigned long *close_on_exec;
	unsigned long *open_fds;
	unsigned long *full_fds_bits;
	struct rcu_head rcu;
};

1
2

struct thread_info		thread_info;		// 必须是task_struct的第一个成员
void					*stack;				// 内核栈

1

#define current_thread_info() ((struct thread_info *)current)

1
2
3
4
5
6
7
8

#ifdef CONFIG_THREAD_INFO_IN_TASK
static inline struct thread_info *task_thread_info(struct task_struct *task)
{
	return &task->thread_info;
}
#elif !defined(__HAVE_THREAD_FUNCTIONS)
# define task_thread_info(task)	((struct thread_info *)(task)->stack)
#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#ifdef CONFIG_KASAN
#define KASAN_STACK_ORDER 1
#else
#define KASAN_STACK_ORDER 0
#endif
#define THREAD_SIZE_ORDER	(2 + KASAN_STACK_ORDER)
#define THREAD_SIZE  (PAGE_SIZE << THREAD_SIZE_ORDER)

union thread_union {
#ifndef CONFIG_ARCH_TASK_STRUCT_ON_STACK
	struct task_struct task;
#endif
#ifndef CONFIG_THREAD_INFO_IN_TASK
	struct thread_info thread_info;
#endif
	unsigned long stack[THREAD_SIZE/sizeof(long)];
};