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号物理内存页开始*/

}    
  


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 < numnodes; node++) {
     ......
    
		 free_area_init_node(node, pgdat, 0, zone_size,
				  bdata->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 < MAX_NR_ZONES; j++) {    
	   ....
  	zone->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型的变量是否有问题,后来
参考了:
<<Compiler Usage Guidelines for 
64-Bit Operating Systems 
on AMD64 Platforms Application Note >>
指出在linux的64bit环境中, long是64bit的!!!和windows不同啊.


第二部分  本模块对外接口详解

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不再做其他说明.

   
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 < end) {
		if (!vma || 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) <= 0) 
			goto out_unlock;
		spin_lock(&mm->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 < end));
}
   如果某个pte已经映射了一个页面,就将其释放.这个操作也没有涉及vma,没有
加锁.

  
VI)vmtruncate (sys_truncate)
   先来看看此系统调用执行流程:
sys_truncate->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 < offset)
		goto do_expand; /*对于文件扩展不影响对此文件的maping*/
	inode->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再议.
         
       
    
VII)Understanding Swap in
  接口函数: swapin_readahead,handle_mm_fault,make_pages_present.
  我们从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