copy_mm流程解析,顺便问两个问题。。没看太懂。。

cluter

只讲大体流程，不过分追究细节了，因为细节我也没全搞懂，所以只能先整体上把握了。。。 希望大牛指正！

1. //******************************copy_mm**********************************************
   
2. static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
   
3. {
   
4. 
   
5.         // 1 如果内存空间共享,直接增加内存描述符mm的引用计数,然后退出
   
6.         if (clone_flags & CLONE_VM) {
   
7.                 atomic_inc(&oldmm->mm_users);
   
8.                 mm = oldmm;
   
9.                 goto good_mm;
   
10.         }
    
11. 
    
12.         // 2 如果内存空间不共享,则创建一个新的内存空间
    
13.         mm = dup_mm(tsk);
    
14. 
    
15. 
    
16. good_mm:
    
17. 
    
18.         // 3 对于进程来说mm和active_mm指向同一内存描述符mm
    
19.         //   对于内核线程来说,使用active_mm指向当前进程的内存描述符mm
    
20.         //   内核线程不使用线性区
    
21.         tsk->mm = mm;
    
22.         tsk->active_mm = mm;
    
23.         return 0;
    
24. 
    
25. }
    
26. 
    
27. 
    
28. 
    
29. struct mm_struct *dup_mm(struct task_struct *tsk)
    
30. {
    
31. 
    
32.         // 1 为新进程分配一个新的内存描述符mm
    
33.         mm = allocate_mm();
    
34. 
    
35. 
    
36.         // 2 先拷贝父进程内存描述符的所有内容
    
37.         memcpy(mm, oldmm, sizeof(*mm));
    
38. 
    
39. 
    
40.         // 3 初始化新内存描述符mm中的字段(包括为新进程分配一个新的pgd)
    
41.         if (!mm_init(mm, tsk))
    
42.                 goto fail_nomem;
    
43. 
    
44. 
    
45.         // 4 复制父进程的线性区间和页表
    
46.         err = dup_mmap(mm, oldmm);
    
47. 
    
48. }
    
49. 
    
50. 
    
51. 
    
52. // 1 分配新的vma线性区并初始化
    
53. // 2 如果vma线性区是file 映射则加入priority-search tree
    
54. // 3 把新的vma线性区加入内存描述符mm的red-black tree
    
55. // 4 链接vma线性区间
    
56. // 5 复制页表项
    
57. static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
    
58. {
    
59.         struct vm_area_struct *mpnt, *tmp, *prev, **pprev;
    
60.         struct rb_node **rb_link, *rb_parent;
    
61.         int retval;
    
62.         unsigned long charge;
    
63.         struct mempolicy *pol;
    
64. 
    
65.         //获取锁
    
66.         down_write(&oldmm->mmap_sem);
    
67.         flush_cache_dup_mm(oldmm);
    
68.         /*
    
69.          * Not linked in yet - no deadlock potential:
    
70.          */
    
71.         down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
    
72. 
    
73.         //初始化mm描述符
    
74.         mm->locked_vm = 0;
    
75.         mm->mmap = NULL;
    
76.         mm->mmap_cache = NULL;
    
77.         mm->free_area_cache = oldmm->mmap_base;
    
78.         mm->cached_hole_size = ~0UL;
    
79.         mm->map_count = 0;
    
80.         cpumask_clear(mm_cpumask(mm));
    
81.         mm->mm_rb = RB_ROOT;
    
82.         rb_link = &mm->mm_rb.rb_node;
    
83.         rb_parent = NULL;
    
84.         pprev = &mm->mmap;
    
85.         retval = ksm_fork(mm, oldmm);
    
86.         if (retval)
    
87.                 goto out;
    
88. 
    
89.         prev = NULL;
    
90.         //开始复制vma线性区
    
91.         for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
    
92.                 struct file *file;
    
93. 
    
94.                 //线性区间不允许拷贝
    
95.                 if (mpnt->vm_flags & VM_DONTCOPY) {
    
96.                         long pages = vma_pages(mpnt);
    
97.                         //那么进程地址空间大小就要减去该线性区间
    
98.                         mm->total_vm -= pages;
    
99.                         vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
    
100.                                                                 -pages);
     
101.                         continue;
     
102.                 }
     
