init_task

版权声明:本文为博主原创文章,未经博主允许不得转载。

init_task是kernel的第一个进程,0号进程,当kernel初始化完成后,它便化身为idle进程出现在我们的面前。

一init_thread_union

unionthread_union init_thread_union __init_task_data =

    { INIT_THREAD_INFO(init_task) };

#define INIT_THREAD_INFO(tsk)                       \

{                                  \

    .task        = &tsk, \\ 进程描述符init_task                      \

    .exec_domain    = &default_exec_domain,\\ Linux执行域              \

    .flags        = 0,                       \

    .preempt_count    =INIT_PREEMPT_COUNT,                \

    .addr_limit    = KERNEL_DS,// 内核地址空间0-0xFFFFFFFF                \

    .restart_block    = {//重新启动系统调用相关                      \

        .fn    =do_no_restart_syscall,            \

    },                               \

}

structthread_info { // 定义在kernel/arch/ar,64/include/asm/thread_info.h中

    unsigned long        flags;       /* low level flags */

    mm_segment_t       addr_limit;    /* address limit */

    struct task_struct    *task;       /* main task structure */ // 进程描述符

    struct exec_domain    *exec_domain;   /* execution domain */ // 

执行域描述符

    struct restart_block    restart_block;

    int           preempt_count;    /* 0 => preemptable, <0 => bug */

    int           cpu;        /* cpu */

};

structexec_domain default_exec_domain = { // Linux执行域

    .name       ="Linux",      /* name */

    .handler    = default_handler,  /*lcall7 causes a seg fault. */

    .pers_low   = 0,           /* PER_LINUX personality. */

    .pers_high  = 0,           /* PER_LINUX personality. */

    .signal_map = ident_map,        /*Identity map signals. */

    .signal_invmap  = ident_map,       /*  - both ways. */

};

#define INIT_PREEMPT_COUNT  (1 +PREEMPT_ACTIVE) // 定义在include/linux/sched.h

#define PREEMPT_ACTIVE  0x40000000 // 定义在arch/arm64/include/asm/thread_info.h

将preempt_count赋值为0x40000001是为了在scheduler还没初始化前暂时禁掉进程抢占

#define KERNEL_DS   (-1UL) // 内核地址空间0-0xFFFFFFFF

二init_task

2.1 INIT_TASK(tsk)

structtask_struct init_task = INIT_TASK(init_task);

#define INIT_TASK(tsk)    \

