Linux - 进程管理task_struct

·进程概念

简单来讲，进程是程序的一个执行实例；是一个正在执行的程序。

进程与程序的关系：进程是由程序代码和代码相关联的数据集组成。

进程与程序的区别：

①进程是动态的，程序是静态的

②进程只能存在于一段时间，而程序可以长期存在

③进程是可以被调度器调度，并且进程具有运行时的堆桟开销

总得来说：进程是程序加载到内存后，操作系统会衍生出一个PCB结构体来存放该进程的信息。

·PCB

即进程控制块（Process Control Block），是进程中的一部分，它描述了进程的基本信息，记录了操作系统所需要的、用于描述进程情况以及进程运行状态的全部信息。Linux内核的进程控制块是task_struct结构体。

·task_struct

task_struct是Linux内核的一种数据结构(可以在include/linux/sched.h中找到它)，它会被装载到RAM里并且包含着进程的信息。

task_struct包含了这些内容：

标识符：描述本进程的唯一标识符，用来区别其他进程

状态：任务状态，退出代码，退出信号等

优先级：相对于其他进程的优先级

程序计数器：程序中即将被执行的下一条指令的地址

内存指针：包括程序代码和程序相关的指针，还有和其他进程共享内存块的指针

上下文数据：进程执行过程中处理器的寄存器中的数据

I/O状态信息：包括显示的I/O请求，分配给进程的I/O设备和被进程使用的文件列表

记账信息：可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

接下来我们着重分析task_struct结构体：

1.进程状态

 volatile long state;

state可能的取值：

 #define TASK_RUNNING            0
 #define TASK_INTERRUPTIBLE      1
 #define TASK_UNINTERRUPTIBLE    2
 #define __TASK_STOPPED          4
 #define __TASK_TRACED           8

/* in tsk->exit_state */
 #define EXIT_DEAD               16
 #define EXIT_ZOMBIE             32
 #define EXIT_TRACE              (EXIT_ZOMBIE | EXIT_DEAD)

/* in tsk->state again */
 #define TASK_DEAD               64
 #define TASK_WAKEKILL           128    /** wake on signals that are deadly **/
 #define TASK_WAKING             256
 #define TASK_PARKED             512
 #define TASK_NOLOAD             1024
 #define TASK_STATE_MAX          2048

 /* Convenience macros for the sake of set_task_state */
#define TASK_KILLABLE           (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
#define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)
#define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)

2.进程标识符（PID）

pid_t pid;  
pid_t tgid;  

pid用来标识进程，ppid用来标识父进程，而关于tgid的解释是：一个线程组所有线程与领头线程具有相同的pid，存入tgid字段。getpid()返回的是当前进程的tgid而不是pid。

在CONFIG_BASE_SMALL配置为0的情况先，PID的取值范围是0到32767，即系统中的进程数最大为32768个。

3.进程内核栈

void *stack;

进程内核栈与进程描述符的关系：

对进程内核栈的认识可以参考这篇文章：http://blog.chinaunix.net/uid-20543672-id-2996319.html

4.进程标记

unsigned int flags; /* per process flags, defined below */  

反应进程的状态信息，而不是运行状态，用于内核识别进程当前的状态，以备下一步操作。

flags成员的可能取值：

#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_FSTRANS      0x00020000      /* inside a filesystem transaction */
#define PF_KSWAPD       0x00040000      /* I am kswapd */
#define PF_MEMALLOC_NOIO 0x00080000     /* Allocating memory without IO involved */
#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_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_MUTEX_TESTER 0x20000000      /* Thread belongs to the rt mutex tester */
#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 */

5.表示进程亲属关系的成员

struct task_struct __rcu *real_parent; /* real parent process */
struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
struct list_head children;      /* list of my children */
struct list_head sibling;       /* linkage in my parent's children list */
struct task_struct *group_leader;       /* threadgroup leader */

Linux中，一个进程与其他进程之间都有着直接或者间接的联系，一个进程有可能是父进程、子进程或其他进程的兄弟进程，拥有同一父进程的所有进程为兄弟进程。

