Linux內核之頁面換出詳解

kswap線程主要用於頁面的按期換出,接下來講說kswap線程的實現

首先kswap線程的初始化時,須要根據物理內存的大小設置一個page_cluster變量的值,這個值表示預讀數目

(好比原本只讀一個頁面,預讀3個,就會一次性讀取3個頁面,這樣根據訪問局部性原理有利於提升速度)

kswap是一個線程共享內核的內存空間,建立使用kernel_thread建立

kswap線程首先調用inactive_shortage()檢查整個系統物理頁面是否短缺.

系統物理頁面的最低底線值由freepages.high(空閒頁面的數量),inactive_targe(不活躍頁面的數目)提供

而系統物理頁面的實際可用物理頁面由三部分組成,分別是

空閒頁面(當即可分配,來自於各個zone),其數目由nr_free_pages()統計提供

不活躍乾淨頁面(本質是能夠分配的頁面,但其頁面還存在內容(在swap緩存),多保留這樣的頁面有利於減小從swap設備讀入,提供速度),其數量由nr_inactive_clean_pages記錄

不活躍髒頁面(須要寫入交換設備後,才能被分配的),由nr_inactive_dirty_pages記錄

1. int inactive_shortage(void)
2. {
3. int shortage = 0;
4. //系統應該維持的物理內存由xxxhigh跟target維持
5. //實際的由下面3個函數統計，若是無法知足那就返回正數
6. shortage += freepages.high;
7. shortage += inactive_target;
8. shortage -= nr_free_pages();
9. shortage -= nr_inactive_clean_pages();
10. shortage -= nr_inactive_dirty_pages;
12. if (shortage > 0)
13. return shortage;
15. return 0;
16. }

即便以上條件知足(及實際頁面數目高於底線數目),還須要調用free_shortage()檢查各個管理區是否頁面很是短缺.

統計管理區的實際的頁面是否知足管理區的水準,若是不知足,則返回差值..

2. /*
3. * Check if there are zones with a severe shortage of free pages,
4. * or if all zones have a minor shortage.
5. */
6. int free_shortage(void)
7. {
8. pg_data_t *pgdat = pgdat_list;//節點
9. int sum = 0;
10. int freeable = nr_free_pages() + nr_inactive_clean_pages();//實際空閒
11. int freetarget = freepages.high + inactive_target / 3;//理論空閒
12. //實際小於理論,直接返回差值,表示須要擴充
13. /* Are we low on free pages globally? */
14. if (freeable < freetarget)
15. return freetarget - freeable;
17. /* If not, are we very low on any particular zone? */
18. do {
19. int i;
20. for(i = 0; i < MAX_NR_ZONES; i++) {
21. zone_t *zone = pgdat->node_zones+ i;//獲取管理區
22. if (zone->size && (zone->inactive_clean_pages +
23. zone->free_pages < zone->pages_min+1)) {//空閒頁面+乾淨不活躍頁面是否小於最低水準
24. /* + 1 to have overlap with alloc_pages() !! */
25. sum += zone->pages_min + 1;
26. sum -= zone->free_pages;
27. sum -= zone->inactive_clean_pages;
28. }
29. }
30. pgdat = pgdat->node_next;
31. } while (pgdat);
33. return sum;
34. }

以上兩個條件都知足,那麼將調用refill_inactive_scan函數,試圖將一些活躍頁面(沒有用戶映射)轉換爲非活躍髒頁面,

據priority的值掃描活躍隊列一部分頁面,priority爲0時才所有掃描,另外判斷頁面是否最近受到訪問,收到了就增長age值,不然減小age值

