浅析Linux下的task_struct结构体

最新推荐文章于 2024-05-08 23:08:00 发布

带着耳机去梦游

最新推荐文章于 2024-05-08 23:08:00 发布

阅读量816

点赞数

分类专栏： linux kernel 进程管理文章标签： linux

本文链接：https://blog.csdn.net/qq_37635373/article/details/122896052

版权

linux kernel 同时被 2 个专栏收录

7 篇文章 1 订阅

订阅专栏

进程管理

1 篇文章 0 订阅

订阅专栏

参考：
https://www.jianshu.com/p/691d02380312
https://blog.csdn.net/npy_lp/article/details/7292563
https://blog.csdn.net/gatieme/article/details/51383272

1.首先什么是进程？

1.1进程可以这样描述：

进程是程序的一个执行实例；
进程是正在执行的程序；
进程是能分配处理器并由处理器执行的实体。
按内核观点来谈进程：它担当分配系统资源（CPU时间，内存）的实体。

1.2进程的两个基本元素

一是程序代码（可能被执行相同程序的其他进程共享），二是和代码相关联的数据集。这里的“和代码相关联的数据集指的是数据段和进程控制块”。进程是一种动态描述，但是并不代表所有的进程都在运行。(进程在内存中因策略或调度需求，会处于各种状态)。

1.3这里再明确以下几点：

（1）操作系统执行程序的过程：
在这里插入图片描述
（2）进程是动态运行的实例，但是并不是所有的进程都在运行，这前后两句话并不矛盾，因为程序被加载到内存中后，它的执行由进程的状态以及调度算法等来决定进程的运行

2.进程的描述

上面我们已经提到过PCB，那么PCB到底是用来干什么的呢？

学了操作系统后，我们都知道操作系统要想管理一个对象，它不是直接进行管理的，而是通过得到被管理者的一些有效信息加以管理的，因此在这里我们也可以这样理解，操作系统管理进程，实则是将进程的有效信息提取出来然后通过管理这些信息来管理进程，而所有的进程信息被存放在一个叫做 进程控制块 的数据结构中(可以理解为进程属性的集合)，这也就是即将要介绍的进程控制块(PCB).

每个进程在内核中都有一个进程控制块(PCB)来维护进程相关的信息,Linux内核的进程控制块是task_struct结构体.

task_struct 是Linux内核的一种数据结构，它会被装载到RAM中并且包含着进程的信息。每个进程都把它的信息放在 task_struct 这个数据结构体包含了这些内容：

标示符：描述本进程的唯一标识符，用来区别其他进程。
状态：任务状态，退出代码，退出信号等。
优先级：相对于其他进程的优先级。
程序计数器：程序中即将被执行的下一条指令的地址。
内存指针：包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针。
上下文数据：进程执行时处理器的寄存器中的数据。
I/O状态信息：包括显示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表。
记账信息：可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。

有关进程信息还有以下三点需要了解：

保存进程信息的数据结构叫做 task_struct，可以在 include/linux/sched.h 中找到它；
所有运行在系统中的进程都以 task_struct 链表的形式存在内核中；
进程的信息可以通过 /proc 系统文件夹查看。要获取 PID 为400的进程信息，你需要查看 /proc/400 这个文件夹。大多数进程信息同样可以使用 top 和 ps 这些用户级工具来获取,例如：

3.剖析task_struct结构体

3.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_ZOMBIE     16 //僵尸状态的进程，表示进程被终止，但是父进程还没有获取它的终止信息，比如进程有没有执行完等信息。                     
#define EXIT_DEAD       32 //进程的最终状态，进程死亡
/* in tsk->state again */ 
#define TASK_DEAD       64 //死亡
#define TASK_WAKEKILL       128 //唤醒并杀死的进程
#define TASK_WAKING     256 //唤醒进程

进程状态的切换过程和原因大致如下图（图片来自《Linux Kernel Development》）：
在这里插入图片描述

五个互斥状态

