los_memory.c 文件参考

http://www.gii.upv.es/tlsf/files/ecrts04_tlsf.pdf 更多...

浏览源代码.

结构体
struct	OsMemNodeHead
	内存池节点 更多...
struct	OsMemUsedNodeHead
	已使用内存池节点 更多...
struct	OsMemFreeNodeHead
	内存池空闲节点 更多...
struct	OsMemPoolInfo
	内存池信息 更多...
struct	OsMemPoolHead
	内存池头信息 更多...

函数
STATIC INLINE UINT16	OsMemFFS (UINT32 bitmap)
STATIC INLINE UINT16	OsMemFLS (UINT32 bitmap)
STATIC INLINE UINT32	OsMemLog2 (UINT32 size)
STATIC INLINE UINT32	OsMemFlGet (UINT32 size)
STATIC INLINE UINT32	OsMemSlGet (UINT32 size, UINT32 fl)
STATIC INLINE VOID	OsMemFreeNodeAdd (VOID *pool, struct OsMemFreeNodeHead *node)
	添加一个空闲节点 更多...
STATIC INLINE UINT32	OsMemFree (struct OsMemPoolHead *pool, struct OsMemNodeHead *node)
	释放内存 更多...
STATIC VOID	OsMemInfoPrint (VOID *pool)
STATIC INLINE UINT32	OsMemAllocCheck (struct OsMemPoolHead *pool, UINT32 intSave)
STATIC INLINE VOID	OsMemNodeSetTaskID (struct OsMemUsedNodeHead *node)
STATIC INLINE VOID	OsMemWaterUsedRecord (struct OsMemPoolHead *pool, UINT32 size)
STATIC INLINE struct OsMemNodeHead *	OsMemLastSentinelNodeGet (const struct OsMemNodeHead *sentinelNode)
	更新哨兵节点内容 更多...
STATIC INLINE BOOL	OsMemSentinelNodeCheck (struct OsMemNodeHead *sentinelNode)
	检查哨兵节点 更多...
STATIC INLINE BOOL	OsMemIsLastSentinelNode (struct OsMemNodeHead *sentinelNode)
	是否为最后一个哨兵节点 更多...
STATIC INLINE VOID	OsMemSentinelNodeSet (struct OsMemNodeHead *sentinelNode, VOID *newNode, UINT32 size)
	设置哨兵节点内容 更多...
STATIC INLINE VOID *	OsMemSentinelNodeGet (struct OsMemNodeHead *node)
STATIC INLINE struct OsMemNodeHead *	PreSentinelNodeGet (const VOID *pool, const struct OsMemNodeHead *node)
UINT32	OsMemLargeNodeFree (const VOID *ptr)
	大内存释放 更多...
STATIC INLINE BOOL	TryShrinkPool (const VOID *pool, const struct OsMemNodeHead *node)
STATIC INLINE INT32	OsMemPoolExpandSub (VOID *pool, UINT32 size, UINT32 intSave)
	内存池扩展实现 更多...
STATIC INLINE INT32	OsMemPoolExpand (VOID *pool, UINT32 allocSize, UINT32 intSave)
	扩展内存池 更多...
VOID	LOS_MemExpandEnable (VOID *pool)
	Enable memory pool to support dynamic expansion. 更多...
STATIC INLINE VOID	OsLmsFirstNodeMark (VOID *pool, struct OsMemNodeHead *node)
STATIC INLINE VOID	OsLmsAllocAlignMark (VOID *ptr, VOID *alignedPtr, UINT32 size)
STATIC INLINE VOID	OsLmsReallocMergeNodeMark (struct OsMemNodeHead *node)
STATIC INLINE VOID	OsLmsReallocSplitNodeMark (struct OsMemNodeHead *node)
STATIC INLINE VOID	OsLmsReallocResizeMark (struct OsMemNodeHead *node, UINT32 resize)
STATIC INLINE VOID	OsMemLinkRegisterRecord (struct OsMemNodeHead *node)
STATIC INLINE VOID	OsMemUsedNodePrint (struct OsMemNodeHead *node)
VOID	OsMemUsedNodeShow (VOID *pool)
	打印已使用的节点 更多...
STATIC VOID	OsMemNodeBacktraceInfo (const struct OsMemNodeHead *tmpNode, const struct OsMemNodeHead *preNode)
STATIC INLINE UINT32	OsMemFreeListIndexGet (UINT32 size)
STATIC INLINE struct OsMemFreeNodeHead *	OsMemFindCurSuitableBlock (struct OsMemPoolHead *poolHead, UINT32 index, UINT32 size)
STATIC INLINE UINT32	OsMemNotEmptyIndexGet (struct OsMemPoolHead *poolHead, UINT32 index)
STATIC INLINE struct OsMemFreeNodeHead *	OsMemFindNextSuitableBlock (VOID *pool, UINT32 size, UINT32 *outIndex)
	找到下一个合适的块 更多...
STATIC INLINE VOID	OsMemSetFreeListBit (struct OsMemPoolHead *head, UINT32 index)
STATIC INLINE VOID	OsMemClearFreeListBit (struct OsMemPoolHead *head, UINT32 index)
STATIC INLINE VOID	OsMemListAdd (struct OsMemPoolHead *pool, UINT32 listIndex, struct OsMemFreeNodeHead *node)
STATIC INLINE VOID	OsMemListDelete (struct OsMemPoolHead *pool, UINT32 listIndex, struct OsMemFreeNodeHead *node)
	从空闲链表中删除 更多...
STATIC INLINE VOID	OsMemFreeNodeDelete (VOID *pool, struct OsMemFreeNodeHead *node)
	从空闲链表上摘除节点 更多...
STATIC INLINE struct OsMemNodeHead *	OsMemFreeNodeGet (VOID *pool, UINT32 size)
STATIC INLINE VOID	OsMemMergeNode (struct OsMemNodeHead *node)
	合并节点,和前面的节点合并 node 消失 更多...
STATIC INLINE VOID	OsMemSplitNode (VOID *pool, struct OsMemNodeHead *allocNode, UINT32 allocSize)
	切割节点 更多...
STATIC INLINE VOID *	OsMemCreateUsedNode (VOID *addr)
STATIC UINT32	OsMemPoolInit (VOID *pool, UINT32 size)
	OsMemPoolInit 内存池初始化 内存池节点部分包含3种类型节点：未使用空闲内存节点(OsMemFreeNodeHead)，已使用内存节点(OsMemUsedNodeHead) 和 尾节点(OsMemNodeHead)。 每个内存节点维护一个前序指针，指向内存池中上一个内存节点，还维护内存节点的大小和使用标记。 空闲内存节点和已使用内存节点后面的内存区域是数据域 更多...
STATIC VOID	OsMemPoolDeinit (VOID *pool)
STATIC UINT32	OsMemPoolAdd (VOID *pool, UINT32 size)
	新增内存池 更多...
STATIC UINT32	OsMemPoolDelete (VOID *pool)
	删除内存池 更多...
UINT32	LOS_MemInit (VOID *pool, UINT32 size)
	LOS_MemInit 初始化一块指定的动态内存池，大小为size 初始一个内存池后生成一个内存池控制头、尾节点EndNode，剩余的内存被标记为FreeNode内存节点。 更多...
UINT32	LOS_MemDeInit (VOID *pool)
	删除指定内存池 更多...
UINT32	LOS_MemPoolList (VOID)
	打印系统中已初始化的所有内存池，包括内存池的起始地址、内存池大小、空闲内存总大小、已使用内存总大小、最大的空闲内存块大小、空闲内存块数量、已使用的内存块数量。 更多...
STATIC INLINE VOID *	OsMemAlloc (struct OsMemPoolHead *pool, UINT32 size, UINT32 intSave)
	从指定动态内存池中申请size长度的内存 更多...
VOID *	LOS_MemAlloc (VOID *pool, UINT32 size)
	从指定内存池中申请size长度的内存,注意这可不是从内核堆空间中申请内存 更多...
VOID *	LOS_MemAllocAlign (VOID *pool, UINT32 size, UINT32 boundary)
	从指定内存池中申请size长度的内存且地址按boundary字节对齐的内存 更多...
STATIC INLINE BOOL	OsMemAddrValidCheck (const struct OsMemPoolHead *pool, const VOID *addr)
	内存池有效性检查 更多...
STATIC INLINE BOOL	OsMemIsNodeValid (const struct OsMemNodeHead *node, const struct OsMemNodeHead *startNode, const struct OsMemNodeHead *endNode, const struct OsMemPoolHead *poolInfo)
STATIC BOOL	MemCheckUsedNode (const struct OsMemPoolHead *pool, const struct OsMemNodeHead *node, const struct OsMemNodeHead *startNode, const struct OsMemNodeHead *endNode)
STATIC UINT32	OsMemCheckUsedNode (const struct OsMemPoolHead *pool, const struct OsMemNodeHead *node)
UINT32	LOS_MemFree (VOID *pool, VOID *ptr)
	释放从指定动态内存中申请的内存 更多...
STATIC INLINE VOID	OsMemReAllocSmaller (VOID *pool, UINT32 allocSize, struct OsMemNodeHead *node, UINT32 nodeSize)
STATIC INLINE VOID	OsMemMergeNodeForReAllocBigger (VOID *pool, UINT32 allocSize, struct OsMemNodeHead *node, UINT32 nodeSize, struct OsMemNodeHead *nextNode)
STATIC INLINE VOID *	OsGetRealPtr (const VOID *pool, VOID *ptr)
STATIC INLINE VOID *	OsMemRealloc (struct OsMemPoolHead *pool, const VOID *ptr, struct OsMemNodeHead *node, UINT32 size, UINT32 intSave)
VOID *	LOS_MemRealloc (VOID *pool, VOID *ptr, UINT32 size)
	按size大小重新分配内存块，并将原内存块内容拷贝到新内存块。如果新内存块申请成功，则释放原内存块 更多...
UINT32	LOS_MemFreeByTaskID (VOID *pool, UINT32 taskID)
UINT32	LOS_MemPoolSizeGet (const VOID *pool)
	获取指定动态内存池的总大小 更多...
UINT32	LOS_MemTotalUsedGet (VOID *pool)
	获取指定动态内存池的总使用量大小 更多...
STATIC INLINE VOID	OsMemMagicCheckPrint (struct OsMemNodeHead **tmpNode)
STATIC UINT32	OsMemAddrValidCheckPrint (const VOID *pool, struct OsMemFreeNodeHead **tmpNode)
STATIC UINT32	OsMemIntegrityCheckSub (struct OsMemNodeHead **tmpNode, const VOID *pool, const struct OsMemNodeHead *endNode)
STATIC UINT32	OsMemFreeListNodeCheck (const struct OsMemPoolHead *pool, const struct OsMemFreeNodeHead *node)
STATIC VOID	OsMemPoolHeadCheck (const struct OsMemPoolHead *pool)
STATIC UINT32	OsMemIntegrityCheck (const struct OsMemPoolHead *pool, struct OsMemNodeHead **tmpNode, struct OsMemNodeHead **preNode)
STATIC VOID	OsMemNodeInfo (const struct OsMemNodeHead *tmpNode, const struct OsMemNodeHead *preNode)
STATIC VOID	OsMemIntegrityCheckError (struct OsMemPoolHead *pool, const struct OsMemNodeHead *tmpNode, const struct OsMemNodeHead *preNode, UINT32 intSave)
UINT32	LOS_MemIntegrityCheck (const VOID *pool)
	对指定内存池做完整性检查 更多...
