task_struct结构体成员详解

系统管理员 2022-07-13 12:36 206阅读 0赞

## 1：引言 ##

进程就是程序动态运行的实例，它是承担分配系统资源的实体。我们也可以把进程当成是由一组元素组成的实体，进程的两个基本的元素时程序代码和与代码相关联的**数据集合**。在进程执行时，都可以被表征为一下元素：

>  *  **标识符**：与进程相关的唯一标识符，用来区别正在执行的进程和其他进程。
>  *  **状态**：描述进程的状态，因为进程有挂起，阻塞，运行等好几个状态，所以都有个标识符来记录进程的执行状态。
>  *  **优先级**：如果有好几个进程正在执行，就涉及到进程被执行的先后顺序的问题，这和进程优先级这个标识符有关。
>  *  **程序计数器**：程序中即将被执行的下一条指令的地址。
>  *  **内存指针**：程序代码和进程相关数据的指针。
>  *  **上下文数据**：进程执行时处理器的寄存器中的数据。
>  *  **I/O状态信息**：包括显示的I/O请求，分配给进程的I/O设备和被进程使用的文件列表等。
>  *  **记账信息**：包括处理器的时间总和，记账号等等。

上面的内容可以参考《操作系统精髓与设计原理》。

操作系统对进程的控制就是通过对上面的这些元素的控制来控制操作系统的，但这些信息都不是单独存放的，而是存放在一个叫做**PCB(进程控制块)数据结构中**，这个数据结构是一种结构体，由操作系统创建和管理，下面我们就通过了解一下task\_struct来看一看操作系统是怎么通过进程控制块来对进程进行控制和调度的吧。

## 2：task\_struct源码成员解析 ##

