Linu內核內存管理解析

構，也為操作系統(tǒng)的設計帶來了一定便利：可以取地址的上半段保留做為操作

系統(tǒng)的邏輯地址空間，而低地址部分做為裝載應用程序的空間，而canonical

form不允許的地址空間則做為操作系統(tǒng)的標志、以及特權級的標識等。當然，

這樣的設計在未來地址進一步擴展的時候將成為一個新的問題。

采用64位地址空間的X86-86被稱為是運行在“長模式"(longmode)下，該

模式可以看成是對PAE模式的一個擴充。長模式允許使用三個不同的物理頁面大

小：4KB、2MB和1GB。在使用64位中的48位用來存放地址時，與PAE模式下

的三級頁面映射機制不同的是，長模式下線性地址到物理地址的映射需要經過四

級地址映射。在這四級地址映射機制中，原來PAE模式下僅擁有4個表項的頁

目錄指針表被擴展到512個表項。同時，在最末一級加入一?級新的頁面映射結構,

該結構被稱為第四級頁表(MapLevel4Table,PML4),它跟PAE模式下

的頁目錄及頁表(在長模式中，成為了頁目錄)一樣，擁有512個表項。如果地

址進一步擴充，如把64位尋址全部用上，該頁表就能夠擴充到33,554,432個

表項，或者干脆再加一層地址映射(PML5),當然，按照目前只用了48位的情

況下，用到512個表項的PML4就已經夠用了。

可以想象，用到48位的X86-64虛擬地址的分配機制為：

-0—11(12)位：頁內偏移；

-12-20(9)位：由PML4來映射;

-21-29(9)位：高一級頁目錄來映射(如果PS=1,則該頁表項指向一個2MB

的頁)；

-30-38(9)位：再高一級的頁目錄來映射(如果PS=2,則該頁表項指向一個

1GB的頁)；

-39—47(9)位：頁目錄指針表來映射。

X86-64的長模式下，對16位以及32位代碼進行了兼容，即使CPU上跑的是64

位的操作系統(tǒng)，歷史遺留的16位以及32位代碼將都能夠在該操作系統(tǒng)上運行。

由于X86-64兼容IA32的指令，所以，這些代碼在這種情況下運行，基本上沒有

性能損耗。

在傳統(tǒng)模式(Legacymode)下，x86-64的CPU的工作模式跟傳統(tǒng)的IA32沒有

什么兩樣。

6堆的管理譴

一般人喜歡把堆和棧來做對比，網(wǎng)上資料也很多，這里我只分享一下我本人的理

解。堆這個東西跟棧沒有直接的關聯(lián)，它只給程序員提供一個手工分配和釋放的

內存空間，僅此而已。

對于每個Unix進程來說，都擁有一個特殊的線性區(qū)，這個線性區(qū)就是所謂的堆

(heap),堆用于滿足進程的動態(tài)內存請求。內存描述符的start_brk與brk

字段分別限定了這個區(qū)的開始地址和結束地址。

進程可以使用下面的C語言API來請求和釋放動態(tài)內存：

malloc(size)

請求size個字節(jié)的動態(tài)內存。如果分配成功，就返回所分配內存單元第一

個字節(jié)的線性地址。

calloc(n,size)

請求含有n個大小為size的元素的一個數(shù)組。如果分配成功，就把數(shù)組元

素初始化為0,并返回第一個元素的線性地址。

realloc(ptr,size)

改變由前面的malloc?；騝alloc()分配的內存區(qū)字段的大小。

free(addr)

釋放由mallocO或calloc。分配的起始地址為addr的線性區(qū)。

brk(addr)

直接修改堆的大小。addr參數(shù)指定current->mm->brk的新值，返回值是線

性區(qū)新的結束地址(進程必須檢查這個地址和所請求的地址值addr是否致)。

sbrk(incr)

類似于brk(),不過其中的incr參數(shù)指定是增加還是減少以字節(jié)為單位的

堆大小。

brk()函數(shù)和以上列出的函數(shù)有所不同，因為它是唯一以系統(tǒng)調用的方式實現(xiàn)的

函數(shù),而其他所有的函數(shù)都是使用brk()和mmap()系統(tǒng)調用實現(xiàn)的C語言庫函數(shù)。

當用戶態(tài)的進程調用brk()系統(tǒng)調用時，內核執(zhí)行sys_brk(addr)函數(shù)。該函數(shù)

