Dynamic memory 的协作图:

结构体
struct	LOS_MEM_POOL_STATUS

函数
UINT32	LOS_MemDeInit (VOID *pool)
	Deinitialize dynamic memory. 更多...

UINT32	LOS_MemPoolList (VOID)
	Print infomation about all pools. 更多...

UINT32	LOS_MemInit (VOID *pool, UINT32 size)
	Initialize dynamic memory. 更多...

VOID	LOS_MemExpandEnable (VOID *pool)
	Enable memory pool to support dynamic expansion. 更多...

VOID *	LOS_MemAlloc (VOID *pool, UINT32 size)
	Allocate dynamic memory. 更多...

UINT32	LOS_MemFree (VOID pool, VOID ptr)
	Free dynamic memory. 更多...

VOID *	LOS_MemRealloc (VOID pool, VOID ptr, UINT32 size)
	Re-allocate a memory block. 更多...

VOID *	LOS_MemAllocAlign (VOID *pool, UINT32 size, UINT32 boundary)
	Allocate aligned memory. 更多...

UINT32	LOS_MemPoolSizeGet (const VOID *pool)
	Get the size of memory pool's size. 更多...

UINT32	LOS_MemTotalUsedGet (VOID *pool)
	Get the size of memory totally used. 更多...

UINT32	LOS_MemInfoGet (VOID pool, LOS_MEM_POOL_STATUS poolStatus)
	Get the infomation of memory pool. 更多...

UINT32	LOS_MemFreeNodeShow (VOID *pool)
	Get the number of free node in every size. 更多...

UINT32	LOS_MemIntegrityCheck (const VOID *pool)
	Check the memory pool integrity. 更多...

变量
UINT8 *	m_aucSysMem0
	异常交互动态内存池地址的起始地址，当不支持异常交互特性时，m_aucSysMem0等于m_aucSysMem1。更多...

UINT8 *	m_aucSysMem1
	系统动态内存池地址的起始地址 @note_thinking 能否不要用 0,1来命名核心变量 ??? 更多...

详细描述

函数说明

◆ LOS_MemAlloc()

VOID * LOS_MemAlloc	(	VOID *	pool,
		UINT32	size
	)

Allocate dynamic memory.

Description:

This API is used to allocate a memory block of which the size is specified.

注意

The input pool parameter must be initialized via func LOS_MemInit.
The size of the input parameter size can not be greater than the memory pool size that specified at the second input parameter of LOS_MemInit.
The size of the input parameter size must be four byte-aligned.

参数

pool	[IN] Pointer to the memory pool that contains the memory block to be allocated.
size	[IN] Size of the memory block to be allocated (unit: byte).

返回值

#NULL	The memory fails to be allocated.
#VOID*	The memory is successfully allocated with the starting address of the allocated memory block returned.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: LOS_MemRealloc | LOS_MemAllocAlign | LOS_MemFree

Allocate dynamic memory.

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

{
    if ((pool == NULL) || (size == 0)) {//没提供内存池时
        return (size > 0) ? OsVmBootMemAlloc(size) : NULL;
    }
 
    if (size < OS_MEM_MIN_ALLOC_SIZE) {
        size = OS_MEM_MIN_ALLOC_SIZE;
    }
 
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    VOID *ptr = NULL;
    UINT32 intSave;
 
    do {
        if (OS_MEM_NODE_GET_USED_FLAG(size) || OS_MEM_NODE_GET_ALIGNED_FLAG(size)) {
            break;
        }
        MEM_LOCK(poolHead, intSave);
        ptr = OsMemAlloc(poolHead, size, intSave);//真正的分配内存函数,详细查看 鸿蒙内核源码分析(内存池篇)
        MEM_UNLOCK(poolHead, intSave);
    } while (0);
 
    OsHookCall(LOS_HOOK_TYPE_MEM_ALLOC, pool, ptr, size);//打印日志,到此一游
    return ptr;
}

函数调用图:

◆ LOS_MemAllocAlign()

VOID * LOS_MemAllocAlign	(	VOID *	pool,
		UINT32	size,
		UINT32	boundary
	)

Allocate aligned memory.

Description:

This API is used to allocate memory blocks of specified size and of which the starting addresses are aligned on a specified boundary.

注意

The input pool parameter must be initialized via func LOS_MemInit.
The size of the input parameter size can not be greater than the memory pool size that specified at the second input parameter of LOS_MemInit.
The alignment parameter value must be a power of 2 with the minimum value being 4.

参数

pool	[IN] Pointer to the memory pool that contains the memory blocks to be allocated.
size	[IN] Size of the memory to be allocated.
boundary	[IN] Boundary on which the memory is aligned.

返回值

#NULL	The memory fails to be allocated.
#VOID*	The memory is successfully allocated with the starting address of the allocated memory returned.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: LOS_MemAlloc | LOS_MemRealloc | LOS_MemFree

Allocate aligned memory.

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

{
    UINT32 gapSize;
 
    if ((pool == NULL) || (size == 0) || (boundary == 0) || !OS_MEM_IS_POW_TWO(boundary) ||
        !OS_MEM_IS_ALIGNED(boundary, sizeof(VOID *))) {
        return NULL;
    }
 
    if (size < OS_MEM_MIN_ALLOC_SIZE) {
        size = OS_MEM_MIN_ALLOC_SIZE;
    }
 
    /*
     * sizeof(gapSize) bytes stores offset between alignedPtr and ptr,
     * the ptr has been OS_MEM_ALIGN_SIZE(4 or 8) aligned, so maximum
     * offset between alignedPtr and ptr is boundary - OS_MEM_ALIGN_SIZE
     */
    if ((boundary - sizeof(gapSize)) > ((UINT32)(-1) - size)) {
        return NULL;
    }
 
    UINT32 useSize = (size + boundary) - sizeof(gapSize);
    if (OS_MEM_NODE_GET_USED_FLAG(useSize) || OS_MEM_NODE_GET_ALIGNED_FLAG(useSize)) {
        return NULL;
    }
 
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    UINT32 intSave;
    VOID *ptr = NULL;
    VOID *alignedPtr = NULL;
 
    do {
        MEM_LOCK(poolHead, intSave);
        ptr = OsMemAlloc(pool, useSize, intSave);
        MEM_UNLOCK(poolHead, intSave);
        alignedPtr = (VOID *)OS_MEM_ALIGN(ptr, boundary);
        if (ptr == alignedPtr) {
#ifdef LOSCFG_KERNEL_LMS
            OsLmsAllocAlignMark(ptr, alignedPtr, size);
#endif
            break;
        }
 
        /* store gapSize in address (ptr - 4), it will be checked while free */
        gapSize = (UINT32)((UINTPTR)alignedPtr - (UINTPTR)ptr);
        struct OsMemUsedNodeHead *allocNode = (struct OsMemUsedNodeHead *)ptr - 1;
        OS_MEM_NODE_SET_ALIGNED_FLAG(allocNode->header.sizeAndFlag);
        OS_MEM_NODE_SET_ALIGNED_FLAG(gapSize);
        *(UINT32 *)((UINTPTR)alignedPtr - sizeof(gapSize)) = gapSize;
#ifdef LOSCFG_KERNEL_LMS
        OsLmsAllocAlignMark(ptr, alignedPtr, size);
#endif
        ptr = alignedPtr;
    } while (0);
 
    OsHookCall(LOS_HOOK_TYPE_MEM_ALLOCALIGN, pool, ptr, size, boundary);//打印对齐日志,表示程序曾临幸过此处
    return ptr;
}

函数调用图:

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

◆ LOS_MemDeInit()

UINT32 LOS_MemDeInit ( VOID * pool )

Deinitialize dynamic memory.

Description:

This API is used to deinitialize the dynamic memory of a doubly linked list.

参数

