los_vm_map.c 文件参考

虚拟内存管理 http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/kernel-small-basic-memory-virtual.html 更多...

浏览源代码.

函数
	LOS_DL_LIST_HEAD (g_vmSpaceList)
	初始化全局虚拟空间节点,所有虚拟空间都挂到此节点上. 更多...
LosVmSpace *	LOS_CurrSpaceGet (VOID)
	获取当前进程空间结构体指针 更多...
LosVmSpace *	LOS_SpaceGet (VADDR_T vaddr)
	获取虚拟地址对应的进程空间结构体指针 更多...
LosVmSpace *	LOS_GetKVmSpace (VOID)
	内核空间只有g_kVmSpace一个，所有的内核进程都共用一个内核空间 更多...
LOS_DL_LIST *	LOS_GetVmSpaceList (VOID)
	获取进程空间链表指针 g_vmSpaceList中挂的是进程空间 g_kVmSpace, g_vMallocSpace,所有用户进程的空间(独有一个进程空间) 更多...
LosVmSpace *	LOS_GetVmallocSpace (VOID)
	获取内核堆空间的全局变量 更多...
ULONG_T	OsRegionRbFreeFn (LosRbNode *pstNode)
	释放挂在红黑树上节点,等于释放了线性区 更多...
VOID *	OsRegionRbGetKeyFn (LosRbNode *pstNode)
	通过红黑树节点找到对应的线性区 更多...
ULONG_T	OsRegionRbCmpKeyFn (const VOID *pNodeKeyA, const VOID *pNodeKeyB)
	比较两个红黑树节点 更多...
STATIC BOOL	OsVmSpaceInitCommon (LosVmSpace *vmSpace, VADDR_T *virtTtb)
	OsVmSpaceInitCommon 初始化进程虚拟空间，必须提供L1表的虚拟内存地址 更多...
VOID	OsVmMapInit (VOID)
	@note_thinking 这个函数名称和内容不太搭 更多...
BOOL	OsKernVmSpaceInit (LosVmSpace *vmSpace, VADDR_T *virtTtb)
	初始化内核虚拟空间 更多...
BOOL	OsVMallocSpaceInit (LosVmSpace *vmSpace, VADDR_T *virtTtb)
	初始化内核堆空间 更多...
VOID	OsKSpaceInit (VOID)
	内核虚拟空间初始化 更多...
BOOL	OsUserVmSpaceInit (LosVmSpace *vmSpace, VADDR_T *virtTtb)
	OsUserVmSpaceInit 用户空间的TTB表是动态申请得来,每个进程有属于自己的L1,L2表 初始化用户进程虚拟空间,主要划分数据区,堆区,映射区和创建mmu 更多...
LosVmSpace *	OsCreateUserVmSpace (VOID)
	创建用户进程空间 更多...
STATIC BOOL	OsVmSpaceParamCheck (LosVmSpace *vmSpace)
STATUS_T	LOS_VmSpaceClone (LosVmSpace *oldVmSpace, LosVmSpace *newVmSpace)
LosVmMapRegion *	OsFindRegion (LosRbTree *regionRbTree, VADDR_T vaddr, size_t len)
	通过虚拟(线性)地址查找所属线性区,红黑树 更多...
LosVmMapRegion *	LOS_RegionFind (LosVmSpace *vmSpace, VADDR_T addr)
	查找线性区 根据起始地址在进程空间内查找是否存在 更多...
LosVmMapRegion *	LOS_RegionRangeFind (LosVmSpace *vmSpace, VADDR_T addr, size_t len)
	查找线性区 根据地址区间在进程空间内查找是否存在 更多...
VADDR_T	OsAllocRange (LosVmSpace *vmSpace, size_t len)
	分配指定长度的线性区 更多...
VADDR_T	OsAllocSpecificRange (LosVmSpace *vmSpace, VADDR_T vaddr, size_t len, UINT32 regionFlags)
	分配指定开始地址和长度的线性区 更多...
BOOL	LOS_IsRegionFileValid (LosVmMapRegion *region)
	映射类型为文件的线性区是否有效 更多...
BOOL	OsInsertRegion (LosRbTree *regionRbTree, LosVmMapRegion *region)
	向红黑树中插入线性区 更多...
LosVmMapRegion *	OsCreateRegion (VADDR_T vaddr, size_t len, UINT32 regionFlags, unsigned long offset)
	创建一个线性区 更多...
PADDR_T	LOS_PaddrQuery (VOID *vaddr)
	通过虚拟地址查询映射的物理地址 更多...
LosVmMapRegion *	LOS_RegionAlloc (LosVmSpace *vmSpace, VADDR_T vaddr, size_t len, UINT32 regionFlags, VM_OFFSET_T pgoff)
STATIC VOID	OsAnonPagesRemove (LosArchMmu *archMmu, VADDR_T vaddr, UINT32 count)
STATIC VOID	OsDevPagesRemove (LosArchMmu *archMmu, VADDR_T vaddr, UINT32 count)
STATIC VOID	OsFilePagesRemove (LosVmSpace *space, LosVmMapRegion *region)
STATUS_T	LOS_RegionFree (LosVmSpace *space, LosVmMapRegion *region)
	释放进程空间指定线性区 更多...

变量
LosMux	g_vmSpaceListMux
	用于锁g_vmSpaceList的互斥量 更多...
LosVmSpace	g_kVmSpace
	内核非分配空间,用于内核运行栈,代码区,数据区 更多...