state域能够取5个互为排斥的值（通俗一点就是这五个值任意两个不能一起使用，只能单独使用）。系统中的每个进程都必然处于以上所列进程状态中的一种。

状态	描述
TASK_RUNNING	表示进程要么正在执行，要么正要准备执行（已经就绪），正在等待cpu时间片的调度
TASK_INTERRUPTIBLE	进程因为等待一些条件而被挂起（阻塞）而所处的状态。这些条件主要包括：硬中断、资源、一些信号……，一旦等待的条件成立，进程就会从该状态（阻塞）迅速转化成为就绪状态TASK_RUNNING
TASK_UNINTERRUPTIBLE	意义与TASK_INTERRUPTIBLE类似，除了不能通过接受一个信号来唤醒以外，对于处于TASK_UNINTERRUPIBLE状态的进程，哪怕我们传递一个信号或者有一个外部中断都不能唤醒他们。只有它所等待的资源可用的时候，他才会被唤醒。这个标志很少用，但是并不代表没有任何用处，其实他的作用非常大，特别是对于驱动刺探相关的硬件过程很重要，这个刺探过程不能被一些其他的东西给中断，否则就会让进城进入不可预测的状态
TASK_STOPPED	进程被停止执行，当进程接收到SIGSTOP、SIGTTIN、SIGTSTP或者SIGTTOU信号之后就会进入该状态
TASK_TRACED	表示进程被debugger等进程监视，进程执行被调试程序所停止，当一个进程被另外的进程所监视，每一个信号都会让进城进入该状态

2个终止状态

/* task state */
int exit_state;
int exit_code, exit_signal;

状态	描述
EXIT_ZOMBIE	进程的执行被终止，但是其父进程还没有使用wait()等系统调用来获知它的终止信息，此时进程成为僵尸进程
EXIT_DEAD	进程的最终状态

新增睡眠状态

Linux 内核提供了两种方法将进程置为睡眠状态。

将进程置为睡眠状态的普通方法是将进程状态设置为 TASK_INTERRUPTIBLE 或 TASK_UNINTERRUPTIBLE 并调用调度程序的 schedule() 函数。这样会将进程从 CPU 运行队列中移除。
如果进程处于 可中断模式的睡眠状态（通过将其状态设置TASK_INTERRUPTIBLE），那么可以通过显式的唤醒呼叫（wakeup_process()）或需要处理的信号来唤醒它。
但是，如果进程处于 非可中断模式的睡眠状态（通过将其状态设置为 TASK_UNINTERRUPTIBLE），那么只能通过显式的唤醒呼叫将其唤醒。除非万不得已，否则我们建议您将进程置为可中断睡眠模式，而不是不可中断睡眠模式（比如说在设备 I/O 期间，处理信号非常困难时）。
当处于可中断睡眠模式的任务接收到信号时，它需要处理该信号（除非它已被屏弊），离开之前正在处理的任务（此处需要清除代码），并将 -EINTR 返回给用户空间。再一次，检查这些返回代码和采取适当操作的工作将由程序员完成。

因此，懒惰的程序员可能比较喜欢将进程置为不可中断模式的睡眠状态，因为信号不会唤醒这类任务。

但需要注意的一种情况是，对不可中断睡眠模式的进程的唤醒呼叫可能会由于某些原因不会发生，这会使进程无法被终止，从而最终引发问题，因为惟一的解决方法就是重启系统。一方面，您需要考虑一些细节，因为不这样做会在内核端和用户端引入 bug。另一方面，您可能会生成永远不会停止的进程（被阻塞且无法终止的进程）。

现在，我们在内核中实现了一种新的睡眠方法

状态	描述
TASK_KILLABLE	当进程处于这种可以终止的新睡眠状态中，它的运行原理类似于 TASK_UNINTERRUPTIBLE，只不过可以响应致命信号