STATIC INLINE VOID	OsMemInfoGet (struct OsMemPoolHead *poolInfo, struct OsMemNodeHead *node, LOS_MEM_POOL_STATUS *poolStatus)
UINT32	LOS_MemInfoGet (VOID *pool, LOS_MEM_POOL_STATUS *poolStatus)
	LOS_MemInfoGet 获取指定内存池的内存结构信息，包括空闲内存大小、已使用内存大小、空闲内存块数量、已使用的内存块数量、最大的空闲内存块大小 更多...
UINT32	LOS_MemFreeNodeShow (VOID *pool)
	打印指定内存池的空闲内存块的大小及数量 更多...
STATUS_T	OsKHeapInit (size_t size)
	内核空间动态内存(堆内存)初始化 , 争取系统动态内存池 更多...
BOOL	OsMemIsHeapNode (const VOID *ptr)

变量
UINT8 *	m_aucSysMem0 = NULL
	异常交互动态内存池地址的起始地址，当不支持异常交互特性时，m_aucSysMem0等于m_aucSysMem1。 更多...
UINT8 *	m_aucSysMem1 = NULL
	系统动态内存池地址的起始地址 @note_thinking 能否不要用 0,1来命名核心变量 ??? 更多...
VOID *	g_poolHead = NULL

详细描述

http://www.gii.upv.es/tlsf/files/ecrts04_tlsf.pdf

https://www.codenong.com/cs106845116/ TLSF算法（一）分配中的位图计算
基本概念
    内存管理模块管理系统的内存资源，它是操作系统的核心模块之一，主要包括内存的初始化、分配以及释放。
    OpenHarmony LiteOS-A的堆内存管理提供内存初始化、分配、释放等功能。在系统运行过程中，堆内存管理
    模块通过对内存的申请/释放来管理用户和OS对内存的使用，使内存的利用率和使用效率达到最优，同时最大限度地解决系统的内存碎片问题。

运行机制
    堆内存管理，即在内存资源充足的情况下，根据用户需求，从系统配置的一块比较大的连续内存
    （内存池，也是堆内存）中分配任意大小的内存块。当用户不需要该内存块时，又可以释放回系统供下一次使用。
    与静态内存相比，动态内存管理的优点是按需分配，缺点是内存池中容易出现碎片。
    OpenHarmony LiteOS-A堆内存在TLSF算法的基础上，对区间的划分进行了优化，获得更优的性能，降低了碎片率。
    动态内存核心算法框图如下：

 根据空闲内存块的大小，使用多个空闲链表来管理。根据内存空闲块大小分为两个部分：[4, 127]和[27, 231]，如上图size class所示：

 1. 对[4,127]区间的内存进行等分，如上图下半部分所示，分为31个小区间，每个小区间对应内存块大小为4字节的倍数。
    每个小区间对应一个空闲内存链表和用于标记对应空闲内存链表是否为空的一个比特位，值为1时，空闲链表非空。
    [4,127]区间的31个小区间内存对应31个比特位进行标记链表是否为空。
 2. 大于127字节的空闲内存块，按照2的次幂区间大小进行空闲链表管理。总共分为24个小区间，每个小区间又等分为8个二级小区间，
    见上图上半部分的Size Class和Size SubClass部分。每个二级小区间对应一个空闲链表和用于标记对应空闲内存链表是否为空的一个比特位。
    总共24*8=192个二级小区间，对应192个空闲链表和192个比特位进行标记链表是否为空。
 例如，当有40字节的空闲内存需要插入空闲链表时，对应小区间[40,43]，第10个空闲链表，位图标记的第10比特位。
 把40字节的空闲内存挂载第10个空闲链表上，并判断是否需要更新位图标记。当需要申请40字节的内存时，
 根据位图标记获取存在满足申请大小的内存块的空闲链表，从空闲链表上获取空闲内存节点。如果分配的节点大于需要申请的内存大小，
 进行分割节点操作，剩余的节点重新挂载到相应的空闲链表上。当有580字节的空闲内存需要插入空闲链表时，对应二级小区间[29,29+2^6]，
 第31+2*8=47个空闲链表，并使用位图的第47个比特位来标记链表是否为空。把580字节的空闲内存挂载第47个空闲链表上，并判断是否需要更新位图标记。
 当需要申请580字节的内存时，根据位图标记获取存在满足申请大小的内存块的空闲链表，从空闲链表上获取空闲内存节点。
 如果分配的节点大于需要申请的内存大小，进行分割节点操作，剩余的节点重新挂载到相应的空闲链表上。如果对应的空闲链表为空，
 则向更大的内存区间去查询是否有满足条件的空闲链表，实际计算时，会一次性查找到满足申请大小的空闲链表。
 
 内存信息包括内存池大小、内存使用量、剩余内存大小、最大空闲内存、内存水线、内存节点数统计、碎片率等。
 内存水线：即内存池的最大使用量，每次申请和释放时，都会更新水线值，实际业务可根据该值，优化内存池大小；
 碎片率：衡量内存池的碎片化程度，碎片率高表现为内存池剩余内存很多，但是最大空闲内存块很小，可以用公式（fragment=100-最大空闲内存块大小/剩余内存大小）来度量；

 内存管理结构如下图所示：

版本

作者

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

日期

2021-11-19

在文件 los_memory.c 中定义.

函数说明

LOS_MemFreeByTaskID()

UINT32 LOS_MemFreeByTaskID	(	VOID *	pool,
		UINT32	taskID
	)

在文件 los_memory.c 第 1554 行定义.

{
    if (pool == NULL) {
        return OS_ERROR;
    }
 
    if (taskID >= LOSCFG_BASE_CORE_TSK_LIMIT) {
        return OS_ERROR;
    }
 
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemUsedNodeHead *node = NULL;
    struct OsMemNodeHead *endNode = NULL;
    UINT32 size;
    UINT32 intSave;
 
    MEM_LOCK(poolHead, intSave);
    endNode = OS_MEM_END_NODE(pool, poolHead->info.totalSize);
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode <= endNode;) {
        if (tmpNode == endNode) {
            if (OsMemIsLastSentinelNode(endNode) == FALSE) {
                size = OS_MEM_NODE_GET_SIZE(endNode->sizeAndFlag);
                tmpNode = OsMemSentinelNodeGet(endNode);
                endNode = OS_MEM_END_NODE(tmpNode, size);
                continue;
            } else {
                break;
            }
        } else {
            if (!OS_MEM_NODE_GET_USED_FLAG(tmpNode->sizeAndFlag)) {
                tmpNode = OS_MEM_NEXT_NODE(tmpNode);
                continue;
            }
 
            node = (struct OsMemUsedNodeHead *)tmpNode;
            tmpNode = OS_MEM_NEXT_NODE(tmpNode);
 
            if (node->taskID == taskID) {
                OsMemFree(poolHead, &node->header);
            }
        }
    }
    MEM_UNLOCK(poolHead, intSave);
 
    return LOS_OK;
}

函数调用图:

MemCheckUsedNode()

STATIC BOOL MemCheckUsedNode	(	const struct OsMemPoolHead *	pool,
		const struct OsMemNodeHead *	node,
		const struct OsMemNodeHead *	startNode,
		const struct OsMemNodeHead *	endNode
	)

在文件 los_memory.c 第 1260 行定义.

{
    if (!OsMemIsNodeValid(node, startNode, endNode, pool)) {
        return FALSE;
    }
 
    if (!OS_MEM_NODE_GET_USED_FLAG(node->sizeAndFlag)) {
        return FALSE;
    }
 
    const struct OsMemNodeHead *nextNode = OS_MEM_NEXT_NODE(node);
    if (!OsMemIsNodeValid(nextNode, startNode, endNode, pool)) {
        return FALSE;
    }
 
    if (!OS_MEM_NODE_GET_LAST_FLAG(nextNode->sizeAndFlag)) {
        if (nextNode->ptr.prev != node) {
            return FALSE;
        }
    }
 
    if ((node != startNode) &&
        ((!OsMemIsNodeValid(node->ptr.prev, startNode, endNode, pool)) ||
        (OS_MEM_NEXT_NODE(node->ptr.prev) != node))) {
        return FALSE;
    }
 
    return TRUE;
}

函数调用图:

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

OsGetRealPtr()

STATIC INLINE VOID * OsGetRealPtr	(	const VOID *	pool,
		VOID *	ptr
	)

在文件 los_memory.c 第 1456 行定义.

{
    VOID *realPtr = ptr;
    UINT32 gapSize = *((UINT32 *)((UINTPTR)ptr - sizeof(UINT32)));
 
    if (OS_MEM_NODE_GET_ALIGNED_FLAG(gapSize) && OS_MEM_NODE_GET_USED_FLAG(gapSize)) {
        PRINT_ERR("[%s:%d]gapSize:0x%x error\n", __FUNCTION__, __LINE__, gapSize);
        return NULL;
    }
    if (OS_MEM_NODE_GET_ALIGNED_FLAG(gapSize)) {
        gapSize = OS_MEM_NODE_GET_ALIGNED_GAPSIZE(gapSize);
        if ((gapSize & (OS_MEM_ALIGN_SIZE - 1)) ||
            (gapSize > ((UINTPTR)ptr - OS_MEM_NODE_HEAD_SIZE - (UINTPTR)pool))) {
            PRINT_ERR("[%s:%d]gapSize:0x%x error\n", __FUNCTION__, __LINE__, gapSize);
            return NULL;
        }
        realPtr = (VOID *)((UINTPTR)ptr - (UINTPTR)gapSize);
    }
    return realPtr;
}

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

OsKHeapInit()

STATUS_T OsKHeapInit

(

size_t

size

)

内核空间动态内存(堆内存)初始化 , 争取系统动态内存池

判断地址是否在堆区

在文件 los_memory.c 第 2095 行定义.

函数调用图:

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

OsLmsAllocAlignMark()

STATIC INLINE VOID OsLmsAllocAlignMark	(	VOID *	ptr,
		VOID *	alignedPtr,
		UINT32	size
	)

在文件 los_memory.c 第 525 行定义.

{
    struct OsMemNodeHead *allocNode = NULL;
 
    if ((g_lms == NULL) || (ptr == NULL)) {
        return;
    }
    allocNode = (struct OsMemNodeHead *)((struct OsMemUsedNodeHead *)ptr - 1);
    if (ptr != alignedPtr) {
        g_lms->simpleMark((UINTPTR)ptr, (UINTPTR)ptr + sizeof(UINT32), LMS_SHADOW_PAINT_U8);
        g_lms->simpleMark((UINTPTR)ptr + sizeof(UINT32), (UINTPTR)alignedPtr, LMS_SHADOW_REDZONE_U8);
    }
 
    /* mark remining as redzone */
    g_lms->simpleMark(LMS_ADDR_ALIGN((UINTPTR)alignedPtr + size), (UINTPTR)OS_MEM_NEXT_NODE(allocNode),
        LMS_SHADOW_REDZONE_U8);
}

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