LosVmSpace	g_vMallocSpace
	内核分配空间,用于内核分配内存 更多...

详细描述

虚拟内存管理 http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/kernel-small-basic-memory-virtual.html

基本概念
    虚拟内存管理是计算机系统管理内存的一种技术。每个进程都有连续的虚拟地址空间，虚拟地址空间的大小由CPU的位数决定，
    32位的硬件平台可以提供的最大的寻址空间为0-4GiB。整个4GiB空间分成两部分，LiteOS-A内核占据3GiB的高地址空间，
    1GiB的低地址空间留给进程使用。各个进程空间的虚拟地址空间是独立的，代码、数据互不影响。
   
    系统将虚拟内存分割为称为虚拟页的内存块，大小一般为4KiB或64KiB，LiteOS-A内核默认的页的大小是4KiB，
    根据需要可以对MMU（Memory Management Units）进行配置。虚拟内存管理操作的最小单位就是一个页，
    LiteOS-A内核中一个虚拟地址区间region包含地址连续的多个虚拟页，也可只有一个页。同样，物理内存也会按照页大小进行分割，
    分割后的每个内存块称为页帧。虚拟地址空间划分：内核态占高地址3GiB(0x40000000 ~ 0xFFFFFFFF)，
    用户态占低地址1GiB(0x01000000 ~ 0x3F000000)，具体见下表，详细可以查看或配置los_vm_zone.h。
    
内核态地址规划：
   Zone名称       描述                                                      属性
   ----------------------------------------------------------------------------
   DMA zone     供IO设备的DMA使用。                                            Uncache
   
   Normal zone  加载内核代码段、数据段、堆和栈的地址区间。                                   Cache
   
   high mem zone可以分配连续的虚拟内存，但其所映射的物理内存不一定连续。Cache

用户态地址规划：
  Zone名称        描述                                                      属性
  ----------------------------------------------------------------------------
  代码段           用户态代码段地址区间。                                             Cache
  堆             用户态堆地址区间。                                               Cache
  栈             用户态栈地址区间。                                               Cache
  共享库           用于加载用户态共享库的地址区间，包括mmap所映射的区间。                           Cache

运行机制
   虚拟内存管理中，虚拟地址空间是连续的，但是其映射的物理内存并不一定是连续的，如下图所示。
   可执行程序加载运行，CPU访问虚拟地址空间的代码或数据时存在两种情况：
   
   1. CPU访问的虚拟地址所在的页，如V0，已经与具体的物理页P0做映射，CPU通过找到进程对应的页表条目（详见虚实映射），
   根据页表条目中的物理地址信息访问物理内存中的内容并返回。
   2. CPU访问的虚拟地址所在的页，如V2，没有与具体的物理页做映射，系统会触发缺页异常，系统申请一个物理页，
   并把相应的信息拷贝到物理页中，并且把物理页的起始地址更新到页表条目中。此时CPU重新执行访问虚拟内存的指令
   便能够访问到具体的代码或数据。

版本

作者

weharmonyos.com | 鸿蒙研究站 | 每天死磕一点点

日期

2021-11-25

在文件 los_vm_map.c 中定义.

函数说明

LOS_CurrSpaceGet()

LosVmSpace * LOS_CurrSpaceGet

(

VOID

)

获取当前进程空间结构体指针

在文件 los_vm_map.c 第 112 行定义.

{
    return OsCurrProcessGet()->vmSpace;
}

函数调用图:

这是这个函数的调用关系图:

LOS_DL_LIST_HEAD()

LOS_DL_LIST_HEAD

(

g_vmSpaceList

)

初始化全局虚拟空间节点,所有虚拟空间都挂到此节点上.

这是这个函数的调用关系图:

LOS_GetKVmSpace()

LosVmSpace * LOS_GetKVmSpace

(

VOID

)

内核空间只有g_kVmSpace一个，所有的内核进程都共用一个内核空间

在文件 los_vm_map.c 第 130 行定义.

{
    return &g_kVmSpace;
}

这是这个函数的调用关系图:

LOS_GetVmallocSpace()

LosVmSpace * LOS_GetVmallocSpace

(

VOID

)

获取内核堆空间的全局变量

在文件 los_vm_map.c 第 140 行定义.

{
    return &g_vMallocSpace;
}

这是这个函数的调用关系图:

LOS_GetVmSpaceList()

LOS_DL_LIST * LOS_GetVmSpaceList

(

VOID

)

获取进程空间链表指针 g_vmSpaceList中挂的是进程空间 g_kVmSpace, g_vMallocSpace,所有用户进程的空间(独有一个进程空间)

在文件 los_vm_map.c 第 135 行定义.

{
    return &g_vmSpaceList;
}

这是这个函数的调用关系图:

LOS_IsRegionFileValid()

BOOL LOS_IsRegionFileValid

(

LosVmMapRegion *

region

)

映射类型为文件的线性区是否有效

在文件 los_vm_map.c 第 512 行定义.

{
    if ((region != NULL) && (LOS_IsRegionTypeFile(region)) &&
        (region->unTypeData.rf.vnode != NULL)) {
        return TRUE;
    }
    return FALSE;
}

函数调用图:

这是这个函数的调用关系图:

LOS_PaddrQuery()

PADDR_T LOS_PaddrQuery

(

VOID *

vaddr

)

通过虚拟地址查询映射的物理地址

在文件 los_vm_map.c 第 550 行定义.

