linux 内核task_struct 源码分析与解析(整合配图）

本文来自个人网站 https://htmonster.xyz/blog/post/linux-nei-he-task-struct-yuan-ma-fen-xi-yu-jie-xi/

文章目录

• • • • 进程状态
      • • 0. 进程标志符
        • 1. 运行状态
        • 2. 进程标记
      • 任务状态
      • • 1. 任务终止
        • 2.ABI处理
        • 3.execve
        • 4.io等待
      • 进程内核栈地址
      • • • 内核栈布局
      • 进程调度
      • • 1.优先级
        • 2. 调度策略
        • 3. 进程调度
        • • 调度器
          • 调度器策略实体
          • 调度器、策略、调度实体关系
        • 4. 就绪队列
        • 5. 其它信息
      • 进程地址空间
      • • • 进程描述符mm_struct核心分析（
          • mm_struct图解
      • 进程亲属关系
      • 时间与定时器
      • • 1. 时间
        • 2. 定时器
        • • 定时器分类
      • 信号处理
      • 文件系统
      • Ptrace
      • • 1. ptrace 标志
        • 2.ptrace 任务列表
        • 3.其它
      • 其它信息
      • • 1. 进程描述符被使用计数
        • 2. 进程链表
        • 3. 自旋锁
        • 4. PID hansh表和链表
        • 5. do_fork函数
        • 6. 缺页统计
        • 7. 命名空间
        • 8.JFS文件系统
        • 9.块设备
      • 部分可选编译选项
      • • 1. SMP 多处理器
        • 2. Cgroup
        • 3. Cgroup资源管理器
    • 附源码

进程控制块（ Processing Control Block)是操作系统中很重要的一个结构。内核中为了描述和控制进程的运行，为每个进程定义了一个数据结构——进程控制块。而在linux内核中，这个数据结构就是task_struct，现在我们就来分析这个非常重要的数据结构。

首先是源码分析的基本信息：

linux 内核版本	源码所处文件
4.49	include/linux/sched.h

好了，接下来开始慢慢分析

进程状态

0. 进程标志符

pid_t pid; //进程ID
pid_t tgid;//线程组ID

1. 运行状态

volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */

• volatile 关键字： 说明该变量会随时变化，告诉编译器不要优化这个变量有关的运算，以免出错。

• 取值含义

  • -1 : unrunable 不可运行的

  • 0 : runable 在运行

  • > 0：停止的

    #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
    #define TASK_WAKING		256
    #define TASK_PARKED		512
    #define TASK_NOLOAD		1024
    #define TASK_STATE_MAX		2048
    

2. 进程标记

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

用来反映进程状态的信息（区别于运行状态），用于内核识别进程当前的状态，以备下一步操作。候选值：

#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 */

任务状态

1. 任务终止

int exit_state;                                             
int exit_code, exit_signal;     //终止代码  终止信号（exit_signal被置为-1时表示是某个线程组中的一员）
int pdeath_signal;  			//判断父进程终止时发送信号

2.ABI处理

/* Used for emulating ABI behavior of previous Linux versions */
unsigned int personality;

/* unserialized, strictly 'current' */
unsigned in_execve:1; /* bit to tell LSMs we're in execve */
unsigned in_iowait:1;

3.execve

unsigned in_execve:1; /* bit to tell LSMs we're in execve */

4.io等待

unsigned in_iowait:1; 

进程内核栈地址

void *stack;

内核在创建进程的时候，会创建两个堆栈，一个用户栈，存在于用户空间，一个内核栈，存在于内核空间。当进程在用户空间运行时，CPU堆栈寄存器的内容是用户堆栈地址，使用用户栈。当进程在内核空间时，CPU堆栈寄存器的内容是内核栈地址空间，使用的是内核栈。

而内核栈的地址就保存在 stack中。

内核栈布局

• thread_info VS. task_struct:

  • task_struct 在不同体系之间 一种通用的描述进程的结构
  • thread_info 则保存了特定体系结构的汇编代码段需要访问的那部分进程的数据

