进程管理之struct_task结构体的简述

1. 什么是进程？

概念：

进程是程序的一个执行实例；

在操作系统中运行的程序；

是操作系统资源管理的最小单位。

   内核的角度：

        进程担当分配资源（cpu时间、内存）的实体。

  注意：进程是一个动态的实体，是程序的一次执行过程

  进程和程序的区别：进程是动态的，程序是静态的，进程试运行中的程序，而程序是保存在硬盘上的可执行代码，删掉可执行程序并不影响原有的进程。

2．进程的描述

   进程的信息被放在一个叫做进程控制块（PCB）的数据结构中，也可以理解为进程属性的集合，进程控制块是进程存在的唯一标识，系统通过PCB的存在而感知进程的存在。

3.task_struct

1>.task_struct是PCB的一种（是Linux中描述进程的结构体）。

2>.task_struct会被装载到RAM(内存)里并且包含着进程的信息

4.task_struct的内容

  1>.标识符：描述本进程的唯一标识符（pid）,用来区别其它进程，同一个主机的多个进程的pid 不会相同

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

  3>.辅助操作系统进行进程调度的属性：

1. 优先级：性对于其它进程的优先级，优先级决定了进程被调度在cpu上执行的先后顺序
2. 上下文数据：进程执行时处理器的寄存器中的数据，保存了该进程上次在CPU上执行的现场
3. 程序计数器：保存程序将被执行的下一条指令的地址。
4. 记账信息：可能包括处理器时间总和、使用的时钟数总和、时间限制、记账号等，也就是说，决定进程什么时候需要占用CPU ,什么时候需要放弃CPU，具体的量化指标就是记账信息。
5. 状态：任务状态、退出代码、退出信号等。
6. I/O状态信息：包括显示的I/O请求、分配进程的I/O设备和被进程使用的文件列表。

5.task_struct结构体的代码（部分有注释）

struct task_struct {
    volatile long state;    //任务的运行状态（-1 不可运行，0 可运行(就绪)，>0 已停止）。
    void *stack;            //进程内核栈
    atomic_t usage;         //有几个进程正在使用该结构
    unsigned int flags;     //per process flags, defined below//反应进程状态的信息，但不是运行状态
    unsigned int ptrace;    //系统调用

    int lock_depth;     /* BKL lock depth */

#ifdef CONFIG_SMP
#ifdef __ARCH_WANT_UNLOCKED_CTXSW
    int oncpu;            //运行于哪个CPU上
#endif
#endif

    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_PREEMPT_NOTIFIERS  
//list of struct preempt_notifier: 
    struct hlist_head preempt_notifiers; //与抢占有关的  
#endif  

    /*
     * fpu_counter contains the number of consecutive context switches
     * that the FPU is used. If this is over a threshold, the lazy fpu
     * saving becomes unlazy to save the trap. This is an unsigned char
     * so that after 256 times the counter wraps and the behavior turns
     * lazy again; this to deal with bursty apps that only use FPU for
     * a short time
     */
    unsigned char fpu_counter;
#ifdef CONFIG_BLK_DEV_IO_TRACE
    unsigned int btrace_seq;
#endif

    unsigned int policy;          //调度策略
    cpumask_t cpus_allowed;       //多核体系结构中管理CPU的位图

#ifdef CONFIG_TREE_PREEMPT_RCU    //一种新型的锁机制
    int rcu_read_lock_nesting;
    char rcu_read_unlock_special;
    struct rcu_node *rcu_blocked_node;
    struct list_head rcu_node_entry;
#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */

#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
    struct sched_info sched_info;// //调度相关的信息，如在CPU上运行的时间/在队列中等待的时间等。
#endif

    struct list_head tasks;            //任务队列  
    struct plist_node pushable_tasks;

    struct mm_struct *mm, *active_mm;   //mm是进程的内存管理信息

/* task state */
    int exit_state;             //进程退出时的状态 
    int exit_code, exit_signal; //进程退出时发出的信号  
    int pdeath_signal;  /*  The signal sent when the parent dies  */
    /* ??? */
    unsigned int personality;   //由于Unix有许多不同的版本和变种，应用程序也有了适用范围。
    unsigned did_exec:1;        //根据POSIX程序设计的标准，did_exec是用来表示当前进程是在执行原来的代码还是在执行由execve调度的新的代码
    unsigned in_execve:1;   /* Tell the LSMs that the process is doing an
                 * execve */
    unsigned in_iowait:1;