OsLmsFirstNodeMark()

STATIC INLINE VOID OsLmsFirstNodeMark	(	VOID *	pool,
		struct OsMemNodeHead *	node
	)

在文件 los_memory.c 第 511 行定义.

{
    if (g_lms == NULL) {
        return;
    }
 
    g_lms->simpleMark((UINTPTR)pool, (UINTPTR)node, LMS_SHADOW_PAINT_U8);
    g_lms->simpleMark((UINTPTR)node, (UINTPTR)node + OS_MEM_NODE_HEAD_SIZE, LMS_SHADOW_REDZONE_U8);
    g_lms->simpleMark((UINTPTR)OS_MEM_NEXT_NODE(node), (UINTPTR)OS_MEM_NEXT_NODE(node) + OS_MEM_NODE_HEAD_SIZE,
        LMS_SHADOW_REDZONE_U8);
    g_lms->simpleMark((UINTPTR)node + OS_MEM_NODE_HEAD_SIZE, (UINTPTR)OS_MEM_NEXT_NODE(node),
        LMS_SHADOW_AFTERFREE_U8);
}

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

OsLmsReallocMergeNodeMark()

STATIC INLINE VOID OsLmsReallocMergeNodeMark

(

struct OsMemNodeHead *

node

)

在文件 los_memory.c 第 543 行定义.

{
    if (g_lms == NULL) {
        return;
    }
 
    g_lms->simpleMark((UINTPTR)node + OS_MEM_NODE_HEAD_SIZE, (UINTPTR)OS_MEM_NEXT_NODE(node),
        LMS_SHADOW_ACCESSABLE_U8);
}

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

OsLmsReallocResizeMark()

STATIC INLINE VOID OsLmsReallocResizeMark	(	struct OsMemNodeHead *	node,
		UINT32	resize
	)

在文件 los_memory.c 第 565 行定义.

{
    if (g_lms == NULL) {
        return;
    }
    /* mark remaining as redzone */
    g_lms->simpleMark((UINTPTR)node + resize, (UINTPTR)OS_MEM_NEXT_NODE(node), LMS_SHADOW_REDZONE_U8);
}

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

OsLmsReallocSplitNodeMark()

STATIC INLINE VOID OsLmsReallocSplitNodeMark

(

struct OsMemNodeHead *

node

)

在文件 los_memory.c 第 553 行定义.

{
    if (g_lms == NULL) {
        return;
    }
    /* mark next node */
    g_lms->simpleMark((UINTPTR)OS_MEM_NEXT_NODE(node),
        (UINTPTR)OS_MEM_NEXT_NODE(node) + OS_MEM_NODE_HEAD_SIZE, LMS_SHADOW_REDZONE_U8);
    g_lms->simpleMark((UINTPTR)OS_MEM_NEXT_NODE(node) + OS_MEM_NODE_HEAD_SIZE,
        (UINTPTR)OS_MEM_NEXT_NODE(OS_MEM_NEXT_NODE(node)), LMS_SHADOW_AFTERFREE_U8);
}

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

OsMemAddrValidCheck()

STATIC INLINE BOOL OsMemAddrValidCheck	(	const struct OsMemPoolHead *	pool,
		const VOID *	addr
	)

内存池有效性检查

在文件 los_memory.c 第 1210 行定义.

{
    UINT32 size;
 
    /* First node prev is NULL */
    if (addr == NULL) {
        return TRUE;
    }
 
    size = pool->info.totalSize;
    if (OS_MEM_MIDDLE_ADDR_OPEN_END(pool + 1, addr, (UINTPTR)pool + size)) {
        return TRUE;
    }
#if OS_MEM_EXPAND_ENABLE //如果支持可扩展
    struct OsMemNodeHead *node = NULL;
    struct OsMemNodeHead *sentinel = OS_MEM_END_NODE(pool, size);
    while (OsMemIsLastSentinelNode(sentinel) == FALSE) {
        size = OS_MEM_NODE_GET_SIZE(sentinel->sizeAndFlag);
        node = OsMemSentinelNodeGet(sentinel);
        sentinel = OS_MEM_END_NODE(node, size);
        if (OS_MEM_MIDDLE_ADDR_OPEN_END(node, addr, (UINTPTR)node + size)) {
            return TRUE;
        }
    }
#endif
    return FALSE;
}

函数调用图:

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

OsMemAddrValidCheckPrint()

STATIC UINT32 OsMemAddrValidCheckPrint	(	const VOID *	pool,
		struct OsMemFreeNodeHead **	tmpNode
	)

在文件 los_memory.c 第 1682 行定义.

{
    if (((*tmpNode)->prev != NULL) && !OsMemAddrValidCheck(pool, (*tmpNode)->prev)) {
        PRINT_ERR("[%s], %d, memory check error!\n"
                  " freeNode.prev:%#x is out of legal mem range\n",
                  __FUNCTION__, __LINE__, (*tmpNode)->prev);
        return LOS_NOK;
    }
    if (((*tmpNode)->next != NULL) && !OsMemAddrValidCheck(pool, (*tmpNode)->next)) {
        PRINT_ERR("[%s], %d, memory check error!\n"
                  " freeNode.next:%#x is out of legal mem range\n",
                  __FUNCTION__, __LINE__, (*tmpNode)->next);
        return LOS_NOK;
    }
    return LOS_OK;
}

函数调用图:

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

OsMemAlloc()

STATIC INLINE VOID * OsMemAlloc	(	struct OsMemPoolHead *	pool,
		UINT32	size,
		UINT32	intSave
	)

从指定动态内存池中申请size长度的内存

在文件 los_memory.c 第 1075 行定义.

{
    struct OsMemNodeHead *allocNode = NULL;
 
#ifdef LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK
    if (OsMemAllocCheck(pool, intSave) == LOS_NOK) {
        return NULL;
    }
#endif
 
    UINT32 allocSize = OS_MEM_ALIGN(size + OS_MEM_NODE_HEAD_SIZE, OS_MEM_ALIGN_SIZE);
#if OS_MEM_EXPAND_ENABLE
retry: //这种写法也挺赞的 @note_good
#endif
    allocNode = OsMemFreeNodeGet(pool, allocSize);//获取空闲节点
    if (allocNode == NULL) {//没有内存了,怎搞? 
#if OS_MEM_EXPAND_ENABLE
        if (pool->info.attr & OS_MEM_POOL_EXPAND_ENABLE) {
            INT32 ret = OsMemPoolExpand(pool, allocSize, intSave);//扩展内存池
            if (ret == 0) {
                goto retry;//再来一遍 
            }
        }
#endif
        MEM_UNLOCK(pool, intSave);
        PRINT_ERR("---------------------------------------------------"
                  "--------------------------------------------------------\n");
        OsMemInfoPrint(pool);
        PRINT_ERR("[%s] No suitable free block, require free node size: 0x%x\n", __FUNCTION__, allocSize);
        PRINT_ERR("----------------------------------------------------"
                  "-------------------------------------------------------\n");
        MEM_LOCK(pool, intSave);
        return NULL;
    }
 
    if ((allocSize + OS_MEM_NODE_HEAD_SIZE + OS_MEM_MIN_ALLOC_SIZE) <= allocNode->sizeAndFlag) {//所需小于内存池可供分配量
        OsMemSplitNode(pool, allocNode, allocSize);//劈开内存池
    }
 
    OS_MEM_NODE_SET_USED_FLAG(allocNode->sizeAndFlag);//给节点贴上已使用的标签
    OsMemWaterUsedRecord(pool, OS_MEM_NODE_GET_SIZE(allocNode->sizeAndFlag));//更新吃水线
 
#ifdef LOSCFG_MEM_LEAKCHECK //检测内存泄漏开关
    OsMemLinkRegisterRecord(allocNode);
#endif
    return OsMemCreateUsedNode((VOID *)allocNode);//创建已使用节点
}

函数调用图:

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

OsMemAllocCheck()

STATIC INLINE UINT32 OsMemAllocCheck	(	struct OsMemPoolHead *	pool,
		UINT32	intSave
	)

在文件 los_memory.c 第 1890 行定义.

{
    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemNodeHead *preNode = NULL;
 
    if (OsMemIntegrityCheck(pool, &tmpNode, &preNode)) {
        OsMemIntegrityCheckError(pool, tmpNode, preNode, intSave);
        return LOS_NOK;
    }
    return LOS_OK;
}

函数调用图:

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

OsMemCheckUsedNode()

STATIC UINT32 OsMemCheckUsedNode	(	const struct OsMemPoolHead *	pool,
		const struct OsMemNodeHead *	node
	)

在文件 los_memory.c 第 1291 行定义.

{
    struct OsMemNodeHead *startNode = (struct OsMemNodeHead *)OS_MEM_FIRST_NODE(pool);
    struct OsMemNodeHead *endNode = (struct OsMemNodeHead *)OS_MEM_END_NODE(pool, pool->info.totalSize);
    BOOL doneFlag = FALSE;
 
    do {
        doneFlag = MemCheckUsedNode(pool, node, startNode, endNode);
        if (!doneFlag) {
#if OS_MEM_EXPAND_ENABLE
            if (OsMemIsLastSentinelNode(endNode) == FALSE) {
                startNode = OsMemSentinelNodeGet(endNode);
                endNode = OS_MEM_END_NODE(startNode, OS_MEM_NODE_GET_SIZE(endNode->sizeAndFlag));
                continue;
            }
#endif
            return LOS_NOK;
        }
    } while (!doneFlag);
 
    return LOS_OK;
}

函数调用图:

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

OsMemClearFreeListBit()

STATIC INLINE VOID OsMemClearFreeListBit	(	struct OsMemPoolHead *	head,
		UINT32	index
	)

在文件 los_memory.c 第 764 行定义.

{
    head->freeListBitmap[BITMAP_INDEX(index)] &= ~(1U << (index & 0x1f));
}

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

OsMemCreateUsedNode()

STATIC INLINE VOID * OsMemCreateUsedNode

(

VOID *

addr

)

在文件 los_memory.c 第 866 行定义.

{
    struct OsMemUsedNodeHead *node = (struct OsMemUsedNodeHead *)addr;//直接将地址转成使用节点,说明节点信息也存在内存池中
    //这种用法是非常巧妙的
#if OS_MEM_FREE_BY_TASKID
    OsMemNodeSetTaskID(node);//设置使用内存节点的任务
#endif
 
#ifdef LOSCFG_KERNEL_LMS //检测内存泄漏
    struct OsMemNodeHead *newNode = (struct OsMemNodeHead *)node;
    if (g_lms != NULL) {
        g_lms->mallocMark(newNode, OS_MEM_NEXT_NODE(newNode), OS_MEM_NODE_HEAD_SIZE);
    }
#endif
    return node + 1; //@note_good 这个地方挺有意思的,只是将结构体扩展下,留一个 int 位 ,变成了已使用节点,返回的地址正是要分配给应用的地址
}

