CPU及内存调度（二） -- Linux内存管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// linux-5.10.10/include/linux/sched.h
struct task_struct {
    //2.1 进程状态 （标号对应于参考链接中的小章节）
    volatile long state;

    //2.2 进程线程的pid
    pid_t pid;
    pid_t tgid;

    //2.3 进程树关系：父进程、子进程、兄弟进程
    struct task_struct __rcu *parent;
    struct list_head children; 
    struct list_head sibling;
    struct task_struct *group_leader; 

    //2.4 进程调度优先级
    int prio, static_prio, normal_prio;
    unsigned int rt_priority;

    //2.5 进程地址空间
    struct mm_struct *mm, *active_mm;

    //2.6 进程文件系统信息（当前目录等）
    struct fs_struct *fs;

    //2.7 进程打开的文件信息
    struct files_struct *files;

    //2.8 namespaces
    // 命名空间，用于隔离内核资源
    struct nsproxy *nsproxy;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// linux-5.10.10/kernel/fork.c
// fork和vfork定义，省略了部分条件编译相关判断分支
#ifdef __ARCH_WANT_SYS_FORK
SYSCALL_DEFINE0(fork)
{
    struct kernel_clone_args args = {
        .exit_signal = SIGCHLD,
    };
    return kernel_clone(&args);
}
#endif

#ifdef __ARCH_WANT_SYS_VFORK
SYSCALL_DEFINE0(vfork)
{
    struct kernel_clone_args args = {
        .flags		= CLONE_VFORK | CLONE_VM,
        .exit_signal	= SIGCHLD,
    };

    return kernel_clone(&args);
}
#endif

// clone系统调用定义节选
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
         int __user *, parent_tidptr,
         int __user *, child_tidptr,
         unsigned long, tls)
{
    struct kernel_clone_args args = {
        .flags		= (lower_32_bits(clone_flags) & ~CSIGNAL),
        .pidfd		= parent_tidptr,
        .child_tid	= child_tidptr,
        .parent_tid	= parent_tidptr,
        .exit_signal	= (lower_32_bits(clone_flags) & CSIGNAL),
        .stack		= newsp,
        .tls		= tls,
    };

    return kernel_clone(&args);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// linux-5.10.10/kernel/fork.c
pid_t kernel_clone(struct kernel_clone_args *args)
{
    struct task_struct *p;
    ...
    // 核心是一个 copy_process 函数
    // 复制一个 task_struct 出来
    p = copy_process(NULL, trace, NUMA_NO_NODE, args);
    ...
    pid = get_task_pid(p, PIDTYPE_PID);
    nr = pid_vnr(pid);
    ...
    // 子任务加入到就绪队列中去，等待调度器调度
    wake_up_new_task(p);
    ...
    put_pid(pid);
    return nr;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// linux-5.10.10/kernel/fork.c
// 说明：基于5.10.10代码，保留了参考链接对应的标号，便于对照查看
static __latent_entropy struct task_struct *copy_process(
                    struct pid *pid,
                    int trace,
                    int node,
                    struct kernel_clone_args *args)
{
    int pidfd = -1, retval;
    // 用于复制进程 task_struct 结构体
    struct task_struct *p;
    ...

    //3.1 复制进程 task_struct 结构体
    p = dup_task_struct(current, node);
    ...

    //3.2 拷贝 files_struct
    retval = copy_files(clone_flags, p);

    //3.3 拷贝 fs_struct
    retval = copy_fs(clone_flags, p);

    // 拷贝信号处理结构
    retval = copy_sighand(clone_flags, p);
    // 拷贝信号
    retval = copy_signal(clone_flags, p);

    //3.4 拷贝 mm_struct
    retval = copy_mm(clone_flags, p);

    //3.5 拷贝进程的命名空间 nsproxy
    retval = copy_namespaces(clone_flags, p);

    // 拷贝io上下文：io_context
    retval = copy_io(clone_flags, p);
    // 拷贝线程相关信息
    retval = copy_thread(clone_flags, args->stack, args->stack_size, p, args->tls);

    //3.6 申请 pid && 设置进程号
    if (pid != &init_struct_pid) {
        pid = alloc_pid(p->nsproxy->pid_ns_for_children, args->set_tid,
                args->set_tid_size);
    }
    ...
    p->pid = pid_nr(pid);
    if (clone_flags & CLONE_THREAD) {
        p->group_leader = current->group_leader;
        p->tgid = current->tgid;
    } else {
        p->group_leader = p;
        // 如果不是创建线程，则设置 tgid 为pid
        p->tgid = p->pid;
    }
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// linux-5.10.10/kernel/fork.c
static int copy_mm(unsigned long clone_flags, struct task_struct *tsk)
{
    // 子进程虚拟内存空间，父进程虚拟内存空间
    struct mm_struct *mm, *oldmm;
    int retval;
    ...
    tsk->mm = NULL;
    tsk->active_mm = NULL;
    // 获取父进程虚拟内存空间
    oldmm = current->mm;
    if (!oldmm)
        return 0;
    ...
    // 通过 vfork 或者 clone 系统调用创建出的子进程（线程）和父进程共享虚拟内存空间
    if (clone_flags & CLONE_VM) {
        // 增加父进程虚拟地址空间的引用计数
        mmget(oldmm);
        // 直接将父进程的虚拟内存空间赋值给子进程（线程）
        // 线程共享其所属进程的虚拟内存空间
        mm = oldmm;
        goto good_mm;
    }

    retval = -ENOMEM;
    // 如果是 fork 系统调用创建出的子进程，则将父进程的虚拟内存空间以及相关页表拷贝到子进程中的 mm_struct 结构中。
    mm = dup_mm(tsk, current->mm);
    ...
good_mm:
    // 将拷贝出来的父进程虚拟内存空间 mm_struct 赋值给子进程
    tsk->mm = mm;
    tsk->active_mm = mm;
    ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// linux-5.10.10/include/linux/mm_types.h
struct mm_struct {
    struct {
        // vm_area_struct 用于表示每个 虚拟内存区域（VMA），通过该结构将这些区域组织起来
        struct vm_area_struct *mmap;    /* list of VMAs */
        struct rb_root mm_rb;
        ...
        unsigned long mmap_base;  /* base of mmap area */
        ...
        // 通过 task_size 将进程虚拟内存空间和内核虚拟内存空间分割开
        unsigned long task_size;    /* size of task vm space */
        ...
        // total_vm 表示在进程虚拟内存空间中总共与物理内存映射的页 的总数
        unsigned long total_vm;    /* Total pages mapped */
        // locked_vm 表示不能换出到硬盘的页总数（当内存吃紧的时候，有些页可以换出到硬盘上，而有些页因为比较重要，不能换出）
        unsigned long locked_vm;  /* Pages that have PG_mlocked set */
        // pinned_vm 表示既不能换出，也不能移动的内存页总数
        unsigned long pinned_vm;  /* Refcount permanently increased */
        // data_vm 表示数据段中映射的内存页数目
        unsigned long data_vm;    /* VM_WRITE & ~VM_SHARED & ~VM_STACK */
        // exec_vm 是代码段中存放可执行文件的内存页数目
        unsigned long exec_vm;    /* VM_EXEC & ~VM_WRITE & ~VM_STACK */
        // stack_vm 是栈中所映射的内存页数目
        unsigned long stack_vm;    /* VM_STACK */
        unsigned long def_flags;

        spinlock_t arg_lock; /* protect the below fields */
        // start_code 和 end_code 定义代码段的起始和结束位置，程序编译后的二进制文件中的机器码被加载进内存之后就存放在这里
        // start_data 和 end_data 定义数据段的起始和结束位置，初始化的全局变量和静态变量被加载进内存中就存放在这里
        unsigned long start_code, end_code, start_data, end_data;
        // start_brk 定义堆的起始位置，brk 定义堆当前的结束位置
        // start_stack 是栈的起始位置（栈基地址）在 RBP 寄存器中存储，栈的结束位置也就是栈顶指针 stack pointer 在 RSP 寄存器中存储。
        // end_data 和 start_brk 之间是 BSS段，所以不用单独定义BSS段相关边界字段
        unsigned long start_brk, brk, start_stack;
        // arg_start 和 arg_end 是参数列表的位置
        // env_start 和 env_end 是环境变量的位置
        unsigned long arg_start, arg_end, env_start, env_end;
        ...
    } __randomize_layout;
    unsigned long cpu_bitmap[];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// linux-5.10.10/include/linux/mm_types.h
// 该结构是一个双向链表，将虚拟内存空间中的这些虚拟内存区域 VMA 串联起来
struct vm_area_struct {
    /* The first cache line has the info for VMA tree walking. */
    // 本VMA区域的起始和结束地址
    unsigned long vm_start;     /* Our start address within vm_mm. */
    unsigned long vm_end;       /* The first byte after our end address within vm_mm. */

    // vm_next，vm_prev 指针分别指向 VMA 节点所在双向链表中的后继节点和前驱节点
    struct vm_area_struct *vm_next, *vm_prev;

    // 每个 VMA 区域都是红黑树中的一个节点，通过 vm_rb 将自己连接到红黑树中
    struct rb_node vm_rb;

    unsigned long rb_subtree_gap;

    /* Second cache line starts here. */
    // 双向链表的头指针存储在内存描述符 struct mm_struct 结构中的 mmap 中
    // 正是这个 mmap 串联起了整个虚拟内存空间中的虚拟内存区域（对应进程结构体task_struct中的mm_struct）
    struct mm_struct *vm_mm;	/* The address space we belong to. */

    pgprot_t vm_page_prot;
    // 当前虚拟内存区域的访问权限 VM_READ/VM_WRITE/VM_EXEC/VM_SHARD/VM_IO等等
    unsigned long vm_flags;

    struct {
        struct rb_node rb;
        unsigned long rb_subtree_last;
    } shared;

    struct list_head anon_vma_chain;
    struct anon_vma *anon_vma;

    // 针对虚拟内存区域的操作，定义了各种函数指针，比如open/close/fault/huge_fault/pagesize等等
    const struct vm_operations_struct *vm_ops;

    unsigned long vm_pgoff;
    struct file * vm_file;
    void * vm_private_data;

#ifdef CONFIG_SWAP
    atomic_long_t swap_readahead_info;
#endif
#ifndef CONFIG_MMU
    struct vm_region *vm_region;	/* NOMMU mapping region */
#endif
#ifdef CONFIG_NUMA
    struct mempolicy *vm_policy;	/* NUMA policy for the VMA */
#endif
    struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
} __randomize_layout;

1
2
3
4
5
6
7
8
9
10
11
12
13
// linux-5.10.10/include/linux/mm.h
struct vm_operations_struct {
    // 当指定的虚拟内存区域被加入到进程虚拟内存空间中时，open 函数会被调用
    void (*open)(struct vm_area_struct * area);
    // 当虚拟内存区域 VMA 从进程虚拟内存空间中被删除时，close 函数会被调用
    void (*close)(struct vm_area_struct * area);
    int (*split)(struct vm_area_struct * area, unsigned long addr);
    int (*mremap)(struct vm_area_struct * area);
    // 当进程访问虚拟内存时，访问的页面不在物理内存中，这时就会产生缺页异常，fault 函数就会被调用
    // 可能是未分配物理内存也可能是被置换到磁盘中
    vm_fault_t (*fault)(struct vm_fault *vmf);
    ...
};

1
2
3
4
5
6
// linux-5.10.10/fs/binfmt_elf.c
// 逻辑也不少，500多行
static int load_elf_binary(struct linux_binprm *bprm)
{
    ...
}