kernel task_struct

Posted demonmaster

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了kernel task_struct相关的知识,希望对你有一定的参考价值。


struct task_struct {

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


    
    void                *stack;                     /* 堆指针 */
    atomic_t            usage;                      /*  进程描述符使用计数,被置为2时,表示进
                                                        程描述符正在被使用而且
                                                        其相应的进程处于活动状态 */
    
    unsigned int            flags;                  /* Per task flags (PF_*), defined further below: */
    unsigned int            ptrace;                 /* ptrace系统调用,成员ptrace被设置为0时表示不需要被跟踪 */

    /* SMP CPU: */
    struct llist_node       wake_entry;
    int             on_cpu;                         /* 在SMP上帮助实现无加锁的进程切换 */
    unsigned int            cpu;
    /* end: */
    
    unsigned int            wakee_flips;
    unsigned long           wakee_flip_decay_ts;
    struct task_struct      *last_wakee;

    /*
     * recent_used_cpu is initially set as the last CPU used by a task
     * that wakes affine another task. Waker/wakee relationships can
     * push tasks around a CPU where each wakeup moves to the next one.
     * Tracking a recently used CPU allows a quick search for a recently
     * used CPU that may be idle.
     */
    int             recent_used_cpu;
    int             wake_cpu;
#endif
    int             on_rq;

    int             prio, static_prio, normal_prio;  /* prio: 调度器考虑的优先级保存在prio*/
                                                     /* static_prio: 用于保存进程的"静态优先级*/
                                                     /* normal_prio: 表示基于进程的"静态优先级"和"调度策略"计算出的优先级*/
    unsigned int            rt_priority;             /* rt_priority:表示实时进程的优先级,需要明白的是,
                                                        "实时进程优先级"和"普通进程优先级"有两个独立的范畴,
                                                        实时进程即使是最低优先级也高于普通进程,最低的实时优先级为0,
                                                        最高的优先级为99,值越大,表明优先级越高*/
                                                        

    const struct sched_class    *sched_class;        /* sched_class: 该进程所属的调度类*/
    
    struct sched_entity     se;
    struct sched_rt_entity      rt;                  /* rt: 用于实时进程的调用实体 */

    struct task_group       *sched_task_group;       /* 组调度*/   

    struct sched_dl_entity      dl;


    /* List of struct preempt_notifier: */
    struct hlist_head       preempt_notifiers;



    unsigned int            btrace_seq;


    unsigned int            policy;                 /* policy表示进程的调度策略 */
    int             nr_cpus_allowed;
    cpumask_t           cpus_allowed;

                            #ifdef CONFIG_PREEMPT_RCU   /* 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;
                                u8              rcu_tasks_holdout;
                                u8              rcu_tasks_idx;
                                int             rcu_tasks_idle_cpu;
                                struct list_head        rcu_tasks_holdout_list;
                            #endif /* #ifdef CONFIG_TASKS_RCU */

    struct sched_info       sched_info;         /* sched_info:用于调度器统计进程的运行信息*/

    struct list_head        tasks;              /* 通过list_head将当前进程的task_struct串联进内核的进程列表中,
                                                   构建;linux进程链表*/
    struct plist_node       pushable_tasks;     / *    limit pushing to one attempt */
    struct rb_node          pushable_dl_tasks;

    struct mm_struct        *mm;                /* mm: 指向进程所拥有的内存描述符*/
    struct mm_struct        *active_mm;         /* active_mm: active_mm指向进程运行时所使用的内存描述符*/

    /* Per-thread vma caching: */
    struct vmacache         vmacache;

                                #ifdef SPLIT_RSS_COUNTING
                                    struct task_rss_stat        rss_stat;
                                #endif
    int             exit_state;                 /* 进程退出状态码*/
    int             exit_code;                  /* exit_code :用于设置进程的终止代号,
                                                   这个值要么是_exit()或exit_group()
                                                   系统调用参数(正常终止),
                                                   要么是由内核提供的一个错误代号(异常终止)*/
    int             exit_signal;                /* exit_signal被置为-1时表示是某个线程组中的一员。
                                                   只有当线程组的最后一个成员终止时,
                                                   才会产生一个信号,以通知线程组的领头进程的父进程*/
    