pool	[IN] Starting address of memory.

返回值

#OS_ERROR	The dynamic memory fails to be deinitialized.
#LOS_OK	The dynamic memory is successfully deinitialized.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Deinitialize dynamic memory.

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

{
    if (pool == NULL) {
        return OS_ERROR;
    }
 
    if (OsMemPoolDelete(pool)) {
        return OS_ERROR;
    }
 
    OsMemPoolDeinit(pool);
 
    OsHookCall(LOS_HOOK_TYPE_MEM_DEINIT, pool);
    return LOS_OK;
}

函数调用图:

◆ LOS_MemExpandEnable()

VOID LOS_MemExpandEnable ( VOID * pool )

Enable memory pool to support dynamic expansion.

Description:

This API is used to enable the dynamic memory to expand size dynamically.

注意

The memory pool is default diabled dynamic expansion.

参数

pool	[IN] Starting address of memory.

返回值

node.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

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

{
    if (pool == NULL) {
        return;
    }
 
    ((struct OsMemPoolHead *)pool)->info.attr |= OS_MEM_POOL_EXPAND_ENABLE;
}

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

◆ LOS_MemFree()

UINT32 LOS_MemFree	(	VOID *	pool,
		VOID *	ptr
	)

Free dynamic memory.

Description:: This API is used to free specified dynamic memory that has been allocated.

注意

The input pool parameter must be initialized via func LOS_MemInit.
The input ptr parameter must be allocated by LOS_MemAlloc or LOS_MemAllocAlign or LOS_MemRealloc.

参数

pool	[IN] Pointer to the memory pool that contains the dynamic memory block to be freed.
ptr	[IN] Starting address of the memory block to be freed.

返回值

#LOS_NOK	The memory block fails to be freed because the starting address of the memory block is invalid, or the memory overwriting occurs.
#LOS_OK	The memory block is successfully freed.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: LOS_MemAlloc | LOS_MemRealloc | LOS_MemAllocAlign

Free dynamic memory.

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

{
    UINT32 intSave;
    UINT32 ret = LOS_NOK;
 
    if ((pool == NULL) || (ptr == NULL) || !OS_MEM_IS_ALIGNED(pool, sizeof(VOID *)) ||
        !OS_MEM_IS_ALIGNED(ptr, sizeof(VOID *))) {
        return ret;
    }
    OsHookCall(LOS_HOOK_TYPE_MEM_FREE, pool, ptr);
 
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *node = NULL;
 
    do {
        UINT32 gapSize = *(UINT32 *)((UINTPTR)ptr - sizeof(UINT32));//获取节点大小和标签 即: sizeAndFlag
        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);
            break;
        }
 
        node = (struct OsMemNodeHead *)((UINTPTR)ptr - OS_MEM_NODE_HEAD_SIZE);//定位到节点开始位置
 
        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))) {
                PRINT_ERR("illegal gapSize: 0x%x\n", gapSize);
                break;
            }
            node = (struct OsMemNodeHead *)((UINTPTR)ptr - gapSize - OS_MEM_NODE_HEAD_SIZE);
        }
        MEM_LOCK(poolHead, intSave);
        ret = OsMemFree(poolHead, node);
        MEM_UNLOCK(poolHead, intSave);
    } while (0);
 
    return ret;
}

函数调用图:

◆ LOS_MemFreeNodeShow()

UINT32 LOS_MemFreeNodeShow ( VOID * pool )

Get the number of free node in every size.

Description:

This API is used to get the number of free node in every size.

注意

The input pool parameter must be initialized via func LOS_MemInit.

参数

pool	[IN] A pointer pointed to the memory pool.

返回值

#LOS_NOK	The incoming parameter pool is NULL.
UINT32	The address of the last used node that casts to UINT32.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Get the number of free node in every size.

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