(關於age值,age爲0才考慮是否移到不活躍隊列中),接着判斷頁面age是否等於0而且判斷頁面是否有用戶進程映射(頁面分配時count設置爲1,

當作讀寫緩衝時+1,每當一個進程映射到這頁面時+1,因此須要判斷該頁面是佛屬於緩衝頁面(讀/寫),若是age=0而且沒有用戶映射,那就

調用deactivate_page_nolock()函數,將頁面的age設置爲0,清除頁面最近訪問標誌,並從活躍頁面隊列轉移到非活躍髒隊列,

固然若是頁面仍是活躍的就放入活躍隊列尾.

2. /**
3. * refill_inactive_scan - scan the active list and find pages to deactivate
4. * @priority: the priority at which to scan
5. * @oneshot: exit after deactivating one page
6. *
7. * This function will scan a portion of the active list to find
8. * unused pages, those pages will then be moved to the inactive list.
9. *///據priority的值掃描隊列一部分頁面,priority爲0時才所有掃描
10. int refill_inactive_scan(unsigned int priority, int oneshot)
11. {
12. struct list_head * page_lru;
13. struct page * page;
14. int maxscan, page_active = 0;//maxscan控制掃描頁面數目
15. int ret = 0;
17. /* Take the lock while messing with the list... */
18. spin_lock(&pagemap_lru_lock);
19. maxscan = nr_active_pages >> priority;
20. while (maxscan-- > 0 && (page_lru = active_list.prev) != &active_list) {
21. page = list_entry(page_lru, struct page, lru);
23. /* Wrong page on list?! (list corruption, should not happen) */
24. if (!PageActive(page)) {//掃描的頁面必須是在活躍隊列中
25. printk("VM: refill_inactive, wrong page on list.\n");
26. list_del(page_lru);
27. nr_active_pages--;
28. continue;
29. }
31. /* 判斷頁面是否受到訪問,,決定增長或減小壽命,若是減小壽命到0,那說明此頁面好久都沒訪問了Do aging on the pages. */
32. if (PageTestandClearReferenced(page)) {
33. age_page_up_nolock(page);
34. page_active = 1;
35. } else {
36. age_page_down_ageonly(page);
37. /*
38. * Since we don't hold a reference on the page
39. * ourselves, we have to do our test a bit more
40. * strict then deactivate_page(). This is needed
41. * since otherwise the system could hang shuffling
42. * unfreeable pages from the active list to the
43. * inactive_dirty list and back again...
44. *
45. * SUBTLE: we can have buffer pages with count 1.
46. *///緩衝頁面若是引用計數大於1,說明還要用戶空間映射,不能轉爲不活躍頁面
47. if (page->age == 0 && page_count(page) <=
48. (page->buffers ? 2 : 1)) {
49. deactivate_page_nolock(page);
50. page_active = 0;
51. } else {
52. page_active = 1;
53. }
54. }
55. /*
56. * If the page is still on the active list, move it
57. * to the other end of the list. Otherwise it was
58. * deactivated by age_page_down and we exit successfully.
59. */
60. if (page_active || PageActive(page)) {
61. list_del(page_lru);//若是頁面仍是活躍的,就放入活躍尾部
62. list_add(page_lru, &active_list);
63. } else {
64. ret = 1;
65. if (oneshot)//根據oneshot參數選擇是否繼續掃描一次
66. break;
67. }
68. }
69. spin_unlock(&pagemap_lru_lock);
71. return ret;
72. }

上面是kswap檢測了系統物理內存是夠了而且管理區物理頁面也夠了的操做,kswap線程是一個死循環,完成上述操做,再次判斷頁面是否短缺或管理區短缺,若是不短缺就調用interruptibale_sleep_on_timeon()進入睡眠,讓內核自由調度其餘進程運行,而後在內核運行必定時間(HZ本身能夠定義)後,又喚醒kswap繼續重複操做

 

2.若是判斷出系統內存不足或者管理區頁面不足則調用do_try_free_pages()試圖騰出一些內存頁面來

 1.若是頁面緊缺，或者髒的不活躍頁面的數量大於空閒頁面跟不活躍乾淨頁面的數目就須要調用page_launder試圖把不活躍狀態的髒頁面洗淨，使得它們成爲馬上可分配的頁面,

若是通過page_launder()後,系統頁面依舊緊缺,釋放dentry目錄項跟inode數據結構的緩存，通常而言即便關閉這些，頁面也不會馬上釋放而是保存到lru隊列做爲後備,不然若是頁面不緊缺了,就只調用 kmem_cache_reap回收一部分slab緩存

 

2. static int do_try_to_free_pages(unsigned int gfp_mask, int user)
3. {
4. int ret = 0;
6. /*
7. 若是頁面緊缺，或者髒的不活躍頁面的數量大於空閒頁面跟不活躍乾淨頁面的數目
8. 就須要調用page_launder試圖把不活躍狀態的髒頁面洗淨，使得它們成爲馬上可分配的
9. 頁面
10. */
11. if (free_shortage() || nr_inactive_dirty_pages > nr_free_pages() +
12. nr_inactive_clean_pages())
13. ret += page_launder(gfp_mask, user);
15. /*若是內存依舊緊缺
16. * If needed, we move pages from the active list
17. * to the inactive list. We also "eat" pages from
18. * the inode and dentry cache whenever we do this.
19. *///釋放dentry目錄項跟inode數據結構的緩存，即便關閉這些，頁面也不會馬上釋放
20. //而是保存到lru隊列做爲後備
21. if (free_shortage() || inactive_shortage()) {
22. shrink_dcache_memory(6, gfp_mask);//釋放dentry目錄項緩存
23. shrink_icache_memory(6, gfp_mask);//釋放inode緩存
24. ret += refill_inactive(gfp_mask, user);//user表示是否有等待隊列的進程
25. } else {
26. /*
27. * 不然回收slab緩存
28. */
29. kmem_cache_reap(gfp_mask);
30. ret = 1;
31. }
33. return ret;
34. }

 

以上是大致流程,接下來分析do_try_free_pages中的 page_launder()函數

做用是把不活躍狀態的髒頁面洗淨.

從不活躍髒頁面隊列取出每一個頁,判斷是否最近受到訪問(雖然是髒頁面隊列仍是有可能會受到訪問的,因此須要判斷,若是受到了訪問,那就移入活躍隊列,

頁面依舊是髒頁面,判斷是不是第一輪掃描,是的話放入隊尾而後繼續循環,不然若是是第二輪循環(固然有條件的,就是空閒頁面是否短缺),那就清除髒位,同時調用address_space提供的相關寫到swap設備的函數進行寫入.

若是頁面再也不是髒的了但做用於緩存,先把該頁面脫離髒隊列,再調用try_to_free_buffers()後,count值減一

,若是失敗了,那就轉入活躍隊列或者不活躍乾淨頁面,接着判斷 判斷該頁面是否有映射,不是的話,那就釋放該頁面,或者判斷是否還有用戶進程映射,若是有,那就轉移到活躍隊列中,不然那就是雖然此頁面曾經是映射頁面,但沒有用戶映射了,那就也釋放該頁面,(注:前面的釋放,只是設置標誌位.須要再通過page_cache_release()使其count減爲0,那就頁面進入了空閒頁面隊列了,接着判斷是否釋放了一個頁面後系統再也不短缺,那就跳出循環,結束清洗,不然

判斷頁面是不是乾淨頁面而且是以前映射過的頁面那就轉移到不活躍乾淨隊列中.

完成一趟掃描後,判斷是否頁面緊缺,若是依舊緊缺就第二輪掃描了

1. int page_launder(int gfp_mask, int sync)
2. {
3. int launder_loop, maxscan, cleaned_pages, maxlaunder;
4. int can_get_io_locks;
5. struct list_head * page_lru;
6. struct page * page;
8. /*
9. * We can only grab the IO locks (eg. for flushing dirty
10. * buffers to disk) if __GFP_IO is set.
11. */
12. can_get_io_locks = gfp_mask & __GFP_IO;
14. launder_loop = 0;
15. maxlaunder = 0;
16. cleaned_pages = 0;
18. dirty_page_rescan:
19. spin_lock(&pagemap_lru_lock);
20. maxscan = nr_inactive_dirty_pages;//避免重複處理同一頁面，設定的變量
21. //對不活躍髒頁面隊列掃描
22. while ((page_lru = inactive_dirty_list.prev) != &inactive_dirty_list &&
23. maxscan-- > 0) {
24. page = list_entry(page_lru, struct page, lru);
26. /* Wrong page on list?! (list corruption, should not happen) */
27. if (!PageInactiveDirty(page)) {檢查其標誌是否爲1
28. printk("VM: page_launder, wrong page on list.\n");
29. list_del(page_lru);//從隊列中刪除
30. nr_inactive_dirty_pages--;
31. page->zone->inactive_dirty_pages--;
32. continue;
33. }
35. /* 到了髒隊列，因爲可能受到訪問，就會放入活躍頁面隊列Page is or was in use? Move it to the active list. */
36. if (PageTestandClearReferenced(page) || page->age > 0 ||
37. (!page->buffers && page_count(page) > 1) ||
38. page_ramdisk(page)) {
39. del_page_from_inactive_dirty_list(page);//刪除非活躍隊列
40. add_page_to_active_list(page);//加入到活躍隊列中
41. continue;
42. }
44. /*頁面是否被鎖住，是的話表示把它移到隊列尾部
45. * The page is locked. IO in progress?
46. * Move it to the back of the list.
47. */
48. if (TryLockPage(page)) {
49. list_del(page_lru);
50. list_add(page_lru, &inactive_dirty_list);
51. continue;
52. }
54. /*
55. * Dirty swap-cache page? Write it out if
56. * last copy..
57. */
58. if (PageDirty(page)) {//是髒頁面
59. int (*writepage)(struct page *) = page->mapping->a_ops->writepage;
60. int result;
62. if (!writepage)//若是沒有提供具體寫swp的函數，則放入活躍隊列中
63. goto page_active;
65. /*判斷是不是第一次掃描，是的話就移到隊列尾部，繼續 First time through? Move it to the back of the list */
66. if (!launder_loop) {
67. list_del(page_lru);
68. list_add(page_lru, &inactive_dirty_list);
69. UnlockPage(page);
70. continue;
71. }
73. /* OK, do a physical asynchronous write to swap. */
74. ClearPageDirty(page);//清除page結構的_dirty位，防止再次寫入
75. page_cache_get(page);//增長page->count表示多了一個用戶操做此
76. //頁面，由於kswap線程把這個頁面寫出到swp設備中
77. spin_unlock(&pagemap_lru_lock);
79. result = writepage(page);
80. page_cache_release(page);//count--完成了寫入操做
81. //因此就用戶--了
82. /* And re-start the thing.. */
83. spin_lock(&pagemap_lru_lock);
84. if (result != 1)//寫入失敗的話
85. continue;
86. /* writepage refused to do anything */
87. set_page_dirty(page);//又設置爲髒頁
88. goto page_active;
89. }
91. /*
92. * 若是頁面不是髒的而後又是用於緩存文件讀寫的頁面
93. */
94. if (page->buffers) {
95. int wait, clearedbuf;
96. int freed_page = 0;
97. /*
98. * Since we might be doing disk IO, we have to
99. * drop the spinlock and take an extra reference
100. * on the page so it doesn't go away from under us.
101. */
102. del_page_from_inactive_dirty_list(page);//脫離髒隊列
103. page_cache_get(page);//表示kswap進程須要做用於page,count++
104. spin_unlock(&pagemap_lru_lock);
106. /* Will we do (asynchronous) IO? */
107. if (launder_loop && maxlaunder == 0 && sync)
108. wait = 2; /* Synchrounous IO */
109. else if (launder_loop && maxlaunder-- > 0)
110. wait = 1; /* Async IO */
111. else
112. wait = 0; /* No IO */
114. /*試圖將頁面釋放，這裏是count減一 Try to free the page buffers. */
115. clearedbuf = try_to_free_buffers(page, wait);
117. /*
118. * Re-take the spinlock. Note that we cannot
119. * unlock the page yet since we're still
120. * accessing the page_struct here...
121. */
122. spin_lock(&pagemap_lru_lock);
124. /* 不能釋放或者說釋放失敗繼續放入髒隊列The buffers were not freed. */
125. if (!clearedbuf) {
126. add_page_to_inactive_dirty_list(page);
128. /*/*頁面只在buffer cache隊列中，而不在某個文件的inode->i_mapping中,這樣的頁有超級塊，索引節點位圖等等，它們不屬於某個文件，所以咱們就成功釋放了一個頁面*/ 
若是該頁面只用於緩存，而非映射The page was only in the buffer cache. */
129. } else if (!page->mapping) {
130. atomic_dec(&buffermem_pages);
131. freed_page = 1;
132. cleaned_pages++;
134. /* *不然這個頁面還在某個文件的inode->i_mapping中，而且還有超過2個用戶(the cache and us)在訪問它,例若有多個進程映射到該文件若是該頁有幾個用戶，加入到活躍隊列中The page has more users besides the cache and us. */
135. } else if (page_count(page) > 2) {
136. add_page_to_active_list(page);
138. /* 最後,只剩下page->mapping && page_count(page) == 2,說明雖然這個頁面還在某個inode->i_mapping中,可是已經沒有任何用戶在訪問他們了，所以能夠釋放該頁面OK, we "created" a freeable page. */
139. } else /* page->mapping && page_count(page) == 2 */ {
140. add_page_to_inactive_clean_list(page);
141. cleaned_pages++;
142. }
144. /*
145. * Unlock the page and drop the extra reference.
146. * We can only do it here because we ar accessing
147. * the page struct above.
148. */
149. UnlockPage(page);
150. page_cache_release(page);//最終釋放頁面到空閒隊列緩存中
152. /*
153. * If we're freeing buffer cache pages, stop when
154. * we've got enough free memory.
155. 釋放了一個頁面，而且系統內存再也不緊缺，那就中止
156. */
157. if (freed_page && !free_shortage())
158. break;
159. continue;//頁面再也不是髒頁面，而且屬於address_space紅
160. } else if (page->mapping && !PageDirty(page)) {
161. /*
162. * If a page had an extra reference in
163. * deactivate_page(), we will find it here.
164. * Now the page is really freeable, so we
165. * move it to the inactive_clean list.
166. */
167. del_page_from_inactive_dirty_list(page);//轉移到不活躍隊列中
168. add_page_to_inactive_clean_list(page);
169. UnlockPage(page);
170. cleaned_pages++;
171. } else {
172. page_active:
173. /*
174. * OK, we don't know what to do with the page.
175. * It's no use keeping it here, so we move it to
176. * the active list.
177. */
178. del_page_from_inactive_dirty_list(page);
179. add_page_to_active_list(page);
180. UnlockPage(page);
181. }
182. }
183. spin_unlock(&pagemap_lru_lock);
185. /*
186. * If we don't have enough free pages, we loop back once
187. * to queue the dirty pages for writeout. When we were called
188. * by a user process (that /needs/ a free page) and we didn't
189. * free anything yet, we wait synchronously on the writeout of
190. * MAX_SYNC_LAUNDER pages.
191. *
192. * We also wake up bdflush, since bdflush should, under most
193. * loads, flush out the dirty pages before we have to wait on
194. * IO.
195. *///若是內存繼續緊缺，那就二次掃描一趟
196. if (can_get_io_locks && !launder_loop && free_shortage()) {
197. launder_loop = 1;
198. /* If we cleaned pages, never do synchronous IO. */
199. if (cleaned_pages)
200. sync = 0;
201. /* We only do a few "out of order" flushes. */
202. maxlaunder = MAX_LAUNDER;
203. /* Kflushd takes care of the rest. */
204. wakeup_bdflush(0);
205. goto dirty_page_rescan;
206. }
208. /* Return the number of pages moved to the inactive_clean list. */
209. return cleaned_pages;//返回有多少頁面被移到不活躍乾淨頁面中
210. }

若是通過page_launder後,頁面也就緊缺,那就調用shrink_dcache_memory跟shrink_icache_memory

函數分別釋放釋放dentry目錄項緩存跟釋放inode緩存,而且調用refill_inactive函數進一步回收,不然若是

頁面充裕,那就只調用kmem_cache_reap回收slab緩存

 

接下來分析refill_inactive函數.

首先判斷系統還須要多少頁面,接着回收slab緩存,而後一個do_while循環,從優先級最低的6開始,加大力度到0.

其循環調用了refill_active_scan(上面已經分析了)試圖將一部分活躍頁面轉移到非活躍髒頁面隊列,

接着調用shrink_dcache_memory跟shrink_icache_memory,函數分別釋放釋放dentry目錄項緩存跟釋放inode緩存,

接着根據count的數目屢次調用swap_out函數 試圖找出一個進程,掃描其映射表,找到能夠轉入不活躍狀態頁面,最後根據count的數目屢次調用refill_active_scan再次掃描就結束了

2. /*
3. * We need to make the locks finer granularity, but right
4. * now we need this so that we can do page allocations
5. * without holding the kernel lock etc.
6. *
7. * We want to try to free "count" pages, and we want to
8. * cluster them so that we get good swap-out behaviour.
9. *
10. * OTOH, if we're a user process (and not kswapd), we
11. * really care about latency. In that case we don't try
12. * to free too many pages.
13. */
14. static int refill_inactive(unsigned int gfp_mask, int user)
15. {
16. int priority, count, start_count, made_progress;
18. count = inactive_shortage() + free_shortage();//獲取須要的頁面數目
19. if (user)
20. count = (1 << page_cluster);
21. start_count = count;
23. /* 任什麼時候候，當頁面緊缺時，從slab開始回收Always trim SLAB caches when memory gets low. */
24. kmem_cache_reap(gfp_mask);
26. priority = 6;//從最低優先級別6開始
27. do {
28. made_progress = 0;
29. //每次循環都要檢查下當前進程是否被設置被調度,設置了,說明某個中斷程序須要調度
30. if (current->need_resched) {
31. __set_current_state(TASK_RUNNING);
32. schedule();
33. }
34. //掃描活躍頁面隊列,試圖從中找出能夠轉入不活躍狀態頁面
35. while (refill_inactive_scan(priority, 1)) {
36. made_progress = 1;
37. if (--count <= 0)
38. goto done;
39. }
41. /*
42. * don't be too light against the d/i cache since
43. * refill_inactive() almost never fail when there's
44. * really plenty of memory free.
45. */
46. shrink_dcache_memory(priority, gfp_mask);
47. shrink_icache_memory(priority, gfp_mask);
49. /*試圖找出一個進程,掃描其映射表,找到能夠轉入不活躍狀態頁面
50. * Then, try to page stuff out..
51. */
52. while (swap_out(priority, gfp_mask)) {
53. made_progress = 1;
54. if (--count <= 0)
55. goto done;
56. }
58. /*
59. * If we either have enough free memory, or if
60. * page_launder() will be able to make enough
61. * free memory, then stop.
62. */
63. if (!inactive_shortage() || !free_shortage())
64. goto done;
66. /*
67. * Only switch to a lower "priority" if we
68. * didn't make any useful progress in the
69. * last loop.
70. */
71. if (!made_progress)
72. priority--;
73. } while (priority >= 0);
75. /* Always end on a refill_inactive.., may sleep... */
76. while (refill_inactive_scan(0, 1)) {
77. if (--count <= 0)
78. goto done;
79. }
81. done:
82. return (count < start_count);
83. }

接着看看swap_out函數的實現

根據內核中進程的個數跟調用swap_out的優先級計算獲得的counter.counter表示循環次數,每次循環的任務從全部進程中找出最合適的進程best，斷開頁面印射，進一步轉換成不活躍狀態,最合適的準則是"劫富濟貧「和」輪流坐莊「的結合

 

2. static int swap_out(unsigned int priority, int gfp_mask)
3. {
4. int counter;//循環次數
5. int __ret = 0;
7. /*
8. * We make one or two passes through the task list, indexed by
9. * assign = {0, 1}:
10. * Pass 1: select the swappable task with maximal RSS that has
11. * not yet been swapped out.
12. * Pass 2: re-assign rss swap_cnt values, then select as above.
13. *
14. * With this approach, there's no need to remember the last task
15. * swapped out. If the swap-out fails, we clear swap_cnt so the
16. * task won't be selected again until all others have been tried.
17. *
18. * Think of swap_cnt as a "shadow rss" - it tells us which process
19. * we want to page out (always try largest first).
20. *///根據內核中進程的個數跟調用swap_out的優先級計算獲得的
21. counter = (nr_threads << SWAP_SHIFT) >> priority;
22. if (counter < 1)
23. counter = 1;
25. for (; counter >= 0; counter--) {
26. struct list_head *p;
27. unsigned long max_cnt = 0;
28. struct mm_struct *best = NULL;
29. int assign = 0;
30. int found_task = 0;
31. select:
32. spin_lock(&mmlist_lock);
33. p = init_mm.mmlist.next;
34. for (; p != &init_mm.mmlist; p = p->next) {
35. struct mm_struct *mm = list_entry(p, struct mm_struct, mmlist);
36. if (mm->rss <= 0)
37. continue;
38. found_task++;
39. /* Refresh swap_cnt? */
40. if (assign == 1) {////增長這層判斷目的是，但咱們找不到mm->swap_cnt不爲0的mm時候，
41. 咱們就會設置assign=1，而後再重新掃描一遍，這次就會直接把內存頁面數量賦值給還沒有考察頁面數量，
42. 從而重新刷新一次,這樣咱們就會從最富有的進程開始下手,mm->swap_cnt用於保證咱們所說的輪流坐莊，
43. mm->rss則是保證劫富濟貧第二輪循環,將mm->rss拷貝到mm_swap_cnt,從最大的開始繼續
44. mm->swap_cnt = (mm->rss >> SWAP_SHIFT);//記錄一次輪換中還沒有內存頁面還沒有考察的數量
45. if (mm->swap_cnt < SWAP_MIN)
46. mm->swap_cnt = SWAP_MIN;
47. }
48. if (mm->swap_cnt > max_cnt) {
49. max_cnt = mm->swap_cnt;
50. best = mm;
51. }
52. }///從循環退出來，咱們就找到了最大的mm->swap_cnt的mm
54. /* Make sure it doesn't disappear */
55. if (best)
56. atomic_inc(&best->mm_users);
57. spin_unlock(&mmlist_lock);
59. /*
60. * We have dropped the tasklist_lock, but we
61. * know that "mm" still exists: we are running
62. * with the big kernel lock, and exit_mm()
63. * cannot race with us.
64. */
65. if (!best) {
66. if (!assign && found_task > 0) {//第一次進入，表示全部進程mm->swap_cnt都爲0，第2次不會再進入了，通常不會出現第2次
67. assign = 1;//第二輪循環
68. goto select;
69. }
70. break;
71. } else {//掃出一個最佳換出的進程,調用swap_out_mm
72. __ret = swap_out_mm(best, gfp_mask);
73. mmput(best);
74. break;
75. }
76. }
77. return __ret;
78. }

swap_out_vma會調用關係swap_out_vma()>swap_out_pgd()>swap_out_pmd()>try_to_swap_out() static int try_to_swap_out()(struct mm_struct * mm, struct vm_area_struct * vma, unsigned long address, pte_t * page_table, int gfp_mask){//page_table指向頁面表項，不是頁面表到了try_to_swap_out()這個是很是關鍵的..因此本身主要分析try_to_swap_out()函數的實現,

一開始判斷準備換出的頁的合法性,判斷是否訪問過,是的話增長其age,即便不在活躍隊列,並且最近沒有訪問,還不能馬上換出,而要保留觀察,直到其

page->age等於0爲止,若是page->age等於0了,又經過了上面的測試,清除其頁表項設置爲0,接着判斷該頁是否已經在swap緩存中,若是存在就判斷是否最近寫過,若是是,那就設置該頁爲髒頁,同時轉移到不活躍髒隊列中,而且釋放頁面的緩存.

若是頁面不是髒頁面也不在swap緩存中,那就直接把映射解除而不是暫時斷開.若是頁面來自於mmap映射也不在swap緩存中,把頁面設置爲髒頁面,而且轉移到該文件映射的髒頁面隊列中.

若是頁面是髒頁面又不屬於文件映射也不在swap緩存,那就說明該頁面好久都沒訪問了,那就必須先分配一個swap設備的磁盤頁面,將其內容寫入該磁盤頁面.

同時經過add_swap_cache將頁面鏈入swapper_space的隊列中跟活躍頁面隊列中.

至此,對一個進程的空間頁面的掃描就OK了

2. /*
3. * The swap-out functions return 1 if they successfully
4. * threw something out, and we got a free page. It returns
5. * zero if it couldn't do anything, and any other value
6. * indicates it decreased rss, but the page was shared.
7. *
8. * NOTE! If it sleeps, it *must* return 1 to make sure we
9. * don't continue with the swap-out. Otherwise we may be
10. * using a process that no longer actually exists (it might
11. * have died while we slept).
12. */
13. static int try_to_swap_out(struct mm_struct * mm, struct vm_area_struct* vma, unsigned long address, pte_t * page_table, int gfp_mask)
14. {
15. pte_t pte;
16. swp_entry_t entry;
17. struct page * page;
18. int onlist;
20. pte = *page_table;//獲取頁表項
21. if (!pte_present(pte))//是否存在物理內存中
22. goto out_failed;
23. page = pte_page(pte);//獲取具體的頁
24. if ((!VALID_PAGE(page)) || PageReserved(page))//頁面不合法或者頁面不容許換出swap分區
25. goto out_failed;
27. if (!mm->swap_cnt)
28. return 1;
29. //須要具體的考察訪問一個頁面,swap_cnt減一
30. mm->swap_cnt--;
32. onlist = PageActive(page);//判斷是否活躍
33. /* Don't look at this pte if it's been accessed recently. */
34. if (ptep_test_and_clear_young(page_table)) {//測試頁面是否訪問過(訪問過說明年輕)
35. age_page_up(page);//增長保留觀察時間
36. goto out_failed;
37. }
38. if (!onlist)//即便不在活躍隊列,並且最近沒有訪問,還不能馬上換出,而要保留觀察,直到其
39. //page->age等於0爲止
40. age_page_down_ageonly(page);
42. /*
43. * If the page is in active use by us, or if the page
44. * is in active use by others, don't unmap it or
45. * (worse) start unneeded IO.
46. */
47. if (page->age > 0)
48. goto out_failed;
50. if (TryLockPage(page))
51. goto out_failed;
53. /* From this point on, the odds are that we're going to
54. * nuke this pte, so read and clear the pte. This hook
55. * is needed on CPUs which update the accessed and dirty
56. * bits in hardware.
57. *///把頁表項的內容清0(撤銷了映射)
58. pte = ptep_get_and_clear(page_table);
59. flush_tlb_page(vma, address);
61. /*
62. * Is the page already in the swap cache? If so, then
63. * we can just drop our reference to it without doing
64. * any IO - it's already up-to-date on disk.
65. *
66. * Return 0, as we didn't actually free any real
67. * memory, and we should just continue our scan.
68. */
69. if (PageSwapCache(page)) {//判斷該頁是否已經在swap緩存中
70. entry.val = page->index;
71. if (pte_dirty(pte))
72. set_page_dirty(page);//轉入髒頁面
73. set_swap_pte:
74. swap_duplicate(entry);//對index作一些印證
75. set_pte(page_table, swp_entry_to_pte(entry));//設置pte爲swap的索引了,這樣完成了交換
76. drop_pte:
77. UnlockPage(page);
78. mm->rss--;//物理頁面斷開的映射,因此rss--
79. deactivate_page(page);//將其從活躍隊列移到不活躍隊列中
80. page_cache_release(page);//釋放頁面緩存
81. out_failed:
82. return 0;
83. }
85. /*
86. * Is it a clean page? Then it must be recoverable
87. * by just paging it in again, and we can just drop
88. * it..
89. *
90. * However, this won't actually free any real
91. * memory, as the page will just be in the page cache
92. * somewhere, and as such we should just continue
93. * our scan.
94. *
95. * Basically, this just makes it possible for us to do
96. * some real work in the future in "refill_inactive()".
97. */
98. flush_cache_page(vma, address);
99. if (!pte_dirty(pte))
100. goto drop_pte;
102. /*
103. * Ok, it's really dirty. That means that
104. * we should either create a new swap cache
105. * entry for it, or we should write it back
106. * to its own backing store.
107. */
108. if (page->mapping) {
109. set_page_dirty(page);
110. goto drop_pte;
111. }
113. /*
114. * This is a dirty, swappable page. First of all,
115. * get a suitable swap entry for it, and make sure
116. * we have the swap cache set up to associate the
117. * page with that swap entry.
118. */
119. entry = get_swap_page();
120. if (!entry.val)
121. goto out_unlock_restore; /* No swap space left */
123. /* Add it to the swap cache and mark it dirty */
124. add_to_swap_cache(page, entry);
125. set_page_dirty(page);
126. goto set_swap_pte;
128. out_unlock_restore:
129. set_pte(page_table, pte);
130. UnlockPage(page);
131. return 0;
132. }