• 在内核中，内核栈和进程控制块thread_info融合在一起, 组成一个联合体thread_union

  union thread_union
  {
      struct thread_info thread_info;                    //线程描述符
      unsigned long stack[THREAD_SIZE/sizeof(long)];     //内核栈
  };
  

进程调度

参考文章：https://blog.csdn.net/gatieme/article/details/51702662

1.优先级

int prio, static_prio, normal_prio;
unsigned int rt_priority;

• prio: 动态优先级
• static_prio： 静态优先级（可以nice来修改）
• normal_prio： 取决于静态优先级和调度策略
• rt_priority：实时优先级

2. 调度策略

unsigned int policy;

可选调度策略

#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  

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

linux实现了6种调度策略, 依据其调度策略的不同实现了5个调度器类, 实现了3个调度实体，一个调度器类可以用一种或者多种调度策略调度某一类进程, 也可以用于特殊情况或者调度特殊功能的进程.

3. 进程调度

const struct sched_class *sched_class;

struct sched_entity se;     //普通进程的调用实体
struct sched_rt_entity rt;  //实时进程的调用实体
struct sched_dl_entity dl;  //deadline的调度实体

调度器

每个进程都属于某个调度器类(由字段task_struct->sched_class标识), 由调度器类采用进程对应的调度策略调度(由task_struct->policy )进行调度

调度器策略实体

定义	含义
sched_entity	采用CFS算法调度的普通非实时进程的调度实体
sched_rt_entity	采用Roound-Robin或者FIFO算法调度的实时调度实体
sched_dl_entity	采用EDF算法调度的实时调度实体

调度器、策略、调度实体关系

调度器类	调度策略	调度策略对应的调度算法	调度实体	调度实体对应的调度对象
stop_sched_class	无	无	无	特殊情况, 发生在cpu_stop_cpu_callback 进行cpu之间任务迁移migration或者HOTPLUG_CPU的情况下关闭任务
dl_sched_class	SCHED_DEADLINE	Earliest-Deadline-First最早截至时间有限算法	sched_dl_entity	采用DEF最早截至时间有限算法调度实时进程
rt_sched_class	SCHED_RR SCHED_FIFO	Roound-Robin时间片轮转算法FIFO先进先出算法	sched_rt_entity	采用Roound-Robin或者FIFO算法调度的实时调度实体
fair_sched_class	SCHED_NORMAL SCHED_BATCH CFS	完全公平懂调度算法	sched_entity	采用CFS算法普通非实时进程
idle_sched_class	SCHED_IDLE	无	无	特殊进程, 用于cpu空闲时调度空闲进程idle

4. 就绪队列

int on_rq; //是否在就绪队列

5. 其它信息

cpumask_t cpus_allowed; //用于控制进程可以在哪里处理器上运行
int nr_cpus_allowed; //该进程允许使用的cpu的数量

#ifdef CONFIG_SCHED_INFO
	struct sched_info sched_info; //调度信息
#endif

/* scheduler bits, serialized by scheduler locks */
unsigned sched_reset_on_fork:1;
unsigned sched_contributes_to_load:1;
unsigned sched_migrated:1;
unsigned :0; /* force alignment to the next boundary */

进程地址空间

struct mm_struct *mm, *active_mm;

成员	介绍	备注
mm	用户空间描述符	内核进程 mm为空
active_mm	使用的内存描述符	普通进程 mm==active_mm

进程描述符mm_struct核心分析（

struct mm_struct { 
	struct vm_area_struct *mmap;		   /* list of VMAs 线性区对象的链表头*/
	struct rb_root mm_rb;				   /* 线性区对象的红黑树 */
	u32 vmacache_seqnum;                   /* per-thread vmacache 最近使用的内存区域 */

/*用来在进程地址空间中搜索有效的进程地址空间的函数*/
#ifdef CONFIG_MMU
	unsigned long (*get_unmapped_area) (struct file *filp,
				unsigned long addr, unsigned long len,
				unsigned long pgoff, unsigned long flags);
#endif
    