{
    struct OsMemPoolHead *poolInfo = (struct OsMemPoolHead *)pool;
 
    if ((poolInfo == NULL) || ((UINTPTR)pool != (UINTPTR)poolInfo->info.pool)) {
        PRINT_ERR("wrong mem pool addr: %#x, line:%d\n", poolInfo, __LINE__);
        return LOS_NOK;
    }
 
    struct OsMemFreeNodeHead *node = NULL;
    UINT32 countNum[OS_MEM_FREE_LIST_COUNT] = {0};
    UINT32 index;
    UINT32 intSave;
 
    MEM_LOCK(poolInfo, intSave);
    for (index = 0; index < OS_MEM_FREE_LIST_COUNT; index++) {
        node = poolInfo->freeList[index];
        while (node) {
            node = node->next;
            countNum[index]++;
        }
    }
    MEM_UNLOCK(poolInfo, intSave);
 
    PRINTK("\n   ************************ left free node number**********************\n");
    for (index = 0; index < OS_MEM_FREE_LIST_COUNT; index++) {
        if (countNum[index] == 0) {
            continue;
        }
 
        PRINTK("free index: %03u, ", index);
        if (index < OS_MEM_SMALL_BUCKET_COUNT) {
            PRINTK("size: [%#x], num: %u\n", (index + 1) << 2, countNum[index]); /* 2: setup is 4. */
        } else {
            UINT32 val = 1 << (((index - OS_MEM_SMALL_BUCKET_COUNT) >> OS_MEM_SLI) + OS_MEM_LARGE_START_BUCKET);
            UINT32 offset = val >> OS_MEM_SLI;
            PRINTK("size: [%#x, %#x], num: %u\n",
                   (offset * ((index - OS_MEM_SMALL_BUCKET_COUNT) % (1 << OS_MEM_SLI))) + val,
                   ((offset * (((index - OS_MEM_SMALL_BUCKET_COUNT) % (1 << OS_MEM_SLI)) + 1)) + val - 1),
                   countNum[index]);
        }
    }
    PRINTK("\n   ********************************************************************\n\n");
 
    return LOS_OK;
}

◆ LOS_MemInfoGet()

UINT32 LOS_MemInfoGet	(	VOID *	pool,
		LOS_MEM_POOL_STATUS *	poolStatus
	)

Get the infomation of memory pool.

Description:

This API is used to get the infomation of memory pool.

注意

The input pool parameter must be initialized via func LOS_MemInit.

参数

pool	[IN] A pointer pointed to the memory pool.
poolStatus	[IN] A pointer for storage the pool status

返回值

#LOS_NOK	The incoming parameter pool is NULL or invalid.
#LOS_OK	Success to get memory infomation.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Get the infomation of memory pool.

参数

pool
poolStatus

返回

参见

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

{//内存碎片率计算：同样调用LOS_MemInfoGet接口，可以获取内存池的剩余内存大小和最大空闲内存块大小，然后根据公式（fragment=100-最大空闲内存块大小/剩余内存大小）得出此时的动态内存池碎片率。
    struct OsMemPoolHead *poolInfo = pool;
 
    if (poolStatus == NULL) {
        PRINT_ERR("can't use NULL addr to save info\n");
        return LOS_NOK;
    }
 
    if ((pool == NULL) || (poolInfo->info.pool != pool)) {
        PRINT_ERR("wrong mem pool addr: %#x, line:%d\n", poolInfo, __LINE__);
        return LOS_NOK;
    }
 
    (VOID)memset(poolStatus, 0, sizeof(LOS_MEM_POOL_STATUS));
 
    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemNodeHead *endNode = NULL;
    UINT32 intSave;
 
    MEM_LOCK(poolInfo, intSave);
    endNode = OS_MEM_END_NODE(pool, poolInfo->info.totalSize);
#if OS_MEM_EXPAND_ENABLE
    UINT32 size;
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode <= endNode; tmpNode = OS_MEM_NEXT_NODE(tmpNode)) {
        if (tmpNode == endNode) {
            poolStatus->totalUsedSize += OS_MEM_NODE_HEAD_SIZE;
            poolStatus->usedNodeNum++;
            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 {
            OsMemInfoGet(poolInfo, tmpNode, poolStatus);
        }
    }
#else
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode < endNode; tmpNode = OS_MEM_NEXT_NODE(tmpNode)) {
        OsMemInfoGet(poolInfo, tmpNode, poolStatus);
    }