    int             pdeath_signal;              /* pdeath_signal用于判断父进程终止时发送信号 */
    
    /* JOBCTL_*, siglock protected: */
    unsigned long           jobctl;

    
    unsigned int            personality;        /* Used for emulating ABI behavior 
                                                   of previous Linux versions: */
                                                /* personality用于处理不同的ABI */

    /* Scheduler bits, serialized by scheduler locks: */
    unsigned            sched_reset_on_fork:1;
    unsigned            sched_contributes_to_load:1;
    unsigned            sched_migrated:1;
    unsigned            sched_remote_wakeup:1;
                                        #ifdef CONFIG_PSI
                                            unsigned            sched_psi_wake_requeue:1;
                                        #endif

    /* Force alignment to the next boundary: */
    unsigned            :0;

    /* Unserialized, strictly 'current' */

    /* in_execve用于通知LSM是否被do_execve()函数所调用 */
    unsigned            in_execve:1;    
    unsigned            in_iowait:1;            /* in_iowait用于判断是否进行iowait计数 */
                                        #ifndef TIF_RESTORE_SIGMASK
                                            unsigned            restore_sigmask:1;
                                        #endif

                                            unsigned            in_user_fault:1;

                                        #ifdef CONFIG_COMPAT_BRK
                                            unsigned            brk_randomized:1;
                                        #endif
                                        #ifdef CONFIG_CGROUPS
                                            /* disallow userland-initiated cgroup migration */
                                            unsigned            no_cgroup_migration:1;
                                        #endif
                                        #ifdef CONFIG_BLK_CGROUP
                                            /* to be used once the psi infrastructure lands upstream. */
                                            unsigned            use_memdelay:1;
                                        #endif

    unsigned long           atomic_flags; /* Flags requiring atomic access. */

    struct restart_block        restart_block;

    pid_t               pid;            
    pid_t               tgid;
                            进程标识符(PID)
                            在CONFIG_BASE_SMALL配置为0的情况下,PID的取值范围是0到32767,即系统中的进程数最大为32768个
                            #define PID_MAX_DEFAULT (CONFIG_BASE_SMALL ? 0x1000 : 0x8000)  
                            在Linux系统中,一个线程组中的所有线程使用和该线程组的领头线程
                            (该组中的第一个轻量级进程)相同的PID,并被存放在tgid成员中。
                            只有线程组的领头线程的pid成员才会被设置为与tgid相同的值。
                            注意,getpid()系统调用返回的是当前进程的tgid值而不是pid值


    /* 防止内核堆栈溢出,在GCC编译内核时,需要加上-fstack-protector选项 */
    unsigned long           stack_canary;

    /*
     * Pointers to the (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;           /* 指向其父进程,如果创建它的父进程不再存在,则指向PID为1的init进程 */

    /* Recipient of SIGCHLD, wait4() reports: */
    struct task_struct __rcu    *parent;                /* parent: 指向其父进程,当它终止时,必须向它的父进程发送信号。
                                                           它的值通常与real_parent相同*/

    /*
     * Children/sibling form the list of natural children:
     */
    struct list_head        children;                   /* children: 表示链表的头部,链表中的所有元素都是它的子进程(子进程链表)*/
    struct list_head        sibling;                    /* sibling: 用于把当前进程插入到兄弟链表中(连接到父进程的子进程链表(兄弟链表)*/
    struct task_struct      *group_leader;              /* group_leader: 指向其所在进程组的领头进程*/

    /*
     * 'ptraced' is the list of tasks this task is using ptrace() on.
     *
     * This includes both natural children and PTRACE_ATTACH targets.
     * 'ptrace_entry' is this task's link on the p->parent->ptraced list.
     */
    struct list_head        ptraced;
    struct list_head        ptrace_entry;