{
    PADDR_T paddr = 0;
    STATUS_T status;
    LosVmSpace *space = NULL;
    LosArchMmu *archMmu = NULL;
    //先取出对应空间的mmu
    if (LOS_IsKernelAddress((VADDR_T)(UINTPTR)vaddr)) {//是否内核空间地址
        archMmu = &g_kVmSpace.archMmu;
    } else if (LOS_IsUserAddress((VADDR_T)(UINTPTR)vaddr)) {//是否为用户空间地址
        space = OsCurrProcessGet()->vmSpace;
        archMmu = &space->archMmu;
    } else if (LOS_IsVmallocAddress((VADDR_T)(UINTPTR)vaddr)) {//是否为分配空间地址,堆区地址
        archMmu = &g_vMallocSpace.archMmu;
    } else {
        VM_ERR("vaddr is beyond range");
        return 0;
    }
 
    status = LOS_ArchMmuQuery(archMmu, (VADDR_T)(UINTPTR)vaddr, &paddr, 0);//查询物理地址
    if (status == LOS_OK) {
        return paddr;
    } else {
        return 0;
    }
}

函数调用图:

这是这个函数的调用关系图:

LOS_RegionAlloc()

LosVmMapRegion * LOS_RegionAlloc	(	LosVmSpace *	vmSpace,
		VADDR_T	vaddr,
		size_t	len,
		UINT32	regionFlags,
		VM_OFFSET_T	pgoff
	)

这里不是真的分配物理内存，而是逻辑上画一个连续的区域，标记这个区域可以拿用，表示内存已经归你了。 但真正的物理内存的占用会延迟到使用的时候才由缺页中断调入内存

If addr is NULL, then the kernel chooses the address at which to create the mapping; this is the most portable method of creating a new mapping. If addr is not NULL, then the kernel takes it as where to place the mapping;

在文件 los_vm_map.c 第 581 行定义.

{
    VADDR_T rstVaddr;
    LosVmMapRegion *newRegion = NULL;
    BOOL isInsertSucceed = FALSE;
    /**
     * If addr is NULL, then the kernel chooses the address at which to create the mapping;
     * this is the most portable method of creating a new mapping.  If addr is not NULL,
     * then the kernel takes it as where to place the mapping;
     */
    (VOID)LOS_MuxAcquire(&vmSpace->regionMux);//获得互斥锁
    if (vaddr == 0) {//如果地址是0，根据线性区管理的实际情况,自动创建虚拟地址，    这是创建新映射的最便捷的方法。
        rstVaddr = OsAllocRange(vmSpace, len);
    } else {
        /* if it is already mmapped here, we unmmap it | 如果已经被映射了, 则解除映射关系*/
        rstVaddr = OsAllocSpecificRange(vmSpace, vaddr, len, regionFlags);//创建包含指定虚拟地址的线性区,       rstVaddr !=        vaddr || rstVaddr == vaddr
        if (rstVaddr == 0) {
            VM_ERR("alloc specific range va: %#x, len: %#x failed", vaddr, len);
            goto OUT;
        }
    }
    if (rstVaddr == 0) {//没有可供映射的虚拟地址
        goto OUT;
    }
 
    newRegion = OsCreateRegion(rstVaddr, len, regionFlags, pgoff);//创建一个线性区,指定线性区的开始地址rstVaddr ...
    if (newRegion == NULL) {
        goto OUT;
    }
    newRegion->space = vmSpace;
    isInsertSucceed = OsInsertRegion(&vmSpace->regionRbTree, newRegion);//插入红黑树和双循环链表中管理
    if (isInsertSucceed == FALSE) {//插入失败
        (VOID)LOS_MemFree(m_aucSysMem0, newRegion);//从内存池中释放
        newRegion = NULL;
    }
 
OUT:
    (VOID)LOS_MuxRelease(&vmSpace->regionMux);//释放互斥锁
    return newRegion;
}

函数调用图:

这是这个函数的调用关系图:

LOS_RegionFind()

LosVmMapRegion * LOS_RegionFind	(	LosVmSpace *	vmSpace,
		VADDR_T	addr
	)

查找线性区 根据起始地址在进程空间内查找是否存在

在文件 los_vm_map.c 第 414 行定义.

{
    LosVmMapRegion *region = NULL;
 
    (VOID)LOS_MuxAcquire(&vmSpace->regionMux);//因进程空间是隔离的,所以此处只会涉及到任务(线程)之间的竞争,故使用互斥锁,而自旋锁则用于CPU核间的竞争
    region = OsFindRegion(&vmSpace->regionRbTree, addr, 1);
    (VOID)LOS_MuxRelease(&vmSpace->regionMux);
 
    return region;
}

函数调用图:

这是这个函数的调用关系图:

LOS_RegionFree()

STATUS_T LOS_RegionFree	(	LosVmSpace *	space,
		LosVmMapRegion *	region
	)

释放进程空间指定线性区

复制线性区

劈开线性区

对线性区进行调整

删除线性区

根据指定参数范围[addr,addr+len] 释放用户空间中堆区所占用的物理内存

线性区是否支持扩展

解除一定范围的虚拟地址的映射关系

释放所有线性区

释放虚拟空间

释放虚拟空间,注意内核空间不能被释放掉,永驻内存

虚拟地址和size是否在空间

在进程空间中预留一块内存空间

实现从虚拟地址到物理地址的映射,将指定长度的物理地址区间与虚拟地址区间做映射，需提前申请物理地址区间