函数调用图:

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

OsMemFFS()

STATIC INLINE UINT16 OsMemFFS

(

UINT32

bitmap

)

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

{
    bitmap &= ~bitmap + 1;
    return (OS_MEM_BITMAP_MASK - CLZ(bitmap));
}

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

OsMemFindCurSuitableBlock()

STATIC INLINE struct OsMemFreeNodeHead * OsMemFindCurSuitableBlock	(	struct OsMemPoolHead *	poolHead,
		UINT32	index,
		UINT32	size
	)

在文件 los_memory.c 第 686 行定义.

{
    struct OsMemFreeNodeHead *node = NULL;
 
    for (node = poolHead->freeList[index]; node != NULL; node = node->next) {
        if (node->header.sizeAndFlag >= size) {
            return node;
        }
    }
 
    return NULL;
}

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

OsMemFindNextSuitableBlock()

STATIC INLINE struct OsMemFreeNodeHead * OsMemFindNextSuitableBlock	(	VOID *	pool,
		UINT32	size,
		UINT32 *	outIndex
	)

找到下一个合适的块

在文件 los_memory.c 第 715 行定义.

{
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    UINT32 fl = OsMemFlGet(size);
    UINT32 sl;
    UINT32 index, tmp;
    UINT32 curIndex = OS_MEM_FREE_LIST_COUNT;
    UINT32 mask;
 
    do {
        if (size < OS_MEM_SMALL_BUCKET_MAX_SIZE) {
            index = fl;
        } else {
            sl = OsMemSlGet(size, fl);
            curIndex = ((fl - OS_MEM_LARGE_START_BUCKET) << OS_MEM_SLI) + sl + OS_MEM_SMALL_BUCKET_COUNT;
            index = curIndex + 1;
        }
 
        tmp = OsMemNotEmptyIndexGet(poolHead, index);
        if (tmp != OS_MEM_FREE_LIST_COUNT) {
            index = tmp;
            goto DONE;
        }
 
        for (index = LOS_Align(index + 1, 32); index < OS_MEM_FREE_LIST_COUNT; index += 32) { /* 32: align size */
            mask = poolHead->freeListBitmap[BITMAP_INDEX(index)];
            if (mask != 0) {
                index = OsMemFFS(mask) + index;
                goto DONE;
            }
        }
    } while (0);
 
    if (curIndex == OS_MEM_FREE_LIST_COUNT) {
        return NULL;
    }
 
    *outIndex = curIndex;
    return OsMemFindCurSuitableBlock(poolHead, curIndex, size);
DONE:
    *outIndex = index;
    return poolHead->freeList[index];
}

函数调用图:

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

OsMemFlGet()

STATIC INLINE UINT32 OsMemFlGet

(

UINT32

size

)

在文件 los_memory.c 第 153 行定义.

{
    if (size < OS_MEM_SMALL_BUCKET_MAX_SIZE) {
        return ((size >> 2) - 1); /* 2: The small bucket setup is 4. */
    }
    return OsMemLog2(size);
}

函数调用图:

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

OsMemFLS()

STATIC INLINE UINT16 OsMemFLS

(

UINT32

bitmap

)

在文件 los_memory.c 第 142 行定义.

{
    return (OS_MEM_BITMAP_MASK - CLZ(bitmap));
}

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

OsMemFree()

STATIC INLINE UINT32 OsMemFree	(	struct OsMemPoolHead *	pool,
		struct OsMemNodeHead *	node
	)

释放内存

在文件 los_memory.c 第 1314 行定义.

{
    UINT32 ret = OsMemCheckUsedNode(pool, node);
    if (ret != LOS_OK) {
        PRINT_ERR("OsMemFree check error!\n");
        return ret;
    }
 
#ifdef LOSCFG_MEM_WATERLINE
    pool->info.curUsedSize -= OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);//降低水位线
#endif
 
    node->sizeAndFlag = OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);//获取大小和标记
#ifdef LOSCFG_MEM_LEAKCHECK
    OsMemLinkRegisterRecord(node);
#endif
#ifdef LOSCFG_KERNEL_LMS
    struct OsMemNodeHead *nextNodeBackup = OS_MEM_NEXT_NODE(node);
    struct OsMemNodeHead *curNodeBackup = node;
    if (g_lms != NULL) {
        g_lms->check((UINTPTR)node + OS_MEM_NODE_HEAD_SIZE, TRUE);
    }
#endif
    struct OsMemNodeHead *preNode = node->ptr.prev; /* merage preNode | 合并前一个节点*/
    if ((preNode != NULL) && !OS_MEM_NODE_GET_USED_FLAG(preNode->sizeAndFlag)) {
        OsMemFreeNodeDelete(pool, (struct OsMemFreeNodeHead *)preNode);//删除前节点的信息
        OsMemMergeNode(node);//向前合并
        node = preNode;
    }
 
    struct OsMemNodeHead *nextNode = OS_MEM_NEXT_NODE(node); /* merage nextNode  | 计算后一个节点位置*/
    if ((nextNode != NULL) && !OS_MEM_NODE_GET_USED_FLAG(nextNode->sizeAndFlag)) {
        OsMemFreeNodeDelete(pool, (struct OsMemFreeNodeHead *)nextNode);//删除后节点信息
        OsMemMergeNode(nextNode);//合并节点
    }
 
#if OS_MEM_EXPAND_ENABLE
    if (pool->info.attr & OS_MEM_POOL_EXPAND_ENABLE) {
        /* if this is a expand head node, and all unused, free it to pmm */
        if ((node->ptr.prev != NULL) && (node->ptr.prev > node)) {
            if (TryShrinkPool(pool, node)) {
                return LOS_OK;
            }
        }
    }
#endif
    OsMemFreeNodeAdd(pool, (struct OsMemFreeNodeHead *)node);
#ifdef LOSCFG_KERNEL_LMS
    if (g_lms != NULL) {
        g_lms->freeMark(curNodeBackup, nextNodeBackup, OS_MEM_NODE_HEAD_SIZE);
    }
#endif
    return ret;
}

函数调用图:

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

OsMemFreeListIndexGet()

STATIC INLINE UINT32 OsMemFreeListIndexGet

(

UINT32

size

)

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

{
    UINT32 fl = OsMemFlGet(size);//获取一级位图
    if (size < OS_MEM_SMALL_BUCKET_MAX_SIZE) {
        return fl;
    }
 
    UINT32 sl = OsMemSlGet(size, fl);//获取二级位图
    return (OS_MEM_SMALL_BUCKET_COUNT + ((fl - OS_MEM_LARGE_START_BUCKET) << OS_MEM_SLI) + sl);
}

函数调用图:

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

OsMemFreeListNodeCheck()

STATIC UINT32 OsMemFreeListNodeCheck	(	const struct OsMemPoolHead *	pool,
		const struct OsMemFreeNodeHead *	node
	)

在文件 los_memory.c 第 1715 行定义.

{
    if (!OsMemAddrValidCheck(pool, node) ||
        !OsMemAddrValidCheck(pool, node->prev) ||
        !OsMemAddrValidCheck(pool, node->next) ||
        !OsMemAddrValidCheck(pool, node->header.ptr.prev)) {
        return LOS_NOK;
    }
 
    if (!OS_MEM_IS_ALIGNED(node, sizeof(VOID *)) ||
        !OS_MEM_IS_ALIGNED(node->prev, sizeof(VOID *)) ||
        !OS_MEM_IS_ALIGNED(node->next, sizeof(VOID *)) ||
        !OS_MEM_IS_ALIGNED(node->header.ptr.prev, sizeof(VOID *))) {
        return LOS_NOK;
    }
 
    return LOS_OK;
}

函数调用图:

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

OsMemFreeNodeAdd()

STATIC INLINE VOID OsMemFreeNodeAdd	(	VOID *	pool,
		struct OsMemFreeNodeHead *	node
	)

添加一个空闲节点

在文件 los_memory.c 第 800 行定义.

{
    UINT32 index = OsMemFreeListIndexGet(node->header.sizeAndFlag);//根据大小定位索引位
    if (index >= OS_MEM_FREE_LIST_COUNT) {
        LOS_Panic("The index of free lists is error, index = %u\n", index);
        return;
    }
    OsMemListAdd(pool, index, node);//挂入链表
}

函数调用图:

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

OsMemFreeNodeDelete()

STATIC INLINE VOID OsMemFreeNodeDelete	(	VOID *	pool,
		struct OsMemFreeNodeHead *	node
	)

从空闲链表上摘除节点

在文件 los_memory.c 第 810 行定义.

{
    UINT32 index = OsMemFreeListIndexGet(node->header.sizeAndFlag);//根据大小定位索引位
    if (index >= OS_MEM_FREE_LIST_COUNT) {
        LOS_Panic("The index of free lists is error, index = %u\n", index);
        return;
    }
    OsMemListDelete(pool, index, node);
}

函数调用图:

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

OsMemFreeNodeGet()

STATIC INLINE struct OsMemNodeHead * OsMemFreeNodeGet	(	VOID *	pool,
		UINT32	size
	)

在文件 los_memory.c 第 820 行定义.

{
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    UINT32 index;
    struct OsMemFreeNodeHead *firstNode = OsMemFindNextSuitableBlock(pool, size, &index);
    if (firstNode == NULL) {
        return NULL;
    }
 
    OsMemListDelete(poolHead, index, firstNode);
 
    return &firstNode->header;
}

函数调用图:

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

OsMemInfoGet()

STATIC INLINE VOID OsMemInfoGet	(	struct OsMemPoolHead *	poolInfo,
		struct OsMemNodeHead *	node,
		LOS_MEM_POOL_STATUS *	poolStatus
	)

在文件 los_memory.c 第 1926 行定义.

{
    UINT32 totalUsedSize = 0;
    UINT32 totalFreeSize = 0;
    UINT32 usedNodeNum = 0;
    UINT32 freeNodeNum = 0;
    UINT32 maxFreeSize = 0;
    UINT32 size;
 
    if (!OS_MEM_NODE_GET_USED_FLAG(node->sizeAndFlag)) {
        size = OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);
        ++freeNodeNum;
        totalFreeSize += size;
        if (maxFreeSize < size) {
            maxFreeSize = size;
        }
    } else {
        size = OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);
        ++usedNodeNum;
        totalUsedSize += size;
    }
 
    poolStatus->totalUsedSize += totalUsedSize;
    poolStatus->totalFreeSize += totalFreeSize;
    poolStatus->maxFreeNodeSize = MAX(poolStatus->maxFreeNodeSize, maxFreeSize);
    poolStatus->usedNodeNum += usedNodeNum;
    poolStatus->freeNodeNum += freeNodeNum;
}

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

OsMemInfoPrint()

STATIC VOID OsMemInfoPrint

(

VOID *

pool

)

在文件 los_memory.c 第 2018 行定义.