    //mmap 
	unsigned long mmap_base;		       /* base of mmap area 内存映射区的基地址*/
	unsigned long mmap_legacy_base;        /* base of mmap area in bottom-up allocations */
	unsigned long task_size;		       /* size of task vm space */
	unsigned long highest_vm_end;		   /* highest vma end address */
	
    // 页表
    pgd_t * pgd;                
    
	atomic_t mm_users;			          /* How many users with user space? 共享进程个数*/
	atomic_t mm_count;			          /* How many references to "struct mm_struct" (users count as 1) 内存描述符使用计数*/
	atomic_long_t nr_ptes;			      /* PTE page table pages PTE页表页 */
	
	int map_count;				          /* number of VMAs 线性区的个数*/
	
    // 锁  保护任务页表和引用计数
	spinlock_t page_table_lock;		      /* Protects page tables and some counters */
	struct rw_semaphore mmap_sem;

	struct list_head mmlist;		     /* 所有mm_struct形成的链表*/
...
	unsigned long total_vm;				 /*Total pages mapped 全部页面数目*/
	unsigned long locked_vm;	         /* Pages that have PG_mlocked set 上锁的页面数目 */
	unsigned long pinned_vm;	         /* Refcount permanently increased */
	unsigned long shared_vm;	         /* Shared pages (files) 共享文件内存映射的页数*/
	unsigned long exec_vm;		         /* VM_EXEC & ~VM_WRITE 可执行内存映射中的页数*/
	unsigned long stack_vm;		         /* VM_GROWSUP/DOWN  用户态堆栈的页数*/
	unsigned long def_flags;
	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;      /*命令行  环境变量的首尾地址*/

	unsigned long saved_auxv[AT_VECTOR_SIZE];                  /* for /proc/PID/auxv */
...
	/* Architecture-specific MM context */
	mm_context_t context;                                      /*体系结构特殊数据*/

	unsigned long flags;                                      /* Must use atomic bitops to access the bits 状态标志 */

	struct core_state *core_state;                            /* 核心转储支持 */
... 
	struct user_namespace *user_ns;                           /* 命名空间*/
...
};

mm_struct图解

进程亲属关系

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 */

成员	含义
real_parent	指向真正父进程（调fork的那个，亲爹）
parent	指向父进程（干爹）
children	子进程列表
sibling	连接到父进程的子进程的链表
group_leader	线程组组长

时间与定时器

1. 时间

cputime_t utime, stime, utimescaled, stimescaled;
cputime_t gtime;

unsigned long nvcsw, nivcsw; /* context switch counts */
u64 start_time;		/* monotonic time in nsec */
u64 real_start_time;	/* boot based time in nsec */

struct task_cputime cputime_expires;

成员	含义
utime/stime	用户态/进程态所经过的时间定时器
utimescaled/stimescaled	用户态/进程态所经过的时间
gtime	虚拟机的运行时间
nvcsw/nivcsw	自愿/非自愿上下文切换计数
start_time/real_start_time	进程创建时间 real_start_time 包含了睡眠时间
cputime_expires	统计进程或进程组被跟踪的处理器时间

2. 定时器

struct list_head cpu_timers[3];

定时器分类

名字	分类	含义
ITIMER_REAL	实时定时器	实时更新，不在乎进程是否运行
ITIMER_VIRTUAL	虚拟定时器	只在进程运行用户态时更新
ITIMER_PROF	概况定时器	进程运行于用户态和系统态进行更新

信号处理

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

sigset_t blocked, real_blocked;  //表示被阻塞信号的掩码
struct sigpending pending;       //存放私有挂起信号的数据结构

unsigned long sas_ss_sp;         //信号处理程序备用堆栈的地址
size_t sas_ss_size;

文件系统

struct fs_struct *fs;       //文件系统

struct files_struct *files;//文件

Ptrace

ptrace 是linux系统内核中的一种机制，它提供了一种使父进程得以监视和控制其它进程的方式。它还能够改变子进程中的寄存器和内核映像，因而可以实现断点调试和系统调用的跟踪。