{                                  \

    .state        = 0, // 进程状态,0表示可运行状态,说明正在运行或正准备运行                      \

    .stack        =&init_thread_info, //thread_info              \

    .usage        =ATOMIC_INIT(2), //2个进程正在使用该结构             \

    .flags        = PF_KTHREAD, //kernel进程                  \

    .prio        = MAX_PRIO-20, // 优先级                  \

    .static_prio    = MAX_PRIO-20,                   \

    .normal_prio    = MAX_PRIO-20,                   \

    .policy        = SCHED_NORMAL, // 采用SCHED_NORMAL调度策略                  \

    .cpus_allowed    = CPU_MASK_ALL, // cpu亲和性                  \

    .nr_cpus_allowed= NR_CPUS, // 该进程可以在全部cpu上运行                  \

    .mm        = NULL,                       \

    .active_mm    = &init_mm, // 3.2                  \

    .se        = { // 调度实体                      \

        .group_node     =LIST_HEAD_INIT(tsk.se.group_node),    \

    },                               \

    .rt        = { // 实时任务调度实体                      \

        .run_list    =LIST_HEAD_INIT(tsk.rt.run_list),    \

        .time_slice    =RR_TIMESLICE,                \

    },                               \

    .tasks        =LIST_HEAD_INIT(tsk.tasks), // 任务队列           \

    INIT_PUSHABLE_TASKS(tsk) // .pushable_tasks =PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO),                  \

    INIT_CGROUP_SCHED(tsk) // .sched_task_group =&root_task_group, // 而root_task_group在sched_init中初始化                      \

    .ptraced    =LIST_HEAD_INIT(tsk.ptraced),            \

    .ptrace_entry    =LIST_HEAD_INIT(tsk.ptrace_entry),        \

    .real_parent    = &tsk, // init_task进程的父进程是他自己                      \

    .parent        = &tsk,//init_task进程的父进程是他自己                      \

    .children    = LIST_HEAD_INIT(tsk.children),// 初始化子进程链表          \

    .sibling    = LIST_HEAD_INIT(tsk.sibling),// 初始化兄弟进程链表          \

    .group_leader    = &tsk, // init_task线程链表指向它自己                      \

    RCU_POINTER_INITIALIZER(real_cred, &init_cred), //.p = (typeof(*v) __force __rcu *)(v)           \

    RCU_POINTER_INITIALIZER(cred, &init_cred), // rcu指针指向init_cred//init_cred3.3          \

    .comm        = INIT_TASK_COMM, //#define INIT_TASK_COMM "swapper" // 进程名字为swapper              \

    .thread        = INIT_THREAD, //#define INIT_THREAD  {    }                  \

    .fs        = &init_fs,// 3.4                  \

    .files        = &init_files,//3.5                  \

    .signal        =&init_signals, // 3.6               \

    .sighand    = &init_sighand, // 3.7              \

    .nsproxy    = &init_nsproxy, // 3.8              \

    .pending    = { // 等待处理的signal列表                      \

        .list =LIST_HEAD_INIT(tsk.pending.list),        \

        .signal = {{0}}},                   \

    .blocked    = {{0}}, // 被阻塞的信号集                   \

    .alloc_lock    =__SPIN_LOCK_UNLOCKED(tsk.alloc_lock), // 自旋锁       \

    .journal_info    = NULL,                       \

    .cpu_timers    =INIT_CPU_TIMERS(tsk.cpu_timers), // cpu定时器      \

    .pi_lock    =__RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock),    \

    .timer_slack_ns = 50000, /* 50 usec default slack */// 设置select()poll()的超时时间为50ms       \

    .pids = { // 3.9                          \

        [PIDTYPE_PID]  =INIT_PID_LINK(PIDTYPE_PID), \\ 进程pid       \

        [PIDTYPE_PGID] =INIT_PID_LINK(PIDTYPE_PGID), \\ 线程组领头线程pid       \

        [PIDTYPE_SID]  =INIT_PID_LINK(PIDTYPE_SID),        \

    },                               \

    .thread_group    =LIST_HEAD_INIT(tsk.thread_group), // init_task的线程链表       \

    .thread_node    =LIST_HEAD_INIT(init_signals.thread_head),    \

    INIT_IDS // loginuid, sessionid                          \

    INIT_PERF_EVENTS(tsk) \\ Performance Event是一个的性能诊断工具                      \

    INIT_TRACE_IRQFLAGS \\ softirqs_enabled                       \

    INIT_LOCKDEP \\ Linux死锁检测模块                          \

    INIT_FTRACE_GRAPH \\ ftrace跟踪器                      \

    INIT_TRACE_RECURSION                       \

    INIT_TASK_RCU_PREEMPT(tsk) // RCU同步原语                   \

    INIT_TASK_RCU_TASKS(tsk)                   \

    INIT_CPUSET_SEQ(tsk)                       \

    INIT_RT_MUTEXES(tsk) \\ 基于PI协议的等待互斥锁,priorityinheritance(优先级继承)                      \

    INIT_VTIME(tsk)                           \

    INIT_KASAN(tsk) \\ Kasan Kernel Address Sanitizer 的缩写,它是一个动态检测内存错误的工具,主要功能是检查内存越界访问和使用已释放的内存等问题。                         \

}

#define init_thread_info   (init_thread_union.thread_info)

#define init_stack       (init_thread_union.stack)

 

 

 

 init_task相关结构体

本节仅仅是摘录,并没有对结构体内容进行解释说明