    /* Revert to default priority/policy when forking */
    unsigned sched_reset_on_fork:1;

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

#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 *real_parent; /* real parent process */
    struct task_struct *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 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;// // utime是进程用户态耗费的时间，stime是系统态运行时间。                          
    cputime_t gtime;
    cputime_t prev_utime, prev_stime;
    unsigned long nvcsw, nivcsw; /* context switch counts */
    struct timespec start_time;         /* monotonic time */
    struct timespec real_start_time;    /* boot based time */
/* 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 */                    //请参考cred结构定义文件的注释说明  

const struct cred __rcu *real_cred; /* objective and real subjective task * credentials (COW) */  
        const struct cred __rcu *cred; /* effective (overridable) subjective task * credentials (COW) */  
        struct cred *replacement_session_keyring; /* for KEYCTL_SESSION_TO_PARENT */  
        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 */  
        int link_count, total_link_count;  //硬连接的数量  
        #ifdef CONFIG_SYSVIPC/* ipc stuff  //进程间通信相关的东西  
        struct sysv_sem sysvsem;   
        #endif  
        #ifdef CONFIG_DETECT_HUNG_TASK/* hung task detection */   
        unsigned long last_switch_count;  
        #endif/* CPU-specific state of this task */  
struct thread_struct thread; /*因为task_stcut是与硬件体系结构无关的，因此用thread_struct这个结构来包容不同的体系结构*/  
        /* 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;  
        /*Although signal handling takes place in the kernel, the installed signal handlers run in usermode — otherwise, 
          it would be very easy to introduce malicious or faulty code into the kernel andundermine the system security mechanisms. 
          Generally, signal handlers use the user mode stack ofthe process in question. 
          However, POSIX mandates the option of running signal handlers on a stackset up specifically for this purpose (using the 
          sigaltstack system call). The address and size of this additional stack (which must be explicitly allocated by the 
          user application) are held in sas_ss_sp andsas_ss_size, respectively. （Professional Linux® Kernel Architecture Page384）*/  
        int (*notifier)(void *priv);  
        void *notifier_data;  
        sigset_t *notifier_mask;  
        struct audit_context *audit_context; //请参看 Professional Linux® Kernel Architecture Page1100  
        #ifdef CONFIG_AUDITSYSCALL  
        uid_t loginuid;  
        unsigned int sessionid;  
        #endif  
        seccomp_t 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;  
        #ifdef CONFIG_GENERIC_HARDIRQS/* IRQ handler threads */  
        struct irqaction *irqaction;#endif/* Protection of the PI data structures: */   //PI --> Priority Inheritanceraw_spinlock_t pi_lock;  
        #ifdef CONFIG_RT_MUTEXES    //RT-->  RealTime Task 实时任务/* 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  
        #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; //块IO设备表  
        #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; //a structure which is used for recording a single task's IO statistics.  
        #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 */  
        int mems_allowed_change_disable;  
        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;  
        #endifstruct 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_NUMA  
        struct mempolicy *mempolicy;  
        /* Protected by alloc_lock */  
        short il_next;  
        short pref_node_fork;  
        #endifatomic_t fs_excl; /* holding fs exclusive resources *///是否允许进程独占文件系统。为0表示否。  
        struct rcu_head rcu;/* * cache last used pipe for splice */  
        struct pipe_inode_info *splice_pipe;  
        #ifdef CONFIG_TASK_DELAY_ACCT  
        struct task_delay_info *delays;  
        #endif  
        #ifdef CONFIG_FAULT_INJECTION  
        int make_it_fail;  
        #endif  
        struct prop_local_single dirties;  
        #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;  
        struct list_head *scm_work_list;  
        #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_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 nr_pages; /* uncharged usage */  
        unsigned long memsw_nr_pages; /* uncharged mem+swap usage */  
        } memcg_batch;  
        #endif  
        #ifdef CONFIG_HAVE_HW_BREAKPOINT  
        atomic_t ptrace_bp_refcnt;  
        #endif  
     };