对外接口|释放内核堆空间内存

内核空间内存分配,申请小于16KiB的内存则通过堆内存池获取，否则申请多个连续物理页

申请具有对齐属性的内存，申请规则：申请小于16KiB的内存则通过堆内存池获取，否则申请多个连续物理页

重新分配内核内存空间

在文件 los_vm_map.c 第 694 行定义.

这是这个函数的调用关系图:

LOS_RegionRangeFind()

LosVmMapRegion * LOS_RegionRangeFind	(	LosVmSpace *	vmSpace,
		VADDR_T	addr,
		size_t	len
	)

查找线性区 根据地址区间在进程空间内查找是否存在

在文件 los_vm_map.c 第 425 行定义.

{
    LosVmMapRegion *region = NULL;
 
    (VOID)LOS_MuxAcquire(&vmSpace->regionMux);
    region = OsFindRegion(&vmSpace->regionRbTree, addr, len);
    (VOID)LOS_MuxRelease(&vmSpace->regionMux);
 
    return region;
}

函数调用图:

这是这个函数的调用关系图:

LOS_SpaceGet()

LosVmSpace * LOS_SpaceGet

(

VADDR_T

vaddr

)

获取虚拟地址对应的进程空间结构体指针

在文件 los_vm_map.c 第 117 行定义.

{
    if (LOS_IsKernelAddress(vaddr)) {   //是否为内核空间
        return LOS_GetKVmSpace();       //获取内核空间
    } else if (LOS_IsUserAddress(vaddr)) {//是否为用户空间
        return LOS_CurrSpaceGet();
    } else if (LOS_IsVmallocAddress(vaddr)) {//是否为内核分配空间
        return LOS_GetVmallocSpace();//获取内核分配空间
    } else {
        return NULL;
    }
}

函数调用图:

这是这个函数的调用关系图:

LOS_VmSpaceClone()

STATUS_T LOS_VmSpaceClone	(	LosVmSpace *	oldVmSpace,
		LosVmSpace *	newVmSpace
	)

在文件 los_vm_map.c 第 318 行定义.

