2023-06-11  阅读(244)
原文作者:奇小葩 原文地址:https://blog.csdn.net/u012489236/category_10946851.html

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

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

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

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

1. 写时复制技术

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

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

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

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

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

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

202306111304258931.png

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的其他各级页表的创建和填充工作由缺页异常处理来完成。

阅读全文
  • 点赞