3.1 task_struct

structtask_struct { // 定义在kernel/include/linux/sched.h

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

    void *stack;

    atomic_t usage;

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

    unsigned int ptrace;

#ifdefCONFIG_SMP

    struct llist_node wake_entry;

    int on_cpu;

    struct task_struct *last_wakee;

    unsigned long wakee_flips;

    unsigned long wakee_flip_decay_ts;

    int wake_cpu;

#endif

    int on_rq;

    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;

#ifdefCONFIG_SCHED_HMP

    struct ravg ravg;

    /*

     * 'init_load_pct' represents the initial taskload assigned to children

     * of this task

     */

    u32 init_load_pct;

    u64 last_wake_ts;

    u64 last_switch_out_ts;

#ifdefCONFIG_SCHED_QHMP

    u64 run_start;

#endif

    struct related_thread_group *grp;

    struct list_head grp_list;

#endif

#ifdefCONFIG_CGROUP_SCHED

    struct task_group *sched_task_group;

#endif

    struct sched_dl_entity dl;

#ifdefCONFIG_PREEMPT_NOTIFIERS

    /* list of struct preempt_notifier: */

    struct hlist_head preempt_notifiers;

#endif

#ifdefCONFIG_BLK_DEV_IO_TRACE

    unsigned int btrace_seq;

#endif

    unsigned int policy;

    int nr_cpus_allowed;

    cpumask_t cpus_allowed;

#ifdefCONFIG_PREEMPT_RCU

    int rcu_read_lock_nesting;

    union rcu_special rcu_read_unlock_special;

    struct list_head rcu_node_entry;

#endif/* #ifdef CONFIG_PREEMPT_RCU */

#ifdefCONFIG_TREE_PREEMPT_RCU

    struct rcu_node *rcu_blocked_node;

#endif/* #ifdef CONFIG_TREE_PREEMPT_RCU */

#ifdefCONFIG_TASKS_RCU

    unsigned long rcu_tasks_nvcsw;

    bool rcu_tasks_holdout;

    struct list_head rcu_tasks_holdout_list;

    int rcu_tasks_idle_cpu;

#endif/* #ifdef CONFIG_TASKS_RCU */

#ifdefined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)

    struct sched_info sched_info;

#endif

    struct list_head tasks;

#ifdefCONFIG_SMP

    struct plist_node pushable_tasks;

    struct rb_node pushable_dl_tasks;

#endif

    struct mm_struct *mm, *active_mm;

#ifdefCONFIG_COMPAT_BRK

    unsigned brk_randomized:1;

#endif

    /* per-thread vma caching */

    u32 vmacache_seqnum;

    struct vm_area_struct *vmacache[VMACACHE_SIZE];

#ifdefined(SPLIT_RSS_COUNTING)

    struct task_rss_stat    rss_stat;

#endif

/* taskstate */

    int exit_state;

    int exit_code, exit_signal;

    int pdeath_signal;  /*  The signal sent whenthe parent dies  */

    unsigned int jobctl;    /* JOBCTL_*, siglockprotected */

    /* Used for emulating ABI behavior of previous Linuxversions */

    unsigned int personality;

    unsigned in_execve:1;    /* Tell the LSMsthat the process is doing an

                 *execve */

    unsigned in_iowait:1;

    /* Revert to default priority/policy when forking */

    unsigned sched_reset_on_fork:1;

    unsigned sched_contributes_to_load:1;

    unsigned long atomic_flags; /* Flags needing atomicaccess. */

    pid_t pid;

    pid_t tgid;

#ifdefCONFIG_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 __rcu *real_parent; /* real parentprocess */

    struct task_struct __rcu *parent; /* recipient ofSIGCHLD, wait4() reports */

    /*

     * children/sibling forms the list of my naturalchildren

     */

    struct list_head children;    /* list of mychildren */

    struct list_head sibling;    /* linkage inmy parent's children list */

    struct task_struct *group_leader;    /*threadgroup leader */

    /*

     * ptraced is the list of tasks this task isusing ptrace on.

     * This includes both natural children andPTRACE_ATTACH targets.

     * p->ptrace_entry is p's link on thep->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 list_head thread_node;

    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;

    cputime_t gtime;

    unsigned long long cpu_power;

#ifndefCONFIG_VIRT_CPU_ACCOUNTING_NATIVE

    struct cputime prev_cputime;

#endif

#ifdefCONFIG_VIRT_CPU_ACCOUNTING_GEN

    seqlock_t vtime_seqlock;

    unsigned long long vtime_snap;

    enum {

        VTIME_SLEEPING = 0,

        VTIME_USER,

        VTIME_SYS,

    } vtime_snap_whence;

#endif

    unsigned long nvcsw, nivcsw; /* context switch counts*/

    u64 start_time;        /*monotonic time in nsec */

    u64 real_start_time;    /* boot based timein nsec */

/* mmfault and swap info: this can arguably be seen as either mm-specific orthread-specific */

    unsigned long min_flt, maj_flt;

    struct task_cputime cputime_expires;

    struct list_head cpu_timers[3];

/*process credentials */

    const struct cred __rcu *real_cred; /* objective andreal subjective task

                    * credentials (COW) */

    const struct cred __rcu *cred;    /*effective (overridable) subjective task

                    * credentials (COW) */

    char comm[TASK_COMM_LEN]; /* executable name excludingpath

                    - access with [gs]et_task_comm (which lock

                      it with task_lock())

                    - initialized normally by setup_new_exec */

/* filesystem info */

    int link_count, total_link_count;

#ifdefCONFIG_SYSVIPC

/* ipcstuff */

    struct sysv_sem sysvsem;

    struct sysv_shm sysvshm;

#endif

#ifdefCONFIG_DETECT_HUNG_TASK

/* hungtask detection */

    unsigned long last_switch_count;

#endif

/*CPU-specific state of this task */

    struct thread_struct thread;

/*filesystem information */

    struct fs_struct *fs;

/* openfile 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 ifset_restore_sigmask() was used */

    struct sigpending pending;

    unsigned long sas_ss_sp;

    size_t sas_ss_size;

    int (*notifier)(void *priv);

    void *notifier_data;

    sigset_t *notifier_mask;

    struct callback_head *task_works;

    struct audit_context *audit_context;

#ifdefCONFIG_AUDITSYSCALL

    kuid_t loginuid;

    unsigned int sessionid;

#endif

    struct seccomp 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;

    /* Protection of the PI data structures: */

    raw_spinlock_t pi_lock;

#ifdefCONFIG_RT_MUTEXES

    /* PI waiters blocked on a rt_mutex held by this task*/

    struct rb_root pi_waiters;

    struct rb_node *pi_waiters_leftmost;

    /* Deadlock detection and priority inheritancehandling */

    struct rt_mutex_waiter *pi_blocked_on;

#endif

#ifdefCONFIG_DEBUG_MUTEXES

    /* mutex deadlock detection */

    struct mutex_waiter *blocked_on;

#endif

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

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

#ifdefCONFIG_BLOCK

/*stack plugging */

    struct blk_plug *plug;

#endif

/* VMstate */

    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;

#ifdefined(CONFIG_TASK_XACCT)

    u64 acct_rss_mem1;    /* accumulated rssusage */

    u64 acct_vm_mem1;    /* accumulated virtualmemory usage */

    cputime_t acct_timexpd;    /* stime + utimesince last update */

#endif

#ifdefCONFIG_CPUSETS

    nodemask_t mems_allowed;    /* Protected byalloc_lock */

    seqcount_t mems_allowed_seq;    /* Seqenceno to catch updates */

    int cpuset_mem_spread_rotor;

    int cpuset_slab_spread_rotor;

#endif

#ifdefCONFIG_CGROUPS

    /* Control Group info protected by css_set_lock */

    struct css_set __rcu *cgroups;

    /* cg_list protected by css_set_lock andtsk->alloc_lock */

    struct list_head cg_list;

#endif

#ifdefCONFIG_FUTEX

    struct robust_list_head __user *robust_list;

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

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

#ifdefCONFIG_DEBUG_PREEMPT

    unsigned long preempt_disable_ip;

#endif

#ifdefCONFIG_NUMA

    struct mempolicy *mempolicy;    /* Protectedby alloc_lock */

    short il_next;

    short pref_node_fork;

#endif

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

    u64 node_stamp;           /* migration stamp  */

    u64 last_task_numa_placement;

    u64 last_sum_exec_runtime;

    struct callback_head numa_work;

    struct list_head numa_entry;

    struct numa_group *numa_group;

    /*

     * Exponential decaying average of faults on aper-node basis.

     * Scheduling placement decisions are made basedon the these counts.

     * The values remain static for the duration of aPTE scan

     */

    unsigned long *numa_faults_memory;

    unsigned long total_numa_faults;

    /*

     * numa_faults_buffer records faults per nodeduring the current

     * scan window. When the scan completes, thecounts in

     * numa_faults_memory decay and these values arecopied.

     */

    unsigned long *numa_faults_buffer_memory;

    /*

     * Track the nodes the process was running onwhen a NUMA hinting

     * fault was incurred.

     */

    unsigned long *numa_faults_cpu;

    unsigned long *numa_faults_buffer_cpu;

    /*

     * numa_faults_locality tracks if faults recordedduring the last

     * scan window were remote/local. The task scanperiod is adapted

     * based on the locality of the faults withdifferent weights

     * depending on whether they were shared orprivate faults

     */

    unsigned long numa_faults_locality[2];

    unsigned long numa_pages_migrated;

#endif/* CONFIG_NUMA_BALANCING */

    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

#ifdefCONFIG_FAULT_INJECTION

    int make_it_fail;

#endif

    /*

     * when (nr_dirtied >= nr_dirtied_pause), it'stime to call

     * balance_dirty_pages() for some dirtythrottling pause

     */

    int nr_dirtied;

    int nr_dirtied_pause;

    unsigned long dirty_paused_when; /* start of awrite-and-pause period */

#ifdefCONFIG_LATENCYTOP

    int latency_record_count;

    struct latency_record latency_record[LT_SAVECOUNT];

#endif

    /*

     * time slack values; these are used to round uppoll() and

     * select() etc timeout values. These are innanoseconds.

     */

    unsigned long timer_slack_ns;

    unsigned long default_timer_slack_ns;

#ifdefCONFIG_KASAN

    unsigned int kasan_depth;

#endif

#ifdefCONFIG_FUNCTION_GRAPH_TRACER

    /* Index of current stored address in ret_stack */

    int curr_ret_stack;

    /* Stack of return addresses for return functiontracing */

    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

#ifdefCONFIG_TRACING

    /* state flags for use by tracers */

    unsigned long trace;

    /* bitmask and counter of trace recursion */

    unsigned long trace_recursion;

#endif/* CONFIG_TRACING */

#ifdefCONFIG_MEMCG /* memcg uses this to do batch job */

    unsigned int memcg_kmem_skip_account;

    struct memcg_oom_info {

        struct mem_cgroup *memcg;

        gfp_t gfp_mask;

        int order;

        unsigned int may_oom:1;

    } memcg_oom;

#endif

#ifdefCONFIG_UPROBES

    struct uprobe_task *utask;

#endif

#ifdefined(CONFIG_BCACHE) || defined(CONFIG_BCACHE_MODULE)

    unsigned int    sequential_io;

    unsigned int    sequential_io_avg;

#endif

};

 

 

