进程管理(九)--创建进程内存管理copy_mm_奇小葩-程序员宅基地

技术标签: 操作系统  内核  进程管理  

对于进程,除了0号进程,其他的所有进程(无论是内核线程还是普通线程)都是通过fork出来的,而创建进程是在内核中完成的

  • 要么在内核空间直接创建出所谓的内核线程
  • 要么是应用空间通过fork/clone/vfork这样的系统调用进入内核,再内核空间创建

同上一章,我们完成的分析了fork的整个过程,fork分为两部分,一部分是初始化进程控制块,另外一部分是进程管理部分。本章的重点学习以下内容

  • 子进程如何构建自己的内存管理
  • 父子进程如何共享地址空间
  • 写时复制如何发生

1. 写时复制技术

在传统的unix操作系统中,创建新建成时就会复制父进程所拥有的所有资源,这样进程的创建就变的很低效。其原因如下

  1. 每次创建子进程时,都要把父进程的进程地址空间中的内容复制到子进程,但是子进程甚至不用父进程的资源
  2. 子进程调用execve()系统调用之后,可能和父进程分道扬镳

所以现在的操作系统都采用写时复制(COW,Copy on Write)技术进行优化,其原理如下

  • 父进程在创建子进程的时,不需要复制进程地址空间的内容到子进程,只需要复制父进程的进程地址空间的页表到子进程,并将页面属性修改为只读,这样父、子进程就共享相同的物理内存。
  • 当父、子进程中有一方需要修改某个物理页面的内容,触发写保护的缺页异常,然后才复制共享页面的内容,从而让父、子进程拥有各自的副本

也就是说,进程地址空间以只读的方式共享,当需要写入时,才发生复制

在采用写时复制技术的Linux内核中,用fork函数创建一个新进程的开销就变得很小,免去了复制父进程整个进程地址空间导致的巨大开销,现在只需要复制父进程页表就可以了。

在这里插入图片描述

2. copy的内存管理

2.1 内存初始化

static int copy_mm(unsigned long clone_flags, struct task_struct *tsk)
{
    
	struct mm_struct *mm, *oldmm;
	int retval;
	
	tsk->min_flt = tsk->maj_flt = 0;
	tsk->nvcsw = tsk->nivcsw = 0;
#ifdef CONFIG_DETECT_HUNG_TASK
	tsk->last_switch_count = tsk->nvcsw + tsk->nivcsw;
#endif
	//初始化task的mm_struct和VMA为空
	tsk->mm = NULL;
	tsk->active_mm = NULL;

	/*
	 * Are we cloning a kernel thread?
	 *
	 * We need to steal a active VM for that..
	 */
	oldmm = current->mm;		//current宏表明当前进程,即父进程
	if (!oldmm)		//如果父进程使一个没有进程地址空间的内核线程,不需要为子进程做内存复制,直接退出
		return 0;

	/* initialize the new vmacache entries */
	vmacache_flush(tsk);
	//如果调用vfork创建子进程,那么CLONE_VM标志位就会被置位,因此子进程进程的mm直接指向父进程的内存描述符
	if (clone_flags & CLONE_VM) {
    
		atomic_inc(&oldmm->mm_users);
		mm = oldmm;
		goto good_mm;
	}
	//如果CLONE_VM没有置位,那么调用dump_mm来复制父进程的进程地址空间
	retval = -ENOMEM;
	mm = dup_mm(tsk);
	if (!mm)
		goto fail_nomem;

good_mm:
	tsk->mm = mm;
	tsk->active_mm = mm;
	return 0;

fail_nomem:
	return retval;
}

该函数比较简单,其主要做了以下几件事情

  • 如果使内核线程,也就是当前进程地址空间为空,就不需要为子进程做内存复制,直接退出
  • 在创建的时候,会根据fork参数的clone_flags来决定,如果是CLONE_VM标志位就会被置位,子进程的mm指针指向父进程的内存描述符的mm即可
  • 如果CLONE_VM没有被置为,那么调用dump_mm来复制父进程的进程地址空间

dum_mm函数实现也在fork.c文件中,实现也比较简单