换句话说，ASK_UNINTERRUPTIBLE + TASK_WAKEKILL = TASK_KILLABLE 。而TASK_WAKEKILL 用于在接收到致命信号时唤醒进程，新的睡眠状态允许 TASK_UNINTERRUPTIBLE 响应致命信号。

3.2 进程的唯一标识(pid)

pid_t pid;//进程的唯一标识
pid_t tgid;// 线程组的领头线程的pid成员的值

在Linux系统中，一个线程组中的所有线程使用和该线程组的领头线程（该组中的第一个轻量级进程）相同的PID，并被存放在tgid成员中。只有线程组的领头线程的pid成员才会被设置为与tgid相同的值 。注意，getpid()系统调用返回的是当前进程的tgid值而不是pid值。（线程是程序运行的最小单位，进程是程序运行的基本单位。）

3.3 进程内核栈

void *stack;

进程通过 alloc_thread_info 函数分配它的内核栈，通过 free_thread_info 函数释放所分配的内核栈。

/* linux-2.6.38.8/kernel/fork.c */ 
static inline struct thread_info *alloc_thread_info(struct task_struct *tsk)
{
	#ifdef CONFIG_DEBUG_STACK_USAGE
		gfp_t mask = GFP_KERNEL | __GFP_ZERO;
	#else
		gfp_t mask = GFP_KERNEL;
	#endif
		return (struct thread_info *)__get_free_pages(mask, THREAD_SIZE_ORDER);
}
static inline void free_thread_info(struct thread_info *ti)
{
	free_pages((unsigned long)ti, THREAD_SIZE_ORDER);
}

其中，THREAD_SIZE_ORDER宏在linux-2.6.38.8/arch/arm/include/asm/thread_info.h文件中被定义为1，也就是说alloc_thread_info函数通过调用 get_free_pages 函数分配2个页的内存（它的首地址是8192字节对齐的）。
Linux内核通过 thread_union 联合体来表示进程的内核栈，其中THREAD_SIZE宏的大小为8192。

union thread_union {
   struct thread_info thread_info;
   unsigned long stack[THREAD_SIZE/sizeof(long)];
};

当进程从用户态切换到内核态时，进程的内核栈总是空的，所以ARM的sp寄存器指向这个栈的顶端。因此，内核能够轻易地通过sp寄存器获得当前正在CPU上运行的进程。

/* linux-2.6.38.8/arch/arm/include/asm/current.h */
static inline struct task_struct *get_current(void)
{
	return current_thread_info()->task;
}
 
#define current (get_current())
 
/* linux-2.6.38.8/arch/arm/include/asm/thread_info.h */ 
static inline struct thread_info *current_thread_info(void)
{
	register unsigned long sp asm ("sp");
	return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));
}

进程内核栈与进程描述符的关系如下图：
在这里插入图片描述

3.4 进程的标记

unsigned int flags; //flags成员的可能取值如下

#define PF_ALIGNWARN    0x00000001    /* Print alignment warning msgs */
                    /* Not implemented yet, only for 486*/
#define PF_STARTING    0x00000002    /* being created */
#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_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_FLUSHER    0x00001000    /* responsible for disk writeback */
#define PF_USED_MATH    0x00002000    /* if unset the fpu must be initialized before use */
#define PF_FREEZING    0x00004000    /* freeze in progress. do not account to load */
#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_OOM_ORIGIN    0x00080000    /* Allocating much memory to others */
#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_SPREAD_PAGE    0x01000000    /* Spread page cache over cpuset */
#define PF_SPREAD_SLAB    0x02000000    /* Spread some slab caches over cpuset */
#define PF_THREAD_BOUND    0x04000000    /* Thread bound to specific cpu */
#define PF_MCE_EARLY    0x08000000      /* Early kill for mce process policy */
#define PF_MEMPOLICY    0x10000000    /* Non-default NUMA mempolicy */
#define PF_MUTEX_TESTER    0x20000000    /* Thread belongs to the rt mutex tester */
#define PF_FREEZER_SKIP    0x40000000    /* Freezer should not count it as freezeable */
#define PF_FREEZER_NOSIG 0x80000000    /* Freezer won't send signals to it */