字段	描述
real_parent	指向其父进程，如果创建它的父进程不再存在，则指向PID为1的init进程
parent	指向其父进程，当它终止时，必须向它的父进程发送信号。它的值通常与real_parent相同
children	表示链表的头部，链表中的所有元素都是它的子进程
sibling	用于把当前进程插入到兄弟链表中
group_leader	指向其所在进程组的领头进程

6.ptrace调用

ptrace提供了一种父进程可以控制子进程运行，并可以检查和改变它的核心image。主要用于断点调试。当ptrace被设置为0时表示不需要被追踪。

unsigned int ptrace;

struct list_head ptraced;
struct list_head ptrace_entry;

unsigned long ptrace_message;
siginfo_t *last_siginfo; /* For ptrace use.  */

7.PerformanceEvent

是一款性能诊断工具，这些成员用于帮助Performance Event分析进程的性能问题。

#ifdef CONFIG_PERF_EVENTS
    struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
    struct mutex perf_event_mutex;
    struct list_head perf_event_list;
#endif

8.进程调度

8.1优先级

int prio, static_prio, normal_prio;
unsigned int rt_priority;

字段	描述
static_prio	保存静态优先级，可以通过nice系统调用来进行修改
rt_priority	保存实时优先级
normal_prio	取决于静态优先级和调度策略
prio	保存动态优先级

实时优先级范围：0 到 MAX_RT_PRIO-1（即99）

普通进程的静态优先级范围：MAX_RT_PRIO 到 MAX_PRIO-1（即100 到 139）。值越大静态优先级越低

8.2调度策略相关字段

const struct sched_class *sched_class;
struct sched_entity se;
struct sched_rt_entity rt;
cpumask_t cpus_allowed;

字段	描述
policy	调度策略
sched_class	调度类
se	普通进程的调用实体，每个进程都有其中之一的实体
rt	实时进程的调用实体，每个进程都有其中之一的实体
cpus_allowed	用于控制进程可以在哪里处理器上运行

8.3调度策略（policy）

/*
* Scheduling policies
*/
#define SCHED_NORMAL            0
#define SCHED_FIFO              1
#define SCHED_RR                2
#define SCHED_BATCH             3
/* SCHED_ISO: reserved but not implemented yet */
#define SCHED_IDLE              5
#define SCHED_DEADLINE          6