static struct mm_struct *dup_mm(struct task_struct *tsk)
{
    
	struct mm_struct *mm, *oldmm = current->mm;
	int err;
//1.通过allocate_mm分配属于进程自己的mm_struct结构来管理自己的地址空间
	mm = allocate_mm();
	if (!mm)
		goto fail_nomem;

	memcpy(mm, oldmm, sizeof(*mm));
//2.通过mm_init来初始化mm_struct中相关成员
	if (!mm_init(mm, tsk, mm->user_ns))
		goto fail_nomem;
//3.通过dup_mmap来复制父进程的地址空间
	err = dup_mmap(mm, oldmm);
	if (err)
		goto free_pt;

	mm->hiwater_rss = get_mm_rss(mm);
	mm->hiwater_vm = mm->total_vm;

	if (mm->binfmt && !try_module_get(mm->binfmt->module))
		goto free_pt;

	return mm;

free_pt:
	/* don't put binfmt in mmput, we haven't got module yet */
	mm->binfmt = NULL;
	mmput(mm);

fail_nomem:
	return NULL;
}

分配mm_struct结构就不需要赘述,我们先看下mm_init,其函数如下

static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p,
	struct user_namespace *user_ns)
{
    
// 1. 初始化mm
	mm->mmap = NULL;
	mm->mm_rb = RB_ROOT;
	mm->vmacache_seqnum = 0;
	atomic_set(&mm->mm_users, 1);
	atomic_set(&mm->mm_count, 1);
	init_rwsem(&mm->mmap_sem);
	INIT_LIST_HEAD(&mm->mmlist);
	mm->core_state = NULL;
	atomic_long_set(&mm->nr_ptes, 0);
	mm_nr_pmds_init(mm);
	mm->map_count = 0;
	mm->locked_vm = 0;
	mm->pinned_vm = 0;
	memset(&mm->rss_stat, 0, sizeof(mm->rss_stat));
	spin_lock_init(&mm->page_table_lock);
	mm_init_cpumask(mm);
	mm_init_aio(mm);
	mm_init_owner(mm, p);
	RCU_INIT_POINTER(mm->exe_file, NULL);
	mmu_notifier_mm_init(mm);
	clear_tlb_flush_pending(mm);
#if defined(CONFIG_TRANSPARENT_HUGEPAGE) && !USE_SPLIT_PMD_PTLOCKS
	mm->pmd_huge_pte = NULL;
#endif
	mm_init_uprobes_state(mm);

	if (current->mm) {
    
		mm->flags = current->mm->flags & MMF_INIT_MASK;
		mm->def_flags = current->mm->def_flags & VM_INIT_DEF_MASK;
	} else {
    
		mm->flags = default_dump_filter;
		mm->def_flags = 0;
	}
//2,分配一个进程私有的page页,当需要va->pa转换的时候,查找属于当前进程的pgd表项
	if (mm_alloc_pgd(mm))
		goto fail_nopgd;
//3. 设置了mm->context.id为0,当进程调度的时候进行地址空间切换,如果mm->context.id为0就为进程分配新的ASID
	if (init_new_context(p, mm))
		goto fail_nocontext;

	mm->user_ns = get_user_ns(user_ns);
	return mm;
}

每个进程在创建的时都会分配一级页表,并且内存描述符中一个pdg的成员指向这个进程的一级页表的基地址。当进程初始化完成后,需要转换,进程切换的时候,会使用tsk->mm->pgd指向的页表作为base来进程页表中遍历,对于ARM64架构来说,他们由两个页表的基地址寄存器ttbr0_el1和ttbr1_el0。

讲完mm_init相关的内容,接着返回dum_mmap,dup_mmap函数参数中,mm表示新进程的mm_struct数据结构,oldmm表示父进程的mm_struct数据结构。该函数的主要作用是遍历父进程中所有的VMA,然后复制父进程VMA中对应的PTE到子进程的VMA对应的PTE中。注意,只是复制PTE,并不是复制VMA对应页面的内容。

static __latent_entropy int dup_mmap(struct mm_struct *mm,
					struct mm_struct *oldmm)
{
    