3.5 进程之间的亲属关系

struct task_struct *real_parent; /* real parent process */
struct task_struct *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 指向其所在进程组的领头进程。

3.6 进程调度信息

 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;
 unsigned int policy;

实时优先级范围是0到MAX_RT_PRIO-1（即99），而普通进程的静态优先级范围是从MAX_RT_PRIO到MAX_PRIO-1（即100到139)。值越大静态优先级越低。

static_prio 用于保存静态优先级，可以通过nice系统调用来进行修改。
rt_priority 用于保存实时优先级。
normal_prio 的值取决于静态优先级和调度策略(进程的调度策略有：先来先服务，短作业优先、时间片轮转、高响应比优先等等的调度算法。
prio 用于保存动态优先级。
se和rt 都是调用实体，一个用于普通进程，一个用于实时进程，每个进程都有其中之一的实体。
cpus_allowed 用于控制进程可以在哪里处理器上运行。
policy 表示进程的调度策略，目前主要有以下五种：

#define SCHED_NORMAL        0//按照优先级进行调度（有些地方也说是CFS调度器）
#define SCHED_FIFO        1//先进先出的调度算法
#define SCHED_RR        2//时间片轮转的调度算法
#define SCHED_BATCH        3//用于非交互的处理机消耗型的进程
#define SCHED_IDLE        5//系统负载很低时的调度算法
#define SCHED_RESET_ON_FORK     0x40000000

SCHED_NORMAL 用于普通进程，通过CFS调度器实现;
SCHED_BATCH 用于非交互的处理器消耗型进程;
SCHED_IDLE 是在系统负载很低时使用;
SCHED_FIFO（先入先出调度算法）和 SCHED_RR（轮流调度算法）都是实时调度策略.

3.7 ptrace系统调用

unsigned int ptrace;  
struct list_head ptraced;  
struct list_head ptrace_entry;  
unsigned long ptrace_message;  
siginfo_t *last_siginfo;      /* For ptrace use.  */  
ifdef CONFIG_HAVE_HW_BREAKPOINT  
atomic_t ptrace_bp_refcnt;

成员ptrace被设置为0时表示不需要被跟踪，它的可能取值如下：

/* linux-2.6.38.8/include/linux/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

3.8 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

Performance Event是一款随 Linux 内核代码一同发布和维护的性能诊断工具。这些成员用于帮助PerformanceEvent分析进程的性能问题。

关于Performance Event工具的介绍可参考文章http://www.ibm.com/developerworks/cn/linux/l-cn-perf1/index.html?ca=drs-#major1和http://www.ibm.com/developerworks/cn/linux/l-cn-perf2/index.html?ca=drs-#major1。

3.9 时间数据成员

一个进程从创建到终止叫做该进程的生存期，进程在 其生存期内使用CPU时间，内核都需要进行记录，进程耗费的时间分为两部分，一部分是用户模式下耗费的时间，一部分是在系统模式下耗费的时间

cputime_t utime, stime, utimescaled, stimescaled;
cputime_t gtime;
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;

3.8 信号处理信息

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;//信号处理程序的堆栈的地址

3.9 文件系统信息

/* filesystem information */
struct fs_struct *fs;//文件系统的信息的指针
/* open file information */
struct files_struct *files;//打开文件的信息指针

带着耳机去梦游

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
浅析Linux下的task_struct结构体

参考：https://www.jianshu.com/p/691d02380312https://blog.csdn.net/npy_lp/article/details/7292563https://blog.csdn.net/gatieme/article/details/513832721.首先什么是进程？1.1进程可以这样描述：进程是程序的一个执行实例；进程是正在执行的程序；进程是能分配处理器并由处理器执行的实体。按内核观点来谈进程：它担当分配系统资源（CPU时间，内存）的实体。
复制链接

扫一扫