task_sturct (Linux 的 PCB)

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;                                      

        int lock_depth;         /* BKL lock depth */  //   BLK 锁深度

#ifdef CONFIG_SMP
#ifdef __ARCH_WANT_UNLOCKED_CTXSW                      //  配置多核多线程 
        int oncpu;
#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   // fpu_count 里面内容是如果一个浮点运算器被使用，它
         * that the FPU is used. If this is over a threshold, the lazy fpu   // 记录着连续的上下文切换的次数，如果fpu_Count超过一个
         * saving becomes unlazy to save the trap. This is an unsigned char  // 临界值，不怎么工作的FPU会火力全开以至于当fpu_count
         * so that after 256 times the counter wraps and the behavior turns  // 超过 256次后才变得闲置下来，为了解决这个问题，FPU
         * lazy again; this to deal with bursty apps that only use FPU for  //  仅仅使用一段时间
         * a short time 
         */                               
        unsigned char fpu_counter;  //  定义 fpu_count 
#ifdef CONFIG_BLK_DEV_IO_TRACE      // 配置 BLK 锁开发版的输入输出跟踪器
       unsigned int btrace_seq;         
#endif

        unsigned int policy;      
        cpumask_t cpus_allowed;

#ifdef CONFIG_TREE_PREEMPT_RCU     // 配置 抢占树，抢占的结构体的读写机制，即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;          // 调度器 的 状态 
#endif

        struct list_head tasks;
        struct plist_node pushable_tasks;

        struct mm_struct *mm, *active_mm;     // 虚拟地址空间的结构体 

/* task state */                        // 进程退出时getpid 就获取status就是它。
        int exit_state;                // task 状态 ，正常退出状态 
        int exit_code, exit_signal;   // 退出信号
        int pdeath_signal;  /*  The signal sent when the parent dies  */  // 当成为孤儿进程时发送信号 
        /* ??? */
        unsigned int personality;   // 这个字段表明了 进程的状态   
        unsigned did_exec:1;
        unsigned in_execve:1;   /* Tell the LSMs that the process is doing an
                                 * execve */       定义 四个字段 来告诉Linux安全模块进程的状态
                                       // 第一个表已经调过了exec族函数，已经发生了进程的程序替换 第二个代表该进程正在调用execve函数 第三个 正在等待i/o设备 第四个 表示当fork生成子进程时，是否恢复了进程的默认优先级
        unsigned in_iowait:1;


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

#ifdef CONFIG_CC_STACKPROTECTOR        // 配置堆栈保护措施
        /* Canary value for the -fstack-protector gcc feature */
        unsigned long stack_canary;     // 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;                  // 跟踪器的头结点 ， 跟踪器 跟踪 进程的逻辑流，即PC指令流
        struct list_head ptrace_entry;            

        /* PID/PID hash table linkage. */
        struct pid_link pids[PIDTYPE_MAX];   //  定义 PID_LINK 结构体 用它通过PID在哈希散列表中查找相应的task_struct
        struct list_head thread_group;         // 用来保存线程组的PID

        struct completion *vfork_done;          /* for vfork() */   
        int __user *set_child_tid;              /* CLONE_CHILD_SETTID */     // 指向 用户创造创立的线程的TID 号 
        int __user *clear_child_tid;            /* CLONE_CHILD_CLEARTID */  // 指向被清除的线程的TID号 

        cputime_t utime, stime, utimescaled, stimescaled;
        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 */
        const struct cred *real_cred;   /* objective and real subjective task
                                         * credentials (COW) */
        const struct cred *cred;        /* effective (overridable) subjective task
                                         * credentials (COW) */
        struct mutex cred_guard_mutex;  /* guard against foreign influences on
                                         * credential calculations
                                         * (notably. ptrace) */
        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;       // CPU特殊 状态的测试 , 线程结构体 
/* filesystem information */
        struct fs_struct *fs;    //fs 指向一个文件系统信息结构体 ,该结构体有文件系统的信息
/* open file information */   //  指向记录打开文件信息的 结构体 
        struct files_struct *files;
/* namespaces */           // 命名空间的定义 
        struct nsproxy *nsproxy;
/* signal handlers */   // 配置 进程的信号处理  
        struct signal_struct *signal;   // 以下是普通信号部分
        struct sighand_struct *sighand; //这个指向 handler表 

        sigset_t blocked, real_blocked;  // 这个表示进程的屏蔽字
        sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */ 这个用来储存之前的屏蔽字，在调用sigprocmask时。
        struct sigpending pending; // pending表

        unsigned long sas_ss_sp;  // 以下是实时信号部分
        size_t sas_ss_size;
        int (*notifier)(void *priv);
        void *notifier_data;
        sigset_t *notifier_mask;
        struct audit_context *audit_context;
#ifdef CONFIG_AUDITSYSCALL   // 配置系统调用 
        uid_t loginuid;
        unsigned int sessionid;
#endif
        seccomp_t seccomp;

#ifdef CONFIG_UTRACE
        struct utrace *utrace;
        unsigned long utrace_flags;
#endif
/* 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: */
        spinlock_t pi_lock;

#ifdef CONFIG_RT_MUTEXES  // 互斥的配置 
        /* 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;
        int hardirqs_enabled;
        unsigned long hardirq_enable_ip;
        unsigned int hardirq_enable_event;
        unsigned long hardirq_disable_ip;
        unsigned int hardirq_disable_event;
        int softirqs_enabled;
        unsigned long softirq_disable_ip;
        unsigned int softirq_disable_event;
        unsigned long softirq_enable_ip;
        unsigned int softirq_enable_event;
        int hardirq_context;
        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 *bio_list, **bio_tail;
 
/* VM state */  //VM 虚拟机的状态 
        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 */ // 定义一个结构体 标志 内存是否允许访问 保护配置器的锁的
#ifndef __GENKSYMS__
        /*
         * This does not change the size of the struct_task(2+2+4=4+4)
         * so the offsets of the remaining fields are unchanged and 
         * therefore the kABI is preserved.  Only the kernel uses
         * cpuset_mem_spread_rotor and cpuset_slab_spread_rotor so
         * it is safe to change it to use shorts instead of ints.
         */
        unsigned short cpuset_mem_spread_rotor;
        unsigned short cpuset_slab_spread_rotor;
        int mems_allowed_change_disable;
#else
        int cpuset_mem_spread_rotor;
        int cpuset_slab_spread_rotor;
#endif
#endif
#ifdef CONFIG_CGROUPS // 配置控制组信息 
        /* Control Group info protected by css_set_lock */
        struct css_set *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
#ifndef __GENKSYMS__
        void * __reserved_perf__;
#else
        struct perf_event_context *perf_event_ctxp;
#endif
        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;
#endif
        atomic_t fs_excl;       /* holding fs exclusive resources */
        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 adress 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 of trace recursion */
        unsigned long trace_recursion;
#endif /* CONFIG_TRACING */
        /* reserved for Red Hat */
        unsigned long rh_reserved[2];
#ifndef __GENKSYMS__
        struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
#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 bytes;            /* uncharged usage */
                unsigned long memsw_bytes; /* uncharged mem+swap usage */
        } memcg_batch;
#endif
#endif
};