{
    struct OsMemPoolHead *poolInfo = (struct OsMemPoolHead *)pool;
    LOS_MEM_POOL_STATUS status = {0};
 
    if (LOS_MemInfoGet(pool, &status) == LOS_NOK) {
        return;
    }
 
#ifdef LOSCFG_MEM_WATERLINE
    PRINTK("pool addr          pool size    used size     free size    "
           "max free node size   used node num     free node num      UsageWaterLine\n");
    PRINTK("---------------    --------     -------       --------     "
           "--------------       -------------      ------------      ------------\n");
    PRINTK("%-16#x   0x%-8x   0x%-8x    0x%-8x   0x%-16x   0x%-13x    0x%-13x    0x%-13x\n",
           poolInfo->info.pool, LOS_MemPoolSizeGet(pool), status.totalUsedSize,
           status.totalFreeSize, status.maxFreeNodeSize, status.usedNodeNum,
           status.freeNodeNum, status.usageWaterLine);
#else
    PRINTK("pool addr          pool size    used size     free size    "
           "max free node size   used node num     free node num\n");
    PRINTK("---------------    --------     -------       --------     "
           "--------------       -------------      ------------\n");
    PRINTK("%-16#x   0x%-8x   0x%-8x    0x%-8x   0x%-16x   0x%-13x    0x%-13x\n",
           poolInfo->info.pool, LOS_MemPoolSizeGet(pool), status.totalUsedSize,
           status.totalFreeSize, status.maxFreeNodeSize, status.usedNodeNum,
           status.freeNodeNum);
#endif
}

函数调用图:

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

OsMemIntegrityCheck()

STATIC UINT32 OsMemIntegrityCheck	(	const struct OsMemPoolHead *	pool,
		struct OsMemNodeHead **	tmpNode,
		struct OsMemNodeHead **	preNode
	)

在文件 los_memory.c 第 1778 行定义.

{
    struct OsMemNodeHead *endNode = OS_MEM_END_NODE(pool, pool->info.totalSize);
 
    OsMemPoolHeadCheck(pool);
 
    *preNode = OS_MEM_FIRST_NODE(pool);
    do {
        for (*tmpNode = *preNode; *tmpNode < endNode; *tmpNode = OS_MEM_NEXT_NODE(*tmpNode)) {
            if (OsMemIntegrityCheckSub(tmpNode, pool, endNode) == LOS_NOK) {
                return LOS_NOK;
            }
            *preNode = *tmpNode;
        }
#if OS_MEM_EXPAND_ENABLE
        if (OsMemIsLastSentinelNode(*tmpNode) == FALSE) {
            *preNode = OsMemSentinelNodeGet(*tmpNode);
            endNode = OS_MEM_END_NODE(*preNode, OS_MEM_NODE_GET_SIZE((*tmpNode)->sizeAndFlag));
        } else
#endif
        {
            break;
        }
    } while (1);
    return LOS_OK;
}

函数调用图:

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

OsMemIntegrityCheckError()

STATIC VOID OsMemIntegrityCheckError	(	struct OsMemPoolHead *	pool,
		const struct OsMemNodeHead *	tmpNode,
		const struct OsMemNodeHead *	preNode,
		UINT32	intSave
	)

在文件 los_memory.c 第 1853 行定义.

{
    OsMemNodeInfo(tmpNode, preNode);
 
#if OS_MEM_FREE_BY_TASKID
    LosTaskCB *taskCB = NULL;
    if (OS_MEM_NODE_GET_USED_FLAG(preNode->sizeAndFlag)) {
        struct OsMemUsedNodeHead *usedNode = (struct OsMemUsedNodeHead *)preNode;
        UINT32 taskID = usedNode->taskID;
        if (OS_TID_CHECK_INVALID(taskID)) {
            MEM_UNLOCK(pool, intSave);
            LOS_Panic("Task ID %u in pre node is invalid!\n", taskID);
            return;
        }
 
        taskCB = OS_TCB_FROM_TID(taskID);
        if (OsTaskIsUnused(taskCB) || (taskCB->taskEntry == NULL)) {
            MEM_UNLOCK(pool, intSave);
            LOS_Panic("\r\nTask ID %u in pre node is not created!\n", taskID);
            return;
        }
    } else {
        PRINTK("The prev node is free\n");
    }
    MEM_UNLOCK(pool, intSave);
    LOS_Panic("cur node: %#x\npre node: %#x\npre node was allocated by task:%s\n",
              tmpNode, preNode, taskCB->taskName);
#else
    MEM_UNLOCK(pool, intSave);
    LOS_Panic("Memory integrity check error, cur node: %#x, pre node: %#x\n", tmpNode, preNode);
#endif
}

函数调用图:

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

OsMemIntegrityCheckSub()

STATIC UINT32 OsMemIntegrityCheckSub	(	struct OsMemNodeHead **	tmpNode,
		const VOID *	pool,
		const struct OsMemNodeHead *	endNode
	)

在文件 los_memory.c 第 1699 行定义.

{
    if (!OS_MEM_MAGIC_VALID(*tmpNode)) {
        OsMemMagicCheckPrint(tmpNode);
        return LOS_NOK;
    }
 
    if (!OS_MEM_NODE_GET_USED_FLAG((*tmpNode)->sizeAndFlag)) { /* is free node, check free node range */
        if (OsMemAddrValidCheckPrint(pool, (struct OsMemFreeNodeHead **)tmpNode)) {
            return LOS_NOK;
        }
    }
    return LOS_OK;
}

函数调用图:

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

OsMemIsHeapNode()

BOOL OsMemIsHeapNode

(

const VOID *

ptr

)

在文件 los_memory.c 第 2126 行定义.

{
    struct OsMemPoolHead *pool = (struct OsMemPoolHead *)m_aucSysMem1;//内核堆区开始地址
    struct OsMemNodeHead *firstNode = OS_MEM_FIRST_NODE(pool);//获取内存池首个节点
    struct OsMemNodeHead *endNode = OS_MEM_END_NODE(pool, pool->info.totalSize);//获取内存池的尾节点
 
    if (OS_MEM_MIDDLE_ADDR(firstNode, ptr, endNode)) {//如果在首尾范围内
        return TRUE;
    }
 
#if OS_MEM_EXPAND_ENABLE//内存池经过扩展后,新旧块的虚拟地址是不连续的,所以需要跳块判断
    UINT32 intSave; 
    UINT32 size;//详细查看百篇博客系列篇之 鸿蒙内核源码分析(内存池篇)
    MEM_LOCK(pool, intSave); //获取自旋锁
    while (OsMemIsLastSentinelNode(endNode) == FALSE) { //哨兵节点是内存池结束的标记
        size = OS_MEM_NODE_GET_SIZE(endNode->sizeAndFlag);//获取节点大小
        firstNode = OsMemSentinelNodeGet(endNode);//获取下一块的开始地址
        endNode = OS_MEM_END_NODE(firstNode, size);//获取下一块的尾节点
        if (OS_MEM_MIDDLE_ADDR(firstNode, ptr, endNode)) {//判断地址是否在该块中
            MEM_UNLOCK(pool, intSave);
            return TRUE;
        }
    }
    MEM_UNLOCK(pool, intSave);
#endif
    return FALSE;
}

函数调用图:

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

OsMemIsLastSentinelNode()

STATIC INLINE BOOL OsMemIsLastSentinelNode

(

struct OsMemNodeHead *

sentinelNode

)

是否为最后一个哨兵节点

在文件 los_memory.c 第 327 行定义.

{
    if (OsMemSentinelNodeCheck(sentinelNode) == FALSE) {
        PRINT_ERR("%s %d, The current sentinel node is invalid\n", __FUNCTION__, __LINE__);
        return TRUE;
    }
 
    if ((OS_MEM_NODE_GET_SIZE(sentinelNode->sizeAndFlag) == 0) ||
        (sentinelNode->ptr.next == NULL)) {
        return TRUE;
    }
 
    return FALSE;
}

函数调用图:

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

OsMemIsNodeValid()

STATIC INLINE BOOL OsMemIsNodeValid	(	const struct OsMemNodeHead *	node,
		const struct OsMemNodeHead *	startNode,
		const struct OsMemNodeHead *	endNode,
		const struct OsMemPoolHead *	poolInfo
	)

在文件 los_memory.c 第 1238 行定义.

{
    if (!OS_MEM_MIDDLE_ADDR(startNode, node, endNode)) {
        return FALSE;
    }
 
    if (OS_MEM_NODE_GET_USED_FLAG(node->sizeAndFlag)) {
        if (!OS_MEM_MAGIC_VALID(node)) {
            return FALSE;
        }
        return TRUE;
    }
 
    if (!OsMemAddrValidCheck(poolInfo, node->ptr.prev)) {
        return FALSE;
    }
 
    return TRUE;
}

函数调用图:

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

OsMemLargeNodeFree()

UINT32 OsMemLargeNodeFree

(

const VOID *

ptr

)

大内存释放

在文件 los_memory.c 第 382 行定义.

{
    LosVmPage *page = OsVmVaddrToPage((VOID *)ptr);//获取物理页
    if ((page == NULL) || (page->nPages == 0)) {
        return LOS_NOK;
    }
    LOS_PhysPagesFreeContiguous((VOID *)ptr, page->nPages);//释放连续的几个物理页
 
    return LOS_OK;
}

函数调用图:

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

OsMemLastSentinelNodeGet()

STATIC INLINE struct OsMemNodeHead * OsMemLastSentinelNodeGet

(

const struct OsMemNodeHead *

sentinelNode

)

更新哨兵节点内容

在文件 los_memory.c 第 299 行定义.

{
    struct OsMemNodeHead *node = NULL;
    VOID *ptr = sentinelNode->ptr.next;//返回不连续的内存块
    UINT32 size = OS_MEM_NODE_GET_SIZE(sentinelNode->sizeAndFlag); // 获取大小
 
    while ((ptr != NULL) && (size != 0)) {
        node = OS_MEM_END_NODE(ptr, size);
        ptr = node->ptr.next;
        size = OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);
    }
 
    return node;
}

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

OsMemLinkRegisterRecord()

STATIC INLINE VOID OsMemLinkRegisterRecord

(

struct OsMemNodeHead *

node

)

在文件 los_memory.c 第 575 行定义.

{
    LOS_RecordLR(node->linkReg, LOS_RECORD_LR_CNT, LOS_RECORD_LR_CNT, LOS_OMIT_LR_CNT);
}

函数调用图:

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

OsMemListAdd()

STATIC INLINE VOID OsMemListAdd	(	struct OsMemPoolHead *	pool,
		UINT32	listIndex,
		struct OsMemFreeNodeHead *	node
	)

在文件 los_memory.c 第 769 行定义.

{
    struct OsMemFreeNodeHead *firstNode = pool->freeList[listIndex];
    if (firstNode != NULL) {
        firstNode->prev = node;
    }
    node->prev = NULL;
    node->next = firstNode;
    pool->freeList[listIndex] = node;
    OsMemSetFreeListBit(pool, listIndex);
    node->header.magic = OS_MEM_NODE_MAGIC;
}

函数调用图:

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

