Understand Swap in & mem_map
Understand Swap in & mem_map
2010年10月19日
Understand Swap in & mem_map
mm/memory.c PageReserved
这1000多行代码,有绝大多数函数定义为static,意味着这个模块只提供了少量
的对外接口. 这几个接口是我们理解此模块的一个重要线索.
第一部分 ：全局量的仔细解释
I)首先是几个全局变量,下面给出其具体含义:
+================================================= =====================
/*mem_map 中最高地址页面的map number，可以使用的ram全在其中*/
unsigned long max_mapnr;
/*物理内存页面总数(当然包括highmem在内)*/
unsigned long num_physpages;
/*从虚拟地址 high_memory 开始不再是线性映射区
*如果全部可以线性映射其值为物理内存顶端之虚拟地址
*/
void * high_memory;
struct page *highmem_start_page; /*高端物理内存的起始 page(struct page)*/
+================================================= =====================
II) i386下的 mem_map
另外一个重要的全局数组:
==========================================
mem_map_t * mem_map; /*page 结构的总数组*/
==========================================
这个数组存放有全部的struct page结构(i386 not numa),每一个物理内存页面
都对应一个page 机构,存储于此数组.下面来看看i386体系下如何初始化mem_map:
setup.S->asmlinkage void __init start_kernel(void) (init/main.c)
|
+-->setup_arch ---> 处理e820内存报告
--> 关于内存的提示信息
---> 初始化bootmem (init_bootmem)
---> paging_init
+
| +--> pagetable_init(含fix map,vmalloc init)
\ / +--> load cr3
. +--> kmap_init
. +--> free_area_init(zone-buddy初始化)
函数paging_init如此调用free_area_init(zones_size);参数zones_size给出
每一个zone(DMA,NORMAL,HIGH)的大小.再看:
void __init free_area_init(unsigned long *zones_size)
{
free_area_init_core(0, &contig_page_data, &mem_map, zones_size,
0, 0, 0);
}
对于i386此种"连续"内存结构,使用了一个pg_data_t类型的变量:contig_page_data
注意第三个参数是&mem_map.
void __init free_area_init_core(int nid, pg_data_t *pgdat,
struct page **gmap, unsigned long *zones_size ,
unsigned long zone_start_paddr, unsigned long *zholes_size,
struct page *lmem_map)
{
/* pgdat 是contig_page_data, gmap是&mem_map, lmem_map是 0 */
.....
if (lmem_map == (struct page *)0) {
//非numa体系此值为0, 分配mem map数组
lmem_map = (struct page *) alloc_bootmem_node(pgdat, map_size);
lmem_map = (struct page *)(PAGE_OFFSET +
MAP_ALIGN((unsigned long)lmem_map - PAGE_OFFSET));
}
/*mem_map指向刚分配的内存,即是contig_page_data.node_mem_map*/
*gmap = pgdat->node_mem_map = lmem_map;
pgdat->node_size = totalpages;
pgdat->node_start_paddr = zone_start_paddr;
pgdat->node_start_mapnr = (lmem_map - mem_map);
/*从0号物理内存页开始*/
}
NUMA下的 mem_map
III)NUMA下的 mem_map
而对于NUMA类型的体系,mem_map已经失去了其存在的意义,不过2.4处理的
不够好,代码凌乱,可读性不强.以arm体系为例:(arch/arm/mm/init.c)
void __init paging_init(struct meminfo *mi, struct machine_desc *mdesc)
{
.........
for (node = 0; node node_boot_start, zhole_size);
}
......
}
这里调用的free_area_init_node定义于mm/numa.c
void __init free_area_init_node(int nid, pg_data_t *pgdat, struct page *pmap,
unsigned long *zones_size, unsigned long zone_start_paddr,
unsigned long *zholes_size)
{
int i, size = 0;
struct page *discard;
if (mem_map == (mem_map_t *)NULL)
mem_map = (mem_map_t *)PAGE_OFFSET; /*仅为mem_map指定了一个值,其指向
*的地址并没有存放struct page
*/
free_area_init_core(nid, pgdat, &discard, zones_size, zone_start_paddr,
zholes_size, pmap);
pgdat->node_id = nid;
.......
}
void __init free_area_init_core(int nid, pg_data_t *pgdat,
struct page **gmap, unsigned long *zones_size ,
unsigned long zone_start_paddr, unsigned long *zholes_size,
struct page *lmem_map)
{
/* pgdat 是NODE_pgdat, gmap是&discard, lmem_map还是 0 */
.....
if (lmem_map == (struct page *)0) {
//numa体系此值亦为0, 分配mem map数组
lmem_map = (struct page *) alloc_bootmem_node(pgdat, map_size);
lmem_map = (struct page *)(PAGE_OFFSET +
MAP_ALIGN((unsigned long)lmem_map - PAGE_OFFSET));
}
/* *gmap再numa下不指向mem_map,被丢弃不用*/
*gmap = pgdat->node_mem_map = lmem_map;
pgdat->node_size = totalpages;
pgdat->node_start_paddr = zone_start_paddr;
pgdat->node_start_mapnr = (lmem_map - mem_map);
/*node_start_mapnr再numa下失去其意义*/
/*变成了lmem_map这个地址到PAGE_OFFSET有多少个页面*/
offset = lmem_map - mem_map; /*减去常量PAGE_OFFSET*/
for (j = 0; j offset = offset; /*失去意义*/
....
zone->zone_mem_map = mem_map + offset; /*又加上常量PAGE_OFFSET所以
*zone_mem_map确实有意义
*/
zone->zone_start_mapnr = offset; /*失去意义*/
...
offset += size;
}
}
从上面的分析,很明显2.4还没有处理好NUMA和discon mem.在NUMA体系下,mem_map
已经失去存在的意义,只是一个跳板.arm的vir_to_page宏就没有使用这个mem_map.
而ia64-sn的使用方法就巨绕:
*******include/asm-ia64/page.h 定义
# define virt_to_page(kaddr) (mem_map + platform_map_nr(kaddr))
mem_map是一个常量PAGE_OFFSET???
*******include/asm-ia64/machvec_sn1.h定义
#define platform_map_nr sn1_map_nr
*******arch/ia64/sn/sn1/setup.c定义
sn1_map_nr (unsigned long addr)
{
#ifdef CONFIG_DISCONTIGMEM
return MAP_NR_SN1(addr);
#else
return MAP_NR_DENSE(addr);
#endif
}
*******include/asm-ia64/sn/mmzone.h定义
#define NODE_DATA(n) (&((plat_node_data + (n))->gendata))
#define NODE_MEM_MAP(nid) (NODE_DATA((nid))->node_mem_map)
#define LOCAL_MAP_NR(kvaddr) \
(((unsigned long)(kvaddr)-LOCAL_BASE_ADDR((kvaddr))) >> PAGE_SHIFT)
#define MAP_NR_SN1(kaddr) (LOCAL_MAP_NR((kaddr)) + \
(((unsigned long)ADDR_TO_MAPBASE((kaddr)) - PAGE_OFFSET) / \
sizeof(mem_map_t)))
仔细分析MAP_NR_SN1就知道其种缘由了:
mem_map + (((unsigned long)ADDR_TO_MAPBASE((kaddr)) - PAGE_OFFSET) / \
sizeof(mem_map_t))
就定位到了pgdat->node_mem_map,而node_mem_map了在numa中依然有效,指向真
实的"mem_map".
pgdat->node_start_mapnr也失去了意义,不过在kernel2.4中大概只有mips64使
用这个值,并且类似ia64的vir_to_page,见include/asm-mips64/pgtable.h
#define mips64_pte_pagenr(x) \
(PLAT_NODE_DATA_STARTNR(PHYSADDR_TO_NID(pte_val(x) )) + \
PLAT_NODE_DATA_LOCALNR(pte_val(x), PHYSADDR_TO_NID(pte_val(x))))
#define pte_page(x) (mem_map+mips64_pte_pagenr(x))
使用这个变量的时候最终还是加上了mem_map!!!
不过从另外一个角度理解mem_map也可以:这紧紧是一个虚拟的值,借助于这个变
量也简化了一些设计,比如使用zone->offset的地方,如:mm/page_alloc.c
static void __free_pages_ok (struct page *page, unsigned long order)
{
.........
base = mem_map + zone->offset;
page_idx = page - base;
....
}
本来zone->offset减去了mem_map,现在加上mem_map,还是指向这个zone所属的
pgdat->zone_mem_map. 虽然失去其本意,也达到了目的,必是2.4向NUMA转化的过
渡性代码.
在kernel2.6,numa体系下,根本不再有mem_map这个全局变量,
pgdat->node_start_mapnr也时刻保持其原意.zone->offset更是消失不见了,直接
换成了指针.一切都变得clean&clear.
注:看64bit代码时突然想到两个64bit值之差赋值给long型的变量是否有问题,后来
参考了:
>
指出在linux的64bit环境中, long是64bit的!!!和windows不同啊.
Page Reserved详解
第二部分 本模块对外接口详解
I)clear_page_tables : 释放一个进程指定范围内的页表,以及关联的pmd,对应
的pgd entry被清空,pgd本身没有被释放.至于页表中是否还有未断开
影射的物理页面,此函数未做检查.(所以调用之前要先调用
zap_page_range). 对于这个函数和其涉及的其他函数请自己阅读.
II)copy_page_range
从一个进程的mm拷贝指定的vm area到另一个进程,拷贝内容包括:为新进程指
定的这段空间分配pmd页面,分配page table页面.从src进程的mm拷贝pte到新分配
的页表.增加copy的pte所引用页面的引用计数,并且处理pte是swap entry的情况(
增加swap page的引用计数). 对于vm area属性是可写但无VM_SHARE属性的情况,将
新进程的pte置写保护,等到新进程写此页面的时候进行COW. 如果vm area具有共享
属性(那当然就是容许在进程间共享此页面)将新设置的pte的dirty位清除:新进程
还未曾访问此页面.
通过上面的分析阅读copy_page_range应该不是问题了.注意在copy_page_range
的时候就为COW设置了伏笔:共享一个page,但是不容许写.
III)zap_page_range:
从一个进程指定的地址开始释放指定大小的虚拟地址空间内
所有已映射页面. clear_page_tables仅释放"cpu meta data",而此函数
仅释放"user used data pages".如果页面被交换到磁盘,则释放磁盘页面.
此函数相关子函数:
zap_pmd_range zap_pte_range free_pte.
都是对mm进行遍历,只有free_pte还有些"业务"逻辑.
static inline int free_pte(pte_t pte)
{
if (pte_present(pte)) {
struct page *page = pte_page(pte);
if ((!VALID_PAGE(page)) || PageReserved(page))
return 0;
/*
* free_page() used to be able to clear swap cache
* entries. We may now have to do it manually.
*/
if (pte_dirty(pte) && page->mapping)
set_page_dirty(page);
free_page_and_swap_cache(page);
return 1;
}
swap_free(pte_to_swp_entry(pte));
return 0;
}
PageReserved检查page是否就有PG_reserved属性.
到底什么是PG_reserved页面
这里说明一下: 其实非常简单,内核不认为PG_reserved属性的页面是"ram"页
面.从而不会在"任何"地方使用这个物理页面. 这里的任何地方不是指真正的所有
的内核程序,而是指不知道PG_reserved的页面是什么页面的代码.
从另外一种意义上说,就是内核的某个地方保留了这个page,不得再做他用.
首先, 参考arch/i386/mm/init.c的分析,函数mem_init,使用函数free_all_bootmem
清除所有未分配出去的页面的PG_reserved位.仔细阅读一下函数对bootmem的初始
化就可以发现:所有非ram页面,在bootmem中已经标记为已分配,PG_reserved置位.
所以free_all_bootmem也没有将非ram页面的PG_reserved标识清除掉.而对于high
mem, mem_init 将非ram页面的PG_reserved位设置上.这就是PG_reserved的第一
个含义:非ram页面.
然后看setup_arch对reserve_bootmem的调用,可以知道,(0, PAGE_SIZE)被保
留,这样不会有"任何"代码可以分配这段内存. 这就是第二个含义:被内核保留用于
特殊用途.
关于zap_page_range不再做其他说明.
user kiobuf 和 remap, zeromap
IV)user kiobuf
在2.6内核,对应的函数叫做get_user_pages,用于AIO.这里的user kiobuf提供
这样一种服务:
从内核读取数据直接映射到用户空间,减少了copy,可以"大大的"提高效率.不过
看来2.4想用于raw io.到时候再仔细分析,这里先看看user kiobuf是如何建立和使
用的.
int map_user_kiobuf(int rw, struct kiobuf *iobuf, unsigned long va, size_t len)
{
.....
int datain = (rw == READ);
/* Make sure the iobuf is not already mapped somewhere. */
if (iobuf->nr_pages)
return -EINVAL;
mm = current->mm;
dprintk ("map_user_kiobuf: begin\n");
//准备扫描指定的区间(遍历ptr到end之间涉及的vma)
ptr = va & PAGE_MASK;
end = (va + len + PAGE_SIZE - 1) & PAGE_MASK;
err = expand_kiobuf(iobuf, (end - ptr) >> PAGE_SHIFT);
if (err)
return err;
down(&mm->mmap_sem);
iobuf->locked = 0;
iobuf->offset = va & ~PAGE_MASK;
iobuf->length = len;
i = 0;
/*
* First of all, try to fault in all of the necessary pages
*/
while (ptr = vma->vm_end) {
/*指定的虚拟地址va必须有一个vam区间对应*/
vma = find_vma(current->mm, ptr);
if (!vma)
goto out_unlock;
if (vma->vm_start > ptr) {
/*必须使用堆栈(fix me)做io buf*/
if (!(vma->vm_flags & VM_GROWSDOWN))
goto out_unlock;
/*先对vma进行调整*/
if (expand_stack(vma, ptr))
goto out_unlock;
}
/*检查一下访问权限*/
if (((datain) && (!(vma->vm_flags & VM_WRITE))) ||
(!(vma->vm_flags & VM_READ))) {
err = -EACCES;
goto out_unlock;
}
}
/*为涉及到的空间影射物理内存页面*/
if (handle_mm_fault(current->mm, vma, ptr, datain) page_table_lock);
/*记录页面的page 结构到 iobuf中，以便后用*/
map = follow_page(ptr);
if (!map) {
spin_unlock(&mm->page_table_lock);
dprintk (KERN_ERR "Missing page in map_user_kiobuf\n");
goto out_unlock;
}
map = get_page_map(map);
if (map) {
flush_dcache_page(map);
/*增加引用计数,以免被swap out对应unmap_kiobuf*/
atomic_inc(&map->count);
} else
printk (KERN_INFO "Mapped page missing [%d]\n", i);
spin_unlock(&mm->page_table_lock);
iobuf->maplist[i] = map;
iobuf->nr_pages = ++i;
ptr += PAGE_SIZE;
}
up(&mm->mmap_sem);
.......
}
与此相关的其他几个函数unmap_kiobuf,lock_kiovec,unlock_kiovec个人认为
极为简单,就不再分析.
V)zeromap_page_range remap_page_range
int zeromap_page_range(unsigned long address, unsigned long size,
pgprot_t prot)
相关函数zeromap_pmd_range,zeromap_pte_range,forget_pte.是一个遍历
当前进程的页面映射表的函数.将指定地址空间的每一项pte都指向zero page页
(一个4k的全0页面),并将pte置写保护,以后可以进行COW.
如果某个pte已经映射了一个页面,就将其释放. 不过这种情况应该极少出现
一般调用此函数做zero map时都已经撤销了映射.
值得注意的是,这个不涉及vma.没有加锁.
int remap_page_range(unsigned long from, unsigned long phys_addr,
unsigned long size, pgprot_t prot)
相关函数remap_pmd_range,remap_pte_range. 作用是将phy_addr开始的连续
物理页面映射到虚存from, 大小为size(page align).这些物理页面都不能是ram
页面.只负责mem map不能管理的页面,和PageReserved的页面.主要应用于驱动将
设备内存映射到内核的一段虚存. 看看下面的函数就知道了:
static remap_pte_range(pte,address, size, phys_addr, pgprot_t prot)
{
......
do {
struct page *page;
pte_t oldpage;
oldpage = ptep_get_and_clear(pte);
page = virt_to_page(__va(phys_addr));
/*只负责映射保留页面和非ram页面*/
if ((!VALID_PAGE(page)) || PageReserved(page))
set_pte(pte, mk_pte_phys(phys_addr, prot));
/*同时负责拆除老的映射页面*/
forget_pte(oldpage);
.....
pte++;
} while (address && (address do_sys_truncate->do_truncate()
{ ......
newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
error = notify_change(dentry, &newattrs);
....
}
notify_change(){
......
lock_kernel();
if (inode->i_op && inode->i_op->setattr) //ext2 未设置此op
error = inode->i_op->setattr(dentry, attr);
else {
//所以对ext2来讲执行此公共流程
error = inode_change_ok(inode, attr);
if (!error)
inode_setattr(inode, attr);
}
unlock_kernel();
.......
}
inode_setattr(){
......
if (ia_valid & ATTR_SIZE)
vmtruncate(inode, attr->ia_size);
......
mark_inode_dirty(inode);
}
可见, vmtruncate是其核心. 对于一个文件在进行truncate时要考虑文件已经
使用mmap映射到内存的情况. 将所有的映射一并truncate.此外还要处理page cache
保证page cache不再含有相关数据.最后才是文件本身进行truncate. vmtruncate
即此服务.
void vmtruncate(struct inode * inode, loff_t offset)
{
unsigned long partial, pgoff;
struct address_space *mapping = inode->i_mapping;
unsigned long limit;
if (inode->i_size i_size = offset;
/* 清除page cache中相关的缓冲数据 */
truncate_inode_pages(mapping, offset);
spin_lock(&mapping->i_shared_lock);
/*检查是否存在此文件的mapping*/
if (!mapping->i_mmap && !mapping->i_mmap_shared)
goto out_unlock;
pgoff = (offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
partial = (unsigned long)offset & (PAGE_CACHE_SIZE - 1);
/*truncate maping*/
if (mapping->i_mmap != NULL)
/*
*始释放指定虚拟地址空间内所有已映射页面.(not clear cpu meta data)
*/
vmtruncate_list(mapping->i_mmap, pgoff, partial);
if (mapping->i_mmap_shared != NULL)
vmtruncate_list(mapping->i_mmap_shared, pgoff, partial);
out_unlock:
spin_unlock(&mapping->i_shared_lock);
/* this should go into ->truncate */
inode->i_size = offset;
/*最后对文件进行truncate,ext2 参考ext2_truncate */
if (inode->i_op && inode->i_op->truncate)
inode->i_op->truncate(inode);
return;
do_expand:
limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
if (limit != RLIM_INFINITY) {
if (inode->i_size >= limit) {
send_sig(SIGXFSZ, current, 0);
goto out;
}
if (offset > limit) {
send_sig(SIGXFSZ, current, 0);
offset = limit;
}
}
inode->i_size = offset;
if (inode->i_op && inode->i_op->truncate)
inode->i_op->truncate(inode);
out:
return;
}
vmtruncate_list就是将truncate语义指定的范围内的已映射页面umap.这里不
再分析.(就是调用zap_page_range)
清除page cache在分析filemap.c的时候已经分析过了,对于文件本身的操作等
到分析buffer.c再议.
Understanding Swap in
VII)Understanding Swap in
接口函数: swapin_readahead,handle_mm_fault,make_pages_presen t.
我们从handle_mm_fault谈起,在分析fault.c的时候提到过一个mm fault产生的
几种情形,首先是进入到do_page_fault的时候
/*
* 有三种情况下执行流到达此函数:
* 1. pmd, pgt, pte 有一个为空, 即未建立映射或已经撤销.(nomal page
cache)
* 2. 页面不在内存(not present)被内核交换到了磁盘(swap space).
* 3. 权限不正确. (内核已经授权或者根本不容许那样访问)
*
* 说明:
* 情况1)涉及的页面或者没有建立映射或者属于nomal address map(like mmap)
* 一般要到page cache中试图寻找.
* try_to_swap_out处理nomal address map的时候,把相应的pte置成0.
*
* 情况2.涉及页面属于swapper_space管理. try_to_swap_out 不会把pte 置0,
而是讲pte置为相应的swp_entry_t并将present位置0.
*
* 再转交下一级函数处理时, 所有非法操作都在这个函数中处理掉了.所谓非法
* 是用户企图进行一次内核(vma)不容许的操作,如vma无写属性,而进程进行了写操
* 作.
*/
asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long error_code)
{
.........
/*
* 如果处时指令流抵达此地,说明异常点在一个完好的vma中,
* 并且符合OS 赋予用户的权限.
*/
switch (handle_mm_fault(mm, vma, address, write)) {
case 1:
tsk->min_flt++;
break;
case 2:
tsk->maj_flt++;
break;
case 0:
goto do_sigbus;
default:
goto out_of_memory;
}
........
}
上面的分析给出了handle_mm_fault(mm, vma, address, write)执行时所面临的
条件"说明异常点在一个完好的vma中,并且符合OS 赋予用户的权限":vma是经过了
扩展(expand stack)或修改,用户的这次操作应该得到相应的服务.
int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct * vma,
unsigned long address, int write_access)
{
int ret = -1;
pgd_t *pgd;
pmd_t *pmd;
pgd = pgd_offset(mm, address);
pmd = pmd_alloc(pgd, address); /*查找或者分配pmd page*/
if (pmd) {
pte_t * pte = pte_alloc(pmd, address); /*查找或者分配page table*/
if (pte)
ret = handle_pte_fault(mm, vma, address, write_access, pte);
}
return ret;
}
可见在发生页面异常的时候,容许进程被调度,和中断有所不同.这是合理的:可
以看作进程请求内核处理mm fault,就像一个系统调用.
static inline int handle_pte_fault(struct mm_struct *mm,
struct vm_area_struct * vma, unsigned long address,
int write_access, pte_t * pte)
{
pte_t entry;
/*
* We need the page table lock to synchronize with kswapd
* and the SMP-safe atomic PTE updates.
*/
spin_lock(&mm->page_table_lock);
entry = *pte;
/*异常属于映射链断裂的情况*/
if (!pte_present(entry)) {
/*
* If it truly wasn't present, we know that kswapd
* and the PTE updates will not touch it later. So
* drop the lock.
*/
spin_unlock(&mm->page_table_lock);
if (pte_none(entry))
return do_no_page(mm, vma, //页面不存在, 就是没有,或者被 try_to_swap_out
address, // 断开, 这种页面一般属于一个nomal address map
write_access,
pte //参见filemap_nopage 了解page cache 的换入
);
return do_swap_page(mm, vma,//not present, 属于swapper_space
address, pte,
pte_to_swp_entry(entry),
write_access
);
}
/*异常属于内核授权,但是cpu不容许的情况,COW*/
//如果是read 时产生陷入或者是pte的映射问题
//或者是一个非法的操作,已经在do_page_fault 过滤掉了
if (write_access) {//由于页面写保护产生的陷入, 而OS 却容许用户写入
if (!pte_write(entry))
return do_wp_page( mm, //就是处理COW 的第二步
vma, //Copy on Write
address, //第一步是建立一个不容许写的页
pte, entry //却在vma 中赋予用户写的权限
);
entry = pte_mkdirty(entry);
}
/*好像一般都满足write_access为1,read not present从
if (!pte_present(entry))就返回了(fix me),read present更是连
handle mem fault都进不了*/
entry = pte_mkyoung(entry);
establish_pte(vma, address, pte, entry);
spin_unlock(&mm->page_table_lock);
return 1;
}
handle_mm_fault 已经修复了映射链上的系统页面,handle_pte_fault主要是修复
映射链上的用户页面:
1)do_no_page:还未建立映射,或者已经被断开还存在于lru cache(page cache)
或者已经回收到了node-zone-buddy.
2)do_swap_page:从lru恢复,如果已经被回收到node-zone-buddy就从磁盘调入.
3)do_wp_page: 处理COW的copy操作,用户现在要写此页面,copy一份给他.
1)do_no_page:
分配一个匿名页面,或者用vm指定的操作寻找对应页面.在设置pte
的时候考虑COW:对于写操作,表示内核容许写(这里不会遭遇COW,cow是另一个处理
函数,handle_pte_fault已经区分的很清楚了),直接将pte置为可写.如果是read操
作,考虑mmap创建的vma(not anonymous page),并且页面已经是共用页面,则我们
不能直接给这个进程写权限,而是要取消写权限这是COW处理中的一环:建立一个写
保护的页面.参照分析filemap.c时对函数filemap_nopage的分析,那里讲的很详细
-->filemap_nopage 对这个read操作的进程直接返回一个共享页面,如果这是第一
个要求访问此页面的进程do_no_page不会取消这个进程的写操作权限.
static int do_no_page(struct mm_struct * mm, struct vm_area_struct * vma,
unsigned long address, int write_access, pte_t *page_table)
{
struct page * new_page;
pte_t entry;
if (!vma->vm_ops || !vma->vm_ops->nopage)
return do_anonymous_page(mm, vma, page_table, write_access, address);
/*
* The third argument is "no_share", which tells the low-level code
* to copy, not share the page even if sharing is possible. It's
* essentially an early COW detection.
* 对于mmap建立的vm,此函数是 filemap_nopage
*/
new_page = vma->vm_ops->nopage(vma, address & PAGE_MASK, (vma->vm_flags & VM_SHARED)?0:write_access);
if (new_page == NULL) /* no page was available -- SIGBUS */
return 0;
if (new_page == NOPAGE_OOM)
return -1;
++mm->rss;
//其实在上面两个调入函数中(do_anonymous_page vma->vm_ops->nopage)
//也存在cow 的第二步操作,即写操作时do_anonymous_page 返回
//新分配的页面, vma->vm_ops->nopage 不共享页面,而进行copy 操作.
//cow 本质: 写时拷贝,读时共享
//写时拷贝就是刚分析的do_anonymous_page vma->vm_ops->nopage 加上
//do_wp_page
//读时共享就是do_anonymous_page 在read 条件下,返回zero 公共页
//vma->vm_ops->nopage 在read 条件下尽力共享页面.
/*
* This silly early PAGE_DIRTY setting removes a race
* due to the bad i386 page protection. But it's valid
* for other architectures too.
*
* Note that if write_access is true, we either now have
* an exclusive copy of the page, or this is a shared mapping,
* so we can make it writable and dirty to avoid having to
* handle that later.
*/
flush_page_to_ram(new_page);
flush_icache_page(vma, new_page);
entry = mk_pte(new_page, vma->vm_page_prot);
if (write_access) {
entry = pte_mkwrite(pte_mkdirty(entry));
} else if (page_count(new_page) > 1 &&
!(vma->vm_flags & VM_SHARED))
entry = pte_wrprotect(entry);
set_pte(page_table, entry);
/* no need to invalidate: a not-present page shouldn't be cached */
update_mmu_cache(vma, address, entry);
return 2; /* Major fault */
}
2)do_swap_page
对于开始还出的页面,可以从lru恢复,如果已经被回收到node-zone-buddy就从
磁盘调入.
static int do_swap_page(struct mm_struct * mm,
struct vm_area_struct * vma, unsigned long address,
pte_t * page_table, swp_entry_t entry, int write_access)
{
struct page *page = lookup_swap_cache(entry); //先查找swap cache
//如果查找的到,肯定也存在于lru,说不定就要开始换出了
pte_t pte;
if (!page) { /*如果找不到,就从磁盘swap in*/
lock_kernel();
swapin_readahead(entry); /*先预读一部分*/
page = read_swap_cache(entry); /*类似普通文件读写,先读入,并加入swap
cache,并返回指定页面*/
unlock_kernel();
if (!page)
return -1;
flush_page_to_ram(page);
flush_icache_page(vma, page);
}
mm->rss++;
/*得到指定的页面,就开始恢复页面映射*/
pte = mk_pte(page, vma->vm_page_prot);
/*
* Freeze the "shared"ness of the page, ie page_count + swap_count.
* Must lock page before transferring our swap count to already
* obtained page count.
*/
lock_page(page); /*is_page_shared 要求锁定页面,详见filemap.c的分析*/
swap_free(entry);
if (write_access && !is_page_shared(page))
pte = pte_mkwrite(pte_mkdirty(pte));
UnlockPage(page);
set_pte(page_table, pte);
/* No need to invalidate - it was non-present before */
update_mmu_cache(vma, address, pte);
return 1; /* Minor fault */
}
其中预读和读取到swap cache(read_swap_cache)留做以后详解,这里仅仅简单
分析一下预读.
/*
* Primitive swap readahead code. We simply read an aligned block of
* (1 = pager_daemon.swap_cluster
* (1 内存.
全文完.
