page_launder()函数疑问？

_nosay

Linux-2.4.0源码中的page_launder()函数：
我开始以为这个函数分2遍扫描，是在利用“第二次机会算法”，但看来不是，因为页面既然都到了inactive_dirty_list链表，就相当于被判了“死刑”，必须接受“死刑”往交换区写一次，才能变干净，也就没必要像“第二次机会算法”那样排个“你先死我后死”了。所以我猜测“第二次机会算法”应该是用于挑选将要移到inactive_dirty_list链表的页面，而不是用于挑选从inactive_dirty_list链表往交换区写的页面。

这个函数的注释里面有这样一句话：
Since we want to refill those pages as soon as possible, we'll make two loops over the inactive list, one to move the already cleaned pages to the inactive_clean lists and one to (often asynchronously) clean the dirty inactive pages.

如果第1遍扫描之后，空闲页面还是短缺，这个函数会执行第2遍扫描，将链表中的页面全部写到交换区（即洗成干净页面），以后的一段时间，再执行到该函数，一般第1遍扫描就能解决空闲页面短缺的问题，而且只是将上次第2遍扫描过程洗干净的页面直接转移到page->zone->inactive_clean_list链表即可，所以保证了这个函数大部分时间执行很快。

这个函数我看了好久，现在终于感觉有点理解了，请问是我理解的这样吗 ？

即使是这样，我还有疑问：
① 这种牺牲1次，提高大多次，好处体现在哪？反而有个缺点就是：在第2遍扫描时，如果inactive_dirty_list链表很长，内核不是会出现“卡顿”的现象吗？而且页面在链表中移来移去的，从整体上讲，性能也是有损失的（除非内核能保证，第2遍扫描大多数在CPU空闲的时候执行）。
② 第2遍扫描只是将链表中的页面都写到交换区，并没有顺便移到page->zone->inactive_clean_list链表，表示本次执行page_launder()洗净的页面数量cleaned_pages仍然是第1遍扫描的结果，这样不是可能会让后续的代码，由于洗净的页面还是满足不了需求而多走一些“弯路”吗？
③ 按照逻辑，难道不是干净页面在inactive_dirty_list链表最多只可能有1段区域，并且肯定在最前面吗？所以第1遍扫描如果遇到脏页面了，后面肯定都是脏页面，这样依次都移到inactive_dirty_list链表尾部，不是绕个圈又变成原来的形状了吗？而且第2遍扫描是将链表中剩下的页面全部洗干净，也不是从前往后扫一部分就不扫了，那即使“躲”到后面，又有什么意义呢，更别说由于大家都想“躲”，而造成恢复原来的队形了。

Buddy_Zhang1

想帮您看看,可是我的内核代码里已经没有 page_launder() 这个函数了,楼主可以把这个函数贴出来看看吗....

_nosay

回复 2# Buddy_Zhang1

我最近这样往论坛发代码，不知道会不会被公司抓起来 ！我可是冒了好大危险的，你一定要帮我好好想想呀。

1. 
   
2. /**
   
3. * page_launder - clean dirty inactive pages, move to inactive_clean list
   
4. * @gfp_mask: what operations we are allowed to do
   
5. * @sync: should we wait synchronously for the cleaning of pages
   
6. *
   
7. * When this function is called, we are most likely low on free +
   
8. * inactive_clean pages. Since we want to refill those pages as
   
9. * soon as possible, we'll make two loops over the inactive list,
   
10. * one to move the already cleaned pages to the inactive_clean lists
    
11. * and one to (often asynchronously) clean the dirty inactive pages.
    
12. *
    
13. * In situations where kswapd cannot keep up, user processes will
    
14. * end up calling this function. Since the user process needs to
    
15. * have a page before it can continue with its allocation, we'll
    
16. * do synchronous page flushing in that case.
    
17. *
    
18. * This code is heavily inspired by the FreeBSD source code. Thanks
    
19. * go out to Matthew Dillon.
    
20. */
    
21. #define MAX_LAUNDER                 (4 * (1 << page_cluster))
    
22. int page_launder(int gfp_mask, int sync)
    