OsMemListDelete()

STATIC INLINE VOID OsMemListDelete	(	struct OsMemPoolHead *	pool,
		UINT32	listIndex,
		struct OsMemFreeNodeHead *	node
	)

从空闲链表中删除

在文件 los_memory.c 第 782 行定义.

{
    if (node == pool->freeList[listIndex]) {
        pool->freeList[listIndex] = node->next;
        if (node->next == NULL) {//如果链表空了
            OsMemClearFreeListBit(pool, listIndex);//将位图位 置为 0 
        } else {
            node->next->prev = NULL;
        }
    } else {
        node->prev->next = node->next;
        if (node->next != NULL) {
            node->next->prev = node->prev;
        }
    }
    node->header.magic = OS_MEM_NODE_MAGIC;
}

函数调用图:

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

OsMemLog2()

STATIC INLINE UINT32 OsMemLog2

(

UINT32

size

)

在文件 los_memory.c 第 147 行定义.

{
    return OsMemFLS(size);
}

函数调用图:

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

OsMemMagicCheckPrint()

STATIC INLINE VOID OsMemMagicCheckPrint

(

struct OsMemNodeHead **

tmpNode

)

在文件 los_memory.c 第 1675 行定义.

{
    PRINT_ERR("[%s], %d, memory check error!\n"
              "memory used but magic num wrong, magic num = %#x\n",
              __FUNCTION__, __LINE__, (*tmpNode)->magic);
}

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

OsMemMergeNode()

STATIC INLINE VOID OsMemMergeNode

(

struct OsMemNodeHead *

node

)

合并节点,和前面的节点合并 node 消失

在文件 los_memory.c 第 834 行定义.

{
    struct OsMemNodeHead *nextNode = NULL;
 
    node->ptr.prev->sizeAndFlag += node->sizeAndFlag; //前节点长度变长
    nextNode = (struct OsMemNodeHead *)((UINTPTR)node + node->sizeAndFlag); // 下一个节点位置
    if (!OS_MEM_NODE_GET_LAST_FLAG(nextNode->sizeAndFlag)) {//不是哨兵节点
        nextNode->ptr.prev = node->ptr.prev;//后一个节点的前节点变成前前节点
    }
}

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

OsMemMergeNodeForReAllocBigger()

STATIC INLINE VOID OsMemMergeNodeForReAllocBigger	(	VOID *	pool,
		UINT32	allocSize,
		struct OsMemNodeHead *	node,
		UINT32	nodeSize,
		struct OsMemNodeHead *	nextNode
	)

在文件 los_memory.c 第 1432 行定义.

{
    node->sizeAndFlag = nodeSize;
    OsMemFreeNodeDelete(pool, (struct OsMemFreeNodeHead *)nextNode);
    OsMemMergeNode(nextNode);
#ifdef LOSCFG_KERNEL_LMS
    OsLmsReallocMergeNodeMark(node);
#endif
    if ((allocSize + OS_MEM_NODE_HEAD_SIZE + OS_MEM_MIN_ALLOC_SIZE) <= node->sizeAndFlag) {
        OsMemSplitNode(pool, node, allocSize);
#ifdef LOSCFG_KERNEL_LMS
        OsLmsReallocSplitNodeMark(node);
    } else {
        OsLmsReallocResizeMark(node, allocSize);
#endif
    }
    OS_MEM_NODE_SET_USED_FLAG(node->sizeAndFlag);
    OsMemWaterUsedRecord((struct OsMemPoolHead *)pool, node->sizeAndFlag - nodeSize);
#ifdef LOSCFG_MEM_LEAKCHECK
    OsMemLinkRegisterRecord(node);
#endif
}

函数调用图:

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

OsMemNodeBacktraceInfo()

STATIC VOID OsMemNodeBacktraceInfo	(	const struct OsMemNodeHead *	tmpNode,
		const struct OsMemNodeHead *	preNode
	)

在文件 los_memory.c 第 659 行定义.

{
    int i;
    PRINTK("\n broken node head LR info: \n");
    for (i = 0; i < LOS_RECORD_LR_CNT; i++) {
        PRINTK(" LR[%d]:%#x\n", i, tmpNode->linkReg[i]);
    }
 
    PRINTK("\n pre node head LR info: \n");
    for (i = 0; i < LOS_RECORD_LR_CNT; i++) {
        PRINTK(" LR[%d]:%#x\n", i, preNode->linkReg[i]);
    }
}

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

OsMemNodeInfo()

STATIC VOID OsMemNodeInfo	(	const struct OsMemNodeHead *	tmpNode,
		const struct OsMemNodeHead *	preNode
	)

在文件 los_memory.c 第 1806 行定义.

{
    struct OsMemUsedNodeHead *usedNode = NULL;
    struct OsMemFreeNodeHead *freeNode = NULL;
 
    if (tmpNode == preNode) {
        PRINTK("\n the broken node is the first node\n");
    }
 
    if (OS_MEM_NODE_GET_USED_FLAG(tmpNode->sizeAndFlag)) {
        usedNode = (struct OsMemUsedNodeHead *)tmpNode;
        PRINTK("\n broken node head: %#x  %#x  %#x, ",
               usedNode->header.ptr.prev, usedNode->header.magic, usedNode->header.sizeAndFlag);
    } else {
        freeNode = (struct OsMemFreeNodeHead *)tmpNode;
        PRINTK("\n broken node head: %#x  %#x  %#x  %#x, %#x",
               freeNode->header.ptr.prev, freeNode->next, freeNode->prev, freeNode->header.magic,
               freeNode->header.sizeAndFlag);
    }
 
    if (OS_MEM_NODE_GET_USED_FLAG(preNode->sizeAndFlag)) {
        usedNode = (struct OsMemUsedNodeHead *)preNode;
        PRINTK("prev node head: %#x  %#x  %#x\n",
               usedNode->header.ptr.prev, usedNode->header.magic, usedNode->header.sizeAndFlag);
    } else {
        freeNode = (struct OsMemFreeNodeHead *)preNode;
        PRINTK("prev node head: %#x  %#x  %#x  %#x, %#x",
               freeNode->header.ptr.prev, freeNode->next, freeNode->prev, freeNode->header.magic,
               freeNode->header.sizeAndFlag);
    }
 
#ifdef LOSCFG_MEM_LEAKCHECK
    OsMemNodeBacktraceInfo(tmpNode, preNode);
#endif
 
    PRINTK("\n---------------------------------------------\n");
    PRINTK(" dump mem tmpNode:%#x ~ %#x\n", tmpNode, ((UINTPTR)tmpNode + OS_MEM_NODE_DUMP_SIZE));
    OsDumpMemByte(OS_MEM_NODE_DUMP_SIZE, (UINTPTR)tmpNode);
    PRINTK("\n---------------------------------------------\n");
    if (preNode != tmpNode) {
        PRINTK(" dump mem :%#x ~ tmpNode:%#x\n", ((UINTPTR)tmpNode - OS_MEM_NODE_DUMP_SIZE), tmpNode);
        OsDumpMemByte(OS_MEM_NODE_DUMP_SIZE, ((UINTPTR)tmpNode - OS_MEM_NODE_DUMP_SIZE));
        PRINTK("\n---------------------------------------------\n");
    }
}

函数调用图:

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

OsMemNodeSetTaskID()

STATIC INLINE VOID OsMemNodeSetTaskID

(

struct OsMemUsedNodeHead *

node

)

在文件 los_memory.c 第 275 行定义.

{
    node->taskID = LOS_CurTaskIDGet();//将当前任务ID绑定到内存池节点上
}

函数调用图:

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

OsMemNotEmptyIndexGet()

STATIC INLINE UINT32 OsMemNotEmptyIndexGet	(	struct OsMemPoolHead *	poolHead,
		UINT32	index
	)

在文件 los_memory.c 第 701 行定义.

{
    UINT32 mask;
 
    mask = poolHead->freeListBitmap[BITMAP_INDEX(index)];
    mask &= ~((1 << (index & OS_MEM_BITMAP_MASK)) - 1);
    if (mask != 0) {
        index = OsMemFFS(mask) + (index & ~OS_MEM_BITMAP_MASK);
        return index;
    }
 
    return OS_MEM_FREE_LIST_COUNT;
}

函数调用图:

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

OsMemPoolAdd()

STATIC UINT32 OsMemPoolAdd	(	VOID *	pool,
		UINT32	size
	)

新增内存池

在文件 los_memory.c 第 954 行定义.

{
    VOID *nextPool = g_poolHead;
    VOID *curPool = g_poolHead;
    UINTPTR poolEnd;
    while (nextPool != NULL) {//单链表遍历方式
        poolEnd = (UINTPTR)nextPool + LOS_MemPoolSizeGet(nextPool);
        if (((pool <= nextPool) && (((UINTPTR)pool + size) > (UINTPTR)nextPool)) ||
            (((UINTPTR)pool < poolEnd) && (((UINTPTR)pool + size) >= poolEnd))) {
            PRINT_ERR("pool [%#x, %#x) conflict with pool [%#x, %#x)\n",
                      pool, (UINTPTR)pool + size,
                      nextPool, (UINTPTR)nextPool + LOS_MemPoolSizeGet(nextPool));
            return LOS_NOK;
        }
        curPool = nextPool;
        nextPool = ((struct OsMemPoolHead *)nextPool)->nextPool;
    }
 
    if (g_poolHead == NULL) {
        g_poolHead = pool; //首个内存池
    } else {
        ((struct OsMemPoolHead *)curPool)->nextPool = pool; //两池扯上关系
    }
 
    ((struct OsMemPoolHead *)pool)->nextPool = NULL; //新池下一个无所指
    return LOS_OK;
}

函数调用图:

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

OsMemPoolDeinit()

STATIC VOID OsMemPoolDeinit

(

VOID *

pool

)

在文件 los_memory.c 第 949 行定义.

{
    (VOID)memset(pool, 0, sizeof(struct OsMemPoolHead));
}

函数调用图:

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

OsMemPoolDelete()

STATIC UINT32 OsMemPoolDelete

(

VOID *

pool

)

删除内存池

在文件 los_memory.c 第 982 行定义.

{
    UINT32 ret = LOS_NOK;
    VOID *nextPool = NULL;
    VOID *curPool = NULL;
 
    do {
        if (pool == g_poolHead) {
            g_poolHead = ((struct OsMemPoolHead *)g_poolHead)->nextPool;
            ret = LOS_OK;
            break;
        }
 
        curPool = g_poolHead;
        nextPool = g_poolHead;
        while (nextPool != NULL) {
            if (pool == nextPool) {
                ((struct OsMemPoolHead *)curPool)->nextPool = ((struct OsMemPoolHead *)nextPool)->nextPool;
                ret = LOS_OK;
                break;
            }
            curPool = nextPool;
            nextPool = ((struct OsMemPoolHead *)nextPool)->nextPool;
        }
    } while (0);
 
    return ret;
}

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

OsMemPoolExpand()

STATIC INLINE INT32 OsMemPoolExpand	(	VOID *	pool,
		UINT32	allocSize,
		UINT32	intSave
	)