3.2init_mm

内存描述符

structmm_struct init_mm = {

    .mm_rb      = RB_ROOT,

    .pgd        = swapper_pg_dir,

    .mm_users   = ATOMIC_INIT(2),

    .mm_count   = ATOMIC_INIT(1),

    .mmap_sem   =__RWSEM_INITIALIZER(init_mm.mmap_sem),

    .page_table_lock = __SPIN_LOCK_UNLOCKED(init_mm.page_table_lock),

    .mmlist     =LIST_HEAD_INIT(init_mm.mmlist),

    INIT_MM_CONTEXT(init_mm)

};

structmm_struct {

    struct vm_area_struct *mmap;       /* list of VMAs */

    struct rb_root mm_rb;

    u32 vmacache_seqnum;                  /* per-thread vmacache */

#ifdefCONFIG_MMU

    unsigned long (*get_unmapped_area) (struct file *filp,

                unsignedlong addr, unsigned long len,

                unsignedlong pgoff, unsigned long flags);

#endif

    unsigned long mmap_base;        /*base of mmap area */

    unsigned long mmap_legacy_base;        /* base of mmap area in bottom-up allocations */

    unsigned long task_size;        /*size of task vm space */

    unsigned long highest_vm_end;       /* highest vma end address */

    pgd_t * pgd;

    atomic_t mm_users;           /* How many users with user space? */

    atomic_t mm_count;           /* How many references to "struct mm_struct" (users count as1) */

    atomic_long_t nr_ptes;           /* Page table pages */

    int map_count;               /* number of VMAs */

    spinlock_t page_table_lock;       /* Protects page tables and some counters */

    struct rw_semaphore mmap_sem;

    struct list_head mmlist;        /*List of maybe swapped mm's.    These are globally strung

                        * together off init_mm.mmlist, and are protected

                        * by mmlist_lock

                        */

 

    unsigned long hiwater_rss;    /*High-watermark of RSS usage */

    unsigned long hiwater_vm;    /* High-watervirtual memory usage */

    unsigned long total_vm;        /*Total pages mapped */

    unsigned long locked_vm;    /* Pages thathave PG_mlocked set */

    unsigned long pinned_vm;    /* Refcountpermanently increased */

    unsigned long shared_vm;    /* Shared pages(files) */

    unsigned long exec_vm;        /*VM_EXEC & ~VM_WRITE */

    unsigned long stack_vm;        /*VM_GROWSUP/DOWN */

    unsigned long def_flags;

    unsigned long start_code, end_code, start_data,end_data;

    unsigned long start_brk, brk, start_stack;

    unsigned long arg_start, arg_end, env_start, env_end;

    unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for/proc/PID/auxv */

    /*

     * Special counters, in some configurationsprotected by the

     * page_table_lock, in other configurations bybeing atomic.

     */

    struct mm_rss_stat rss_stat;

    struct linux_binfmt *binfmt;

    cpumask_var_t cpu_vm_mask_var;

    /* Architecture-specific MM context */

    mm_context_t context;

    unsigned long flags; /* Must use atomic bitops toaccess the bits */

    struct core_state *core_state; /* coredumping support*/

#ifdefCONFIG_AIO

    spinlock_t           ioctx_lock;

    struct kioctx_table __rcu    *ioctx_table;

#endif

#ifdefCONFIG_MEMCG

    /*

     * "owner" points to a task that isregarded as the canonical

     * user/owner of this mm. All of the followingmust be true in

     * order for it to be changed:

     *

     * current == mm->owner

     * current->mm != mm

     * new_owner->mm == mm

     * new_owner->alloc_lock is held

     */

    struct task_struct __rcu *owner;

#endif

    /* store ref to file /proc//exe symlinkpoints to */

    struct file *exe_file;

#ifdefCONFIG_MMU_NOTIFIER

    struct mmu_notifier_mm *mmu_notifier_mm;

#endif

#ifdefined(CONFIG_TRANSPARENT_HUGEPAGE) && !USE_SPLIT_PMD_PTLOCKS

    pgtable_t pmd_huge_pte; /* protected bypage_table_lock */

#endif

#ifdefCONFIG_CPUMASK_OFFSTACK

    struct cpumask cpumask_allocation;

#endif

#ifdefCONFIG_NUMA_BALANCING

    /*

     * numa_next_scan is the next time that the PTEswill be marked

     * pte_numa. NUMA hinting faults will gatherstatistics and migrate

     * pages to new nodes if necessary.

     */

    unsigned long numa_next_scan;

    /* Restart point for scanning and setting pte_numa */

    unsigned long numa_scan_offset;

    /* numa_scan_seq prevents two threads setting pte_numa*/

    int numa_scan_seq;

#endif

#ifdefined(CONFIG_NUMA_BALANCING) || defined(CONFIG_COMPACTION)

    /*

     * An operation with batched TLB flushing isgoing on. Anything that

     * can move process memory needs to flush the TLBwhen moving a

     * PROT_NONE or PROT_NUMA mapped page.

     */

    bool tlb_flush_pending;

#endif

    struct uprobes_state uprobes_state;

#ifdefCONFIG_MSM_APP_SETTINGS

    int app_setting;

#endif

};

 