#endif
#ifdef LOSCFG_MEM_WATERLINE
    poolStatus->usageWaterLine = poolInfo->info.waterLine;
#endif
    MEM_UNLOCK(poolInfo, intSave);
 
    return LOS_OK;
}

函数调用图:

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

◆ LOS_MemInit()

UINT32 LOS_MemInit	(	VOID *	pool,
		UINT32	size
	)

Initialize dynamic memory.

Description:

This API is used to initialize the dynamic memory of a doubly linked list.

注意

The size parameter value should match the following two conditions : 1) Be less than or equal to the Memory pool size; 2) Be greater than the size of OS_MEM_MIN_POOL_SIZE.
Call this API when dynamic memory needs to be initialized during the startup of Huawei LiteOS.
The parameter input must be four byte-aligned.
The init area [pool, pool + size] should not conflict with other pools.

参数

pool	[IN] Starting address of memory.
size	[IN] Memory size.

返回值

#OS_ERROR	The dynamic memory fails to be initialized.
#LOS_OK	The dynamic memory is successfully initialized.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Initialize dynamic memory.

参数

pool
size

返回

注意: EndNode作为内存池末尾的节点，size为0。

参见

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

{
    if ((pool == NULL) || (size <= OS_MEM_MIN_POOL_SIZE)) {
        return OS_ERROR;
    }
 
    size = OS_MEM_ALIGN(size, OS_MEM_ALIGN_SIZE);//4个字节对齐
    if (OsMemPoolInit(pool, size)) {
        return OS_ERROR;
    }
 
#ifdef LOSCFG_MEM_MUL_POOL //多内存池开关
    if (OsMemPoolAdd(pool, size)) {
        (VOID)OsMemPoolDeinit(pool);
        return OS_ERROR;
    }
#endif
 
    OsHookCall(LOS_HOOK_TYPE_MEM_INIT, pool, size);//打印日志
    return LOS_OK;
}

函数调用图:

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

◆ LOS_MemIntegrityCheck()

UINT32 LOS_MemIntegrityCheck ( const VOID * pool )

Check the memory pool integrity.

Description:

This API is used to check the memory pool integrity.

注意

The input pool parameter must be initialized via func LOS_MemInit.
LOS_MemIntegrityCheck will be called by malloc function when the macro of LOSCFG_BASE_MEM_NODE_INTEGRITY_CHECK is defined in LiteOS.
LOS_MemIntegrityCheck function can be called by user anytime.

参数

pool	[IN] A pointer pointed to the memory pool.

返回值

#LOS_NOK	The memory pool (pool) is impaired.
#LOS_OK	The memory pool (pool) is integrated.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Check the memory pool integrity.

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

{
    if (pool == NULL) {
        return LOS_NOK;
    }
 
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemNodeHead *preNode = NULL;
    UINT32 intSave = 0;
 
    MEM_LOCK(poolHead, intSave);
    if (OsMemIntegrityCheck(poolHead, &tmpNode, &preNode)) {
        goto ERROR_OUT;
    }
    MEM_UNLOCK(poolHead, intSave);
    return LOS_OK;
 
ERROR_OUT:
    OsMemIntegrityCheckError(poolHead, tmpNode, preNode, intSave);
    return LOS_NOK;
}

函数调用图:

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

◆ LOS_MemPoolList()

UINT32 LOS_MemPoolList ( VOID )

Print infomation about all pools.

Description:

This API is used to print infomation about all pools.

返回值

UINT32 The pool number.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Print infomation about all pools.

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