23. {
    
24.         int launder_loop, maxscan, cleaned_pages, maxlaunder;
    
25.         int can_get_io_locks;
    
26.         struct list_head * page_lru;
    
27.         struct page * page;
    
28. 
    
29.         /*
    
30.          * We can only grab the IO locks (eg. for flushing dirty
    
31.          * buffers to disk) if __GFP_IO is set.
    
32.          */
    
33.         can_get_io_locks = gfp_mask & __GFP_IO;
    
34. 
    
35.         launder_loop = 0;
    
36.         maxlaunder = 0;
    
37.         cleaned_pages = 0;
    
38. 
    
39. dirty_page_rescan:
    
40.         spin_lock(&pagemap_lru_lock);
    
41.         maxscan = nr_inactive_dirty_pages;
    
42.         while ((page_lru = inactive_dirty_list.prev) != &inactive_dirty_list &&
    
43.                                 maxscan-- > 0) {
    
44.                 page = list_entry(page_lru, struct page, lru);
    
45. 
    
46.                 /* Wrong page on list?! (list corruption, should not happen) */
    
47.                 if (!PageInactiveDirty(page)) {
    
48.                         printk("VM: page_launder, wrong page on list.\n");
    
49.                         list_del(page_lru);
    
50.                         nr_inactive_dirty_pages--;
    
51.                         page->zone->inactive_dirty_pages--;
    
52.                         continue;
    
53.                 }
    
54. 
    
55.                 /* Page is or was in use?  Move it to the active list. */
    
56.                 if (PageTestandClearReferenced(page) || page->age > 0 ||
    
57.                                 (!page->buffers && page_count(page) > 1) ||
    
58.                                 page_ramdisk(page)) {
    
59.                         del_page_from_inactive_dirty_list(page);
    
60.                         add_page_to_active_list(page);
    
61.                         continue;
    
62.                 }
    
63. 
    
64.                 /*
    
65.                  * The page is locked. IO in progress?
    
66.                  * Move it to the back of the list.
    
67.                  */
    
68.                 if (TryLockPage(page)) {
    
69.                         list_del(page_lru);
    
70.                         list_add(page_lru, &inactive_dirty_list);
    
71.                         continue;
    
72.                 }
    
73. 
    
74.                 /*
    
75.                  * Dirty swap-cache page? Write it out if
    
76.                  * last copy..
    
77.                  */
    
78.                 if (PageDirty(page)) {
    
79.                         int (*writepage)(struct page *) = page->mapping->a_ops->writepage;
    
80.                         int result;
    
81. 
    
82.                         if (!writepage)
    
83.                                 goto page_active;
    
84. 
    
85.                         /* First time through? Move it to the back of the list */
    
86.                         if (!launder_loop) {
    
87.                                 list_del(page_lru);
    
88.                                 list_add(page_lru, &inactive_dirty_list);
    
89.                                 UnlockPage(page);
    
90.                                 continue;
    
91.                         }
    
92. 
    
93.                         /* OK, do a physical asynchronous write to swap.  */
    
94.                         ClearPageDirty(page);
    
95.                         page_cache_get(page);
    
96.                         spin_unlock(&pagemap_lru_lock);
    
97. 
    
98.                         result = writepage(page);
    
99.                         page_cache_release(page);
    
100. 
     
101.                         /* And re-start the thing.. */
     
102.                         spin_lock(&pagemap_lru_lock);
     
103.                         if (result != 1)
     
104.                                 continue;
     
105.                         /* writepage refused to do anything */
     
106.                         set_page_dirty(page);
     
107.                         goto page_active;
     
108.                 }
     
109. 
     
110.                 /*
     
111.                  * If the page has buffers, try to free the buffer mappings
     
112.                  * associated with this page. If we succeed we either free
     
113.                  * the page (in case it was a buffercache only page) or we
     
114.                  * move the page to the inactive_clean list.
     
115.                  *
     
116.                  * On the first round, we should free all previously cleaned
     
117.                  * buffer pages
     
118.                  */
     
119.                 if (page->buffers) {
     
120.                         int wait, clearedbuf;
     
121.                         int freed_page = 0;
     
122.                         /*
     
123.                          * Since we might be doing disk IO, we have to
     
124.                          * drop the spinlock and take an extra reference
     
125.                          * on the page so it doesn't go away from under us.
     
126.                          */
     
127.                         del_page_from_inactive_dirty_list(page);
     
128.                         page_cache_get(page);
     
129.                         spin_unlock(&pagemap_lru_lock);
     
130. 
     
131.                         /* Will we do (asynchronous) IO? */
     
132.                         if (launder_loop && maxlaunder == 0 && sync)
     
133.                                 wait = 2;        /* Synchrounous IO */
     
134.                         else if (launder_loop && maxlaunder-- > 0)
     
135.                                 wait = 1;        /* Async IO */
     
136.                         else
     
137.                                 wait = 0;        /* No IO */
     
138. 
     
139.                         /* Try to free the page buffers. */
     
140.                         clearedbuf = try_to_free_buffers(page, wait);
     
141. 
     
142.                         /*
     
143.                          * Re-take the spinlock. Note that we cannot
     
144.                          * unlock the page yet since we're still
     
145.                          * accessing the page_struct here...
     
146.                          */
     
147.                         spin_lock(&pagemap_lru_lock);
     
148. 
     
149.                         /* The buffers were not freed. */
     
150.                         if (!clearedbuf) {
     
151.                                 add_page_to_inactive_dirty_list(page);
     
152. 
     
153.                         /* The page was only in the buffer cache. */
     
154.                         } else if (!page->mapping) {
     
155.                                 atomic_dec(&buffermem_pages);
     
156.                                 freed_page = 1;
     
157.                                 cleaned_pages++;
     
158. 
     
159.                         /* The page has more users besides the cache and us. */
     
160.                         } else if (page_count(page) > 2) {
     
161.                                 add_page_to_active_list(page);
     
162. 
     
163.                         /* OK, we "created" a freeable page. */
     
164.                         } else /* page->mapping && page_count(page) == 2 */ {
     
165.                                 add_page_to_inactive_clean_list(page);
     
166.                                 cleaned_pages++;
     
167.                         }
     
168. 
     
169.                         /*
     
170.                          * Unlock the page and drop the extra reference.
     
171.                          * We can only do it here because we ar accessing
     
172.                          * the page struct above.
     
173.                          */
     
174.                         UnlockPage(page);
     
175.                         page_cache_release(page);
     
176. 
     
177.                         /*
     
178.                          * If we're freeing buffer cache pages, stop when
     
179.                          * we've got enough free memory.
     
180.                          */
     
181.                         if (freed_page && !free_shortage())
     
182.                                 break;
     
183.                         continue;
     
184.                 } else if (page->mapping && !PageDirty(page)) {
     
185.                         /*
     
186.                          * If a page had an extra reference in
     
187.                          * deactivate_page(), we will find it here.
     
188.                          * Now the page is really freeable, so we
     
189.                          * move it to the inactive_clean list.
     
190.                          */
     
191.                         del_page_from_inactive_dirty_list(page);
     
192.                         add_page_to_inactive_clean_list(page);
     
193.                         UnlockPage(page);
     
194.                         cleaned_pages++;
     
195.                 } else {
     
196. page_active:
     
197.                         /*
     
198.                          * OK, we don't know what to do with the page.
     
199.                          * It's no use keeping it here, so we move it to
     
200.                          * the active list.
     
201.                          */
     
202.                         del_page_from_inactive_dirty_list(page);
     
203.                         add_page_to_active_list(page);
     
204.                         UnlockPage(page);
     
205.                 }
     
206.         }
     
207.         spin_unlock(&pagemap_lru_lock);
     
208. 
     
209.         /*
     
210.          * If we don't have enough free pages, we loop back once
     
211.          * to queue the dirty pages for writeout. When we were called
     
212.          * by a user process (that /needs/ a free page) and we didn't
     
213.          * free anything yet, we wait synchronously on the writeout of
     
214.          * MAX_SYNC_LAUNDER pages.
     
215.          *
     
216.          * We also wake up bdflush, since bdflush should, under most
     
217.          * loads, flush out the dirty pages before we have to wait on
     
218.          * IO.
     
219.          */
     
220.         if (can_get_io_locks && !launder_loop && free_shortage()) {
     
221.                 launder_loop = 1;
     
222.                 /* If we cleaned pages, never do synchronous IO. */
     
223.                 if (cleaned_pages)
     
224.                         sync = 0;
     
225.                 /* We only do a few "out of order" flushes. */
     
226.                 maxlaunder = MAX_LAUNDER;
     
227.                 /* Kflushd takes care of the rest. */
     
228.                 wakeup_bdflush(0);
     
229.                 goto dirty_page_rescan;
     
230.         }
     
231. 
     
232.         /* Return the number of pages moved to the inactive_clean list. */
     
233.         return cleaned_pages;
     
234. }
     

复制代码

_nosay

回复 2# Buddy_Zhang1

书上面说，这个函数是由多个线程执行的。


   

nswcfd

如果不是私有代码，引用公开的lxr就可以了，不过现在2.4版本的应该不多了。

_nosay

回复 5# nswcfd

我看的是《Linux内核源代码情景分析》，它对应的是2.4.0版本。