.3.3init_cred

structcred init_cred = {

    .usage          =ATOMIC_INIT(4),

#ifdefCONFIG_DEBUG_CREDENTIALS

    .subscribers        =ATOMIC_INIT(2),

    .magic          = CRED_MAGIC,

#endif

    .uid            =GLOBAL_ROOT_UID,

    .gid            =GLOBAL_ROOT_GID,

    .suid           =GLOBAL_ROOT_UID,

    .sgid           =GLOBAL_ROOT_GID,

    .euid           =GLOBAL_ROOT_UID,

    .egid           =GLOBAL_ROOT_GID,

    .fsuid          =GLOBAL_ROOT_UID,

    .fsgid          =GLOBAL_ROOT_GID,

    .securebits     = SECUREBITS_DEFAULT,

    .cap_inheritable    = CAP_EMPTY_SET,

    .cap_permitted      = CAP_FULL_SET,

    .cap_effective      = CAP_FULL_SET,

    .cap_bset       = CAP_FULL_SET,

    .user           =INIT_USER,

    .user_ns        =&init_user_ns,

    .group_info     = &init_groups,

};

3.4init_fs

structfs_struct init_fs = {

    .users        = 1,

    .lock        =__SPIN_LOCK_UNLOCKED(init_fs.lock),

    .seq        =SEQCNT_ZERO(init_fs.seq),

    .umask        = 0022,

};

 