首先我们直接附上task\_struct所定义在的头文件**sched.h**的链接吧：  
[http://lxr.free-electrons.com/source/include/linux/sched.h][http_lxr.free-electrons.com_source_include_linux_sched.h]

关于task\_struct的实现大家可以参考源码！  
下面我们就来介绍一下tast\_struct中复杂的成员吧：

### 进程状态 ###

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

上面这个变量就是描述进程状态的成员，结合C语言我们学到的知识volatile关键字是降低编译器对代码的优化，是state变量一直从变量的内存中读取内容而不是寄存器；从而保证对操作系统状态实时访问的稳定性。

**state成员的可能取值如下**

/*
      * Task state bitmask. NOTE! These bits are also
      * encoded in fs/proc/array.c: get_task_state().
      *
      * We have two separate sets of flags: task->state
      * is about runnability, while task->exit_state are
      * about the task exiting. Confusing, but this way
      * modifying one set can't modify the other one by
      * mistake.
      */
     #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)

我们可以看到变量定义后面的注释，它说明变量内容<0是不运行的，=0是运行状态，>0是停止状态。  
下面我们介绍几个常用的取值：

<table> 
 <thead> 
  <tr> 
   <th>状态</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>TASK_RUNNING</td> 
   <td align="left">表示进程正在执行或者处于准备执行的状态</td> 
  </tr> 
  <tr> 
   <td>TASK_INTERRUPTIBLE</td> 
   <td align="left">进程因为等待某些条件处于阻塞（挂起的状态），一旦等待的条件成立，进程便会从该状态转化成就绪状态</td> 
  </tr> 
  <tr> 
   <td>TASK_UNINTERRUPTIBLE</td> 
   <td align="left">意思与TASK_INTERRUPTIBLE类似，但是我们传递任意信号等不能唤醒他们，只有它所等待的资源可用的时候，他才会被唤醒。</td> 
  </tr> 
  <tr> 
   <td>TASK_STOPPED</td> 
   <td align="left">进程被停止执行</td> 
  </tr> 
  <tr> 
   <td>TASK_TRACED</td> 
   <td align="left">进程被debugger等进程所监视。</td> 
  </tr> 
  <tr> 
   <td>EXIT_ZOMBIE</td> 
   <td align="left">进程的执行被终止，但是其父进程还没有使用wait()等系统调用来获知它的终止信息，此时进程成为僵尸进程</td> 
  </tr> 
  <tr> 
   <td>EXIT_DEAD</td> 
   <td align="left">进程被杀死，即进程的最终状态。</td> 
  </tr> 
  <tr> 
   <td>TASK_KILLABLE</td> 
   <td align="left">当进程处于这种可以终止的新睡眠状态中，它的运行原理类似于 TASK_UNINTERRUPTIBLE，只不过可以响应致命信号</td> 
  </tr> 
 </tbody> 
</table>

### 进程标识符 ###

pid_t pid;     //进程的标识符
    pid_t tgid;    //线程组标识符

进程标识符就不用解释了，它的引入是为了区别每个进程；tgid的引入是由于Unix程序员希望同一组线程具有相同的pid所以就引入了tgid.

### 进程标记符 ###

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

flags反应进程的状态信息，用于内核识别当前进程的状态。

**它的取值范围如下**：

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

我们还是介绍常用的状态吧：

<table> 
 <thead> 
  <tr> 
   <th>状态</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PF_FORKNOEXEC</td> 
   <td align="left">表示进程刚被创建，但还没有执行</td> 
  </tr> 
  <tr> 
   <td>PF_SUPERPRIV</td> 
   <td align="left">表示进程拥有超级用户特权</td> 
  </tr> 
  <tr> 
   <td>PF_SIGNALED</td> 
   <td align="left">表示进程被信号杀出</td> 
  </tr> 
  <tr> 
   <td>PF_EXITING</td> 
   <td align="left">表示进程开始关闭</td> 
  </tr> 
 </tbody> 
</table>

### 表示进程亲属关系的成员 ###

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

<table> 
 <thead> 
  <tr> 
   <th>成员</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>real_parent</td> 
   <td align="left">指向当前操作系统执行进程的父进程，如果父进程不存在，指向pid为1的init进程</td> 
  </tr> 
  <tr> 
   <td>paren</td> 
   <td align="left">指向当前进程的父进程，当当前进程终止时，需要向它发送wait4()的信号</td> 
  </tr> 
  <tr> 
   <td>children</td> 
   <td align="left">位于链表的头部，链表的所有元素都是children的子进程</td> 
  </tr> 
  <tr> 
   <td>group_leader</td> 
   <td align="left">指向进程组的领头进程</td> 
  </tr> 
 </tbody> 
</table>

### ptrace系统调用 ###

Ptrace提供了一种父进程，它可以被用来控制子进程的运行，常被用来进行断点调试，当它被设置为0时表示不需要追踪。

/*
     * Ptrace flags
     *
     * The owner ship rules for task->ptrace which holds the ptrace
     * flags is simple.  When a task is running it owns it's task->ptrace
     * flags.  When the a task is stopped the ptracer owns task->ptrace.
     */
    
    #define PT_SEIZED       0x00010000      /* SEIZE used, enable new behavior */
    #define PT_PTRACED      0x00000001
    #define PT_DTRACE       0x00000002      /* delayed trace (used on m68k, i386) */
    #define PT_PTRACE_CAP   0x00000004      /* ptracer can follow suid-exec */
    
    #define PT_OPT_FLAG_SHIFT       3
    /* PT_TRACE_* event enable flags */
    #define PT_EVENT_FLAG(event)    (1 << (PT_OPT_FLAG_SHIFT + (event)))
    #define PT_TRACESYSGOOD         PT_EVENT_FLAG(0)
    #define PT_TRACE_FORK           PT_EVENT_FLAG(PTRACE_EVENT_FORK)
    #define PT_TRACE_VFORK          PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
    #define PT_TRACE_CLONE          PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
    #define PT_TRACE_EXEC           PT_EVENT_FLAG(PTRACE_EVENT_EXEC)
    #define PT_TRACE_VFORK_DONE     PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
    #define PT_TRACE_EXIT           PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
    #define PT_TRACE_SECCOMP        PT_EVENT_FLAG(PTRACE_EVENT_SECCOMP)
    
    #define PT_EXITKILL             (PTRACE_O_EXITKILL << PT_OPT_FLAG_SHIFT)
    #define PT_SUSPEND_SECCOMP      (PTRACE_O_SUSPEND_SECCOMP << PT_OPT_FLAG_SHIFT)
    
    /* single stepping state bits (used on ARM and PA-RISC) */
    #define PT_SINGLESTEP_BIT       31
    #define PT_SINGLESTEP           (1<<PT_SINGLESTEP_BIT)
    #define PT_BLOCKSTEP_BIT        30
    #define PT_BLOCKSTEP            (1<<PT_BLOCKSTEP_BIT)

### 进程调度 ###

**优先级**

int prio, static_prio, normal_prio;
    unsigned int rt_priority;

<table> 
 <thead> 
  <tr> 
   <th>成员</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static_prio</td> 
   <td align="left">用来保存静态优先级，可以调用nice系统直接来修改取值范围为100~139</td> 
  </tr> 
  <tr> 
   <td>rt_priority</td> 
   <td align="left">用来保存实时优先级,取值范围为0~99</td> 
  </tr> 
  <tr> 
   <td>prio</td> 
   <td align="left">用来保存动态优先级</td> 
  </tr> 
  <tr> 
   <td>normal_prio</td> 
   <td align="left">它的值取决于静态优先级和调度策略</td> 
  </tr> 
 </tbody> 
</table>

**实时优先级和静态优先级的取值范围中，值越大，优先级越低**

## 进程地址空间 ##

进程都拥有自己的资源，这些资源指的就是进程的地址空间，每个进程都有着自己的地址空间，在task\_struct中，有关进程地址空间的定义如下：

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
    
    /*  http://lxr.free-electrons.com/source/include/linux/sched.h?V=4.5#L1484  */
    #ifdef CONFIG_COMPAT_BRK
    unsigned brk_randomized:1;
    #endif

<table> 
 <thead> 
  <tr> 
   <th>成员</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>mm</td> 
   <td align="left">进程所拥有的内存空间描述符，对于内核线程的mm为NULL</td> 
  </tr> 
  <tr> 
   <td>active_mm</td> 
   <td align="left">指进程运行时所使用的进程描述符</td> 
  </tr> 
  <tr> 
   <td>rss_stat</td> 
   <td align="left">被用来记录缓冲信息</td> 
  </tr> 
 </tbody> 
</table>

**如果当前内核线程被调度之前运行的也是另外一个内核线程时候，那么其mm和avtive\_mm都是NULL**

总结：有关进程控制块task\_struct大家暂时可以先了解这么多，在后期我会继续更新有关进程控制块方面的内容，总之，操作系统对进程的调度依赖于进程控制块，操作系统在创建进程时也会自动创建进程控制块，进程切换，进程的创建和终止，都和进程控制块有关~

[http_lxr.free-electrons.com_source_include_linux_sched.h]: http://lxr.free-electrons.com/source/include/linux/sched.h%20%E2%80%9C%E2%80%9Dinclude/linux/sched.h%E2%80%9C%E2%80%9D