017 mm/page_io.c

2006-7-14 
mm/page_io.c

首次接触swap设备/文件，简单介绍一下。

首先是swap_entry的结构： 
/* Encode and de-code a swap entry */
/* |......24bits offset ......|1bits|6bit type| present bit==0| */
typedef struct {
 unsigned long val;
} swp_entry_t;

当页面被交换到磁盘时，页表的entry（pte_t）被如上结构的swap entry所取代.
此时present bit被置0,cpu 认为页面不在内存,pte_t的其他部分按照swap entry的
规划由os解释.

然后来看看交换设备紧密相关的一些数据结构. 交换设备可以是单独的交换分区,
也可以是一般的文件. 这一点可以看文件 mm/swapfile.c
 struct swap_info_struct swap_info[MAX_SWAPFILES];
和函数 get_swaphandle_info 即可得到印证.
void get_swaphandle_info(swp_entry_t entry, unsigned long *offset, 
 kdev_t *dev, struct inode **swapf)
{
 unsigned long type;
 struct swap_info_struct *p;

/* |......24bits offset ......|1bits|6bit type| present bit==0| */
 type = SWP_TYPE(entry);
 if (type >= nr_swapfiles) {
 printk("Internal error: bad swap-device\n");
 return;
 }

p = &swap_info[type];
 *offset = SWP_OFFSET(entry);
 if (*offset >= p->max) {
 printk("rw_swap_page: weirdness\n");
 return;
 }
 if (p->swap_map && !p->swap_map[*offset]) {/*引用计数为零,尚未使用*/
 printk("VM: Bad swap entry %08lx\n", entry.val);
 return;
 }
 if (!(p->flags & SWP_USED)) {
 printk(KERN_ERR "rw_swap_page: "
 "Trying to swap to unused swap-device\n");
 return;
 }

if (p->swap_device) { /* 如果是交换分区swap_device非空*/
 *dev = p->swap_device;
 } else if (p->swap_file) {/*否则是交换文件*/
 *swapf = p->swap_file->d_inode;
 } else {
 printk(KERN_ERR "rw_swap_page: no swap file or device\n");
 }
 return;
}

先不说swap_info, 讨论一下交换设备的结构. 交换设备的空间被作为后备页面
来使用,尺寸等于cpu页面的大小.交换设备上的第一个页面被用于swap header,既:

/*交换设备和header格式,大小为一个page */
union swap_header {
 struct 
 {
 char reserved[PAGE_SIZE - 10];
 char magic[10];
 } magic;
 struct 
 {
 char bootbits[1024]; /* Space for disklabel etc. */
 unsigned int version;
 unsigned int last_page; /* 交换设备上最后一个页面的nr*/
 unsigned int nr_badpages; /*多少页面是损坏的*/
 unsigned int padding[125];
 unsigned int badpages[1]; /*损坏页面的索引数组*/
 } info;
};

记录了其大小，版本，损坏页面，magic等信息。在sys_swapon时转化为swap_info
中的信息，刚才已经简单提到了，现在完整的概述一下swap_info：
struct swap_info_struct {
 unsigned int flags;
 kdev_t swap_device;
 spinlock_t sdev_lock;
 struct dentry * swap_file;
 struct vfsmount *swap_vfsmnt;
 unsigned short * swap_map; /*记录交换设备上page 的引用计数(SWAP_MAP_MAX)*/
 /* 数组大小为this->max */

/*按簇分配算法变量,一个簇包含SWAPFILE_CLUSTER 个页面 */
 unsigned int lowest_bit; /* 和highest_bit一起构成有可能空闲的页面的索引范围*/
 unsigned int highest_bit;
 unsigned int cluster_next; /*swap cluster 中下一个可分配页面*/
 unsigned int cluster_nr; /*本簇内剩余页面数量*/

int prio; /* swap priority */
 int pages; /*nr_good_pages*/
 unsigned long max; /*来自swap_header 的last_page(和),见sys_swapon*/
 int next; /* next entry on swap list */
};
 信息来自swap header以及交换设备，还有安cluster分配交换页面所需的一些结构。
仔细看看各个成分代表的含义，具体的代码很容易看懂的。
 暂时介绍到这里。

看看mm/page_io.c所提供的接口：rw_swap_page,rw_swap_page_nolock,其实是swap和
设备驱动的一个接口,提供了对swap设备上文件的读写功能.
 这两个函数差别不大,rw_swap_page_nolock现在只用于sys_swapon(现在关注的范围内)
用于读取上述的swap_header.(见sys_swapon,一个临时页面).这个页面的特殊之处在于它
其实不属于swap cache(特殊的 page cache).不能直接使用rw_swap_page读取,所以做了一
些特殊处理:

/*
 * The swap lock map insists that pages be in the page cache!
 * Therefore we can't use it. Later when we can remove the need for the
 * lock map and we can reduce the number of functions exported.
 */
void rw_swap_page_nolock(int rw, swp_entry_t entry, char *buf, int wait)
{
 struct page *page = virt_to_page(buf);

if (!PageLocked(page))
 PAGE_BUG(page);
 if (PageSwapCache(page)) //在swap cahce 就不对了
 PAGE_BUG(page);
 if (page->mapping) //不能属于某个map
 PAGE_BUG(page);
 /* needs sync_page to wait I/O completation */
 page->mapping = &swapper_space; //借用一下swap space
 if (!rw_swap_page_base(rw, entry, page, wait))
 UnlockPage(page);
 page->mapping = NULL; 
}
 借用swaper_space的原因是,rw_swap_page_base,需要wait_on_page,而wait_on_page