首先驗證addr參數(shù)是否位干進程代碼所在的線性區(qū)。如果是，則立即返回，

因為堆不能與進程代碼所在的線性區(qū)重疊：

mm=current->mm;

down_write(&.mm->mmap_sem);

if(addr<mm->end_code){

out:

up_write(&mm->mmap_sem);

returnmm->brk;

由于brk()系統(tǒng)調用作用于某一個非代碼的線性區(qū)，它分配和釋放完整的頁。

因此，該函數(shù)把addr的值調整為PAGE_SIZE的倍數(shù)，然后把調整的結果與內存

描述符的brk字段的值進行比較：

newbrk=(addr+Oxfff)&OxfffffOOO;

oldbrk=(mm->brk+Oxfff)&OxfffffOOO;

if(oldbrk==newbrk){

mm->brk=addr;

gotoout;

如果進程請求縮小堆，則sys_brk()調用do_munmap()函數(shù)完成這項任務，然后

返回：

if(addr<=mm->brk){

if(!do_munmap(mm,newbrk,o1dbrk-newbrk))

mm->brk=addr;

gotoout;

如果進程請求擴大堆，則sys_brk()首先檢查是否允許進程這樣做。如果進程企

圖分配在其跟制范圍之外的內存，函數(shù)并不多分配內存，只簡單地返回mm->brk

的原有值：

rlim=current->signal->rlim[RLIMIT_DATA].rlim_cur;

if(rlim<RLIM_INFINITY&&addr-mm->start_data>rlim)

gotoout;

然后，函數(shù)檢查擴大后的堆是否和進程的其他線性區(qū)相重疊，如果是，不做任何

事情就返回：

if(find_vma_intersection(mm,oldbrk,newbrk+PAGE_SIZE))

gotoout;

如果一切都順利，則調用do_brk()函數(shù)。如果它返回oldbrk,則分配成功且

sys_brt()函數(shù)返回addr的值；否則,返回舊的mm->brk值:

if(do_brk(oldbrk,newbrk-oldbrk)==oldbrk)

mm->brk=addr;

gotoout;

do_brk()函數(shù)實際上是僅處理匿名線性區(qū)的do_mmap()的簡化版。可以認為它的

調論等價于：

dommap(NULL,oldbrk,newbrk-oldbrk,

PR0T_READ|PROT__WRITE|PR0T_EXEC,

MAP_FIXED|MAP_PRIVATE,0)

當然，do_brk()比do_mmap()稍快，因為前者假定線性區(qū)不映射磁盤上的文件,

從而避免亍檢查線性反對象的兒個字段。

7創(chuàng)建和刪除進程的地址空間收藏

本博，我們重點關注fork。系統(tǒng)調用為子進程創(chuàng)建一個完整的新地址空間。相

反，當進程結束時，內核撤消它的地址空間。我們重點來討論Linux如何執(zhí)行這

兩種操作。

81創(chuàng)建進程的地址空間

回憶一下“進程的創(chuàng)建——dofork。函數(shù)詳解”博文：當創(chuàng)建一個新的進程

時內核調用copy_mm()函數(shù)。這個函數(shù)通過建立新進程的所有頁表和內存描述符

來創(chuàng)建進程一的地址空間：

staticintcopy_mm(unsignedlongclone_flags,structtaskstruct*tsk)

{

structmmstruct*mm,*oldmm;

intretval;

tsk->min_fIt=tsk->maj_fIt=0;

tsk->nvcsw=tsk->nivcsw=0;

tsk->mm=NULL;

tsk->active_mm=NULL;

/*

*Arewecloningakernelthread?

*

*WeneedtostealaactiveVMforthat..

*/

oldmm=current->mm;

if(!oldmm)

return0;

if(clone_flags&CLONE_VM){

atomicinc(&o1users);

mm=oldmm;

gotogood_mm;

)

retval=-ENOMEM;

mm=dup_mm(tsk);

if(!mm)

gotofailnomem;

goodmm:

tsk->mm=mm;

tsk->active_mm=mm;

return0;

fail_nomem:

returnretval;

}

通常，每個進程都有自己的地址空間，但是輕進程可以通過調用clone。函數(shù)(設

置了CL0NE_VM標志)來創(chuàng)建。這些輕量級進程共享同一?地址空間，也就是說，

允許它們對同一組頁進行尋址。

按照前面講述的“寫時復制”方法，傳統(tǒng)的進程繼承父進程的地址空間，只要

頁是只讀的，就依然共享它們。當其中的一個進程試圖對某個頁進行寫時,此時，

這個頁才被復制一份。一段時間之后，所創(chuàng)建的子進程通常會因為缺頁異常而獲

得與父進程不一樣的完全屬于自己的地址空間。

另一方面，輕量級的進程使用父進程的地址空間。Linux實現(xiàn)輕量級進程很簡單,

即不復制父進程地址空間。創(chuàng)建輕量級的進程(clone)比創(chuàng)建普通進程相應要

快得多，而且只要父進程和子進程謹慎地協(xié)調它們的訪問，就可以認為頁的共享

是有益的。

如果通過clone()系統(tǒng)調用已經創(chuàng)建了新進程，并且flag參數(shù)的CLONE_VM標志

被設置，則copy_mm()函數(shù)把父進程(current)地址空間給子進程(tsk)：

if(clone_flags&CL0NE_VM){

atomic_inc(&o1dmm->mm_users);

mm=oldmm;

gotogood_mm;

good_mm:

tsk->mm=mm;

tsk->active_mm=mm;

return0;

如果沒有設置CLONE_VM標志，copy_mm()函數(shù)就必須創(chuàng)建一個新的地址空間(在

進程請求一個地址之前，即使在地癥空間內沒有分配內存)：

mm=dup_mm(tsk);

dup_mm()函數(shù)分配一個新的內存描述符，把它的地址存放在新進程描述符tsk

的mm字段中，并把current->min的內容復制到tsk->mm中。然后改變新進程描

述符的一些字段：

staticstructmm_struct*dupmm(structtask_struct*tsk)

{

structmm_struct*mm,*oldmm=current->mm;

interr;

if(!oldmm)

returnNULL;

mm二allocate_mm();

if(!mm)

gotofailnomem;

memcpy(mm,oldmm,sizeof;

if(!mminit(mm))

gotofail_nomem;

if(init_new_context(tsk,mm))

gotofail_nocontext;

err二dup_mmap(mm,oldmm);

if(err)

gotofree_pt;

mm->hiwater_rss=get_mm_rss(mm);

mm->hiwater_vm=mm->total_vm;

returnmm;

free_pt:

mmput(mm);

fail_nomem:

returnNULL;

fail_nocontext:

free_mm_flags(mm);

mm_free_pgd(mm);

free_mm(mm);

returnNULL;

}

ttdefineallocate_mmO(kmem_cache_alloc(mmcachep,SLABKERNEL))

函數(shù)首先使用allocatemm()函數(shù)調用kmem_cache_alloc(mmcachep,

SLAB_KERNEL)從slab中分配一個mm_struct結構，然后調用mm_init對其進行

初始必

staticstructmm_struct*mminit(structmm_struct*mm)

(

unsignedlongmm_flags;

atomic_set(&mm->mm_users,1);

atomic_set(&mm->mm_count,1);

init_rwsem(&mm->mmap_sem);

INIT_LIST_HEAD(&mm->innilist);

mm->core_waiters=0;

mm->nr_ptes=0;

set_mm_counter(mm,file_rss,0);

set_mm_counter(mm,anon_rss,0);

spin_lock_init(&mm->page_table_lock);

rwlockinit(&mm->ioctx_list_lock);

mm->ioctx_list=NULL;

mm->free_area_cache=TASK_UNMAPPED_BASE;

mm->cached_hole_size=~OUL;

mm_flags=get_mm_flags(current->mm);

if(mm_flags!=MMF_DUMP_FILTER_DEFAULT){

if(uniikely(set_mm_flags(mm,mm_flags,0)<0))

gotofail_nomem;

)

if(likely(!mm_a11oc_pgd(mm))){

mm->def_flags=0;

mmu_notifier_mm_init(mm);

returnmm;

if(mm_flags!=MMF_DUMP_FILTER_DEFAULT)

free_mm_flags(mm);

fail_nomem:

free_mm(mm);

returnNULL;

)

回想一下，mmallocpgd()調用pgd_alloc()宏為新進程分配一個全新的頁全局

目錄：(/arch/i386/mm/Pgtable.c)

staticinlineintmm_alloc_pgd(structmmstruct*mm)

(

mm->pgd=pgd_alloc(mm);

if(unlikely(!mm->pgd))

return-ENOMEM;

return0;

)

pgd_t*pgd_alloc(structmm_struct*mm)

(

inti;

pgd_t*pgd=kmem_cache_alloc(pgd_cache,GFPKERNEL);

if(PTRS_PER_PMD==1||!pgd)

returnpgd;

for(i=0;i<USER_PTRS_PER_PGD;++i){

pmd_t*pmd=kmem_cache_alloc(pmd_cache,GFP_KERNEL);

if(!pmd)

gotoout_oom;

set_pgd(&pgd[i],_pgd(l+_pa(pmd)));

)

returnpgd;

out_oom:

for(i--；i>=0;i--)

kmem_cache_free(pmd_cache,(void*)_va(pgd_val(pgd[i])~l));

kmem_cache_free(pgd_cache,pgd);

returnNULL;

}

SdefineUSER_PTRS_PER_PGD(TASK_SIZE/PGDIR_SIZE)

ttdefinePGDIR_SIZE(1UL?PGDIR_SHIFT)

SdefinePGDIR_SHIFT22

#defineTASKSIZE(PAGE_OFFSET)/*Userspaceprocesssize:3GB

(default).*/

注意，執(zhí)行完mm_a芯oc_pgd()函數(shù)之后,子進程的pgd和pmd有了(32位i386

體系結構)，但是pte是沒有的，后面的工作需要dupjnmapO函數(shù)來完成，馬

上會談到。

接著來，隨后調用依賴于體系結構的init_new_context()函數(shù)：對于80x86處

理器，該函數(shù)檢查當前進程是否擁有定制而局而描述符表，如果是，

init_new_context()復制一份current的局部描述符表并把它插入tsk的地址空

間：

intinit_new_context(structtask_struct*tsk,structmm_struct*mm)

(

structmmstruct*old_mm;

intretval=0;

init_MUTEX(&mm->context.sem);

mm->context.size=0;

old_mm=current->mm;

if(old_mm&&old_mm->context.size>0){

down(&old_mm->context.sem);

retval=copy_ldt(&mm->context,&old_mm->context);

up(&old_mm->context.sem);

)

returnretval;

)

下一個重點步驟：err=dup_mmap(mm,oldmm)：

staticinlineintdupmmap(structmm_struct*mm,structmm_struct*oldmm)

{

structvm_area_struct*mpnt,*tmp,**pprev;

structrb_node**rb_link,*rb_parent;

intretval;

unsignedlongcharge;

structmempolicy*pol;

down_write(&oldmm->mmap_sem);

flush_cache_mm(oldmm);

/*

*Notlinkedinyet-nodeadlockpotential:

*/

down_write_nested(&mm->mmap_sem,SINGLE_DEPTH_NESTING);

mm->locked_vm=0;

mm->mmap=NULL;

mm->mmap_cache=NULL;

mm->free_area_cache=oldmm->mmap_base;

mm->cached_ho1e_size=~OUL;

mm->map_count=0;

cpus_clear(mm->cpu_vm_mask);

mm->mm_rb=RBROOT;

rb_link=rb_node;

rb_parent=NULL;

pprev=&mm->mmap;

for(mpnt=oldmm->mmap;mpnt;mpnt=mpnt->vm_next){

structfile

if(mpnt->vm_flags&VM_DONTCOPY){

longpages=vma_pages(mpnt);

mm->total_vm-二pages;

vm_stat_account(mm,mpnt->vm_flags,mpnt->vm_file,

s);

continue;

)

charge=0;

if(mpnt->vm_flags&VM_ACCOUNT){

unsignedintlen=(mpnt->vm_end-mpnt->vm_start)?

PAGE_SHIFT;

if(security_vm_enough_memory(1en))

gotofail_nomem;

charge=len;

}

tmp=kmem_cache_alloc(vm_area_cachep,SLAB_KERNEL);

if(!tmp)

gotofail_nomem;

*tmp=*mpnt;

pol=mpol_copy(vma_policy(mpnt));

retval=PTR_ERR(pol);

if(IS_ERR(pol))

gotofail_nomempolicy;

vma_set_po1icy(tmp,pol);

tmp->vm_flags&="VM_L0CKED;

tmp->vm_mm=mm;

tmp->vm_next=NULL;

anon_vma_link(tmp);

file=tmp->vm_file;

if(file){

structinodebinode=file->f_dentry->d_inode;

get_file(file);

if(tmp->vm_flags&VM_DENYWRITE)

atomic_dec(&inode->i_writecount);

/*inserttmpintothesharelist,justaftermpnt*/

spinlock(&file->f_mapping->i_mmap_lock);

tmp->vm_truncate_count=mpnt->vm_truncate_count;

flushdcachemmap_lock(file->fmapping);

vma_prio_tree_add(tmp,mpnt);

flushdcachemmap_unlock(file->f_mapping);

spin_unlock(&fi1e->f_mapping->i_mmap_lock);

}

/*

*Linkinthenewvmaandcopythepagetableentries.

*/

*pprev=tmp;

pprev=&tmp->vm_next;

_vma_link_rb(mm,tmp,rb_link,rb_parent);

rb_link=&tmp->vm_rb.rb_right;

rb_parent=&tmp->vmrb;

mm->map_count++;

retval=copyjpage_range(mm,oldmm,mpnt);

if(tmp->vm_ops&&tmp->vm_ops->open)

tmp->vmops->open(tmp);

if(retval)

gotoout;

}

#ifdefarch_dup_mmap

arch_dup_mmap(mm,oldmm);

Sendif

retval=0;

out:

upwrite(&mm->mmapsem);

f1ush_11b_mm(o1dmm);

upwrite(&oldmm->mmap_sem);

returnretval;

fail_nomem_policy:

kmem_cache_free(vm_area_cachep,tmp);

fail_nomem:

retval=-ENOMEM;

vm_unacct_memory(charge);

gotoout;

}

dup_mmap()函數(shù)既復制父進程的線性區(qū)，也復制父進程的頁表。

然后，從current->mm->mmap所指向的線性區(qū)開始掃描父進程的線性區(qū)鏈表：

for(mpnt=oldmm->mmap;mpnt;mpnt=mpnt->vm_next)

它復制遇到的每個vm_area_struct線性區(qū)描述符，并把復制品插入到子進程的

線性區(qū)鏈表和紅-黑樹中：

tmp=kmem_cache_alloc(vm_area_cachep,SLABKERNEL);

*tmp=*mpnt;/*完全復制，這個技巧在這里又用到了*/

rb_link=rb_node;

rbparent=NULL;

_vma_link_rb(mm,tmp,rb_link,rb_parent);

rb_link=&tmp->vm_rb.rb_right;

rb_parent=&tmp->vm_rb;

在插入一個新的線性區(qū)描述符之后，如果需要的話，dup_mmap()立即調用

copy_page_range()創(chuàng)建必要的頁表來映射這個線性區(qū)所包含的一組頁，并且初

始化新頁袤的表項。尤其是，與私有的、可寫的頁(VM_SHARED標志關閉，

VM—MAYWRITE標志打開)所對應的任一頁框都標記為對父子進程是只讀的，以

便這種頁框能用寫時復制機制進行處理：

intcopypage_range(structmmstruct*dst_mm,structmm_struct*src_mm,

structvm_area_struct*vma)

(

pgd_t*src_pgd,*dst_pgd;

unsignedlongnext;

unsignedlongaddr=vma->vm_start;

unsignedlongend=vma->vm_end;

intret;

/*

*Don，tcopypteswhereapagefaultwillfillthemcorrectly.

*Forkbecomesmuchlighterwhentherearebigsharedorprivate

*readonlymappings.Thetradeoffisthatcopy_page_rangeismore

*efficientthanfaulting.

*/

if(!(vma->vm_flags&

(VM_HUGETLB|VM_NONLINEAR|VM_PFNMAP|VM_INSERTPAGE))){

if(!vma->anon_vma)

return0;

if(is_vm_huge11b_page(vma))

returncopyhugetlb_page_range(dstmm,srcmm,vma);

/*

*WeneedtoinvalidatethesecondaryMMUmappingsonlywhen

*therecouldbeapermissiondowngradeontheptesofthe

*parentmm.Andapermissiondowngradewillonlyhappenif

*is_cow_mapping()returnstrue.

*/

if(is_cow_mapping(vma->vm_flags))

mmu_notifier_invalidate_range_start(src_mm,addr,end);

ret=0;

dst_pgd=pgdoffset(dstmm,addr);

src_pgd=pgd_offset(src_mm,addr);

do{

next=pgd_addr_end(addr,end);

if(pgd_none_or_c1ear_bad(src_pgd))

continue;

if(unlikely(copy_pud_range(dst_mm,srcmm,dst_pgd,srcpgd,

vma,addr,next))){

ret=-ENOMEM;

break;

}

}while(dst_pgd++,src_pgd++,addr=next,addr!=end);

if(is_cow_mapping(vma->vm_flags))

mmu_notifier_invalidate_range_end(src_mm,

vma->vm_start,end);

returnret;

)

staticinlineintcopy_pud_range(structmm_structstruct

mm_struct*src_mm,

pgd_t*dst_pgd,pgd_t*src_pgd,structvm_area_struct*vma,

unsignedlongaddr,unsignedlongend)

(

pud_t*src_pud,*dst_pud;

unsignedlongnext;

dst_pud=pud_alloc(dst_mm,dst_pgd,addr);

if(!dst_pud)

return-ENOMEM;

src_pud=pud_offset(src_pgd,addr);

do{

next=pud_addr_end(addr,end);

if(pud_none_or_clear_bad(src_pud))

continue;

if(copy_pmd_range(dst_mm,src_mm,dst_pud,src_pud,

vma,addr,next))

return-ENOMEM;

}while(dst_pud++,src_pud++,addr=next,addr!=end);

return0;

)

staticinlineintcopy_pmd_range(structmm_struct*dst_mm,struct

mm_struct*src_mm,

pud_t*dst_pud,pud_t*src_pud,structvm_area_struct*vma,

unsignedlongaddr,unsignedlongend)

{

pmd_t*src_pmd,*dst_pmd;

unsignedlongnext;

dst_pmd=pmd_alloc(dst_mm,dst_pud,addr);

if(!dst_pmd)

return-ENOMEM;

src_pmd=pmd_offset(src_pud,addr);

do{

next=pmd_addr_end(addr,end);

if(pmd_none_or_c1ear_bad(src_pmd))

continue;

if(copy_pte_range(dst_mm,src_mm,dst_pmd,src_pmd,

vma,addr,next))

return-ENOMEM;

}while(dst_pmd++,src_pmd++,addr=next,addr!=end);

return0;

staticintcopy_pte_range(structmm__structstructmm_struct

*src_mm,

pmd_t*dst_pmd,pmd_t*src_pmd,structvm_area_struct*vma,

unsignedlongaddr,unsignedlongend)

pte_t*src_pte,*dst_pte;

spinlock_t*src_ptl,*dst_ptl;

intprogress=0;

intrss[2];

again:

rssEl]=rss[0]=0;

dst_pte=pte_alloc_map_lock(dst_mm,dst_pmd,addr,&dst_ptl);

if(!dst_pte)

return-ENOMEM;

src_pte=pte_offset_map_nested(src_pmd,addr);

src_ptl=pte_lockptr(src_mm,src_pmd);

spin_lock_nested(src_ptl,SINGLE_DEPTH_NESTING);

do{

/*

*Weareholdingtwolocksatthispoint-eitherofthem

*couldgeneratelatenciesinanothertaskonanotherCPU.

*/

if(progress>=32){

progress=0;

if(need_resched()

need_lockbreak(src_ptl)

needlockbreak(dst_ptl))

break;

)

if(pte_none(*src_pte)){

progress++;

continue;

)

copy_one_pte(dstmm,src_mm,dst_pte,src_pte,vma,addr,rss);

progress+=8;

}while(dst_pte++,src_pte++,addr+二PAGE_SIZE,addr!=end);

spin_unlock(src_ptl);

pte_unmap_nested(src_pte-1);

add_mm_rss(dst_mm,rss[0],rss[l]);

pte_unmap_unlock(dst_pte-1,dst_ptl);

cond_resched();

if(addr!=end)

gotoagain;

return0;

staticinlinevoid

copy_one_pte(structmmstructstructmm_struct*src_mm,

pte_t*dst_pte,pte_t*src_pte,structvm_area_struct*vma,

unsignedlongaddr,int*rss)

(

unsignedlongvm_flags=vma->vm_flags;

pte_tpte=*src_pte;

structpage*page;

/*ptecontainspositioninswaporfile,socopy.*/

if(unlikely(!pte_present(pte))){

if(!pte_file(pte)){

swp_entry_tentry=pte_to_swp_entry(pte);

swap_duplicate(entry);

/*makesuredst_mmisonswapoff，smmlist.*/

if(unlikely(list_empty(&dst_mm->mmlist))){

spin_lock(&mmlist_lock);