1. ptrace 标志

unsigned int ptrace;

为0的时候表示不需要追踪，其它可选值在ptrace.h中定义

#define PT_PTRACED  0x00000001  
#define PT_DTRACE   0x00000002  /* delayed trace (used on m68k, i386) */  
#define PT_TRACESYSGOOD 0x00000004  
#define PT_PTRACE_CAP   0x00000008  /* ptracer can follow suid-exec */  
#define PT_TRACE_FORK   0x00000010  
#define PT_TRACE_VFORK  0x00000020  
#define PT_TRACE_CLONE  0x00000040  
#define PT_TRACE_EXEC   0x00000080  
#define PT_TRACE_VFORK_DONE 0x00000100  
#define PT_TRACE_EXIT   0x00000200  

2.ptrace 任务列表

/*
* ptraced is the list of tasks this task is using ptrace on.
* This includes both natural children and PTRACE_ATTACH targets.
* p->ptrace_entry is p's link on the p->parent->ptraced list.
 */
struct list_head ptraced;
struct list_head ptrace_entry;

3.其它

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

其它信息

1. 进程描述符被使用计数

atomic_t usage;  //描述进程描述符被使用的计数

2. 进程链表

struct list_head tasks;  

3. 自旋锁

spinlock_t alloc_lock; 

4. PID hansh表和链表

struct pid_link pids[PIDTYPE_MAX];  
struct list_head thread_group; //线程组中所有进程的链表

5. do_fork函数

struct completion *vfork_done;      /* for vfork() */  
int __user *set_child_tid;          /* CLONE_CHILD_SETTID */  
int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */  

6. 缺页统计

unsigned long min_flt, maj_flt;

7. 命名空间

struct nsproxy *nsproxy;  

8.JFS文件系统

 void *journal_info;  

9.块设备

struct bio_list *bio_list; 

部分可选编译选项

1. SMP 多处理器

#ifdef CONFIG_SMP
	struct llist_node wake_entry;
	int on_cpu;
	unsigned int wakee_flips;
	unsigned long wakee_flip_decay_ts;
	struct task_struct *last_wakee;

	int wake_cpu;
#endif

#ifdef CONFIG_SMP
	struct plist_node pushable_tasks;
	struct rb_node pushable_dl_tasks;
#endif

2. Cgroup

让CPU调度程序可以在不同的cgroup之间分配CPU的带宽

#ifdef CONFIG_CGROUP_SCHED
	struct task_group *sched_task_group;
#endif

3. Cgroup资源管理器

为cgroup添加内存资源控制器,包含匿名内存和页面缓存

#ifdef CONFIG_MEMCG
	unsigned memcg_may_oom:1;
#endif

附源码

直接上源码（特别长）：

struct task_struct {
	volatile long state;	/* -1 unrunnable, 0 runnable, >0 stopped */
	void *stack;
	atomic_t usage;
	unsigned int flags;	/* per process flags, defined below */
	unsigned int ptrace;

#ifdef CONFIG_SMP
	struct llist_node wake_entry;
	int on_cpu;
	unsigned int wakee_flips;
	unsigned long wakee_flip_decay_ts;
	struct task_struct *last_wakee;

	int wake_cpu;
#endif
	int on_rq;

	int prio, static_prio, normal_prio;
	unsigned int rt_priority;
	const struct sched_class *sched_class;
	struct sched_entity se;
	struct sched_rt_entity rt;
#ifdef CONFIG_CGROUP_SCHED
	struct task_group *sched_task_group;
#endif
	struct sched_dl_entity dl;

#ifdef CONFIG_PREEMPT_NOTIFIERS
	/* list of struct preempt_notifier: */
	struct hlist_head preempt_notifiers;
#endif

#ifdef CONFIG_BLK_DEV_IO_TRACE
	unsigned int btrace_seq;
#endif