则使用sync_page：
static inline int sync_page(struct page *page)
{
 struct address_space *mapping = page->mapping;

if (mapping && mapping->a_ops && mapping->a_ops->sync_page)
 return mapping->a_ops->sync_page(page);
 return 0;
}
 故此需要这样一个辗转的过程。现在来看看这两个接口共同的逻辑部分：
/*
 * Reads or writes a swap page.
 * wait=1: start I/O and wait for completion. wait=0: start asynchronous I/O.
 *
 * Important prevention of race condition: the caller *must* atomically 
 * create a unique swap cache entry for this swap page before calling
 * rw_swap_page, and must lock that page. By ensuring that there is a
 * single page of memory reserved for the swap entry, the normal VM page
 * lock on that page also doubles as a lock on swap entries. Having only
 * one lock to deal with per swap entry (rather than locking swap and memory
 * independently) also makes it easier to make certain swapping operations
 * atomic, which is particularly important when we are trying to ensure 
 * that shared pages stay shared while being swapped.
 */

static int rw_swap_page_base(int rw, swp_entry_t entry, struct page *page, int wait)
{
 unsigned long offset;
 int zones[PAGE_SIZE/512];
 int zones_used;
 kdev_t dev = 0;
 int block_size;
 struct inode *swapf = 0;

/* Don't allow too many pending pages in flight.. */
 if ((rw == WRITE) && atomic_read(&nr_async_pages) >
 pager_daemon.swap_cluster * (1 << page_cluster))
 wait = 1;

if (rw == READ) {
 ClearPageUptodate(page);
 kstat.pswpin++;
 } else
 kstat.pswpout++;

/*从swap entry找到交换设备或者交换文件
 *以及back page 在交换介质上的偏移
 */
 /* |......24bits offset ......|1bits|6bit type| present bit==0| */
 get_swaphandle_info(entry, &offset, &dev, &swapf);
 if (dev) {
 zones[0] = offset;
 zones_used = 1;
 block_size = PAGE_SIZE;
 } else if (swapf) {
 int i, j;
 unsigned int block = offset
 << (PAGE_SHIFT - swapf->i_sb->s_blocksize_bits);

block_size = swapf->i_sb->s_blocksize;
 for (i=0, j=0; j< PAGE_SIZE ; i++, j += block_size)
 if (!(zones[i] = bmap(swapf,block++))) {
 printk("rw_swap_page: bad swap file\n");
 return 0;
 }
 zones_used = i;
 dev = swapf->i_dev;
 } else {
 return 0;
 }
 if (!wait) {
 SetPageDecrAfter(page);
 atomic_inc(&nr_async_pages);
 }

/* block_size == PAGE_SIZE/zones_used */
 brw_page(rw, page, dev, zones, block_size);

/* Note! For consistency we do all of the logic,
 * decrementing the page count, and unlocking the page in the
 * swap lock map - in the IO completion handler.
 */
 if (!wait)
 return 1;

wait_on_page(page);
 /* This shouldn't happen, but check to be sure. */
 if (page_count(page) == 0)
 printk(KERN_ERR "rw_swap_page: page unused while waiting!\n");

return 1;
}

对于这个函数首先要说的是全局变量nr_async_pages：
/* rw_swap_page_base: inc nr_async_pages end_buffer_io_async:dec this one*/
/*异步io 状态就是提交读/写后不等待页面get unlocked*/
atomic_t nr_async_pages = ATOMIC_INIT(0); /*所有在异步io状态的页面总数*/

还有pager_daemon.swap_cluster * (1 << page_cluster))：
其中pager_daemon.swap_cluster是最多容许预读的页面cluster个数，而page_cluster
则是每个cluster拥有的页面个数：2^page_cluster。所以rw_swap_page_base中相关的
判断就是不让在异步io状态的页面超过所容许的总的预读页面数量。

说到这里，page_cluster是某个cluster的大小，上面还提到了SWAPFILE_CLUSTER也是
某个cluster的大小，这连个cluster的区别在于：
 page_cluster所指的是的簇用于filemap相关的预读，以及swap in的时候所做的预读。
而普通文件的预读情况参考do_generic_file_read的相关分析。
 SWAPFILE_CLUSTER则是用于swap设备上的swap页面分配时的分配策略使用的簇，相关
代码参考：mm/swapfile.c 函数scan_swap_map.到时再论.

其次要说的是bmap这个函数,简单看,如果swap设备是一个普通文件,则以ext2文件为例
bmap-> {inode->i_mapping->a_ops->bmap(inode->i_mapping, block)}->ext2_bmap->
generic_block_bmap->ext2_get_block. 核心函数是ext2_get_block,实际上是文件内的
连续的block nr到文件所在的设备的block号的一个 查找/分配 的过程.具体的这里就不
再细述,等到分析ext2文件系统再论不迟.
 看rw_swap_page_base相关部分,如果是一个交换分区,这个复杂过程就可以省略了,所以
交换分区的效率还是值得肯定的.

另外简单提一下这个调用:
 brw_page(rw, page, dev, zones, block_size);
 如果仔细看看rw_swap_page_base,可能会担心block size是否会大于page size?据我所
知对于ext2文件系统,blocksize不会大于4k,见ext2_read_super.
 brw_page在这个page上创建buffers,设置buffer对应的设备block nr,提交设备驱动读取
相应block的内容.细节部分等到分析设备驱动的时候再续.

The end.