扩展内存池

允许指定内存池扩展

在文件 los_memory.c 第 478 行定义.

函数调用图:

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

OsMemPoolExpandSub()

STATIC INLINE INT32 OsMemPoolExpandSub	(	VOID *	pool,
		UINT32	size,
		UINT32	intSave
	)

内存池扩展实现

在文件 los_memory.c 第 428 行定义.

{
    UINT32 tryCount = MAX_SHRINK_PAGECACHE_TRY;
    struct OsMemPoolHead *poolInfo = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *newNode = NULL;
    struct OsMemNodeHead *endNode = NULL;
 
    size = ROUNDUP(size + OS_MEM_NODE_HEAD_SIZE, PAGE_SIZE);//圆整
    endNode = OS_MEM_END_NODE(pool, poolInfo->info.totalSize);//获取哨兵节点
 
RETRY:
    newNode = (struct OsMemNodeHead *)LOS_PhysPagesAllocContiguous(size >> PAGE_SHIFT);//申请新的内存池 | 物理内存
    if (newNode == NULL) {
        if (tryCount > 0) {
            tryCount--;
            MEM_UNLOCK(poolInfo, intSave);
            OsTryShrinkMemory(size >> PAGE_SHIFT);
            MEM_LOCK(poolInfo, intSave);
            goto RETRY;
        }
 
        PRINT_ERR("OsMemPoolExpand alloc failed size = %u\n", size);
        return -1;
    }
#ifdef LOSCFG_KERNEL_LMS
    UINT32 resize = 0;
    if (g_lms != NULL) {
        /*
         * resize == 0, shadow memory init failed, no shadow memory for this pool, set poolSize as original size.
         * resize != 0, shadow memory init successful, set poolSize as resize.
         */
        resize = g_lms->init(newNode, size);
        size = (resize == 0) ? size : resize;
    }
#endif
    newNode->sizeAndFlag = (size - OS_MEM_NODE_HEAD_SIZE);//设置新节点大小
    newNode->ptr.prev = OS_MEM_END_NODE(newNode, size);//新节点的前节点指向新节点的哨兵节点
    OsMemSentinelNodeSet(endNode, newNode, size);//设置老内存池的哨兵节点信息,其实就是指向新内存块
    OsMemFreeNodeAdd(pool, (struct OsMemFreeNodeHead *)newNode);//将新节点加入空闲链表
 
    endNode = OS_MEM_END_NODE(newNode, size);//获取新节点的哨兵节点
    (VOID)memset(endNode, 0, sizeof(*endNode));//清空内存
    endNode->ptr.next = NULL;//新哨兵节点没有后续指向,因为它已成为最后
    endNode->magic = OS_MEM_NODE_MAGIC;//设置新哨兵节的魔法数字
    OsMemSentinelNodeSet(endNode, NULL, 0); //设置新哨兵节点内容
    OsMemWaterUsedRecord(poolInfo, OS_MEM_NODE_HEAD_SIZE);//更新内存池警戒线
 
    return 0;
}

函数调用图:

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

OsMemPoolHeadCheck()

STATIC VOID OsMemPoolHeadCheck

(

const struct OsMemPoolHead *

pool

)

在文件 los_memory.c 第 1735 行定义.

{
    struct OsMemFreeNodeHead *tmpNode = NULL;
    UINT32 index;
    UINT32 flag = 0;
 
    if ((pool->info.pool != pool) || !OS_MEM_IS_ALIGNED(pool, sizeof(VOID *))) {
        PRINT_ERR("wrong mem pool addr: %#x, func:%s, line:%d\n", pool, __FUNCTION__, __LINE__);
        return;
    }
 
    for (index = 0; index < OS_MEM_FREE_LIST_COUNT; index++) {
        for (tmpNode = pool->freeList[index]; tmpNode != NULL; tmpNode = tmpNode->next) {
            if (OsMemFreeListNodeCheck(pool, tmpNode)) {
                flag = 1;
                PRINT_ERR("FreeListIndex: %u, node: %#x, bNode: %#x, prev: %#x, next: %#x\n",
                          index, tmpNode, tmpNode->header.ptr.prev, tmpNode->prev, tmpNode->next);
                goto OUT;
            }
        }
    }
 
OUT:
    if (flag) {
        PRINTK("mem pool info: poolAddr: %#x, poolSize: 0x%x\n", pool, pool->info.totalSize);
#ifdef LOSCFG_MEM_WATERLINE
        PRINTK("mem pool info: poolWaterLine: 0x%x, poolCurUsedSize: 0x%x\n", pool->info.waterLine,
               pool->info.curUsedSize);
#endif
#if OS_MEM_EXPAND_ENABLE
        UINT32 size;
        struct OsMemNodeHead *node = NULL;
        struct OsMemNodeHead *sentinel = OS_MEM_END_NODE(pool, pool->info.totalSize);
        while (OsMemIsLastSentinelNode(sentinel) == FALSE) {
            size = OS_MEM_NODE_GET_SIZE(sentinel->sizeAndFlag);
            node = OsMemSentinelNodeGet(sentinel);
            sentinel = OS_MEM_END_NODE(node, size);
            PRINTK("expand node info: nodeAddr: %#x, nodeSize: 0x%x\n", node, size);
        }
#endif
    }
}

函数调用图:

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

OsMemPoolInit()

STATIC UINT32 OsMemPoolInit	(	VOID *	pool,
		UINT32	size
	)

OsMemPoolInit 内存池初始化 内存池节点部分包含3种类型节点：未使用空闲内存节点(OsMemFreeNodeHead)，已使用内存节点(OsMemUsedNodeHead) 和 尾节点(OsMemNodeHead)。
每个内存节点维护一个前序指针，指向内存池中上一个内存节点，还维护内存节点的大小和使用标记。
空闲内存节点和已使用内存节点后面的内存区域是数据域

参数

pool
size

返回

参见

在文件 los_memory.c 第 894 行定义.

{
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *newNode = NULL;
    struct OsMemNodeHead *endNode = NULL;
#ifdef LOSCFG_KERNEL_LMS
    UINT32 resize = 0;
    if (g_lms != NULL) {
        /*
         * resize == 0, shadow memory init failed, no shadow memory for this pool, set poolSize as original size.
         * resize != 0, shadow memory init successful, set poolSize as resize.
         */
        resize = g_lms->init(pool, size);
        size = (resize == 0) ? size : resize;
    }
#endif
    (VOID)memset(poolHead, 0, sizeof(struct OsMemPoolHead));
 
    LOS_SpinInit(&poolHead->spinlock);
    poolHead->info.pool = pool; //内存池的起始地址,但注意真正的内存并不是从此处分配,它只是用来记录这个内存块的开始位置而已.
    poolHead->info.totalSize = size;//内存池总大小
    poolHead->info.attr = OS_MEM_POOL_LOCK_ENABLE; /* default attr: lock, not expand. | 默认是上锁,不支持扩展,需扩展得另外设置*/
 
    newNode = OS_MEM_FIRST_NODE(pool);//跳到第一个节点位置,即跳过结构体本身位置,真正的分配内存是从newNode开始的.
    newNode->sizeAndFlag = (size - sizeof(struct OsMemPoolHead) - OS_MEM_NODE_HEAD_SIZE);//这才是可供分配给外界使用的总内存块大小,即数据域
    //OS_MEM_NODE_HEAD_SIZE 叫当前使用节点,即指 newNode占用的空间
    newNode->ptr.prev = NULL;//开始是空指向
    newNode->magic = OS_MEM_NODE_MAGIC;//魔法数字 用于标识这是一个 OsMemNodeHead 节点, 魔法数字不能被覆盖,
    OsMemFreeNodeAdd(pool, (struct OsMemFreeNodeHead *)newNode);//添加一个空闲节点,由此有了首个可供分配的空闲节点
 
    /* The last mem node */
    endNode = OS_MEM_END_NODE(pool, size);//确定尾节点位置,尾节点没有数据域
    endNode->magic = OS_MEM_NODE_MAGIC; //填入尾节点的魔法数字
#if OS_MEM_EXPAND_ENABLE //支持扩展
    endNode->ptr.next = NULL;//尾节点没有后继节点
    OsMemSentinelNodeSet(endNode, NULL, 0);//将尾节点设置为哨兵节点
#else
    endNode->sizeAndFlag = 0;//0代表没有数据域
    endNode->ptr.prev = newNode;//前驱指针指向第一个节点
    OS_MEM_NODE_SET_USED_FLAG(endNode->sizeAndFlag);
#endif
#ifdef LOSCFG_MEM_WATERLINE //吃水线开关
    poolHead->info.curUsedSize = sizeof(struct OsMemPoolHead) + OS_MEM_NODE_HEAD_SIZE;//内存池已使用了这么多空间,这些都是存内存池自身数据的空间, 
                                //但此处是否还要算是 endNode ? @note_thinking 
    poolHead->info.waterLine = poolHead->info.curUsedSize; //设置吃水线
#endif
#ifdef LOSCFG_KERNEL_LMS
    if (resize != 0) {
        OsLmsFirstNodeMark(pool, newNode);
    }
#endif
    return LOS_OK;
}

函数调用图:

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

OsMemRealloc()

STATIC INLINE VOID * OsMemRealloc	(	struct OsMemPoolHead *	pool,
		const VOID *	ptr,
		struct OsMemNodeHead *	node,
		UINT32	size,
		UINT32	intSave
	)

在文件 los_memory.c 第 1477 行定义.

{
    struct OsMemNodeHead *nextNode = NULL;
    UINT32 allocSize = OS_MEM_ALIGN(size + OS_MEM_NODE_HEAD_SIZE, OS_MEM_ALIGN_SIZE);
    UINT32 nodeSize = OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);
    VOID *tmpPtr = NULL;
 
    if (nodeSize >= allocSize) {
        OsMemReAllocSmaller(pool, allocSize, node, nodeSize);
        return (VOID *)ptr;
    }
 
    nextNode = OS_MEM_NEXT_NODE(node);
    if (!OS_MEM_NODE_GET_USED_FLAG(nextNode->sizeAndFlag) &&
        ((nextNode->sizeAndFlag + nodeSize) >= allocSize)) {
        OsMemMergeNodeForReAllocBigger(pool, allocSize, node, nodeSize, nextNode);
        return (VOID *)ptr;
    }
 
    tmpPtr = OsMemAlloc(pool, size, intSave);
    if (tmpPtr != NULL) {
        if (memcpy_s(tmpPtr, size, ptr, (nodeSize - OS_MEM_NODE_HEAD_SIZE)) != EOK) {
            MEM_UNLOCK(pool, intSave);
            (VOID)LOS_MemFree((VOID *)pool, (VOID *)tmpPtr);
            MEM_LOCK(pool, intSave);
            return NULL;
        }
        (VOID)OsMemFree(pool, node);
    }
    return tmpPtr;
}

函数调用图:

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

OsMemReAllocSmaller()

STATIC INLINE VOID OsMemReAllocSmaller	(	VOID *	pool,
		UINT32	allocSize,
		struct OsMemNodeHead *	node,
		UINT32	nodeSize
	)