    /* PID/PID hash table linkage. */
    struct pid          *thread_pid;
    struct hlist_node       pid_links[PIDTYPE_MAX];         /* PID散列表和链表*/
    struct list_head        thread_group;                   /* 线程组中所有进程的链表*/
    struct list_head        thread_node;

    /* do_fork函数*/
    struct completion       *vfork_done;                    /* 在执行do_fork()时,如果给定特别标志,则vfork_done会指向一个特殊地址*/

    /* CLONE_CHILD_SETTID: */
    int __user          *set_child_tid;

    /* CLONE_CHILD_CLEARTID: */
    int __user          *clear_child_tid;
    /* 如果copy_process函数的clone_flags参数的值被置为CLONE_CHILD_SETTID或CLONE_CHILD_CLEARTID,
    则会把child_tidptr参数的值分别复制到set_child_tid和clear_child_tid成员。
    这些标志说明必须改变子进程用户态地址空间的child_tidptr所指向的变量的值*/

    u64             utime;
    u64             stime;
    u64             utimescaled;
    u64             stimescaled;
        /*  1) utime
            用于记录进程在"用户态"下所经过的节拍数(定时器)
            2) stime
            用于记录进程在"内核态"下所经过的节拍数(定时器)
            3) utimescaled
            用于记录进程在"用户态"的运行时间,但它们以处理器的频率为刻度
            4) stimescaled
            用于记录进程在"内核态"的运行时间,但它们以处理器的频率为刻度*/
    u64             gtime;      /* 以节拍计数的虚拟机运行时间(guest time)*/
    struct prev_cputime     prev_cputime;   /* prev_utime、prev_stime是先前的运行时间*/
#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
    struct vtime            vtime;
#endif

#ifdef CONFIG_NO_HZ_FULL
    atomic_t            tick_dep_mask;
#endif
    /* Context switch counts: */
    unsigned long           nvcsw;      /* 自愿(voluntary)上下文切换计数*/
    unsigned long           nivcsw;     /* 非自愿(involuntary)上下文切换计数*/

    /* Monotonic time in nsecs: */
    u64             start_time;         /* 进程创建时间*/

    /* Boot based time in nsecs: */
    u64             real_start_time;    /* 进程睡眠时间,还包含了进程睡眠时间,常用于/proc/pid/stat*/

    /* MM fault and swap info: this can arguably be seen as either mm-specific or thread-specific: */
    unsigned long           min_flt;
    unsigned long           maj_flt;

#ifdef CONFIG_POSIX_TIMERS  /* 用来统计进程或进程组被跟踪的处理器时间,其中的三个成员对应着cpu_timers[3]的三个链表*/
    struct task_cputime     cputime_expires;
    struct list_head        cpu_timers[3];
#endif

                        /* Process credentials: */

                        /* Tracer's credentials at attach: */
                        const struct cred __rcu     *ptracer_cred;

                        /* Objective and real subjective task credentials (COW): */
                        const struct cred __rcu     *real_cred;

                        /* Effective (overridable) subjective task credentials (COW): */
                        const struct cred __rcu     *cred;

                        /*
                         * executable name, excluding path.
                         *
                         * - normally initialized setup_new_exec()
                         * - access it with [gs]et_task_comm()
                         * - lock it with task_lock()
                         */
                        char                comm[TASK_COMM_LEN];

                        struct nameidata        *nameidata;

                        #ifdef CONFIG_SYSVIPC   /* 进程通信(SYSVIPC)*/
                            struct sysv_sem         sysvsem;    
                            struct sysv_shm         sysvshm;
                        #endif
                        #ifdef CONFIG_DETECT_HUNG_TASK
                            unsigned long           last_switch_count;
                            unsigned long           last_switch_time;
                        #endif
    /* Filesystem information: */
    struct fs_struct        *fs;        /* 用来表示进程与文件系统的联系,包括当前目录和根目录*/

    /* Open file information: */
    struct files_struct     *files;     /* 表示进程当前打开的文件*/

    /* 命名空间 : */        /* 进程通信(SYSVIPC)*/
    struct nsproxy          *nsproxy;