	unsigned int policy;
	int nr_cpus_allowed;
	cpumask_t cpus_allowed;

#ifdef CONFIG_PREEMPT_RCU
	int rcu_read_lock_nesting;
	union rcu_special rcu_read_unlock_special;
	struct list_head rcu_node_entry;
	struct rcu_node *rcu_blocked_node;
#endif /* #ifdef CONFIG_PREEMPT_RCU */
#ifdef CONFIG_TASKS_RCU
	unsigned long rcu_tasks_nvcsw;
	bool rcu_tasks_holdout;
	struct list_head rcu_tasks_holdout_list;
	int rcu_tasks_idle_cpu;
#endif /* #ifdef CONFIG_TASKS_RCU */

#ifdef CONFIG_SCHED_INFO
	struct sched_info sched_info;
#endif

	struct list_head tasks;
#ifdef CONFIG_SMP
	struct plist_node pushable_tasks;
	struct rb_node pushable_dl_tasks;
#endif

	struct mm_struct *mm, *active_mm;
	/* per-thread vma caching */
	u32 vmacache_seqnum;
	struct vm_area_struct *vmacache[VMACACHE_SIZE];
#if defined(SPLIT_RSS_COUNTING)
	struct task_rss_stat	rss_stat;
#endif
/* task state */
	int exit_state;
	int exit_code, exit_signal;
	int pdeath_signal;  /*  The signal sent when the parent dies  */
	unsigned long jobctl;	/* JOBCTL_*, siglock protected */

	/* Used for emulating ABI behavior of previous Linux versions */
	unsigned int personality;

	/* scheduler bits, serialized by scheduler locks */
	unsigned sched_reset_on_fork:1;
	unsigned sched_contributes_to_load:1;
	unsigned sched_migrated:1;
	unsigned :0; /* force alignment to the next boundary */

	/* unserialized, strictly 'current' */
	unsigned in_execve:1; /* bit to tell LSMs we're in execve */
	unsigned in_iowait:1;
#ifdef CONFIG_MEMCG
	unsigned memcg_may_oom:1;
#endif
#ifdef CONFIG_MEMCG_KMEM
	unsigned memcg_kmem_skip_account:1;
#endif
#ifdef CONFIG_COMPAT_BRK
	unsigned brk_randomized:1;
#endif

	unsigned long atomic_flags; /* Flags needing atomic access. */

	struct restart_block restart_block;

	pid_t pid;
	pid_t tgid;

#ifdef CONFIG_CC_STACKPROTECTOR
	/* Canary value for the -fstack-protector gcc feature */
	unsigned long stack_canary;
#endif
	/*
	 * pointers to (original) parent process, youngest child, younger sibling,
	 * older sibling, respectively.  (p->father can be replaced with
	 * p->real_parent->pid)
	 */
	struct task_struct __rcu *real_parent; /* real parent process */
	struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
	/*
	 * children/sibling forms the list of my natural children
	 */
	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 */

	/*
	 * ptraced is the list of tasks this task is using ptrace on.
	 * This includes both natural children and PTRACE_ATTACH targets.
	 * p->ptrace_entry is p's link on the p->parent->ptraced list.
	 */
	struct list_head ptraced;
	struct list_head ptrace_entry;

	/* PID/PID hash table linkage. */
	struct pid_link pids[PIDTYPE_MAX];
	struct list_head thread_group;
	struct list_head thread_node;

	struct completion *vfork_done;		/* for vfork() */
	int __user *set_child_tid;		/* CLONE_CHILD_SETTID */
	int __user *clear_child_tid;		/* CLONE_CHILD_CLEARTID */

	cputime_t utime, stime, utimescaled, stimescaled;
	cputime_t gtime;
	struct prev_cputime prev_cputime;
#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
	seqlock_t vtime_seqlock;
	unsigned long long vtime_snap;
	enum {
		VTIME_SLEEPING = 0,
		VTIME_USER,
		VTIME_SYS,
	} vtime_snap_whence;
#endif
	unsigned long nvcsw, nivcsw; /* context switch counts */
	u64 start_time;		/* monotonic time in nsec */
	u64 real_start_time;	/* boot based time in nsec */
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
	unsigned long min_flt, maj_flt;