字段	描述	所在调度器类
SCHED_NORMAL	（也叫SCHED_OTHER）用于普通进程，通过CFS调度器实现。 SCHED_BATCH用于非交互的处理器消耗型进程。SCHED_IDLE是在系统负载很低时使用	CFS
SCHED_BATCH	SCHED_NORMAL普通进程策略的分化版本。采用分时策略，根据动态优先级(可用nice()API设置），分配 CPU 运算资源。 注意：这类进程比上述两类实时进程优先级低，换言之，在有实时进程存在时，实时进程优先调度。但针对吞吐量优化	CFS
SCHED_IDLE	优先级最低，在系统空闲时才跑这类进程(如利用闲散计算机资源跑地外文明搜索，蛋白质结构分析等任务，是此调度策略的适用者）	CFS
SCHED_FIFO	先入先出调度算法（实时调度策略），相同优先级的任务先到先服务，高优先级的任务可以抢占低优先级的任务	RT
SCHED_RR	轮流调度算法（实时调度策略），后者提供 Roound-Robin 语义，采用时间片，相同优先级的任务当用完时间片会被放到队列尾部，以保证公平性，同样，高优先级的任务可以抢占低优先级的任务。不同要求的实时任务可以根据需要用sched_setscheduler()API 设置策略	RT
SCHED_DEADLINE	新支持的实时进程调度策略，针对突发型计算，且对延迟和完成时间高度敏感的任务适用。基于Earliest Deadline First (EDF) 调度算法

8.4调度类（sched_class）

extern const struct sched_class stop_sched_class;
extern const struct sched_class dl_sched_class;
extern const struct sched_class rt_sched_class;
extern const struct sched_class fair_sched_class;
extern const struct sched_class idle_sched_class;

调度器类	描述
idle_sched_class	每个cup的第一个pid=0线程：swapper，是一个静态线程。 调度类属于：idel_sched_class，所以在ps里面是看不到的。一般运行在开机过程和cpu异常的时候做dump
stop_sched_class	优先级最高的线程，会中断所有其他线程，且不会被其他任务打断。 作用：1.发生在cpu_stop_cpu_callback 进行cpu之间任务migration；2.HOTPLUG_CPU的情况下关闭任务。
rt_sched_class	RT，作用：实时线程
fair_sched_class	CFS（公平），作用：一般常规线程

优先级：stop > rt > fair > idle

9.进程地址空间

struct mm_struct *mm, *active_mm;

字段	描述
mm	进程所拥有的用户空间内存描述符，内核线程无的mm为NULL
active_mm	active_mm指向进程运行时所使用的内存描述符， 对于普通进程而言，这两个指针变量的值相同。 内核线程kernel thread无进程地址空间，所以内核线程的tsk->mm为NULL。 但是内核必须知道用户空间包含了什么，因此它的active_mm成员被初始化为前一个运行进程的active_mm值。

10.时间

cputime_t utime, stime, utimescaled, stimescaled;  
cputime_t gtime;  //（guest time）虚拟机运行时间
cputime_t prev_utime, prev_stime;//记录当前的运行时间（用户态和内核态）  
unsigned long nvcsw, nivcsw; //自愿/非自愿上下文切换计数  
struct timespec start_time;     
struct timespec real_start_time;
unsigned long min_flt, maj_flt;  
struct task_cputime cputime_expires;//cpu执行的有效时间  
struct list_head cpu_timers[3];//用来统计进程或进程组被处理器追踪的时间  
struct list_head run_list;  
unsigned long timeout;//当前已使用的时间（与开始时间的差值）  
unsigned int time_slice;//进程的时间片的大小  
int nr_cpus_allowed;  

字段	描述
utime/stime	记录进程在用户态/内核态下所经过的节拍数（定时器）
utimescaled/stimescaled	记录进程在用户态/内核态的运行时间，以处理器的频率为刻度
last_switch_count	nvcsw和nivcsw的总和
start_time/real_start_time	进程创建时间，real_start_time还包含了进程睡眠时间，常用于/proc/pid/stat
cputime_expires	用来统计进程或进程组被跟踪的处理器时间，其中的三个成员对应着cpu_timers[3]的三个链表

11.信号处理

struct signal_struct *signal;		//指向进程的信号描述符
struct sighand_struct *sighand;		//指向进程的信号处理程序描述符

sigset_t blocked, real_blocked;		//表示被阻塞信号的掩码，real_blocked表示临时掩码
sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
struct sigpending pending;		//pending存放私有挂起信号的数据结构

unsigned long sas_ss_sp;		//信号处理程序备用堆桟的地址
size_t sas_ss_size;			//表示堆桟的大小

12.其他

1.用于保护资源分配或释放的自旋锁 
spinlock_t alloc_lock;  

2.进程描述符使用计数，被置为2时，表示进程描述符正在被使用而且其相应的进程处于活动状态。 
atomic_t usage;  

3.用于表示获取大内核锁的次数，如果进程未获得过锁，则置为-1。 
int lock_depth;     /* BKL lock depth */  

4.在SMP上帮助实现无加锁的进程切换（unlocked context switches
#ifdef CONFIG_SMP  
#ifdef __ARCH_WANT_UNLOCKED_CTXSW  
    int oncpu;  
#endif  
#endif  

5.preempt_notifier结构体链表 
#ifdef CONFIG_PREEMPT_NOTIFIERS  
    /* list of struct preempt_notifier: */  
    struct hlist_head preempt_notifiers;  
#endif  

6.FPU使用计数 
unsigned char fpu_counter;

7.blktrace是一个针对Linux内核中块设备I/O层的跟踪工具
#ifdef CONFIG_BLK_DEV_IO_TRACE  
    unsigned int btrace_seq;  
#endif  

8.RCU同步原语
#ifdef CONFIG_PREEMPT_RCU  
    int rcu_read_lock_nesting;  
    char rcu_read_unlock_special;  
    struct list_head rcu_node_entry;  
#endif /* #ifdef CONFIG_PREEMPT_RCU */  
#ifdef CONFIG_TREE_PREEMPT_RCU  
    struct rcu_node *rcu_blocked_node;  
#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */  
#ifdef CONFIG_RCU_BOOST  
    struct rt_mutex *rcu_boost_mutex;  
#endif /* #ifdef CONFIG_RCU_BOOST */  

9.用于调度器统计进程的运行信息 
#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)  
    struct sched_info sched_info;  
#endif  

10.用于构建进程链表
struct list_head tasks;  

11.防止内核堆栈溢出
#ifdef CONFIG_CC_STACKPROTECTOR  
    /* Canary value for the -fstack-protector gcc feature */  
    unsigned long stack_canary;  
#endif  
    在GCC编译内核时，需要加上-fstack-protector选项。

12.PID散列表和链表
struct pid_link pids[PIDTYPE_MAX];  
struct list_head thread_group; //线程组中所有进程的链表  

13.do_fork函数
struct completion *vfork_done;      /* for vfork() */  
int __user *set_child_tid;      /* CLONE_CHILD_SETTID */  
int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */  
	//在执行do_fork()时，如果给定特别标志，则vfork_done会指向一个特殊地址。
    //如果copy_process函数的clone_flags参数的值被置为CLONE_CHILD_SETTID或CLONE_CHILD_CLEARTID，则会
	//把child_tidptr参数的值分别复制到set_child_tid和clear_child_tid成员。这些标志说明必须改变子进程
	//用户态地址空间的child_tidptr所指向的变量的值。

14.缺页统计   
unsigned long min_flt, maj_flt;

15.进程权能 
const struct cred __rcu *real_cred;
const struct cred __rcu *cred; 
struct cred *replacement_session_keyring; 

16.相应的程序名
char comm[TASK_COMM_LEN]; 

17.文件  
int link_count, total_link_count;  
struct fs_struct *fs;  
struct files_struct *files;  
    //fs用来表示进程与文件系统的联系，包括当前目录和根目录。
    //files表示进程当前打开的文件。

18.进程通信（SYSVIPC） 
#ifdef CONFIG_SYSVIPC 
    struct sysv_sem sysvsem;  
#endif  

19.处理器特有数据 
    struct thread_struct thread;  

20.命名空间  
    struct nsproxy *nsproxy;  

21.进程审计 
    struct audit_context *audit_context;  
#ifdef CONFIG_AUDITSYSCALL  
    uid_t loginuid;  
    unsigned int sessionid;  
#endif  

22.secure computing 
seccomp_t seccomp;  

23.用于copy_process函数使用CLONE_PARENT 标记时 
    u32 parent_exec_id;  
    u32 self_exec_id;  

24.中断 
#ifdef CONFIG_GENERIC_HARDIRQS  
    /* IRQ handler threads */  
    struct irqaction *irqaction;  
#endif  
#ifdef CONFIG_TRACE_IRQFLAGS  
    unsigned int irq_events;  
    unsigned long hardirq_enable_ip;  
    unsigned long hardirq_disable_ip;  
    unsigned int hardirq_enable_event;  
    unsigned int hardirq_disable_event;  
    int hardirqs_enabled;  
    int hardirq_context;  
    unsigned long softirq_disable_ip;  
    unsigned long softirq_enable_ip;  
    unsigned int softirq_disable_event;  
    unsigned int softirq_enable_event;  
    int softirqs_enabled;  
    int softirq_context;  
#endif  

25.task_rq_lock函数所使用的锁 
raw_spinlock_t pi_lock;  

26.基于PI协议的等待互斥锁，其中PI指的是priority inheritance（优先级继承） 
#ifdef CONFIG_RT_MUTEXES  
    /* PI waiters blocked on a rt_mutex held by this task */  
    struct plist_head pi_waiters;  
    /* Deadlock detection and priority inheritance handling */  
    struct rt_mutex_waiter *pi_blocked_on;  
#endif  

27.死锁检测 
#ifdef CONFIG_DEBUG_MUTEXES  
    /* mutex deadlock detection */  
    struct mutex_waiter *blocked_on;  
#endif  

28.lockdep
#ifdef CONFIG_LOCKDEP  
# define MAX_LOCK_DEPTH 48UL  
    u64 curr_chain_key;  
    int lockdep_depth;  
    unsigned int lockdep_recursion;  
    struct held_lock held_locks[MAX_LOCK_DEPTH];  
    gfp_t lockdep_reclaim_gfp;  
#endif  

29.JFS文件系统 
    void *journal_info;  

30.块设备链表 
    struct bio_list *bio_list;  

31.内存回收 
struct reclaim_state *reclaim_state;  

32.存放块设备I/O数据流量信息
struct backing_dev_info *backing_dev_info;  

33.I/O调度器所使用的信息 
struct io_context *io_context;  

34.记录进程的I/O计数 
struct task_io_accounting ioac;  

35.CPUSET功能 
#ifdef CONFIG_CPUSETS  
    nodemask_t mems_allowed;    /* Protected by alloc_lock */  
    int mems_allowed_change_disable;  
    int cpuset_mem_spread_rotor;  
    int cpuset_slab_spread_rotor;  
#endif  

36.Control Groups 
#ifdef CONFIG_CGROUPS  
    struct css_set __rcu *cgroups;  
    struct list_head cg_list;  
#endif  
#ifdef CONFIG_CGROUP_MEM_RES_CTLR /* memcg uses this to do batch job */  
    struct memcg_batch_info {  
        int do_batch;   /* incremented when batch uncharge started */  
        struct mem_cgroup *memcg; /* target memcg of uncharge */  
        unsigned long bytes;        /* uncharged usage */  
        unsigned long memsw_bytes; /* uncharged mem+swap usage */  
    } memcg_batch;  
#endif  

37.futex同步机制 
#ifdef CONFIG_FUTEX  
    struct robust_list_head __user *robust_list;  
#ifdef CONFIG_COMPAT  
    struct compat_robust_list_head __user *compat_robust_list;  
#endif  
    struct list_head pi_state_list;  
    struct futex_pi_state *pi_state_cache;  
#endif  

38.非一致内存访问（NUMA  Non-Uniform Memory Access） 
#ifdef CONFIG_NUMA  
    struct mempolicy *mempolicy;    /* Protected by alloc_lock */  
    short il_next;  
#endif  

39.文件系统互斥资源 
atomic_t fs_excl;   /* holding fs exclusive resources */  

40.RCU链表 
struct rcu_head rcu;  

41.管道 
struct pipe_inode_info *splice_pipe;  

42.延迟计数 
#ifdef  CONFIG_TASK_DELAY_ACCT  
    struct task_delay_info *delays;  
#endif  

43.fault injection
#ifdef CONFIG_FAULT_INJECTION  
    int make_it_fail;  
#endif  

44.FLoating proportions 
struct prop_local_single dirties;  

45.Infrastructure for displayinglatency 
#ifdef CONFIG_LATENCYTOP  
    int latency_record_count;  
    struct latency_record latency_record[LT_SAVECOUNT];  
#endif  

46.time slack values，常用于poll和select函数 
unsigned long timer_slack_ns;  
unsigned long default_timer_slack_ns;  

47.socket控制消息（control message） 
struct list_head    *scm_work_list;  

48.ftrace跟踪器 
#ifdef CONFIG_FUNCTION_GRAPH_TRACER  
    /* Index of current stored address in ret_stack */  
    int curr_ret_stack;  
    /* Stack of return addresses for return function tracing */  
    struct ftrace_ret_stack *ret_stack;  
    /* time stamp for last schedule */  
    unsigned long long ftrace_timestamp;  
    /* 
     * Number of functions that haven't been traced 
     * because of depth overrun. 
     */  
    atomic_t trace_overrun;  
    /* Pause for the tracing */  
    atomic_t tracing_graph_pause;  
#endif  
#ifdef CONFIG_TRACING  
    /* state flags for use by tracers */  
    unsigned long trace;  
    /* bitmask of trace recursion */  
    unsigned long trace_recursion;  
#endif /* CONFIG_TRACING */  

task_struct结构体的定义参见： http://lxr.free-electrons.com/source/include/linux/sched.h

参考：

http://blog.csdn.net/npy_lp/article/details/7292563

http://blog.csdn.net/npy_lp/article/details/7335187

http://blog.csdn.net/gatieme/article/details/51383272