    /* Signal handlers: */
    struct signal_struct        *signal;        /* signal: 指向进程的信号描述符*/
    struct sighand_struct       *sighand;       /* sighand: 指向进程的信号处理程序描述符*/
    sigset_t            blocked;                /* 表示被阻塞信号的掩码*/
    sigset_t            real_blocked;           /* 表示临时掩码*/
    /* Restored if set_restore_sigmask() was used: */
    sigset_t            saved_sigmask;
    struct sigpending       pending;            /* 存放私有挂起信号的数据结构*/
    unsigned long           sas_ss_sp;          /* 信号处理程序备用堆栈的地址*/
    size_t              sas_ss_size;            /* 表示堆栈的大小*/
    unsigned int            sas_ss_flags;

    struct callback_head        *task_works;
            /* 进程审计 */
            struct audit_context        *audit_context;
        #ifdef CONFIG_AUDITSYSCALL
            kuid_t              loginuid;
            unsigned int            sessionid;  
        #endif
    struct seccomp          seccomp;    /* secure computing*/

    /* Thread group tracking: */    /* 用于copy_process函数使用CLONE_PARENT标记时 */
    u32             parent_exec_id;
    u32             self_exec_id;

    /* Protection against (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;    * task_rq_lock函数所使用的锁*/

    struct wake_q_node      wake_q;

                    #ifdef CONFIG_RT_MUTEXES    /* 基于PI协议的等待互斥锁,其中PI指的是priority inheritance/9优先级继承)*/
                        /* PI waiters blocked on a rt_mutex held by this task: */
                        struct rb_root_cached       pi_waiters; 
                        /* Updated under owner's pi_lock and rq lock */
                        struct task_struct      *pi_top_task;
                        /* 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        /* lockdep*/
    u64             curr_chain_key;
    int             lockdep_depth;
    unsigned int            lockdep_recursion;
    struct held_lock        held_locks[MAX_LOCK_DEPTH];
#endif

#ifdef CONFIG_UBSAN
    unsigned int            in_ubsan;
#endif

    /* Journalling filesystem info: JFS文件系统 */
    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;
    /* 存放块设备I/O数据流量信息*/
    struct backing_dev_info     *backing_dev_info;
    /* I/O调度器所使用的信息 */
    struct io_context       *io_context;

    /* Ptrace state: */
    unsigned long           ptrace_message;
    kernel_siginfo_t        *last_siginfo;

    struct task_io_accounting   ioac;
                    #ifdef CONFIG_PSI
                        /* Pressure stall state */
                        unsigned int            psi_flags;
                    #endif
                    #ifdef CONFIG_TASK_XACCT
                        /* Accumulated RSS usage: */
                        u64             acct_rss_mem1;
                        /* Accumulated virtual memory usage: */
                        u64             acct_vm_mem1;
                        /* stime + utime since last update: */
                        u64             acct_timexpd;
                    #endif
                    #ifdef CONFIG_CPUSETS
                        /* Protected by ->alloc_lock: */
                        nodemask_t          mems_allowed;
                        /* Seqence number to catch updates: */
                        seqcount_t          mems_allowed_seq;
                        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_X86_CPU_RESCTRL
                        u32             closid;
                        u32             rmid;
                    #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
    /* Protected by alloc_lock: */
    struct mempolicy        *mempolicy;
    short               il_prev;
    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;
    /* Migration stamp: */
    u64             node_stamp;
    u64             last_task_numa_placement;
    u64             last_sum_exec_runtime;
    struct callback_head        numa_work;

    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_RSEQ
    struct rseq __user *rseq;
    u32 rseq_len;
    u32 rseq_sig;
    /*
     * RmW on rseq_event_mask must be performed atomically
     * with respect to preemption.
     */
    unsigned long rseq_event_mask;
#endif