{
    VOID *nextPool = g_poolHead;
    UINT32 index = 0;
    while (nextPool != NULL) {
        PRINTK("pool%u :\n", index);
        index++;
        OsMemInfoPrint(nextPool);
        nextPool = ((struct OsMemPoolHead *)nextPool)->nextPool;
    }
    return index;
}

函数调用图:

◆ LOS_MemPoolSizeGet()

UINT32 LOS_MemPoolSizeGet ( const VOID * pool )

Get the size of memory pool's size.

Description:

This API is used to get the size of memory pool' total size.

注意

The input pool parameter must be initialized via func LOS_MemInit.

参数

pool	[IN] A pointer pointed to the memory pool.

返回值

#LOS_NOK	The incoming parameter pool is NULL.
UINT32	The size of the memory pool.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Get the size of memory pool's size.

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

{
    UINT32 count = 0;
 
    if (pool == NULL) {
        return LOS_NOK;
    }
 
    count += ((struct OsMemPoolHead *)pool)->info.totalSize; // 这里的 += 好像没必要吧?, = 就可以了, @note_thinking 
 
#if OS_MEM_EXPAND_ENABLE //支持扩展
    UINT32 size;
    struct OsMemNodeHead *node = NULL;
    struct OsMemNodeHead *sentinel = OS_MEM_END_NODE(pool, count);//获取哨兵节点
 
    while (OsMemIsLastSentinelNode(sentinel) == FALSE) {//不是最后一个节点
        size = OS_MEM_NODE_GET_SIZE(sentinel->sizeAndFlag);//数据域大小
        node = OsMemSentinelNodeGet(sentinel);//再获取哨兵节点
        sentinel = OS_MEM_END_NODE(node, size);//获取尾节点
        count += size; //内存池大小变大
    }
#endif
    return count;
}

函数调用图:

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

◆ LOS_MemRealloc()

VOID * LOS_MemRealloc	(	VOID *	pool,
		VOID *	ptr,
		UINT32	size
	)

Re-allocate a memory block.

Description:

This API is used to allocate a new memory block of which the size is specified by size if the original memory block size is insufficient. The new memory block will copy the data in the original memory block of which the address is specified by ptr. The size of the new memory block determines the maximum size of data to be copied. After the new memory block is created, the original one is freed.

注意

The input pool parameter must be initialized via func LOS_MemInit.
The input ptr parameter must be allocated by LOS_MemAlloc or LOS_MemAllocAlign.
The size of the input parameter size can not be greater than the memory pool size that specified at the second input parameter of LOS_MemInit.
The size of the input parameter size must be aligned as follows: 1) if the ptr is allocated by LOS_MemAlloc, it must be four byte-aligned; 2) if the ptr is allocated by LOS_MemAllocAlign, it must be aligned with the size of the input parameter boundary of LOS_MemAllocAlign.

参数

pool	[IN] Pointer to the memory pool that contains the original and new memory blocks.
ptr	[IN] Address of the original memory block.
size	[IN] Size of the new memory block.

返回值

#NULL	The memory fails to be re-allocated.
#VOID*	The memory is successfully re-allocated with the starting address of the new memory block returned.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: LOS_MemAlloc | LOS_MemAllocAlign | LOS_MemFree

Re-allocate a memory block.

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

{
    if ((pool == NULL) || OS_MEM_NODE_GET_USED_FLAG(size) || OS_MEM_NODE_GET_ALIGNED_FLAG(size)) {
        return NULL;
    }
    OsHookCall(LOS_HOOK_TYPE_MEM_REALLOC, pool, ptr, size);
    if (size < OS_MEM_MIN_ALLOC_SIZE) {
        size = OS_MEM_MIN_ALLOC_SIZE;
    }
 
    if (ptr == NULL) {
        return LOS_MemAlloc(pool, size);
    }
 
    if (size == 0) {
        (VOID)LOS_MemFree(pool, ptr);
        return NULL;
    }
 
    struct OsMemPoolHead *poolHead = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *node = NULL;
    VOID *newPtr = NULL;
    UINT32 intSave;
 
    MEM_LOCK(poolHead, intSave);
    do {
        ptr = OsGetRealPtr(pool, ptr);
        if (ptr == NULL) {
            break;
        }
 
        node = (struct OsMemNodeHead *)((UINTPTR)ptr - OS_MEM_NODE_HEAD_SIZE);
        if (OsMemCheckUsedNode(pool, node) != LOS_OK) {
            break;
        }
 
        newPtr = OsMemRealloc(pool, ptr, node, size, intSave);
    } while (0);
    MEM_UNLOCK(poolHead, intSave);
 
    return newPtr;
}

