标签：task struct int unsigned long 源码 配图 CONFIG define

本文来自个人网站 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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。