2.4.0版本page结构使用计数的疑问

augustusqing

《情景分析》中，2.4.0中，说一个page结构时，有且并且只有一个进程映射到这个页面时，使用计数会是2
但是，在缺页异常处理中，分配一个匿名内存页时，这个计数却只会是alloc_page()中的初始值1，再加1的地方在哪了？

1. /*
   
2. * This only needs the MM semaphore
   
3. */
   
4. static int do_anonymous_page(struct mm_struct * mm, struct vm_area_struct * vma, pte_t *page_table, int write_access, unsigned long addr)
   
5. {
   
6.         struct page *page = NULL;
   
7.         pte_t entry = pte_wrprotect(mk_pte(ZERO_PAGE(addr), vma->vm_page_prot));
   
8.         if (write_access) {
   
9.                 page = alloc_page(GFP_HIGHUSER);
   
10.                 if (!page)
    
11.                         return -1;
    
12.                 clear_user_highpage(page, addr);
    
13.                 entry = pte_mkwrite(pte_mkdirty(mk_pte(page, vma->vm_page_prot)));
    
14.                 mm->rss++;
    
15.                 flush_page_to_ram(page);
    
16.         }
    
17.         set_pte(page_table, entry);
    
18.         /* No need to invalidate - it was non-present before */
    
19.         update_mmu_cache(vma, addr, entry);
    
20.         return 1;        /* Minor fault */
    
21. }

复制代码

在alloc_page()中：

1. set_page_count(page, 1);

复制代码

同时在缺页异常中，是因为COW而调用do_wp_page()函数，新分配一个page页，从旧页拷贝数据到新页，再释放旧页，也不会增加新页的使用计数，这是为什么了？

1. 
   
2. static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
   
3.         unsigned long address, pte_t *page_table, pte_t pte)
   
4. {
   
5.         struct page *old_page, *new_page;
   
6. /*
   
7.          * Ok, we need to copy. Oh, well..
   
8.          */
   
9.         spin_unlock(&mm->page_table_lock);
   
10.         new_page = page_cache_alloc();
    
11.         if (!new_page)
    
12.                 return -1;
    
13.         spin_lock(&mm->page_table_lock);
    
14. 
    
15.         /*
    
16.          * Re-check the pte - we dropped the lock
    
17.          */
    
18.         if (pte_same(*page_table, pte)) {
    
19.                 if (PageReserved(old_page))
    
20.                         ++mm->rss;
    
21.                 break_cow(vma, old_page, new_page, address, page_table);
    
22. 
    
23.                 /* Free the old page.. */
    
24.                 new_page = old_page;
    
25.         }
    
26.         spin_unlock(&mm->page_table_lock);
    
27.         page_cache_release(new_page);
    
28.         return 1;        /* Minor fault */
    
29. 
    
30. bad_wp_page:
    
31.         spin_unlock(&mm->page_table_lock);
    
32.         printk("do_wp_page: bogus page at address %08lx (page 0x%lx)\n",address,(unsigned long)old_page);
    
33.         return -1;
    
34. }
    

复制代码

谢谢，：）

augustusqing

而在2.6.12的do_wp_page中，则在分配page页后，增加使用计数的地方

1. 
   
2. static int do_wp_page(struct mm_struct *mm, struct vm_area_struct * vma,
   
3.         unsigned long address, pte_t *page_table, pmd_t *pmd, pte_t pte)
   
4. {
   
5.         struct page *old_page, *new_page;
   
6.         unsigned long pfn = pte_pfn(pte);
   
7.         pte_t entry;
   
8. /*
   
9.          * Ok, we need to copy. Oh, well..
   
10.          */
    
11.         if (!PageReserved(old_page))
    
12.                 page_cache_get(old_page);
    
13.         spin_unlock(&mm->page_table_lock);
    
14. 
    
15.         if (unlikely(anon_vma_prepare(vma)))
    
16.                 goto no_new_page;
    
17.         if (old_page == ZERO_PAGE(address)) {
    
18.                 new_page = alloc_zeroed_user_highpage(vma, address);
    
19.                 if (!new_page)
    
20.                         goto no_new_page;
    
21.         } else {
    
22.                 new_page = alloc_page_vma(GFP_HIGHUSER, vma, address);
    
23.                 if (!new_page)
    
24.                         goto no_new_page;
    
25.                 copy_user_highpage(new_page, old_page, address);
    
26.         }
    
27.         /*
    
28.          * Re-check the pte - we dropped the lock
    
29.          */
    
30.         spin_lock(&mm->page_table_lock);
    
31.         page_table = pte_offset_map(pmd, address);
    
32.         if (likely(pte_same(*page_table, pte))) {
    
33.                 if (PageAnon(old_page))
    
34.                         dec_mm_counter(mm, anon_rss);
    
35.                 if (PageReserved(old_page))
    
36.                         inc_mm_counter(mm, rss);
    
37.                 else
    
38.                         page_remove_rmap(old_page);
    
39.                 flush_cache_page(vma, address, pfn);
    
40.                 break_cow(vma, new_page, address, page_table);
    
41.                 [color=Red]lru_cache_add_active(new_page);[/color]
    
42.                 page_add_anon_rmap(new_page, vma, address);
    
43. 
    
44.                 /* Free the old page.. */
    
45.                 new_page = old_page;
    
46.         }
    
47.         pte_unmap(page_table);
    
48.         page_cache_release(new_page);
    
49.         page_cache_release(old_page);
    
50.         spin_unlock(&mm->page_table_lock);
    
51.         return VM_FAULT_MINOR;
    
52. 
    
53. no_new_page:
    
54.         page_cache_release(old_page);
    
55.         return VM_FAULT_OOM;
    
56. }
    
57. void fastcall lru_cache_add_active(struct page *page)
    
58. {
    
59.         struct pagevec *pvec = &get_cpu_var(lru_add_active_pvecs);
    
60. 
    
61.         [color=Red]page_cache_get(page);[/color]
    
62.         if (!pagevec_add(pvec, page))
    
63.                 __pagevec_lru_add_active(pvec);
    
64.         put_cpu_var(lru_add_active_pvecs);
    
65. }
    

复制代码