函数调用图:

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

◆ LOS_MemTotalUsedGet()

UINT32 LOS_MemTotalUsedGet ( VOID * pool )

Get the size of memory totally used.

Description:

This API is used to get the size of memory totally used in memory pool.

注意

The input pool parameter must be initialized via func LOS_MemInit.

参数

pool	[IN] A pointer pointed to the memory pool.

返回值

#LOS_NOK	The incoming parameter pool is NULL.
UINT32	The size of the memory pool used.

Dependency:

los_memory.h: the header file that contains the API declaration.

参见: None.

Get the size of memory totally used.

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

{
    struct OsMemNodeHead *tmpNode = NULL;
    struct OsMemPoolHead *poolInfo = (struct OsMemPoolHead *)pool;
    struct OsMemNodeHead *endNode = NULL;
    UINT32 memUsed = 0;
    UINT32 intSave;
 
    if (pool == NULL) {
        return LOS_NOK;
    }
 
    MEM_LOCK(poolInfo, intSave);
    endNode = OS_MEM_END_NODE(pool, poolInfo->info.totalSize);
#if OS_MEM_EXPAND_ENABLE
    UINT32 size;
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode <= endNode;) {
        if (tmpNode == endNode) {
            memUsed += OS_MEM_NODE_HEAD_SIZE;
            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)) {
                memUsed += OS_MEM_NODE_GET_SIZE(tmpNode->sizeAndFlag);
            }
            tmpNode = OS_MEM_NEXT_NODE(tmpNode);
        }
    }
#else
    for (tmpNode = OS_MEM_FIRST_NODE(pool); tmpNode < endNode;) {
        if (OS_MEM_NODE_GET_USED_FLAG(tmpNode->sizeAndFlag)) {
            memUsed += OS_MEM_NODE_GET_SIZE(tmpNode->sizeAndFlag);
        }
        tmpNode = OS_MEM_NEXT_NODE(tmpNode);
    }
#endif
    MEM_UNLOCK(poolInfo, intSave);
 
    return memUsed;
}

函数调用图:

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

变量说明

◆ m_aucSysMem0

UINT8* m_aucSysMem0

extern

异常交互动态内存池地址的起始地址，当不支持异常交互特性时，m_aucSysMem0等于m_aucSysMem1。

The start address of exc interaction dynamic memory pool address, when the exc interaction feature not support, m_aucSysMem0 equals to m_aucSysMem1.

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

◆ m_aucSysMem1

UINT8* m_aucSysMem1

extern

系统动态内存池地址的起始地址 @note_thinking 能否不要用 0,1来命名核心变量 ???

The start address of system dynamic memory pool address.

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

结构体

函数

变量

详细描述

函数说明

◆ LOS_MemAlloc()

◆ LOS_MemAllocAlign()

◆ LOS_MemDeInit()

◆ LOS_MemExpandEnable()

◆ LOS_MemFree()

◆ LOS_MemFreeNodeShow()

◆ LOS_MemInfoGet()

◆ LOS_MemInit()

◆ LOS_MemIntegrityCheck()

◆ LOS_MemPoolList()

◆ LOS_MemPoolSizeGet()

◆ LOS_MemRealloc()

◆ LOS_MemTotalUsedGet()

变量说明

◆ m_aucSysMem0

◆ m_aucSysMem1