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 内存. 
　　全文完.