    struct tlbflush_unmap_batch tlb_ubc;

    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;
    unsigned int            fail_nth;
#endif
    /*
     * When (nr_dirtied >= nr_dirtied_pause), it's time to call
     * balance_dirty_pages() for a dirty throttling pause:
     */
    int             nr_dirtied;
    int             nr_dirtied_pause;
    /* Start of a write-and-pause period: */
    unsigned long           dirty_paused_when;

#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.
     *   time slack values,常用于poll和select函数
     */
    u64             timer_slack_ns;
    u64             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;
    int             curr_ret_depth;

    /* Stack of return addresses for return function tracing:ftrace跟踪器 */
    struct ftrace_ret_stack     *ret_stack;

    /* Timestamp 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 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_KCOV
    /* Coverage collection mode enabled for this task (0 if disabled): */
    unsigned int            kcov_mode;

    /* Size of the kcov_area: */
    unsigned int            kcov_size;

    /* Buffer for coverage collection: */
    void                *kcov_area;

    /* KCOV descriptor wired with this task or NULL: */
    struct kcov         *kcov;
#endif

#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;

    /* Used by memcontrol for targeted memcg charge: */
    struct mem_cgroup       *active_memcg;
#endif

#ifdef CONFIG_BLK_CGROUP
    struct request_queue        *throttle_queue;
#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;
#ifdef CONFIG_MMU
    struct task_struct      *oom_reaper_list;
#endif
#ifdef CONFIG_VMAP_STACK
    struct vm_struct        *stack_vm_area;
#endif
#ifdef CONFIG_THREAD_INFO_IN_TASK
    /* A live task holds one reference: */
    atomic_t            stack_refcount;
#endif
#ifdef CONFIG_LIVEPATCH
    int patch_state;
#endif
#ifdef CONFIG_SECURITY
    /* Used by LSM modules for access restriction: */
    void                *security;
#endif

#ifdef CONFIG_GCC_PLUGIN_STACKLEAK
    unsigned long           lowest_stack;
    unsigned long           prev_lowest_stack;
#endif





    randomized_struct_fields_start              /*M 随机分布,可以提高系统安全,防止黑客入侵 */
    randomized_struct_fields_end

    /* CPU-specific state of this task: Do not put anything below here! */
    struct thread_struct        thread;

    
};

 sched_class: 该进程所属的调度类,目前内核中有实现以下四种: 
            1) static const struct sched_class fair_sched_class;
            2) static const struct sched_class rt_sched_class;
            3) static const struct sched_class idle_sched_class;
            4) static const struct sched_class stop_sched_class;
        
 policy
    policy表示进程的调度策略,目前主要有以下五种:
        1) #define SCHED_NORMAL        0: 用于普通进程,它们通过完全公平调度器来处理
        2) #define SCHED_FIFO        1: 先来先服务调度,由实时调度类处理
        3) #define SCHED_RR            2: 时间片轮转调度,由实时调度类处理
        4) #define SCHED_BATCH        3: 用于非交互、CPU使用密集的批处理进程,通过完全公平调度器来处理,调度决策对此类进程给与"冷处理",它们绝不会抢占CFS调度器处理的另一个进程,因此不会干扰交互式进程,如果不打算用nice降低进程的静态优先级,同时又不希望该进程影响系统的交互性,最适合用该调度策略
        5) #define SCHED_IDLE        5: 可用于次要的进程,其相对权重总是最小的,也通过完全公平调度器来处理。要注意的是,SCHED_IDLE不负责调度空闲进程,空闲进程由内核提供单独的机制来处理
    只有root用户能通过sched_setscheduler()系统调用来改变调度策略 
    */

以上是关于kernel task_struct的主要内容,如果未能解决你的问题,请参考以下文章

内核:如何从进程的 task_struct 中找到所有线程?

Linux 内核进程管理 task_struct 结构体 ① ( task_struct 结构体引入 | task_struct 代码示例 )

"arch/arm/kernel/head.S"里面一点片段的理解

Linux 内核调度器 ④ ( sched_class 调度类结构体分析 | yield_task 函数 | heck_preempt_curr 函数 | task_struct 函数 )

initrdrootfs及内核root=参数

Linux 编程之进程篇:task_struct进程创建和退出