3.5init_files

structfiles_struct init_files = {

    .count        = ATOMIC_INIT(1),

    .fdt        =&init_files.fdtab,

    .fdtab        = {

        .max_fds    = NR_OPEN_DEFAULT,

        .fd        =&init_files.fd_array[0],

        .close_on_exec    =init_files.close_on_exec_init,

        .open_fds    =init_files.open_fds_init,

    },

    .file_lock    =__SPIN_LOCK_UNLOCKED(init_files.file_lock),

};

 

3.6init_signals

staticstruct signal_struct init_signals = INIT_SIGNALS(init_signals);

#define INIT_SIGNALS(sig) {                       \

    .nr_threads    = 1,                       \

    .thread_head    =LIST_HEAD_INIT(init_task.thread_node),    \

    .wait_chldexit    =__WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\

    .shared_pending    = {                        \

        .list =LIST_HEAD_INIT(sig.shared_pending.list),    \

        .signal =  {{0}}},                   \

    .posix_timers     =LIST_HEAD_INIT(sig.posix_timers),        \

    .cpu_timers    =INIT_CPU_TIMERS(sig.cpu_timers),        \

    .rlim        = INIT_RLIMITS,                   \

    .cputimer    = {                        \

        .cputime = INIT_CPUTIME,               \

        .running = 0,                       \

        .lock =__RAW_SPIN_LOCK_UNLOCKED(sig.cputimer.lock),    \

    },                               \

    .cred_guard_mutex =                       \

        __MUTEX_INITIALIZER(sig.cred_guard_mutex),        \

    INIT_GROUP_RWSEM(sig)                       \

}