	struct task_cputime cputime_expires;
	struct list_head cpu_timers[3];

/* process credentials */
	const struct cred __rcu *ptracer_cred; /* Tracer's credentials at attach */
	const struct cred __rcu *real_cred; /* objective and real subjective task
					 * credentials (COW) */
	const struct cred __rcu *cred;	/* effective (overridable) subjective task
					 * credentials (COW) */
	char comm[TASK_COMM_LEN]; /* executable name excluding path
				     - access with [gs]et_task_comm (which lock
				       it with task_lock())
				     - initialized normally by setup_new_exec */
/* file system info */
	struct nameidata *nameidata;
#ifdef CONFIG_SYSVIPC
/* ipc stuff */
	struct sysv_sem sysvsem;
	struct sysv_shm sysvshm;
#endif
#ifdef CONFIG_DETECT_HUNG_TASK
/* hung task detection */
	unsigned long last_switch_count;
#endif
/* filesystem information */
	struct fs_struct *fs;
/* open file information */
	struct files_struct *files;
/* namespaces */
	struct nsproxy *nsproxy;
/* signal handlers */
	struct signal_struct *signal;
	struct sighand_struct *sighand;

	sigset_t blocked, real_blocked;
	sigset_t saved_sigmask;	/* restored if set_restore_sigmask() was used */
	struct sigpending pending;

	unsigned long sas_ss_sp;
	size_t sas_ss_size;

	struct callback_head *task_works;

	struct audit_context *audit_context;
#ifdef CONFIG_AUDITSYSCALL
	kuid_t loginuid;
	unsigned int sessionid;
#endif
	struct seccomp seccomp;

/* Thread group tracking */
   	u32 parent_exec_id;
   	u32 self_exec_id;
/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
 * mempolicy */
	spinlock_t alloc_lock;

	/* Protection of the PI data structures: */
	raw_spinlock_t pi_lock;

	struct wake_q_node wake_q;

#ifdef CONFIG_RT_MUTEXES
	/* PI waiters blocked on a rt_mutex held by this task */
	struct rb_root pi_waiters;
	struct rb_node *pi_waiters_leftmost;
	/* Deadlock detection and priority inheritance handling */
	struct rt_mutex_waiter *pi_blocked_on;
#endif

#ifdef CONFIG_DEBUG_MUTEXES
	/* mutex deadlock detection */
	struct mutex_waiter *blocked_on;
#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
#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

/* journalling filesystem info */
	void *journal_info;

/* stacked block device info */
	struct bio_list *bio_list;

#ifdef CONFIG_BLOCK
/* stack plugging */
	struct blk_plug *plug;
#endif

/* VM state */
	struct reclaim_state *reclaim_state;

	struct backing_dev_info *backing_dev_info;

	struct io_context *io_context;

	unsigned long ptrace_message;
	siginfo_t *last_siginfo; /* For ptrace use.  */
	struct task_io_accounting ioac;
#if defined(CONFIG_TASK_XACCT)
	u64 acct_rss_mem1;	/* accumulated rss usage */
	u64 acct_vm_mem1;	/* accumulated virtual memory usage */
	cputime_t acct_timexpd;	/* stime + utime since last update */
#endif
#ifdef CONFIG_CPUSETS
	nodemask_t mems_allowed;	/* Protected by alloc_lock */
	seqcount_t mems_allowed_seq;	/* Seqence no to catch updates */
	int cpuset_mem_spread_rotor;
	int cpuset_slab_spread_rotor;
#endif
#ifdef CONFIG_CGROUPS
	/* Control Group info protected by css_set_lock */
	struct css_set __rcu *cgroups;
	/* cg_list protected by css_set_lock and tsk->alloc_lock */
	struct list_head cg_list;
#endif
#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
#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
#ifdef CONFIG_DEBUG_PREEMPT
	unsigned long preempt_disable_ip;
#endif
#ifdef CONFIG_NUMA
	struct mempolicy *mempolicy;	/* Protected by alloc_lock */
	short il_next;
	short pref_node_fork;
#endif
#ifdef CONFIG_NUMA_BALANCING
	int numa_scan_seq;
	unsigned int numa_scan_period;
	unsigned int numa_scan_period_max;
	int numa_preferred_nid;
	unsigned long numa_migrate_retry;
	u64 node_stamp;			/* migration stamp  */
	u64 last_task_numa_placement;
	u64 last_sum_exec_runtime;
	struct callback_head numa_work;