103.                 charge = 0;
     
104.                 //IPC共享线性区,检查是否有足够的内存用于映射
     
105.                 if (mpnt->vm_flags & VM_ACCOUNT) {
     
106.                         unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
     
107.                         if (security_vm_enough_memory(len))
     
108.                                 goto fail_nomem;
     
109.                         charge = len;
     
110.                 }
     
111.                 //分配一个新的vma线性区
     
112.                 tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
     
113.                 if (!tmp)
     
114.                         goto fail_nomem;
     
115.                 //复制内容
     
116.                 *tmp = *mpnt;
     
117.                 INIT_LIST_HEAD(&tmp->anon_vma_chain);
     
118.                 pol = mpol_dup(vma_policy(mpnt));
     
119.                 retval = PTR_ERR(pol);
     
120.                 if (IS_ERR(pol))
     
121.                         goto fail_nomem_policy;
     
122.                 vma_set_policy(tmp, pol);
     
123.                 if (anon_vma_fork(tmp, mpnt))
     
124.                         goto fail_nomem_anon_vma_fork;
     
125.                 tmp->vm_flags &= ~VM_LOCKED;
     
126.                 tmp->vm_mm = mm;
     
127.                 tmp->vm_next = tmp->vm_prev = NULL;
     
128.                 file = tmp->vm_file;
     
129.                 //该vma线性区是否是文件映射
     
130.                 if (file) {
     
131.                         //获取该文件映射对应的address_space
     
132.                         struct inode *inode = file->f_path.dentry->d_inode;
     
133.                         struct address_space *mapping = file->f_mapping;
     
134. 
     
135.                         get_file(file);
     
136.                         if (tmp->vm_flags & VM_DENYWRITE)
     
137.                                 atomic_dec(&inode->i_writecount);
     
138.                         spin_lock(&mapping->i_mmap_lock);
     
139.                         if (tmp->vm_flags & VM_SHARED)
     
140.                                 mapping->i_mmap_writable++;
     
141.                         tmp->vm_truncate_count = mpnt->vm_truncate_count;
     
142.                         flush_dcache_mmap_lock(mapping);
     
143.                         /* insert tmp into the share list, just after mpnt */
     
144.                         //新的vma线性区直接插入priority-search tree
     
145.                         //priority-search tree主要用于页框回收时,释放所有映射该页框的页表项
     
146.                         vma_prio_tree_add(tmp, mpnt);
     
147.                         flush_dcache_mmap_unlock(mapping);
     
148.                         spin_unlock(&mapping->i_mmap_lock);
     
149.                 }
     
150. 
     
151.                 /*
     
152.                  * Clear hugetlb-related page reserves for children. This only
     
153.                  * affects MAP_PRIVATE mappings. Faults generated by the child
     
154.                  * are not guaranteed to succeed, even if read-only
     
155.                  */
     
156.                 if (is_vm_hugetlb_page(tmp))
     
157.                         reset_vma_resv_huge_pages(tmp);
     
158. 
     
159.                 /*
     
160.                  * Link in the new vma and copy the page table entries.
     
161.                  */
     
162.                  //把刚分配的vma线性区链接起来
     
163.                 *pprev = tmp;
     
164.                 pprev = &tmp->vm_next;
     
165.                 tmp->vm_prev = prev;
     
166.                 prev = tmp;
     
167.                 //把新分配的vma线性区插入red-black tree
     
168.                 __vma_link_rb(mm, tmp, rb_link, rb_parent);
     
169.                 rb_link = &tmp->vm_rb.rb_right;
     
170.                 rb_parent = &tmp->vm_rb;
     
171. 
     
172.                 mm->map_count++;
     
173.                 //拷贝页表项
     
174.                 retval = copy_page_range(mm, oldmm, mpnt);
     
175. 
     
176.                 if (tmp->vm_ops && tmp->vm_ops->open)
     