3.7init_sighand

staticstruct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);

#define INIT_SIGHAND(sighand) {                       \

    .count        =ATOMIC_INIT(1),                 \

    .action        = { { { .sa_handler= SIG_DFL, } }, },        \

    .siglock    =__SPIN_LOCK_UNLOCKED(sighand.siglock),    \

    .signalfd_wqh    =__WAIT_QUEUE_HEAD_INITIALIZER(sighand.signalfd_wqh),    \

}

3.8init_nsproxy

structnsproxy init_nsproxy = {

    .count            =ATOMIC_INIT(1),

    .uts_ns            =&init_uts_ns, // UTS命名空间包含了运行内核的名称、版本、底层体系结构类型等信息

#ifdefined(CONFIG_POSIX_MQUEUE) || defined(CONFIG_SYSVIPC) // 进程间通信IPC命名空间

    .ipc_ns            =&init_ipc_ns,

#endif

    .mnt_ns            =NULL, // 挂载命名空间

    .pid_ns_for_children    = &init_pid_ns,// PID命名空间

#ifdefCONFIG_NET

    .net_ns            =&init_net, // 网络命名空间

#endif

};

structuts_namespace init_uts_ns = {

    .kref = {

        .refcount    = ATOMIC_INIT(2),

    },

    .name = {

        .sysname    = UTS_SYSNAME,

        .nodename    = UTS_NODENAME,

        .release    = UTS_RELEASE,

        .version    = UTS_VERSION,

        .machine    = UTS_MACHINE,

        .domainname    =UTS_DOMAINNAME,

    },

    .user_ns = &init_user_ns,

    .proc_inum = PROC_UTS_INIT_INO,

};