在文件 los_memory.c 第 1408 行定义.

{
#ifdef LOSCFG_MEM_WATERLINE
    struct OsMemPoolHead *poolInfo = (struct OsMemPoolHead *)pool;
#endif
    node->sizeAndFlag = nodeSize;
    if ((allocSize + OS_MEM_NODE_HEAD_SIZE + OS_MEM_MIN_ALLOC_SIZE) <= nodeSize) {
        OsMemSplitNode(pool, node, allocSize);
        OS_MEM_NODE_SET_USED_FLAG(node->sizeAndFlag);
#ifdef LOSCFG_MEM_WATERLINE
        poolInfo->info.curUsedSize -= nodeSize - allocSize;
#endif
#ifdef LOSCFG_KERNEL_LMS
        OsLmsReallocSplitNodeMark(node);
    } else {
        OsLmsReallocResizeMark(node, allocSize);
#endif
    }
    OS_MEM_NODE_SET_USED_FLAG(node->sizeAndFlag);
#ifdef LOSCFG_MEM_LEAKCHECK
    OsMemLinkRegisterRecord(node);
#endif
}

函数调用图:

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

OsMemSentinelNodeCheck()

STATIC INLINE BOOL OsMemSentinelNodeCheck

(

struct OsMemNodeHead *

sentinelNode

)

检查哨兵节点

在文件 los_memory.c 第 314 行定义.

{
    if (!OS_MEM_NODE_GET_USED_FLAG(sentinelNode->sizeAndFlag)) {
        return FALSE;
    }
 
    if (!OS_MEM_MAGIC_VALID(sentinelNode)) {
        return FALSE;
    }
 
    return TRUE;
}

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

OsMemSentinelNodeGet()

STATIC INLINE VOID * OsMemSentinelNodeGet

(

struct OsMemNodeHead *

node

)

在文件 los_memory.c 第 354 行定义.

{
    return node->ptr.next;
}

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

OsMemSentinelNodeSet()

STATIC INLINE VOID OsMemSentinelNodeSet	(	struct OsMemNodeHead *	sentinelNode,
		VOID *	newNode,
		UINT32	size
	)

设置哨兵节点内容

在文件 los_memory.c 第 342 行定义.

{
    if (sentinelNode->ptr.next != NULL) { //哨兵节点有 逻辑地址不连续的衔接内存块
        sentinelNode = OsMemLastSentinelNodeGet(sentinelNode);//更新哨兵节点内容
    }
 
    sentinelNode->sizeAndFlag = size;
    sentinelNode->ptr.next = newNode;
    OS_MEM_NODE_SET_USED_FLAG(sentinelNode->sizeAndFlag);
    OS_MEM_NODE_SET_LAST_FLAG(sentinelNode->sizeAndFlag);
}

函数调用图:

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

OsMemSetFreeListBit()

STATIC INLINE VOID OsMemSetFreeListBit	(	struct OsMemPoolHead *	head,
		UINT32	index
	)

在文件 los_memory.c 第 759 行定义.

{
    head->freeListBitmap[BITMAP_INDEX(index)] |= 1U << (index & 0x1f);
}

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

OsMemSlGet()

STATIC INLINE UINT32 OsMemSlGet	(	UINT32	size,
		UINT32	fl
	)

在文件 los_memory.c 第 162 行定义.

{
    return (((size << OS_MEM_SLI) >> fl) - OS_MEM_FREE_LIST_NUM);
}

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

OsMemSplitNode()

STATIC INLINE VOID OsMemSplitNode	(	VOID *	pool,
		struct OsMemNodeHead *	allocNode,
		UINT32	allocSize
	)

切割节点

在文件 los_memory.c 第 845 行定义.

{
    struct OsMemFreeNodeHead *newFreeNode = NULL;
    struct OsMemNodeHead *nextNode = NULL;
 
    newFreeNode = (struct OsMemFreeNodeHead *)(VOID *)((UINT8 *)allocNode + allocSize);//切割后出现的新空闲节点,在分配节点的右侧
    newFreeNode->header.ptr.prev = allocNode;//新节点指向前节点,说明是从左到右切割
    newFreeNode->header.sizeAndFlag = allocNode->sizeAndFlag - allocSize;//新空闲节点大小
    allocNode->sizeAndFlag = allocSize;//分配节点大小
    nextNode = OS_MEM_NEXT_NODE(&newFreeNode->header);//获取新节点的下一个节点
    if (!OS_MEM_NODE_GET_LAST_FLAG(nextNode->sizeAndFlag)) {//如果下一个节点不是哨兵节点(末尾节点)
        nextNode->ptr.prev = &newFreeNode->header;//下一个节点的前节点为新空闲节点
        if (!OS_MEM_NODE_GET_USED_FLAG(nextNode->sizeAndFlag)) {//如果下一个节点也是空闲的
            OsMemFreeNodeDelete(pool, (struct OsMemFreeNodeHead *)nextNode);//删除下一个节点信息
            OsMemMergeNode(nextNode);//下一个节点和新空闲节点 合并成一个新节点
        }
    }
 
    OsMemFreeNodeAdd(pool, newFreeNode);//挂入空闲链表
}

函数调用图:

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

OsMemUsedNodePrint()

STATIC INLINE VOID OsMemUsedNodePrint

(

struct OsMemNodeHead *

node

)

在文件 los_memory.c 第 580 行定义.

{
    UINT32 count;
 
    if (OS_MEM_NODE_GET_USED_FLAG(node->sizeAndFlag)) {
#ifdef __LP64__
        PRINTK("0x%018x: ", node);
#else
        PRINTK("0x%010x: ", node);
#endif
        for (count = 0; count < LOS_RECORD_LR_CNT; count++) {
#ifdef __LP64__
            PRINTK(" 0x%018x ", node->linkReg[count]);
#else
            PRINTK(" 0x%010x ", node->linkReg[count]);
#endif
        }
        PRINTK("\n");
    }
}

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

OsMemUsedNodeShow()

VOID OsMemUsedNodeShow

(

VOID *

pool

)

打印已使用的节点

在文件 los_memory.c 第 601 行定义.

{
    if (pool == NULL) {
        PRINTK("input param is NULL\n");
        return;
    }
    if (LOS_MemIntegrityCheck(pool)) {
        PRINTK("LOS_MemIntegrityCheck error\n");
        return;
    }
    struct OsMemPoolHead *poolInfo = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemNodeHead *endNode = NULL;
    UINT32 size;
    UINT32 intSave;
    UINT32 count;
 
#ifdef __LP64__
    PRINTK("\n\rnode                ");
#else
    PRINTK("\n\rnode        ");
#endif
    for (count = 0; count < LOS_RECORD_LR_CNT; count++) {
#ifdef __LP64__
        PRINTK("        LR[%u]       ", count);
#else
        PRINTK("    LR[%u]   ", count);
#endif
    }
    PRINTK("\n");
 
    MEM_LOCK(poolInfo, intSave);
    endNode = OS_MEM_END_NODE(pool, poolInfo->info.totalSize);
#if OS_MEM_EXPAND_ENABLE
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode <= endNode;
         tmpNode = OS_MEM_NEXT_NODE(tmpNode)) {
        if (tmpNode == endNode) {
            if (OsMemIsLastSentinelNode(endNode) == FALSE) {
                size = OS_MEM_NODE_GET_SIZE(endNode->sizeAndFlag);
                tmpNode = OsMemSentinelNodeGet(endNode);
                endNode = OS_MEM_END_NODE(tmpNode, size);
                continue;
            } else {
                break;
            }
        } else {
            OsMemUsedNodePrint(tmpNode);
        }
    }
#else
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode < endNode;
         tmpNode = OS_MEM_NEXT_NODE(tmpNode)) {
        OsMemUsedNodePrint(tmpNode);
    }
#endif
    MEM_UNLOCK(poolInfo, intSave);
}

函数调用图:

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

OsMemWaterUsedRecord()

STATIC INLINE VOID OsMemWaterUsedRecord	(	struct OsMemPoolHead *	pool,
		UINT32	size
	)

在文件 los_memory.c 第 282 行定义.

{
    pool->info.curUsedSize += size; //延长可使用空间
    if (pool->info.curUsedSize > pool->info.waterLine) {
        pool->info.waterLine = pool->info.curUsedSize; //警戒线加高
    }
}

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

PreSentinelNodeGet()

STATIC INLINE struct OsMemNodeHead * PreSentinelNodeGet	(	const VOID *	pool,
		const struct OsMemNodeHead *	node
	)

在文件 los_memory.c 第 359 行定义.

{
    UINT32 nextSize;
    struct OsMemNodeHead *nextNode = NULL;
    struct OsMemNodeHead *sentinelNode = NULL;
 
    sentinelNode = OS_MEM_END_NODE(pool, ((struct OsMemPoolHead *)pool)->info.totalSize);
    while (sentinelNode != NULL) {
        if (OsMemIsLastSentinelNode(sentinelNode)) {
            PRINT_ERR("PreSentinelNodeGet can not find node %#x\n", node);
            return NULL;
        }
        nextNode = OsMemSentinelNodeGet(sentinelNode);
        if (nextNode == node) {
            return sentinelNode;
        }
        nextSize = OS_MEM_NODE_GET_SIZE(sentinelNode->sizeAndFlag);
        sentinelNode = OS_MEM_END_NODE(nextNode, nextSize);
    }
 
    return NULL;
}

函数调用图:

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

TryShrinkPool()

STATIC INLINE BOOL TryShrinkPool	(	const VOID *	pool,
		const struct OsMemNodeHead *	node
	)

在文件 los_memory.c 第 393 行定义.

{
    struct OsMemNodeHead *mySentinel = NULL;
    struct OsMemNodeHead *preSentinel = NULL;
    size_t totalSize = (UINTPTR)node->ptr.prev - (UINTPTR)node;
    size_t nodeSize = OS_MEM_NODE_GET_SIZE(node->sizeAndFlag);
 
    if (nodeSize != totalSize) {
        return FALSE;
    }
 
    preSentinel = PreSentinelNodeGet(pool, node);
    if (preSentinel == NULL) {
        return FALSE;
    }
 
    mySentinel = node->ptr.prev;
    if (OsMemIsLastSentinelNode(mySentinel)) { /* prev node becomes sentinel node */
        preSentinel->ptr.next = NULL;
        OsMemSentinelNodeSet(preSentinel, NULL, 0);
    } else {
        preSentinel->sizeAndFlag = mySentinel->sizeAndFlag;
        preSentinel->ptr.next = mySentinel->ptr.next;
    }
 
    if (OsMemLargeNodeFree(node) != LOS_OK) {
        PRINT_ERR("TryShrinkPool free %#x failed!\n", node);
        return FALSE;
    }
#ifdef LOSCFG_KERNEL_LMS
    LOS_LmsCheckPoolDel(node);
#endif
    return TRUE;
}

函数调用图:

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

变量说明

g_poolHead

VOID* g_poolHead = NULL

在文件 los_memory.c 第 111 行定义.