	struct list_head numa_entry;
	struct numa_group *numa_group;

	/*
	 * numa_faults is an array split into four regions:
	 * faults_memory, faults_cpu, faults_memory_buffer, faults_cpu_buffer
	 * in this precise order.
	 *
	 * faults_memory: Exponential decaying average of faults on a per-node
	 * basis. Scheduling placement decisions are made based on these
	 * counts. The values remain static for the duration of a PTE scan.
	 * faults_cpu: Track the nodes the process was running on when a NUMA
	 * hinting fault was incurred.
	 * faults_memory_buffer and faults_cpu_buffer: Record faults per node
	 * during the current scan window. When the scan completes, the counts
	 * in faults_memory and faults_cpu decay and these values are copied.
	 */
	unsigned long *numa_faults;
	unsigned long total_numa_faults;

	/*
	 * numa_faults_locality tracks if faults recorded during the last
	 * scan window were remote/local or failed to migrate. The task scan
	 * period is adapted based on the locality of the faults with different
	 * weights depending on whether they were shared or private faults
	 */
	unsigned long numa_faults_locality[3];

	unsigned long numa_pages_migrated;
#endif /* CONFIG_NUMA_BALANCING */

#ifdef CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH
	struct tlbflush_unmap_batch tlb_ubc;
#endif

	struct rcu_head rcu;

	/*
	 * cache last used pipe for splice
	 */
	struct pipe_inode_info *splice_pipe;

	struct page_frag task_frag;

#ifdef	CONFIG_TASK_DELAY_ACCT
	struct task_delay_info *delays;
#endif
#ifdef CONFIG_FAULT_INJECTION
	int make_it_fail;
#endif
	/*
	 * when (nr_dirtied >= nr_dirtied_pause), it's time to call
	 * balance_dirty_pages() for some dirty throttling pause
	 */
	int nr_dirtied;
	int nr_dirtied_pause;
	unsigned long dirty_paused_when; /* start of a write-and-pause period */

#ifdef CONFIG_LATENCYTOP
	int latency_record_count;
	struct latency_record latency_record[LT_SAVECOUNT];
#endif
	/*
	 * time slack values; these are used to round up poll() and
	 * select() etc timeout values. These are in nanoseconds.
	 */
	unsigned long timer_slack_ns;
	unsigned long default_timer_slack_ns;

#ifdef CONFIG_KASAN
	unsigned int kasan_depth;
#endif
#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 and counter of trace recursion */
	unsigned long trace_recursion;
#endif /* CONFIG_TRACING */
#ifdef CONFIG_MEMCG
	struct mem_cgroup *memcg_in_oom;
	gfp_t memcg_oom_gfp_mask;
	int memcg_oom_order;

	/* number of pages to reclaim on returning to userland */
	unsigned int memcg_nr_pages_over_high;
#endif
#ifdef CONFIG_UPROBES
	struct uprobe_task *utask;
#endif
#if defined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)
	unsigned int	sequential_io;
	unsigned int	sequential_io_avg;
#endif
#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
	unsigned long	task_state_change;
#endif
	int pagefault_disabled;
/* CPU-specific state of this task */
	struct thread_struct thread;
/*
 * WARNING: on x86, 'thread_struct' contains a variable-sized
 * structure.  It *MUST* be at the end of 'task_struct'.
 *
 * Do not put anything below here!
 */
};

标签：task,struct,int,unsigned,long,源码,配图,CONFIG,define
来源： https://blog.csdn.net/weixin_38371073/article/details/114376410