Linux 内核源代码情景分析 chap 2 存储管理 (四)
物理页面的使用和周转
1. 几个术语
1.1 虚存页面
指虚拟地址空间中一个固定大小， 边界与页面大小 4KB 对齐的区间及其内容
1.2 物理页面
与虚存页面相对的， 需要映射到某种物理存储介质上面的页面。 根据他是否在内存中， 我们可以分为 内存页面 和 盘上页面。
另外， 通常说物理内存页面的分配和释放是指 物理介质， 而谈及页面的换入和换出的时候， 是指他的内容。
1.3 交换技术
当系统内存不够用的时候，我们可以把暂时不用的信息 放到磁盘上， 为其他急用的信息腾出空间， 到需要的时候， 再从磁盘上读进来。
（linux 中 主要使用swap 分区， windows 中使用虚拟内存技术）
早期是基于段式交换的， 可是效率太低， 于是发展成按需页面交换技术。这是一种典型的用时间换空间的做法。
2. 对物理页面的抽象描述
2.1 内存物理页面
在系统的初始化阶段， 内核会根据检测到的物理内存的大小， 为每一个页面都建立一个page结构， 形成一个page数组， 并使用一个全局量 mem_map 指向这个数组。（不过个人感觉， 这是对于UMA 均匀介质而言的， 对于NUMA page 数组应该是从属于 某个node 的）
同时， 又按照需要将这些页面拼合成物理地址连续的许多内存页面块， 然后根据块的大小建立起若干管理区 zone， 而在每个管理区中则设置了一个空闲队列， 以便物理内存页面的分配使用
2.2 交换设备物理页面
2.2.1 swap_info_struct
内核中定义了一个swap_info_struct 数据结构， 用来描述和管理用于页面交换的文件和设备。
==================== include/linux/swap.h 49 64 ====================
49 struct swap_info_struct {
50 unsigned int flags;
51 kdev_t swap_device;
52 spinlock_t sdev_lock;
53 struct dentry * swap_file;
54 struct vfsmount *swap_vfsmnt;
55 unsigned short * swap_map;
56 unsigned int lowest_bit;
57 unsigned int highest_bit;
58 unsigned int cluster_next;
59 unsigned int cluster_nr;
60 int prio; /* swap priority */
61 int pages;
62 unsigned long max;
63 int next; /* next entry on swap list */
64 };其中， swap_map 指向一个数组， 数组中的每个值代表了盘上的一个物理页面， 数组下标决定了页面在盘或者文件中的位置。数组大小与pages 相关。
感觉这个swap_map 和 我们的 mem_map 指针指向一个page 数组的效果非常相似=_=!! <~~ ~.~
特别需要注意的是， 设备上的第一个页面， ie， swap_map[0]所代表的页面时不用于做页面交换的， 他包含了该设备或者文件自身的一些信息， 以及表明哪些页面是可以使用的位图。
我们利用 lowest_bit 和 highest_bit 字段，标记文件从什么地方开始到什么地方结束。利用 max 字段， 标记设备的物理大小。
由于， 我们的磁盘通常都是转动的， 所以在分配盘面空间的时候， 尽可能按照集群cluster 的方式进行， cluster_next 和 cluster_nr 就是为这个来设计的。
由于 linux 允许使用多个页面交换设备(文件)， 所以在内核中定义了一个 swap_info_struct 数组
struct swap_info_struct swap_info[MAX_SWAPFILES];同时， 内核还建立了一个队列 swap_list， 将各个可以分配物理页面的磁盘设备或者文件的 swap_info_struct 结构按优先级高低连接在一起。
==================== mm/swapfile.c 23 23 ====================
23 struct swap_list_t swap_list = {-1, -1};
==================== include/linux/swap.h 153 156 ====================
153 struct swap_list_t {
154 int head; /* head of priority-ordered swapfile list */
155 int next; /* swapfile to be used next */
156 };2.2.2 swap_entry_t 页面交换项
类似于 内存中 的pte_t 数据结构， 把物理内存页面和虚存页面建立联系一样， 盘上页面也有一个swp_entry_t 数据结构， 实现类似功能。
==================== include/linux/shmem_fs.h 8 18 ====================
8 /*
9 * A swap entry has to fit into a "unsigned long", as
10 * the entry is hidden in the "index" field of the
11 * swapper address space.
12 *
13 * We have to move it here, since not every user of fs.h is including
14 * mm.h, but m.h is including fs.h via sched .h :-/
15 */
16 typedef struct {
17 unsigned long val;
18 } swp_entry_t;
在这里， offset 表示页面在 某个磁盘设备或者文件中的位置， ie， 文件中的逻辑页面号。 直白点讲， 他对应着swap_map 所指向的数组中的下标。
而 type 则是指 该页面在哪个文件中， 是个序号。 直白点来讲， 对应的是swap_info， 这个表征多个页面交换设备的数组中的下标。
另外， swp_entry_t 结构和 pte_t 结构关系非常密切。他们有着相同大小的数据结构。
当一个页面在内存中的时候， 最低位 P 为 1， 其余各位描述该物理内存页面的地址和页面属性。
而当这个页面在磁盘上的时候， 最低位P 为 0， 其余位表示这个页面的去向
3. 磁盘周转
3.1 物理空间管理 __swap_free
==================== mm/swapfile.c 141 182 ====================
141 /*
142 * Caller has made sure that the swapdevice corresponding to entry
143 * is still around or has not been recycled.
144 */
145 void __swap_free(swp_entry_t entry, unsigned short count)
146 {
147 struct swap_info_struct * p;
148 unsigned long offset, type;
149
150 if (!entry.val)
151 goto out;
152
153 type = SWP_TYPE(entry);
154 if (type >= nr_swapfiles)
155 goto bad_nofile;
156 p = & swap_info[type];
157 if (!(p->flags & SWP_USED))
158 goto bad_device;
159 offset = SWP_OFFSET(entry);
160 if (offset >= p->max)
161 goto bad_offset;
162 if (!p->swap_map[offset])
163 goto bad_free;
164 swap_list_lock();
165 if (p->prio > swap_info[swap_list.next].prio)
166 swap_list.next = type;
167 swap_device_lock(p);
168 if (p->swap_map[offset] < SWAP_MAP_MAX) {
169 if (p->swap_map[offset] < count)
170 goto bad_count;
171 if (!(p->swap_map[offset] -= count)) {
172 if (offset < p->lowest_bit)
173 p->lowest_bit = offset;
174 if (offset > p->highest_bit)
175 p->highest_bit = offset;
176 nr_swap_pages++;
177 }
178 }
179 swap_device_unlock(p);
180 swap_list_unlock();
181 out:
182 return;需要注意的是， 释放磁盘页面内容的操作， 实际上并不涉及磁盘操作， 只是内存中的 “账面操作”, 表示磁盘上那个页面的内容已经作废了。 因而， 花费是非常小的。
3.2 内存页面周转的含义
含义有两方面：
1. 页面分配，使用和回收， 并不一定涉及页面的盘区交换
2. 盘区交换， 最终目的是为了页面的回收。
对于用户空间中的页面， 及涉及分配， 使用和回收， 还涉及页面的换入和换出， 即使是进程的代码段， 从系统角度看待， 都是动态分配的。
对于映射到系统空间的页面都不会被换出。只会有用完了之后， 需要释放的问题， 有些页面获取比较费劲， 可能还会采用 LRU 队列。
3.2.1 页面交换策略
- 最简单的策略就是即用即分配， 但是可想而知效率很低
- 使用LRU， ie， 最近最少用到的页面交换策略， 但是可能会引起 页面 抖动。
- 为了减少抖动， 引入暂存队列
- 加入页面 脏， 干净 等状态， 进一步优化
3.2.2 物理内存页面换入换出的周转要点
- 空闲， 此时page 在 某个zone 管理区的free_area 队列中。 页面引用计数为 0.
- 分配， 分配页面， 引用计数 为 1， page 不在处于 free_area队列中。
- 活跃状态， 通过 lru 结构连入 active_list, 递增引用计数
- 不活跃状态（脏）， 利用lru 连入 inactive_dirty_list, 递减引用计数
- 将不活跃脏内容写入交换设备， 并将其移动到 inactive_clean_list 中
- 不活跃状态(干净)
- 如果在转入不活跃状态后一段时间内收到访问， 转入活跃状态， 恢复映射
- 如果需要， 可以从干净队列中回收页面， 或者回到空闲队列， 或者另行分配。
用我自己的语言来解释一下：
我们先分配了一个页面， 然后这个页面处于 活动状态 active， 然后， 我们暂时不去访问它了， 他就开始老化， 进入inactive 不活动（脏）状态， 但这时候， 我们不是立即写入交换设备， 等再过一段时间， 确实没人访问， 我们将它写入交换设备， 但是这部分页面， 我们还是没有释放哦， 他被标记为 inactive 不活动(干净) 状态， 现在是由相应的存储区 zone 来管理了， 之前是由全局队列管理的。如果在这个页面被用作其他用途之前， 又被访问了， 直接建立映射就好了， 通过这种方法， 减少了页面的抖动现象
3.2.3 策略实现
- 全局LRU 队列， active_list 和 inactive_dirty_list
- 每个页面管理区设置 inactive_clean_list
- 全局 address_space 数据结构 swapper_space
- 为加快搜索， 引入 page_hash_table
下面来看下， 内核中交换的代码
3.2.3.1 code
==================== mm/swap_state.c 54 70 ====================
54 void add_to_swap_cache(struct page *page, swp_entry_t entry)
55 {
56 unsigned long flags;
57
58 #ifdef SWAP_CACHE_INFO
59 swap_cache_add_total++;
60 #endif
61 if (!PageLocked(page))
62 BUG();
63 if (PageTestandSetSwapCache(page))
64 BUG();
65 if (page->mapping)
66 BUG();
67 flags = page->flags & ~((1 << PG_error) | (1 << PG_arch_1));
68 page->flags = flags | (1 << PG_uptodate);
69 add_to_page_cache_locked(page, &swapper_space, entry.val);
70 }
==================== mm/filemap.c 476 494 ====================
476 /* 477 * Add a page to the inode page cache. 478 * 479 * The caller must have locked the page and 480 * set all the page flags correctly.. 481 */
482 void add_to_page_cache_locked(struct page * page, struct address_space *mapping, unsigned long index)
483 {
484 if (!PageLocked(page))
485 BUG();
486
487 page_cache_get(page);
488 spin_lock(&pagecache_lock);
489 page->index = index;
490 add_page_to_inode_queue(mapping, page);
491 add_page_to_hash_queue(page, page_hash(mapping, index));
492 lru_cache_add(page);
493 spin_unlock(&pagecache_lock);
494 }
==================== include/linux/fs.h 365 375 ====================
365 struct address_space {
366 struct list_head clean_pages; /* list of clean pages */
367 struct list_head dirty_pages; /* list of dirty pages */
368 struct list_head locked_pages; /* list of locked pages */
369 unsigned long nrpages; /* number of total pages */
370 struct address_space_operations *a_ops; /* methods */
371 struct inode *host; /* owner: inode, block_device */
372 struct vm_area_struct *i_mmap; /* list of private mappings */
373 struct vm_area_struct *i_mmap_shared; /* list of shared mappings */
374 spinlock_t i_shared_lock; /* and spinlock protecting it */
375 };
==================== mm/swap_state.c 31 37 ====================
31 struct address_space swapper_space = {
32 LIST_HEAD_INIT(swapper_space.clean_pages),
33 LIST_HEAD_INIT(swapper_space.dirty_pages),
34 LIST_HEAD_INIT(swapper_space.locked_pages),
35 0, /* nrpages */
36 &swap_aops,
37 };
==================== include/linux/mm.h 150 150 ====================
150 #define get_page(p) atomic_inc(&(p)->count)
==================== include/linux/pagemap.h 31 31 ====================
31 #define page_cache_get(x) get_page(x)
==================== mm/filemap.c 72 79 ====================
72 static inline void add_page_to_inode_queue(struct address_space *mapping, struct page * page)
73 {
74 struct list_head *head = &mapping->clean_pages;
75
76 mapping->nrpages++;
77 list_add(&page->list, head);
78 page->mapping = mapping;
79 }
==================== mm/filemap.c 58 70 ====================
58 static void add_page_to_hash_queue(struct page * page, struct page **p)
59 {
60 struct page *next = *p;
61
62 *p = page;
63 page->next_hash = next;
64 page->pprev_hash = p;
65 if (next)
66 next->pprev_hash = &page->next_hash;
67 if (page->buffers)
68 PAGE_BUG(page);
69 atomic_inc(&page_cache_size);
70 }
==================== include/linux/pagemap.h 68 68 ====================
68 #define page_hash(mapping,index) (page_hash_table+_page_hashfn(mapping,index))
==================== mm/swap.c 226 241 ====================
226 /** 227 * lru_cache_add: add a page to the page lists 228 * @page: the page to add 229 */
230 void lru_cache_add(struct page * page)
231 {
232 spin_lock(&pagemap_lru_lock);
233 if (!PageLocked(page))
234 BUG();
235 DEBUG_ADD_PAGE
236 add_page_to_active_list(page);
237 /* This should be relatively rare */
238 if (!page->age)
239 deactivate_page_nolock(page);
240 spin_unlock(&pagemap_lru_lock);
241 }
==================== include/linux/swap.h 209 215 ====================
209 #define add_page_to_active_list(page) { \
210 DEBUG_ADD_PAGE \
211 ZERO_PAGE_BUG \
212 SetPageActive(page); \
213 list_add(&(page)->lru, &active_list); \
214 nr_active_pages++; \
215 }
从add_to_page_cache_locked 函数中， 我们可以知道， 页面page 被加入到了 3 个队列中：
1. 利用 list 加入暂存队列 swapper_space
2. 利用next_hash 和 pprev_hash 加入 hash_queue
3. 利用 lru 加入 LRU 队列 active_list
3.3 用户参与内存管理
特权用户可以通过 swapon, swapoff 参与存储管理等。