从操作系统内存管理来说，malloc申请一块内存的背后原理是什么？ 第1页

       //内存空间地址描述符标志 typedef struct s_MSADFLGS {     u32_t mf_olkty:2;    //挂入链表的类型     u32_t mf_lstty:1;    //是否挂入链表     u32_t mf_mocty:2;    //分配类型，被谁占用了，内核还是应用或者空闲     u32_t mf_marty:3;    //属于哪个区     u32_t mf_uindx:24;   //分配计数 }__attribute__((packed)) msadflgs_t;  ​ //物理地址和标志   typedef struct s_PHYADRFLGS {     u64_t paf_alloc:1;     //分配位     u64_t paf_shared:1;    //共享位     u64_t paf_swap:1;      //交换位     u64_t paf_cache:1;     //缓存位     u64_t paf_kmap:1;      //映射位     u64_t paf_lock:1;      //锁定位     u64_t paf_dirty:1;     //脏位     u64_t paf_busy:1;      //忙位     u64_t paf_rv2:4;       //保留位     u64_t paf_padrs:52;    //页物理地址位 }__attribute__((packed)) phyadrflgs_t; ​ //内存空间地址描述符 typedef struct s_MSADSC {     list_h_t md_list;           //链表     spinlock_t md_lock;         //保护自身的自旋锁     msadflgs_t md_indxflgs;     //内存空间地址描述符标志     phyadrflgs_t md_phyadrs;    //物理地址和标志     void* md_odlink;            //相邻且相同大小msadsc的指针 }__attribute__((packed)) msadsc_t;     

       typedef struct s_MEMAREA {     list_h_t ma_list;             //内存区自身的链表     spinlock_t ma_lock;           //保护内存区的自旋锁     uint_t ma_stus;               //内存区的状态     uint_t ma_flgs;               //内存区的标志      uint_t ma_type;               //内存区的类型     sem_t ma_sem;                 //内存区的信号量     wait_l_head_t ma_waitlst;     //内存区的等待队列     uint_t ma_maxpages;           //内存区总的页面数     uint_t ma_allocpages;         //内存区分配的页面数     uint_t ma_freepages;          //内存区空闲的页面数     uint_t ma_resvpages;          //内存区保留的页面数     uint_t ma_horizline;          //内存区分配时的水位线     adr_t ma_logicstart;          //内存区开始地址     adr_t ma_logicend;            //内存区结束地址     uint_t ma_logicsz;            //内存区大小     //还有一些结构我们这里不关心。后面才会用到 }memarea_t；     

       typedef struct s_BAFHLST {     spinlock_t af_lock;    //保护自身结构的自旋锁     u32_t af_stus;         //状态      uint_t af_oder;        //页面数的位移量     uint_t af_oderpnr;     //oder对应的页面数比如 oder为2那就是1<<2=4     uint_t af_fobjnr;      //多少个空闲msadsc_t结构，即空闲页面     uint_t af_mobjnr;      //此结构的msadsc_t结构总数，即此结构总页面     uint_t af_alcindx;     //此结构的分配计数     uint_t af_freindx;     //此结构的释放计数     list_h_t af_frelst;    //挂载此结构的空闲msadsc_t结构     list_h_t af_alclst;    //挂载此结构已经分配的msadsc_t结构 }bafhlst_t; …… ​ #define MDIVMER_ARR_LMAX 52 typedef struct s_MEMDIVMER {     spinlock_t dm_lock;      //保护自身结构的自旋锁     u32_t dm_stus;           //状态     uint_t dm_divnr;         //内存分配次数     uint_t dm_mernr;         //内存合并次数     bafhlst_t dm_mdmlielst[MDIVMER_ARR_LMAX];//bafhlst_t结构数组     bafhlst_t dm_onemsalst;  //单个的bafhlst_t结构 }memdivmer_t;     

       void init_memmgr() {     //初始化内存页结构     init_msadsc();     //初始化内存区结构     init_memarea();     //处理内存占用     init_search_krloccupymm(&kmachbsp);     //合并内存页到内存区中     init_merlove_mem();     init_memmgrob();     return; }     

       //找到合适的bafhlst_t bool_t onmpgs_retn_bafhlst(memarea_t *malckp, uint_t pages , bafhlst_t **retrelbafh, bafhlst_t **retdivbafh) {     //获取bafhlst_t结构数组的开始地址     bafhlst_t *bafhstat = malckp->ma_mdmdata.dm_mdmlielst;            //根据分配页面数计算出分配页面在dm_mdmlielst数组中下标     sint_t dividx = retn_divoder(pages);     //从第dividx个数组元素开始搜索     for (sint_t idx = dividx; idx < MDIVMER_ARR_LMAX; idx++)     {     //如果第idx个数组元素对应的一次可分配连续的页面数大于等于请求的页面数         //，且其中的可分配对象大于0则返回          if (bafhstat[idx].af_oderpnr >= pages &&              0 < bafhstat[idx].af_fobjnr)         {             //返回请求分配的bafhlst_t结构指针             *retrelbafh = &bafhstat[dividx];             //返回实际分配的bafhlst_t结构指针             *retdivbafh = &bafhstat[idx];             return TRUE;         }     }     *retrelbafh = NULL;     *retdivbafh = NULL;     return FALSE; }     

       msadsc_t *mm_reldpgsdivmsa_bafhl(memarea_t *malckp, uint_t pages, uint_t *retrelpnr, bafhlst_t *relbfl, bafhlst_t *divbfl) {     msadsc_t *retmsa = NULL;     bool_t rets = FALSE;     msadsc_t *retmstat = NULL, *retmend = NULL;     //处理相等的情况     if (relbfl == divbfl)     {     //从bafhlst_t结构中获取msadsc_t结构的开始与结束地址         rets = mm_retnmsaob_onbafhlst(relbfl, &retmstat, &retmend);         //设置msadsc_t结构的相关信息表示已经删除         retmsa = mm_divpages_opmsadsc(retmstat, relbfl->af_oderpnr);         //返回实际的分配页数         *retrelpnr = relbfl->af_oderpnr;         return retmsa;     }     //处理不等的情况     //从bafhlst_t结构中获取msadsc_t结构的开始与结束地址     rets = mm_retnmsaob_onbafhlst(divbfl, &retmstat, &retmend);      uint_t divnr = divbfl->af_oderpnr;      //从高bafhlst_t数组元素中向下遍历     for (bafhlst_t *tmpbfl = divbfl - 1; tmpbfl >= relbfl; tmpbfl--)     {         //开始分割连续的msadsc_t结构，把剩下的一段连续的msadsc_t结构加入到对应该bafhlst_t结构中         if (mrdmb_add_msa_bafh(tmpbfl, &retmstat[tmpbfl->af_oderpnr], (msadsc_t *)retmstat->md_odlink) == FALSE)         {             system_error("mrdmb_add_msa_bafh fail
");         }         retmstat->md_odlink = &retmstat[tmpbfl->af_oderpnr - 1];         divnr -= tmpbfl->af_oderpnr;     } ​     retmsa = mm_divpages_opmsadsc(retmstat, divnr);     if (NULL == retmsa)     {         *retrelpnr = 0;         return NULL;     }     *retrelpnr = relbfl->af_oderpnr;     return retmsa; }     

       bool_t mm_merpages_onbafhlst(msadsc_t *freemsa, uint_t freepgs, bafhlst_t *relbf, bafhlst_t *merbf) {     sint_t rets = 0;     msadsc_t *mnxs = freemsa, *mnxe = &freemsa[freepgs - 1];     bafhlst_t *tmpbf = relbf;     //从实际要开始遍历，直到最高的那个bafhlst_t结构     for (; tmpbf < merbf; tmpbf++)     {         //查看最大地址连续、且空闲msadsc_t结构         //如释放的是第0个msadsc_t结构我们就去查找第1个msadsc_t结构是否空闲         //，且与第0个msadsc_t结构的地址是不是连续的         rets = mm_find_cmsa2blk(tmpbf, &mnxs, &mnxe);         if (1 == rets)         {             break;         }     }     //把合并的msadsc_t结构（从mnxs到mnxe）加入到对应的bafhlst_t结构中     if (mpobf_add_msadsc(tmpbf, mnxs, mnxe) == FALSE)     {         return FALSE;     }     return TRUE; } ​ bool_t mpobf_add_msadsc(bafhlst_t *bafhp, msadsc_t *freemstat, msadsc_t *freemend) {     freemstat->md_indxflgs.mf_olkty = MF_OLKTY_ODER;     //设置起始页面指向结束页     freemstat->md_odlink = freemend;     freemend->md_indxflgs.mf_olkty = MF_OLKTY_BAFH;     //结束页面指向所属的bafhlst_t结构     freemend->md_odlink = bafhp;     //把起始页面挂载到所属的bafhlst_t结构中     list_add(&freemstat->md_list, &bafhp->af_frelst);     //增加bafhlst_t结构的空闲页面对象和总的页面对象的计数     bafhp->af_fobjnr++;     bafhp->af_mobjnr++;     return TRUE; }     

        char *str;           //内存分配 存放15个char字符类型        str = (char *) malloc(15);     if (str == NULL) {             printf("mem alloc err
");     return -1; }     

       typedef struct s_FREOBJH {     list_h_t oh_list;     //链表,将内存对象挂载在其他的结构上，常规操作     uint_t oh_stus;       //对象状态     void* oh_stat;        //对象的开始地址，即该对象的开头地址 }freobjh_t;     

       //内存对象容器 typedef struct s_KMSOB {     list_h_t so_list;        //链表     spinlock_t so_lock;      //保护结构自身的自旋锁     uint_t so_stus;          //状态与标志     uint_t so_flgs;     adr_t so_vstat;          //内存对象容器的开始地址     adr_t so_vend;           //内存对象容器的结束地址     size_t so_objsz;         //内存对象大小     size_t so_objrelsz;      //内存对象实际大小     uint_t so_mobjnr;        //内存对象容器中总共的对象个数     uint_t so_fobjnr;        //内存对象容器中空闲的对象个数     list_h_t so_frelst;      //内存对象容器中空闲的对象链表头     list_h_t so_alclst;      //内存对象容器中分配的对象链表头     list_h_t so_mextlst;     //内存对象容器扩展kmbext_t结构链表头     uint_t so_mextnr;        //内存对象容器扩展kmbext_t结构个数     msomdc_t so_mc;          //内存对象容器占用内存页面管理结构     void* so_privp;          //本结构私有数据指针     void* so_extdp;          //本结构扩展数据指针 }kmsob_t; //管理内存对象容器扩展容量 typedef struct s_KMBEXT {     list_h_t mt_list;        //链表     adr_t mt_vstat;          //内存对象容器扩展容量开始地址     adr_t mt_vend;           //内存对象容器扩展容量结束地址     kmsob_t* mt_kmsb;        //指向内存对象容器结构     uint_t mt_mobjnr;        //内存对象容器扩展容量的内存中有多少对象 }kmbext_t; //管理内存对象容器占用的内存页面所对应的msadsc_t结构 typedef struct s_MSCLST {     uint_t ml_msanr;  //多少个msadsc_t     uint_t ml_ompnr;  //一个msadsc_t对应的连续的物理内存页面数     list_h_t ml_list; //挂载msadsc_t的链表 }msclst_t; //管理内存对象容器占用的内存 typedef struct s_MSOMDC {     //msclst_t结构数组mc_lst[0]=1个连续页面的msadsc_t     //               mc_lst[1]=2个连续页面的msadsc_t     //               mc_lst[2]=4个连续页面的msadsc_t     //               mc_lst[3]=8个连续页面的msadsc_t     //               mc_lst[4]=16个连续页面的msadsc_t     msclst_t mc_lst[MSCLST_MAX];     uint_t mc_msanr;   //总共多个msadsc_t结构     list_h_t mc_list;     //内存对象容器第一个占用msadsc_t     list_h_t mc_kmobinlst;     //内存对象容器第一个占用msadsc_t对应的连续的物理内存页面数     uint_t mc_kmobinpnr; }msomdc_t;     

       //判断内存对象容器中有没有内存对象 uint_t scan_kmob_objnr(kmsob_t *kmsp) {     if (0 < kmsp->so_fobjnr)     {         return kmsp->so_fobjnr;     }     return 0; } //实际分配内存对象 void *kmsob_new_opkmsob(kmsob_t *kmsp, size_t msz) {     //获取kmsob_t中的so_frelst链表头的第一个空闲内存对象     freobjh_t *fobh = list_entry(kmsp->so_frelst.next, freobjh_t, oh_list);     //从链表中脱链     list_del(&fobh->oh_list);     //kmsob_t中的空闲对象计数减一     kmsp->so_fobjnr--;     //返回内存对象首地址     return (void *)(fobh); } ​ void *kmsob_new_onkmsob(kmsob_t *kmsp, size_t msz) {     void *retptr = NULL;     cpuflg_t cpuflg;     knl_spinlock_cli(&kmsp->so_lock, &cpuflg);     //如果内存对象容器中没有空闲的内存对象了就需要扩展内存对象容器的内存了     if (scan_kmsob_objnr(kmsp) < 1)     {//扩展内存对象容器的内存         if (kmsob_extn_pages(kmsp) == FALSE)         {             retptr = NULL;             goto ret_step;         }     }     //实际分配内存对象     retptr = kmsob_new_opkmsob(kmsp, msz); ret_step:     knl_spinunlock_sti(&kmsp->so_lock, &cpuflg);     return retptr; }     

       bool_t kmsob_delete_core(void *fadrs, size_t fsz) {     kmsobmgrhed_t *kmobmgrp = &memmgrob.mo_kmsobmgr;     bool_t rets = FALSE;     koblst_t *koblp = NULL;     kmsob_t *kmsp = NULL;     cpuflg_t cpuflg;     knl_spinlock_cli(&kmobmgrp->ks_lock, &cpuflg);     //根据释放内存对象的大小在kmsobmgrhed_t中查找并返回koblst_t，在其中挂载着对应的kmsob_t，这个在前面已经写好了     koblp = onmsz_retn_koblst(kmobmgrp, fsz);     if (NULL == koblp)     {         rets = FALSE;         goto ret_step;     }     kmsp = onkoblst_retn_delkmsob(koblp, fadrs, fsz);     if (NULL == kmsp)     {         rets = FALSE;         goto ret_step;     }     rets = kmsob_delete_onkmsob(kmsp, fadrs, fsz);     if (FALSE == rets)     {         rets = FALSE;         goto ret_step;     }     if (_destroy_kmsob(kmobmgrp, koblp, kmsp) == FALSE)     {         rets = FALSE;         goto ret_step;     }     rets = TRUE; ret_step:     knl_spinunlock_sti(&kmobmgrp->ks_lock, &cpuflg);     return rets; } //释放内存对象接口 bool_t kmsob_delete(void *fadrs, size_t fsz) {     //对参数进行检查，但是多了对内存对象地址的检查      if (NULL == fadrs || 1 > fsz || 2048 < fsz)     {         return FALSE;     }     //调用释放内存对象的核心函数     return kmsob_delete_core(fadrs, fsz); }     

       uint_t scan_freekmsob_isok(kmsob_t *kmsp) {     //当内存对象容器的总对象个数等于空闲对象个数时，说明这内存对象容器空闲     if (kmsp->so_mobjnr == kmsp->so_fobjnr)     {         return 2;     }     return 1; } ​ bool_t _destroy_kmsob_core(kmsobmgrhed_t *kmobmgrp, koblst_t *koblp, kmsob_t *kmsp) {     list_h_t *tmplst = NULL;     msadsc_t *msa = NULL;     msclst_t *mscp = kmsp->so_mc.mc_lst;     list_del(&kmsp->so_list);     koblp->ol_emnr--;     kmobmgrp->ks_msobnr--;     //释放内存对象容器扩展空间的物理内存页面     //遍历kmsob_t结构中的so_mc.mc_lst数组     for (uint_t j = 0; j < MSCLST_MAX; j++)     {         if (0 < mscp[j].ml_msanr)         {//遍历每个so_mc.mc_lst数组中的msadsc_t结构             list_for_each_head_dell(tmplst, &mscp[j].ml_list)             {                 msa = list_entry(tmplst, msadsc_t, md_list);                 list_del(&msa->md_list);                 //msadsc_t脱链                 //释放msadsc_t对应的物理内存页面                 if (mm_merge_pages(&memmgrob, msa, (uint_t)mscp[j].ml_ompnr) == FALSE)                 {                     system_error("_destroy_kmsob_core mm_merge_pages FALSE2
");                 }             }         }     }     //释放内存对象容器本身占用的物理内存页面     //遍历每个so_mc.mc_kmobinlst中的msadsc_t结构。它只会遍历一次     list_for_each_head_dell(tmplst, &kmsp->so_mc.mc_kmobinlst)     {         msa = list_entry(tmplst, msadsc_t, md_list);         list_del(&msa->md_list);         //msadsc_t脱链         //释放msadsc_t对应的物理内存页面         if (mm_merge_pages(&memmgrob, msa, (uint_t)kmsp->so_mc.mc_kmobinpnr) == FALSE)         {             system_error("_destroy_kmsob_core mm_merge_pages FALSE2
");         }     }     return TRUE; } //销毁内存对象容器 bool_t _destroy_kmsob(kmsobmgrhed_t *kmobmgrp, koblst_t *koblp, kmsob_t *kmsp) {     //看看能不能销毁     uint_t screts = scan_freekmsob_isok(kmsp);     if (2 == screts)     {//调用销毁内存对象容器的核心函数         return _destroy_kmsob_core(kmobmgrp, koblp, kmsp);     }     return FALSE; }     

       typedef struct KMVARSDSC {     spinlock_t kva_lock;        //保护自身自旋锁     u32_t  kva_maptype;         //映射类型     list_h_t kva_list;          //链表     u64_t  kva_flgs;            //相关标志     u64_t  kva_limits;     void*  kva_mcstruct;        //指向它的上层结构     adr_t  kva_start;           //虚拟地址的开始     adr_t  kva_end;             //虚拟地址的结束     kvmemcbox_t* kva_kvmbox;    //管理这个结构映射的物理页面     void*  kva_kvmcobj; }kmvarsdsc_t;     

       typedef struct s_VIRMEMADRS {     spinlock_t vs_lock;            //保护自身的自旋锁     u32_t  vs_resalin;     list_h_t vs_list;              //链表，链接虚拟地址区间     uint_t vs_flgs;                //标志     uint_t vs_kmvdscnr;            //多少个虚拟地址区间     mmadrsdsc_t* vs_mm;            //指向它的上层的数据结构     kmvarsdsc_t* vs_startkmvdsc;   //开始的虚拟地址区间     kmvarsdsc_t* vs_endkmvdsc;     //结束的虚拟地址区间     kmvarsdsc_t* vs_currkmvdsc;    //当前的虚拟地址区间     adr_t vs_isalcstart;           //能分配的开始虚拟地址     adr_t vs_isalcend;             //能分配的结束虚拟地址     void* vs_privte;               //私有数据指针     void* vs_ext;                  //扩展数据指针 }virmemadrs_t;     

       typedef struct s_MMADRSDSC {     spinlock_t msd_lock;               //保护自身的自旋锁     list_h_t msd_list;                 //链表     uint_t msd_flag;                   //状态和标志     uint_t msd_stus;     uint_t msd_scount;                 //计数，该结构可能被共享     sem_t  msd_sem;                    //信号量     mmudsc_t msd_mmu;                  //MMU相关的信息     virmemadrs_t msd_virmemadrs;       //虚拟地址空间     adr_t msd_stext;                   //应用的指令区的开始、结束地址     adr_t msd_etext;     adr_t msd_sdata;                   //应用的数据区的开始、结束地址     adr_t msd_edata;     adr_t msd_sbss;                     //栈区的开始、结束地址     adr_t msd_ebss;     adr_t msd_sbrk;                    //应用的堆区的开始、结束地址     adr_t msd_ebrk; }mmadrsdsc_t;     

       typedef struct KVMEMCBOX  {     list_h_t kmb_list;        //链表     spinlock_t kmb_lock;      //保护自身的自旋锁     refcount_t kmb_cont;      //共享的计数器     u64_t kmb_flgs;           //状态和标志     u64_t kmb_stus;     u64_t kmb_type;           //类型     uint_t kmb_msanr;         //多少个msadsc_t     list_h_t kmb_msalist;     //挂载msadsc_t结构的链表     kvmemcboxmgr_t* kmb_mgr;  //指向上层结构     void* kmb_filenode;       //指向文件节点描述符     void* kmb_pager;          //指向分页器 暂时不使用     void* kmb_ext;            //自身扩展数据指针 }kvmemcbox_t;     

       typedef struct KVMEMCBOXMGR  {     list_h_t kbm_list;        //链表     spinlock_t kbm_lock;      //保护自身的自旋锁     u64_t kbm_flgs;           //标志与状态     u64_t kbm_stus;      uint_t kbm_kmbnr;         //kvmemcbox_t结构个数     list_h_t kbm_kmbhead;     //挂载kvmemcbox_t结构的链表     uint_t kbm_cachenr;       //缓存空闲kvmemcbox_t结构的个数     uint_t kbm_cachemax;      //最大缓存个数，超过了就要释放     uint_t kbm_cachemin;      //最小缓存个数     list_h_t kbm_cachehead;   //缓存kvmemcbox_t结构的链表     void* kbm_ext;            //扩展数据指针 }kvmemcboxmgr_t;     

       //检查kmvarsdsc_t结构 kmvarsdsc_t *vma_find_kmvarsdsc_is_ok(virmemadrs_t *vmalocked, kmvarsdsc_t *curr, adr_t start, size_t vassize) {     kmvarsdsc_t *nextkmvd = NULL;     adr_t newend = start + (adr_t)vassize;     //如果curr不是最后一个先检查当前kmvarsdsc_t结构     if (list_is_last(&curr->kva_list, &vmalocked->vs_list) == FALSE)     {//就获取curr的下一个kmvarsdsc_t结构         nextkmvd = list_next_entry(curr, kmvarsdsc_t, kva_list);         //由系统动态决定分配虚拟空间的开始地址         if (NULL == start)         {//如果curr的结束地址加上分配的大小小于等于下一个kmvarsdsc_t结构的开始地址就返回curr             if ((curr->kva_end + (adr_t)vassize) <= nextkmvd->kva_start)             {                 return curr;             }         }         else         {//否则比较应用指定分配的开始、结束地址是不是在curr和下一个kmvarsdsc_t结构之间             if ((curr->kva_end <= start) && (newend <= nextkmvd->kva_start))             {                 return curr;             }         }     }     else     {//否则curr为最后一个kmvarsdsc_t结构         if (NULL == start)         {//curr的结束地址加上分配空间的大小是不是小于整个虚拟地址空间             if ((curr->kva_end + (adr_t)vassize) < vmalocked->vs_isalcend)             {                 return curr;             }         }         else         {//否则比较应用指定分配的开始、结束地址是不是在curr的结束地址和整个虚拟地址空间的结束地址之间             if ((curr->kva_end <= start) && (newend < vmalocked->vs_isalcend))             {                 return curr;             }         }     }     return NULL; } //查找kmvarsdsc_t结构 kmvarsdsc_t *vma_find_kmvarsdsc(virmemadrs_t *vmalocked, adr_t start, size_t vassize) {     kmvarsdsc_t *kmvdcurrent = NULL, *curr = vmalocked->vs_currkmvdsc;     adr_t newend = start + vassize;     list_h_t *listpos = NULL;     //分配的虚拟空间大小小于4KB不行     if (0x1000 > vassize)     {         return NULL;     }     //将要分配虚拟地址空间的结束地址大于整个虚拟地址空间 不行     if (newend > vmalocked->vs_isalcend)     {         return NULL;     } ​     if (NULL != curr)     {//先检查当前kmvarsdsc_t结构行不行         kmvdcurrent = vma_find_kmvarsdsc_is_ok(vmalocked, curr, start, vassize);         if (NULL != kmvdcurrent)         {             return kmvdcurrent;         }     }     //遍历virmemadrs_t中的所有的kmvarsdsc_t结构     list_for_each(listpos, &vmalocked->vs_list)     {         curr = list_entry(listpos, kmvarsdsc_t, kva_list);         //检查每个kmvarsdsc_t结构         kmvdcurrent = vma_find_kmvarsdsc_is_ok(vmalocked, curr, start, vassize);         if (NULL != kmvdcurrent)         {//如果符合要求就返回             return kmvdcurrent;         }     }     return NULL; }     

       sint_t vma_map_fairvadrs_core(mmadrsdsc_t *mm, adr_t vadrs) {     sint_t rets = FALSE;     adr_t phyadrs = NULL;     virmemadrs_t *vma = &mm->msd_virmemadrs;     kmvarsdsc_t *kmvd = NULL;     kvmemcbox_t *kmbox = NULL;     knl_spinlock(&vma->vs_lock);     //查找对应的kmvarsdsc_t结构     kmvd = vma_map_find_kmvarsdsc(vma, vadrs);     if (NULL == kmvd)     {         rets = -EFAULT;         goto out;     }     //返回kmvarsdsc_t结构下对应kvmemcbox_t结构     kmbox = vma_map_retn_kvmemcbox(kmvd);     if (NULL == kmbox)     {         rets = -ENOMEM;         goto out;     }     //分配物理内存页面并建立MMU页表     phyadrs = vma_map_phyadrs(mm, kmvd, vadrs, (0 | PML4E_US | PML4E_RW | PML4E_P));     if (NULL == phyadrs)     {         rets = -ENOMEM;         goto out;     }     rets = EOK; out:     knl_spinunlock(&vma->vs_lock);     return rets; }