177.                         tmp->vm_ops->open(tmp);
     
178. 
     
179.                 if (retval)
     
180.                         goto out;
     
181.         }
     
182.         /* a new mm has just been created */
     
183.         arch_dup_mmap(oldmm, mm);
     
184.         retval = 0;
     
185. out:
     
186.         up_write(&mm->mmap_sem);
     
187.         flush_tlb_mm(oldmm);
     
188.         up_write(&oldmm->mmap_sem);
     
189.         return retval;
     
190. fail_nomem_anon_vma_fork:
     
191.         mpol_put(pol);
     
192. fail_nomem_policy:
     
193.         kmem_cache_free(vm_area_cachep, tmp);
     
194. fail_nomem:
     
195.         retval = -ENOMEM;
     
196.         vm_unacct_memory(charge);
     
197.         goto out;
     
198. }
     
199. 
     
200. 
     
201. 
     
202. //************copy_page_range**********************
     
203. 
     
204. //调用流程
     
205. copy_page_range
     
206.         |
     
207.         |
     
208.         |
     
209. copy_pud_range
     
210.         |
     
211.         |
     
212.         |
     
213. copy_pmd_range
     
214.               |
     
215.               |
     
216.         |
     
217. copy_pte_range
     
218.         |
     
219.         |
     
220.         |
     
221. copy_one_pte
     
222. 
     
223. 
     
224. //对于copy_one_pte有两个重要的地方
     
225. 
     
226. // 最开始是关于如果页表所映射的页框已经在swap中的处理过程
     
227. 
     
228. // 1 如果是copy on write映射,则父子页表都要写保护
     
229.         /*
     
230.          * If it's a COW mapping, write protect it both
     
231.          * in the parent and the child
     
232.          */
     
233.         if (is_cow_mapping(vm_flags)) {
     
234.                 ptep_set_wrprotect(src_mm, addr, src_pte);
     
235.                 pte = pte_wrprotect(pte);
     
236.         }
     
237. 
     
238. 
     
239. // 2 如果是共享映射 ,则清空子进程页表项,属于请求调页
     
240.      [size=7][color=Magenta]  //如果是共享映射,为啥不直接负责页表项,而是清空子进程页表项？[/color][/size]
     
241. 
     
242.         /*
     
243.          * If it's a shared mapping, mark it clean in
     
244.          * the child
     
245.          */
     
246.         if (vm_flags & VM_SHARED)
     
247.                 pte = pte_mkclean(pte);
     
248.         pte = pte_mkold(pte);[color=Red][size=7]------>这里标记页表被访问过是啥意思？[/size][/color]
     
249. 
     

复制代码

cluter

// 2 如果是共享映射 ,则清空子进程页表项,属于请求调页
       //如果是共享映射,为啥不直接复制页表项,而是清空子进程页表项？

        /*
         * If it's a shared mapping, mark it clean in
         * the child
         */
        if (vm_flags & VM_SHARED)
                pte = pte_mkclean(pte);
        pte = pte_mkold(pte);------>这里标记页表被访问过是啥意思？

chishanmingshen

pte_mkclean/pte_mkold都是修正父进程的pte,然后拷贝到子进程的页表中,你的理解没错.
mkclean不等于清空

懂医术的厨师

1. copy_mm一开始就判断是否CLONE_VM，如果是则加一。否则拷贝，直到copy_page_range，此时以明确不再share,如果发现share,则清空子进程的pte
2.清空pte并不是暴力删除这个条目，可能以后还会用呢，所以直接mark为clean就行了，lazy work

cluter

谢谢楼上2位。。。

cluter

回复 4# 懂医术的厨师


    mkold是标记页表项已经被访问过？这个用意何在？和页框回收有关系?

懂医术的厨师

回复 6# cluter

和tlb，proc统计等有关，简单贴段：
int ptep_clear_flush_young(struct vm_area_struct *vma,
{
    young = ptep_test_and_clear_young(vma, address, ptep);
    if (young)
      flush_tlb_page(vma, address);
...

cluter

回复 7# 懂医术的厨师


    谢谢LS解答。。