structipc_namespace init_ipc_ns = {

    .count        = ATOMIC_INIT(1),

    .user_ns = &init_user_ns,

    .proc_inum = PROC_IPC_INIT_INO,

};

structpid_namespace init_pid_ns = {

    .kref = {

        .refcount       =ATOMIC_INIT(2),

    },

    .pidmap = {

        [ 0 ... PIDMAP_ENTRIES-1] = {ATOMIC_INIT(BITS_PER_PAGE), NULL }

    },

    .last_pid = 0,

    .nr_hashed = PIDNS_HASH_ADDING,

    .level = 0,

    .child_reaper = &init_task,

    .user_ns = &init_user_ns,

    .proc_inum = PROC_PID_INIT_INO,

};

structnet init_net = {

    .dev_base_head =LIST_HEAD_INIT(init_net.dev_base_head),

};

3.9INIT_PID_LINK

#define INIT_PID_LINK(type)                    \

{                               \

    .node = {                       \

        .next = NULL,                   \

        .pprev = NULL,                   \

    },                           \

    .pid = &init_struct_pid,               \

}

structpid init_struct_pid = INIT_STRUCT_PID;

#define INIT_STRUCT_PID {                       \

    .count         =ATOMIC_INIT(1),                \

    .tasks        = {                       \

        { .first = NULL },                   \

        { .first = NULL },                   \

        { .first = NULL },                   \

    },                               \

    .level        = 0,                       \

    .numbers    = { {                       \

        .nr        =0,                    \

        .ns        =&init_pid_ns,                \

        .pid_chain    = { .next =NULL, .pprev = NULL },    \

    }, }                               \

}

structpid_namespace init_pid_ns = {

    .kref = {

        .refcount       =ATOMIC_INIT(2),

    },

    .pidmap = {

        [ 0 ... PIDMAP_ENTRIES-1] = {ATOMIC_INIT(BITS_PER_PAGE), NULL }

    },

    .last_pid = 0,

    .nr_hashed = PIDNS_HASH_ADDING,

    .level = 0,

    .child_reaper = &init_task,

    .user_ns = &init_user_ns,

    .proc_inum = PROC_PID_INIT_INO,

};

 

源文档 <http://blog.csdn.net/xichangbao/article/details/52859472

你可能感兴趣的:(linux-内核篇)