{
    LosVmMapRegion *oldRegion = NULL;
    LosVmMapRegion *newRegion = NULL;
    LosRbNode *pstRbNode = NULL;
    LosRbNode *pstRbNodeNext = NULL;
    STATUS_T ret = LOS_OK;
    UINT32 numPages;
    PADDR_T paddr;
    VADDR_T vaddr;
    UINT32 intSave;
    LosVmPage *page = NULL;
    UINT32 flags;
    UINT32 i;
 
    if ((OsVmSpaceParamCheck(oldVmSpace) == FALSE) || (OsVmSpaceParamCheck(newVmSpace) == FALSE)) {
        return LOS_ERRNO_VM_INVALID_ARGS;
    }
 
    if ((OsIsVmRegionEmpty(oldVmSpace) == TRUE) || (oldVmSpace == &g_kVmSpace)) {//不允许clone内核空间,内核空间是独一无二的.
        return LOS_ERRNO_VM_INVALID_ARGS;
    }
    //空间克隆的主体实现是:线性区重新一个个分配物理内存,重新映射.
    /* search the region list */
    newVmSpace->mapBase = oldVmSpace->mapBase; //复制映射区基址
    newVmSpace->heapBase = oldVmSpace->heapBase; //复制堆区基址
    newVmSpace->heapNow = oldVmSpace->heapNow;  //复制堆区当前使用到哪了
    (VOID)LOS_MuxAcquire(&oldVmSpace->regionMux);
    RB_SCAN_SAFE(&oldVmSpace->regionRbTree, pstRbNode, pstRbNodeNext)//红黑树循环开始
        oldRegion = (LosVmMapRegion *)pstRbNode;
        newRegion = OsVmRegionDup(newVmSpace, oldRegion, oldRegion->range.base, oldRegion->range.size);//复制线性区
        if (newRegion == NULL) {
            VM_ERR("dup new region failed");
            ret = LOS_ERRNO_VM_NO_MEMORY;
            break;
        }
 
#ifdef LOSCFG_KERNEL_SHM
        if (oldRegion->regionFlags & VM_MAP_REGION_FLAG_SHM) {//如果老线性区是共享内存
            OsShmFork(newVmSpace, oldRegion, newRegion);//fork共享线性区,如此新虚拟空间也能用那个线性区
            continue;//不往下走了,因为共享内存不需要重新映射,下面无非就是需要MMU映射虚拟地址<-->物理地址
        }
#endif
 
        if (oldRegion == oldVmSpace->heap) {//如果这个线性区是堆区
            newVmSpace->heap = newRegion;//那么新的线性区也是新虚拟空间的堆区
        }
 
        numPages = newRegion->range.size >> PAGE_SHIFT;//计算线性区页数
        for (i = 0; i < numPages; i++) {//一页一页进行重新映射
            vaddr = newRegion->range.base + (i << PAGE_SHIFT);
            if (LOS_ArchMmuQuery(&oldVmSpace->archMmu, vaddr, &paddr, &flags) != LOS_OK) {//先查物理地址
                continue;
            }
 
            page = LOS_VmPageGet(paddr);//通过物理页获取物理内存的页框
            if (page != NULL) {
                LOS_AtomicInc(&page->refCounts);//refCounts 自增
            }
            if (flags & VM_MAP_REGION_FLAG_PERM_WRITE) {//可写入区标签
                LOS_ArchMmuUnmap(&oldVmSpace->archMmu, vaddr, 1);//先删除老空间映射
                LOS_ArchMmuMap(&oldVmSpace->archMmu, vaddr, paddr, 1, flags & ~VM_MAP_REGION_FLAG_PERM_WRITE);//老空间重新映射
            }
            LOS_ArchMmuMap(&newVmSpace->archMmu, vaddr, paddr, 1, flags & ~VM_MAP_REGION_FLAG_PERM_WRITE);//映射新空间
 
#ifdef LOSCFG_FS_VFS //文件系统开关
            if (LOS_IsRegionFileValid(oldRegion)) {//是都是一个文件映射线性区
                LosFilePage *fpage = NULL;
                LOS_SpinLockSave(&oldRegion->unTypeData.rf.vnode->mapping.list_lock, &intSave);
                fpage = OsFindGetEntry(&oldRegion->unTypeData.rf.vnode->mapping, newRegion->pgOff + i);
                if ((fpage != NULL) && (fpage->vmPage == page)) { /* cow page no need map */
                    OsAddMapInfo(fpage, &newVmSpace->archMmu, vaddr);//添加文件页映射,记录页面被进程映射过
                }
                LOS_SpinUnlockRestore(&oldRegion->unTypeData.rf.vnode->mapping.list_lock, intSave);
            }
#endif
        }
    RB_SCAN_SAFE_END(&oldVmSpace->regionRbTree, pstRbNode, pstRbNodeNext)//红黑树循环结束
    (VOID)LOS_MuxRelease(&oldVmSpace->regionMux);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsAllocRange()

VADDR_T OsAllocRange	(	LosVmSpace *	vmSpace,
		size_t	len
	)

分配指定长度的线性区

在文件 los_vm_map.c 第 436 行定义.

{
    LosVmMapRegion *curRegion = NULL;
    LosRbNode *pstRbNode = NULL;
    LosRbNode *pstRbNodeTmp = NULL;
    LosRbTree *regionRbTree = &vmSpace->regionRbTree;
    VADDR_T curEnd = vmSpace->mapBase;//获取映射区基地址
    VADDR_T nextStart;
 
    curRegion = LOS_RegionFind(vmSpace, vmSpace->mapBase);
    if (curRegion != NULL) {
        pstRbNode = &curRegion->rbNode;
        curEnd = curRegion->range.base + curRegion->range.size;
        RB_MID_SCAN(regionRbTree, pstRbNode)
            curRegion = (LosVmMapRegion *)pstRbNode;
            nextStart = curRegion->range.base;
            if (nextStart < curEnd) {
                continue;
            }
            if ((nextStart - curEnd) >= len) {
                return curEnd;
            } else {
                curEnd = curRegion->range.base + curRegion->range.size;
            }
        RB_MID_SCAN_END(regionRbTree, pstRbNode)
    } else {//红黑树扫描排序，从小到大
        /* rbtree scan is sorted, from small to big */
        RB_SCAN_SAFE(regionRbTree, pstRbNode, pstRbNodeTmp)
            curRegion = (LosVmMapRegion *)pstRbNode;
            nextStart = curRegion->range.base;
            if (nextStart < curEnd) {
                continue;
            }
            if ((nextStart - curEnd) >= len) {
                return curEnd;
            } else {
                curEnd = curRegion->range.base + curRegion->range.size;
            }
        RB_SCAN_SAFE_END(regionRbTree, pstRbNode, pstRbNodeTmp)
    }
 
    nextStart = vmSpace->mapBase + vmSpace->mapSize;
    if ((nextStart >= curEnd) && ((nextStart - curEnd) >= len)) {
        return curEnd;
    }
 
    return 0;
}

函数调用图:

这是这个函数的调用关系图:

OsAllocSpecificRange()

VADDR_T OsAllocSpecificRange	(	LosVmSpace *	vmSpace,
		VADDR_T	vaddr,
		size_t	len,
		UINT32	regionFlags
	)

分配指定开始地址和长度的线性区

在文件 los_vm_map.c 第 485 行定义.

{
    STATUS_T status;
 
    if (LOS_IsRangeInSpace(vmSpace, vaddr, len) == FALSE) {//虚拟地址是否在进程空间范围内
        return 0;
    }
 
    if ((LOS_RegionFind(vmSpace, vaddr) != NULL) ||
        (LOS_RegionFind(vmSpace, vaddr + len - 1) != NULL) ||
        (LOS_RegionRangeFind(vmSpace, vaddr, len - 1) != NULL)) {//没找到的情况
        if ((regionFlags & VM_MAP_REGION_FLAG_FIXED_NOREPLACE) != 0) {
            return 0;
        } else if ((regionFlags & VM_MAP_REGION_FLAG_FIXED) != 0) {//线性区未填满,则解除这部分空间的映射
            status = LOS_UnMMap(vaddr, len);//解除映射
            if (status != LOS_OK) {
                VM_ERR("unmap specific range va: %#x, len: %#x failed, status: %d", vaddr, len, status);
                return 0;
            }
        } else {
            return OsAllocRange(vmSpace, len);//默认分配一个
        }
    }
 
    return vaddr;
}

函数调用图:

这是这个函数的调用关系图:

OsAnonPagesRemove()

STATIC VOID OsAnonPagesRemove	(	LosArchMmu *	archMmu,
		VADDR_T	vaddr,
		UINT32	count
	)

删除匿名页,匿名页就是内存映射页 1.解除映射关系 2.释放物理内存

在文件 los_vm_map.c 第 625 行定义.

{
    status_t status;
    paddr_t paddr;
    LosVmPage *page = NULL;
 
    if ((archMmu == NULL) || (vaddr == 0) || (count == 0)) {
        VM_ERR("OsAnonPagesRemove invalid args, archMmu %p, vaddr %p, count %d", archMmu, vaddr, count);
        return;
    }
 
    while (count > 0) {//一页页操作
        count--;
        status = LOS_ArchMmuQuery(archMmu, vaddr, &paddr, NULL);//通过虚拟地址拿到物理地址
        if (status != LOS_OK) {//失败，拿下一页的物理地址
            vaddr += PAGE_SIZE;
            continue;
        }
 
        LOS_ArchMmuUnmap(archMmu, vaddr, 1);//解除一页的映射
 
        page = LOS_VmPageGet(paddr);//通过物理地址获取所在物理页框的起始地址
        if (page != NULL) {//获取成功
            if (!OsIsPageShared(page)) {//不是共享页，共享页会有专门的共享标签，共享本质是有无多个进程对该页的引用
                LOS_PhysPageFree(page);//释放物理页框
            }
        }
        vaddr += PAGE_SIZE;
    }
}

函数调用图:

这是这个函数的调用关系图:

OsCreateRegion()

LosVmMapRegion * OsCreateRegion	(	VADDR_T	vaddr,
		size_t	len,
		UINT32	regionFlags,
		unsigned long	offset
	)

创建一个线性区

在文件 los_vm_map.c 第 531 行定义.

{
    LosVmMapRegion *region = LOS_MemAlloc(m_aucSysMem0, sizeof(LosVmMapRegion));//只是分配一个线性区结构体
    if (region == NULL) {
        VM_ERR("memory allocate for LosVmMapRegion failed");
        return region;
    }
    //创建线性区的本质就是在画饼，见如下操作:
    (void)memset_s(region, sizeof(LosVmMapRegion), 0, sizeof(LosVmMapRegion));
    region->range.base = vaddr; //虚拟地址作为线性区的基地址
    region->range.size = len;   //线性区大小，这是线性区构思最巧妙的地方，只要不过分，蓝图随便画。
    region->pgOff = offset;     //页标
    region->regionFlags = regionFlags;//标识,可读/可写/可执行
    region->regionType = VM_MAP_REGION_TYPE_NONE;//未映射
    region->forkFlags = 0;      //
    region->shmid = -1;         //默认线性区为不共享,无共享资源ID
    return region;
}

函数调用图:

这是这个函数的调用关系图:

OsCreateUserVmSpace()

LosVmSpace * OsCreateUserVmSpace

(

VOID

)

创建用户进程空间

在文件 los_vm_map.c 第 281 行定义.

{
    BOOL retVal = FALSE;
 
    LosVmSpace *space = LOS_MemAlloc(m_aucSysMem0, sizeof(LosVmSpace));//在内核空间申请用户进程空间
    if (space == NULL) {
        return NULL;
    }
    //此处为何直接申请物理页帧存放用户进程的页表,大概是因为所有页表都被存放在内核空间(g_kVmSpace)而非内核分配空间(g_vMallocSpace)
    VADDR_T *ttb = LOS_PhysPagesAllocContiguous(1);//分配一个物理页用于存放虚实映射关系表, 即:L1表
    if (ttb == NULL) {//若连页表都没有,剩下的也别玩了.
        (VOID)LOS_MemFree(m_aucSysMem0, space);
        return NULL;
    }
    
    (VOID)memset_s(ttb, PAGE_SIZE, 0, PAGE_SIZE);//4K空间置0
    retVal = OsUserVmSpaceInit(space, ttb);//初始化用户空间,mmu
    LosVmPage *vmPage = OsVmVaddrToPage(ttb);//找到所在物理页框
    if ((retVal == FALSE) || (vmPage == NULL)) {
        (VOID)LOS_MemFree(m_aucSysMem0, space);
        LOS_PhysPagesFreeContiguous(ttb, 1);
        return NULL;
    }
    LOS_ListAdd(&space->archMmu.ptList, &(vmPage->node));//页表链表,先挂上L1,后续还会挂上 N个L2表
 
    return space;
}

函数调用图:

这是这个函数的调用关系图:

OsDevPagesRemove()

STATIC VOID OsDevPagesRemove	(	LosArchMmu *	archMmu,
		VADDR_T	vaddr,
		UINT32	count
	)

在文件 los_vm_map.c 第 656 行定义.

{
    status_t status;
 
    if ((archMmu == NULL) || (vaddr == 0) || (count == 0)) {
        VM_ERR("OsDevPagesRemove invalid args, archMmu %p, vaddr %p, count %d", archMmu, vaddr, count);
        return;
    }
 
    status = LOS_ArchMmuQuery(archMmu, vaddr, NULL, NULL);
    if (status != LOS_OK) {
        return;
    }
 
    /* in order to unmap section */
    LOS_ArchMmuUnmap(archMmu, vaddr, count);
}

函数调用图:

这是这个函数的调用关系图:

OsFilePagesRemove()

STATIC VOID OsFilePagesRemove	(	LosVmSpace *	space,
		LosVmMapRegion *	region
	)

在文件 los_vm_map.c 第 675 行定义.

{
    VM_OFFSET_T offset;
    size_t size;
 
    if ((space == NULL) || (region == NULL) || (region->unTypeData.rf.vmFOps == NULL)) {
        return;
    }
 
    offset = region->pgOff;
    size = region->range.size;
    while (size >= PAGE_SIZE) {
        region->unTypeData.rf.vmFOps->remove(region, &space->archMmu, offset);
        offset++;
        size -= PAGE_SIZE;
    }
}

这是这个函数的调用关系图:

OsFindRegion()

LosVmMapRegion * OsFindRegion	(	LosRbTree *	regionRbTree,
		VADDR_T	vaddr,
		size_t	len
	)

通过虚拟(线性)地址查找所属线性区,红黑树

在文件 los_vm_map.c 第 400 行定义.

{
    LosVmMapRegion *regionRst = NULL;
    LosRbNode *pstRbNode = NULL;
    LosVmMapRange rangeKey;
    rangeKey.base = vaddr;
    rangeKey.size = len;
 
    if (LOS_RbGetNode(regionRbTree, (VOID *)&rangeKey, &pstRbNode)) {
        regionRst = (LosVmMapRegion *)LOS_DL_LIST_ENTRY(pstRbNode, LosVmMapRegion, rbNode);
    }
    return regionRst;
}

函数调用图:

这是这个函数的调用关系图:

OsInsertRegion()

BOOL OsInsertRegion	(	LosRbTree *	regionRbTree,
		LosVmMapRegion *	region
	)

向红黑树中插入线性区

在文件 los_vm_map.c 第 521 行定义.

{
    if (LOS_RbAddNode(regionRbTree, (LosRbNode *)region) == FALSE) {
        VM_ERR("insert region failed, base: %#x, size: %#x", region->range.base, region->range.size);
        OsDumpAspace(region->space);
        return FALSE;
    }
    return TRUE;
}

函数调用图:

这是这个函数的调用关系图:

OsKernVmSpaceInit()

BOOL OsKernVmSpaceInit	(	LosVmSpace *	vmSpace,
		VADDR_T *	virtTtb
	)

初始化内核虚拟空间

在文件 los_vm_map.c 第 224 行定义.

{
    vmSpace->base = KERNEL_ASPACE_BASE;//内核空间基地址, 线性区将分配在此范围
    vmSpace->size = KERNEL_ASPACE_SIZE;//内核空间大小
    vmSpace->mapBase = KERNEL_VMM_BASE;//内核空间映射区基地址
    vmSpace->mapSize = KERNEL_VMM_SIZE;//内核空间映射区大小
#ifdef LOSCFG_DRIVERS_TZDRIVER
    vmSpace->codeStart = 0; //代码区开始地址
    vmSpace->codeEnd = 0;   //代码区结束地址
#endif
    return OsVmSpaceInitCommon(vmSpace, virtTtb);//virtTtb 用于初始化 mmu
}

函数调用图:

这是这个函数的调用关系图:

OsKSpaceInit()

VOID OsKSpaceInit

(

VOID

)

内核虚拟空间初始化

在文件 los_vm_map.c 第 250 行定义.

{
    OsVmMapInit();//初始化后续操作 g_vmSpaceList 的互斥锁 
    OsKernVmSpaceInit(&g_kVmSpace, OsGFirstTableGet()); //初始化内核进程虚拟空间
    OsVMallocSpaceInit(&g_vMallocSpace, OsGFirstTableGet());//初始化内核动态分配空间
}

函数调用图:

这是这个函数的调用关系图:

OsRegionRbCmpKeyFn()

ULONG_T OsRegionRbCmpKeyFn	(	const VOID *	pNodeKeyA,
		const VOID *	pNodeKeyB
	)

比较两个红黑树节点

在文件 los_vm_map.c 第 161 行定义.

{
    LosVmMapRange rangeA = *(LosVmMapRange *)pNodeKeyA;
    LosVmMapRange rangeB = *(LosVmMapRange *)pNodeKeyB;
    UINT32 startA = rangeA.base;
    UINT32 endA = rangeA.base + rangeA.size - 1;
    UINT32 startB = rangeB.base;
    UINT32 endB = rangeB.base + rangeB.size - 1;
 
    if (startA > endB) {// A基地址大于B的结束地址
        return RB_BIGGER; //说明线性区A更大,在右边
    } else if (startA >= startB) {
        if (endA <= endB) {
            return RB_EQUAL; //相等,说明 A在B中
        } else {
            return RB_BIGGER; //说明 A的结束地址更大
        }
    } else if (startA <= startB) { //A基地址小于等于B的基地址
        if (endA >= endB) {
            return RB_EQUAL; //相等 说明 B在A中
        } else {
            return RB_SMALLER;//说明A的结束地址更小
        }
    } else if (endA < startB) {//A结束地址小于B的开始地址
        return RB_SMALLER;//说明A在
    }
    return RB_EQUAL;
}

这是这个函数的调用关系图:

OsRegionRbFreeFn()

ULONG_T OsRegionRbFreeFn

(

LosRbNode *

pstNode

)

释放挂在红黑树上节点,等于释放了线性区

在文件 los_vm_map.c 第 149 行定义.

{
    LOS_MemFree(m_aucSysMem0, pstNode);
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsRegionRbGetKeyFn()

VOID * OsRegionRbGetKeyFn

(

LosRbNode *

pstNode

)

通过红黑树节点找到对应的线性区

在文件 los_vm_map.c 第 155 行定义.

{
    LosVmMapRegion *region = (LosVmMapRegion *)LOS_DL_LIST_ENTRY(pstNode, LosVmMapRegion, rbNode);
    return (VOID *)&region->range;
}

这是这个函数的调用关系图:

OsUserVmSpaceInit()

BOOL OsUserVmSpaceInit	(	LosVmSpace *	vmSpace,
		VADDR_T *	virtTtb
	)

OsUserVmSpaceInit 用户空间的TTB表是动态申请得来,每个进程有属于自己的L1,L2表 初始化用户进程虚拟空间,主要划分数据区,堆区,映射区和创建mmu

参数

virtTtb
vmSpace

返回

参见

在文件 los_vm_map.c 第 265 行定义.

{
    vmSpace->base = USER_ASPACE_BASE;//用户空间基地址
    vmSpace->size = USER_ASPACE_SIZE;//用户空间大小
    vmSpace->mapBase = USER_MAP_BASE;//用户空间映射基地址
    vmSpace->mapSize = USER_MAP_SIZE;//用户空间映射大小
    vmSpace->heapBase = USER_HEAP_BASE;//用户堆区开始地址,只有用户进程需要设置这里，动态内存的开始地址
    vmSpace->heapNow = USER_HEAP_BASE;//堆区最新指向地址，用户堆空间大小可通过系统调用 do_brk()扩展
    vmSpace->heap = NULL;   //最近分配的一个堆线性区
#ifdef LOSCFG_DRIVERS_TZDRIVER
    vmSpace->codeStart = 0;
    vmSpace->codeEnd = 0;
#endif
    return OsVmSpaceInitCommon(vmSpace, virtTtb);//创建MMU,为后续的虚实映射做好初始化的工作
}

函数调用图:

这是这个函数的调用关系图:

OsVMallocSpaceInit()

BOOL OsVMallocSpaceInit	(	LosVmSpace *	vmSpace,
		VADDR_T *	virtTtb
	)

初始化内核堆空间

在文件 los_vm_map.c 第 237 行定义.

{
    vmSpace->base = VMALLOC_START;      //内核堆空间基地址
    vmSpace->size = VMALLOC_SIZE;       //内核堆空间大小
    vmSpace->mapBase = VMALLOC_START;   //内核堆空间映射基地址
    vmSpace->mapSize = VMALLOC_SIZE;    //内核堆空间映射区大小
#ifdef LOSCFG_DRIVERS_TZDRIVER
    vmSpace->codeStart = 0;
    vmSpace->codeEnd = 0;
#endif
    return OsVmSpaceInitCommon(vmSpace, virtTtb);//创建MMU,为后续的虚实映射做好初始化的工作
}

函数调用图:

这是这个函数的调用关系图:

OsVmMapInit()

VOID OsVmMapInit

(

VOID

)

@note_thinking 这个函数名称和内容不太搭

在文件 los_vm_map.c 第 216 行定义.

{
    status_t retval = LOS_MuxInit(&g_vmSpaceListMux, NULL);//初始化虚拟空间的互斥量
    if (retval != LOS_OK) {
        VM_ERR("Create mutex for g_vmSpaceList failed, status: %d", retval);
    }
}

函数调用图:

这是这个函数的调用关系图:

OsVmSpaceInitCommon()

STATIC BOOL OsVmSpaceInitCommon	(	LosVmSpace *	vmSpace,
		VADDR_T *	virtTtb
	)

OsVmSpaceInitCommon 初始化进程虚拟空间，必须提供L1表的虚拟内存地址

参数

virtTtb	L1表的地址，TTB表地址
vmSpace

返回

参见

在文件 los_vm_map.c 第 199 行定义.

{
    LOS_RbInitTree(&vmSpace->regionRbTree, OsRegionRbCmpKeyFn, OsRegionRbFreeFn, OsRegionRbGetKeyFn);//初始化虚拟存储空间-以红黑树组织方式
 
    status_t retval = LOS_MuxInit(&vmSpace->regionMux, NULL);//初始化互斥量
    if (retval != LOS_OK) {
        VM_ERR("Create mutex for vm space failed, status: %d", retval);
        return FALSE;
    }
 
    (VOID)LOS_MuxAcquire(&g_vmSpaceListMux);
    LOS_ListAdd(&g_vmSpaceList, &vmSpace->node);//将虚拟空间挂入全局虚拟空间双循环链表上
    (VOID)LOS_MuxRelease(&g_vmSpaceListMux);
 
    return OsArchMmuInit(&vmSpace->archMmu, virtTtb);//对mmu初始化
}

函数调用图:

这是这个函数的调用关系图:

OsVmSpaceParamCheck()

STATIC BOOL OsVmSpaceParamCheck

(

LosVmSpace *

vmSpace

)

在文件 los_vm_map.c 第 309 行定义.

{
    if (vmSpace == NULL) {
        return FALSE;
    }
    return TRUE;
}

这是这个函数的调用关系图:

变量说明

g_kVmSpace

LosVmSpace g_kVmSpace

内核非分配空间,用于内核运行栈,代码区,数据区

在文件 los_vm_map.c 第 105 行定义.

g_vMallocSpace

LosVmSpace g_vMallocSpace

内核分配空间,用于内核分配内存

在文件 los_vm_map.c 第 106 行定义.

g_vmSpaceListMux

LosMux g_vmSpaceListMux

用于锁g_vmSpaceList的互斥量

在文件 los_vm_map.c 第 103 行定义.