    down_write_killable(&oldmm->mmap_sem);
    for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
    
    			INIT_LIST_HEAD(&tmp->anon_vma_chain);
		retval = vma_dup_policy(mpnt, tmp);
		if (retval)
			goto fail_nomem_policy;
		tmp->vm_mm = mm;
		if (anon_vma_fork(tmp, mpnt))
			goto fail_nomem_anon_vma_fork;
        		__vma_link_rb(mm, tmp, rb_link, rb_parent);
		rb_link = &tmp->vm_rb.rb_right;
		rb_parent = &tmp->vm_rb;

		mm->map_count++;
		retval = copy_page_range(mm, oldmm, mpnt);
    }
    up_write(&mm->mmap_sem);
}
  • 由于后续会修改父进程的进程地址空间,因此要给父进程加上一个写类型的信号量
  • 通过fork循环遍历父进程中所有的VMA,进程中所有的VMA都会添加到内存描述符的mmap成员指向的链表中
  • vma_dup_policy为子进程创建一个VMA,子进程VMA中有一个链表aon_vma_chain,用于存放aon_vma_chain数据结构,用在RMAP机制中
  • anon_vma_fork函数创建属于子进程的aon_vma数据结构,并使用aon_vma_chain来实现父子进程VMA的链接
  • __vma_link_rb把刚才创建的VMA插入子进程的mm
  • copy_page_range复制父进程VMA的页表到子进程页表中

对于每一个vma都调用copy_page_range,此函数会遍历vma中每一个虚拟页,然后拷贝父进程的页表到子进程(虚拟页对应的页表存在的话),这里主要是页表遍历的代码,从pgd->copy_page_range->copy_pud_range->copy_pmd_range->copy_pte_range

static int copy_pte_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
		   pmd_t *dst_pmd, pmd_t *src_pmd, struct vm_area_struct *vma,
		   unsigned long addr, unsigned long end)
{
    
    	do {
    
		/*
		 * We are holding two locks at this point - either of them
		 * could generate latencies in another task on another CPU.
		 */
		if (progress >= 32) {
    
			progress = 0;
			if (need_resched() ||
			    spin_needbreak(src_ptl) || spin_needbreak(dst_ptl))
				break;
		}
		if (pte_none(*src_pte)) {
    
			progress++;
			continue;
		}
		entry.val = copy_one_pte(dst_mm, src_mm, dst_pte, src_pte,
							vma, addr, rss);
		if (entry.val)
			break;
		progress += 8;
	}
}

我们看的在copy_present_pte函数中,对父子进程的写保护处理,也就是当发现父进程的vma的属性为私有可写的时候,就设置父进程和子进程的相关的页表项为只读。这点很重要,因为这样既保证了父子进程的地址空间的共享(读的时候),又保证了他们有独立的地址空间(写的时候)。

2.2 写时复制发生

ork创建完子进程后,通过复制父进程的页表来共享父进程的地址空间,我们知道对于私有的可写的页,设置了父子进程的相应页表为为只读,这样就为写实复制创造了页表层面上的条件。当父进程或者子进程,写写保护的页时触发访问权限异常:

 ...   //处理器架构处理
 do_page_fault                       // arch/arm64/mm/fault.c
->  __do_page_fault
    ->  handle_mm_fault 
        -> handle_pte_fault      //mm/memory.c
            ->  if (vmf->flags & FAULT_FLAG_WRITE) {
              
                      if (!pte_write(entry))                
                              return do_wp_page(vmf);       
                      entry = pte_mkdirty(entry);           
              }            

这一章的详细内容,请参考linux内存管理笔记(三十六)----写时复制

3. 总结

fork的时候会创建内核管理初始化,例如mm_struct, vma等用于描述进程自己的地址空间,然后会创建出进程私有的pgd页,用于页表遍历时填充页表,然后还会拷贝父进程所有的vma,然后就是对于每个vma做页表的拷贝和写保护操作。后面的pud pmd的其他各级页表的创建和填充工作由缺页异常处理来完成。

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/u012489236/article/details/116902564

智能推荐

随便推点