update openharmony 1.0.1
This commit is contained in:
mamingshuai
File diff suppressed because it is too large
Load Diff
@@ -1,74 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_multipledlinkhead_pri.h"
|
||||
#include "los_bitmap.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
STATIC INLINE UINT32 OsLog2(UINT32 size)
|
||||
{
|
||||
return (size > 0) ? (UINT32)LOS_HighBitGet(size) : 0;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_INIT VOID OsDLnkInitMultiHead(VOID *headAddr)
|
||||
{
|
||||
LosMultipleDlinkHead *dlinkHead = (LosMultipleDlinkHead *)headAddr;
|
||||
LOS_DL_LIST *listNodeHead = dlinkHead->listHead;
|
||||
UINT32 index;
|
||||
|
||||
for (index = 0; index < OS_MULTI_DLNK_NUM; ++index, ++listNodeHead) {
|
||||
LOS_ListInit(listNodeHead);
|
||||
}
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_MINOR LOS_DL_LIST *OsDLnkMultiHead(VOID *headAddr, UINT32 size)
|
||||
{
|
||||
LosMultipleDlinkHead *dlinkHead = (LosMultipleDlinkHead *)headAddr;
|
||||
UINT32 index = OsLog2(size);
|
||||
if (index > OS_MAX_MULTI_DLNK_LOG2) {
|
||||
return NULL;
|
||||
} else if (index <= OS_MIN_MULTI_DLNK_LOG2) {
|
||||
index = OS_MIN_MULTI_DLNK_LOG2;
|
||||
}
|
||||
|
||||
return dlinkHead->listHead + (index - OS_MIN_MULTI_DLNK_LOG2);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
@@ -1,424 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "string.h"
|
||||
#include "securec.h"
|
||||
#include "los_hwi.h"
|
||||
#include "los_typedef.h"
|
||||
#include "los_heap_pri.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
static UINT32 g_memAllocCount = 0;
|
||||
static UINT32 g_memFreeCount = 0;
|
||||
|
||||
#if (LOSCFG_HEAP_MEMORY_PEAK_STATISTICS == YES)
|
||||
static UINT32 g_memCurHeapUsed = 0;
|
||||
static UINT32 g_memMaxHeapUsed = 0;
|
||||
#endif
|
||||
|
||||
#define HEAP_CAST(t, exp) ((t)(exp))
|
||||
#define HEAP_ALIGN 4
|
||||
#define HEAP_TAIL_NODE_SIZE_THRESHOLD 1024
|
||||
|
||||
/*
|
||||
* Description : look up the next memory node according to one memory node in the memory block list.
|
||||
* Input : struct LosHeapManager *heapMan --- Pointer to the manager,to distinguish heap
|
||||
* struct LosHeapNode *node --- Size of memory in bytes to allocate
|
||||
* Return : Pointer to next memory node
|
||||
*/
|
||||
struct LosHeapNode* OsHeapPrvGetNext(struct LosHeapManager *heapMan, struct LosHeapNode *node)
|
||||
{
|
||||
return (heapMan->tail == node) ? NULL : (struct LosHeapNode *)(UINTPTR)(node->data + node->size);
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : To initialize the heap memory and get the begin address and size of heap memory,
|
||||
* then initialize LosHeapManager.
|
||||
* Input : VOID *pool --- begin address of the heap memory pool
|
||||
* UITN32 size --- size of the heap memory pool
|
||||
* Return : 1:success 0:error
|
||||
*/
|
||||
BOOL OsHeapInit(VOID *pool, UINT32 size)
|
||||
{
|
||||
struct LosHeapNode *node = NULL;
|
||||
struct LosHeapManager *heapMan = HEAP_CAST(struct LosHeapManager *, pool);
|
||||
|
||||
if ((heapMan == NULL) || (size <= (sizeof(struct LosHeapNode) + sizeof(struct LosHeapManager)))) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// Ignore the return code when matching CSEC rule 6.6(2).
|
||||
(VOID)memset_s(pool, size, 0, size);
|
||||
|
||||
heapMan->size = size;
|
||||
|
||||
node = heapMan->head = (struct LosHeapNode *)((UINT8*)pool + sizeof(struct LosHeapManager));
|
||||
|
||||
heapMan->tail = node;
|
||||
|
||||
node->used = 0;
|
||||
node->prev = NULL;
|
||||
node->size = size - sizeof(struct LosHeapNode) - sizeof(struct LosHeapManager);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : update used size
|
||||
* Input : size --- alloc memory size
|
||||
* ret --- memory chunk
|
||||
*/
|
||||
VOID OsHeapUpdateUsedSize(UINT32 size, VOID *ret)
|
||||
{
|
||||
#if (LOSCFG_HEAP_MEMORY_PEAK_STATISTICS == YES)
|
||||
g_memCurHeapUsed += (size + sizeof(struct LosHeapNode));
|
||||
if (g_memCurHeapUsed > g_memMaxHeapUsed) {
|
||||
g_memMaxHeapUsed = g_memCurHeapUsed;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ret != NULL) {
|
||||
g_memAllocCount++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : To alloc memory block from the heap memory poll
|
||||
* Input : VOID *pool --- Pointer to the manager,to distinguish heap
|
||||
* UINT32 size --- size of the heap memory pool
|
||||
* Return : NULL:error, other value:the address of the memory we alloced
|
||||
*/
|
||||
VOID* OsHeapAlloc(VOID *pool, UINT32 size)
|
||||
{
|
||||
struct LosHeapNode *node = NULL;
|
||||
struct LosHeapNode *next = NULL;
|
||||
struct LosHeapNode *best = NULL;
|
||||
VOID *ret = NULL;
|
||||
UINT32 alignSize = ALIGNE(size);
|
||||
|
||||
struct LosHeapManager *heapMan = HEAP_CAST(struct LosHeapManager *, pool);
|
||||
if (heapMan == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
node = heapMan->tail;
|
||||
while (node != NULL) {
|
||||
if ((node->used == 0) && (node->size >= alignSize) &&
|
||||
((best == NULL) || (best->size > node->size))) {
|
||||
best = node;
|
||||
if (best->size == alignSize) {
|
||||
goto SIZE_MATCH;
|
||||
}
|
||||
}
|
||||
node = node->prev;
|
||||
}
|
||||
|
||||
/* alloc failed */
|
||||
if (best == NULL) {
|
||||
PRINT_ERR("there's not enough whole to alloc %x Bytes!\n", alignSize);
|
||||
goto OUT;
|
||||
}
|
||||
|
||||
if ((best->size - alignSize) > sizeof(struct LosHeapNode)) {
|
||||
/* hole divide into 2 */
|
||||
node = (struct LosHeapNode*)(UINTPTR)(best->data + alignSize);
|
||||
|
||||
node->used = 0;
|
||||
node->size = best->size - alignSize - sizeof(struct LosHeapNode);
|
||||
node->prev = best;
|
||||
|
||||
if (best != heapMan->tail) {
|
||||
next = OsHeapPrvGetNext(heapMan, node);
|
||||
if (next != NULL) {
|
||||
next->prev = node;
|
||||
}
|
||||
} else {
|
||||
heapMan->tail = node;
|
||||
}
|
||||
|
||||
best->size = alignSize;
|
||||
}
|
||||
|
||||
SIZE_MATCH:
|
||||
best->align = 0;
|
||||
best->used = 1;
|
||||
ret = best->data;
|
||||
|
||||
OsHeapUpdateUsedSize(alignSize, ret);
|
||||
OUT:
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : To alloc memory block from the heap memory poll with
|
||||
* Input : VOID *pool --- Pointer to the manager,to distinguish heap
|
||||
* UINT32 size --- size of the heap memory pool
|
||||
* UINT32 boundary --- boundary the heap needs align
|
||||
* Return : NULL:error, other value:the address of the memory we alloced
|
||||
*/
|
||||
VOID* OsHeapAllocAlign(VOID *pool, UINT32 size, UINT32 boundary)
|
||||
{
|
||||
UINT32 useSize;
|
||||
UINT32 gapSize;
|
||||
VOID *ret = NULL;
|
||||
VOID *alignedPtr = NULL;
|
||||
|
||||
if ((pool == NULL) || (size == 0) || (boundary < sizeof(VOID *)) || !IS_ALIGNED(boundary, boundary)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* worst case is that the node happen to be 4 bytes ahead of the boundary */
|
||||
useSize = (size + boundary) - sizeof(VOID*);
|
||||
if (useSize < size) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret = OsHeapAlloc(pool, useSize);
|
||||
if (ret != NULL) {
|
||||
alignedPtr = (VOID *)(UINTPTR)OS_MEM_ALIGN(ret, boundary);
|
||||
if (ret == alignedPtr) {
|
||||
goto OUT;
|
||||
}
|
||||
|
||||
gapSize = (UINTPTR)alignedPtr - (UINTPTR)ret;
|
||||
OS_MEM_SET_ALIGN_FLAG(gapSize);
|
||||
*((UINT32 *)((UINTPTR)alignedPtr - (sizeof(UINTPTR) / sizeof(UINT8)))) = gapSize;
|
||||
|
||||
ret = alignedPtr;
|
||||
}
|
||||
OUT:
|
||||
return ret;
|
||||
}
|
||||
|
||||
STATIC VOID OsDoHeapFree(struct LosHeapManager *heapMan, struct LosHeapNode *curNode)
|
||||
{
|
||||
struct LosHeapNode *node = curNode;
|
||||
struct LosHeapNode *next = NULL;
|
||||
/* set to unused status */
|
||||
node->used = 0;
|
||||
|
||||
#if (LOSCFG_HEAP_MEMORY_PEAK_STATISTICS == YES)
|
||||
if (g_memCurHeapUsed >= (node->size + sizeof(struct LosHeapNode))) {
|
||||
g_memCurHeapUsed -= (node->size + sizeof(struct LosHeapNode));
|
||||
}
|
||||
#endif
|
||||
|
||||
/* unused region before and after combination */
|
||||
while (node->prev && !node->prev->used) {
|
||||
node = node->prev;
|
||||
}
|
||||
|
||||
next = OsHeapPrvGetNext(heapMan, node);
|
||||
while (next != NULL) {
|
||||
if (next->used) {
|
||||
next->prev = node;
|
||||
break;
|
||||
}
|
||||
node->size += sizeof(struct LosHeapNode) + next->size;
|
||||
if (heapMan->tail == next) {
|
||||
heapMan->tail = node;
|
||||
}
|
||||
next = OsHeapPrvGetNext(heapMan, node);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : To free the memory block from heap memory poll
|
||||
* Input : VOID* pool --- Pointer to the manager,to distinguish heap
|
||||
* VOID* ptr --- the pointer of heap memory we want to free
|
||||
* Return : 1:success 0:error
|
||||
*/
|
||||
BOOL OsHeapFree(VOID *pool, VOID *ptr)
|
||||
{
|
||||
struct LosHeapNode *node = NULL;
|
||||
|
||||
UINT32 gapSize;
|
||||
BOOL ret = TRUE;
|
||||
|
||||
struct LosHeapManager *heapMan = HEAP_CAST(struct LosHeapManager *, pool);
|
||||
if ((heapMan == NULL) || (ptr == NULL)) {
|
||||
return LOS_NOK;
|
||||
}
|
||||
|
||||
/* find the real ptr through gap size */
|
||||
gapSize = *((UINT32 *)((UINTPTR)ptr - (sizeof(UINTPTR) / sizeof(UINT8))));
|
||||
if (OS_MEM_GET_ALIGN_FLAG(gapSize)) {
|
||||
gapSize = OS_MEM_GET_ALIGN_GAPSIZE(gapSize);
|
||||
ptr = (VOID *)((UINTPTR)ptr - gapSize);
|
||||
}
|
||||
|
||||
if (((UINTPTR)ptr < (UINTPTR)heapMan->head) ||
|
||||
((UINTPTR)ptr > ((UINTPTR)heapMan->tail + sizeof(struct LosHeapNode)))) {
|
||||
PRINT_ERR("0x%x out of range!\n", (UINTPTR)ptr);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
node = ((struct LosHeapNode *)ptr) - 1;
|
||||
/* check if the address is a node of the heap memory list */
|
||||
if ((node->used == 0) || (!((UINTPTR)node == (UINTPTR)heapMan->head) &&
|
||||
(((UINTPTR)node->prev < (UINTPTR)heapMan->head) ||
|
||||
((UINTPTR)node->prev > ((UINTPTR)heapMan->tail + sizeof(struct LosHeapNode))) ||
|
||||
((UINTPTR)OsHeapPrvGetNext(heapMan, node->prev) != (UINTPTR)node)))) {
|
||||
ret = FALSE;
|
||||
goto OUT;
|
||||
}
|
||||
|
||||
OsDoHeapFree(heapMan, node);
|
||||
|
||||
OUT:
|
||||
if (ret == TRUE) {
|
||||
g_memFreeCount++;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : print heap information
|
||||
* Input : pool --- Pointer to the manager, to distinguish heap
|
||||
*/
|
||||
VOID OsAlarmHeapInfo(VOID *pool)
|
||||
{
|
||||
struct LosHeapManager *heapMan = HEAP_CAST(struct LosHeapManager *, pool);
|
||||
LosHeapStatus status = {0};
|
||||
(VOID)heapMan;
|
||||
|
||||
if (OsHeapStatisticsGet(pool, &status) == LOS_NOK) {
|
||||
return;
|
||||
}
|
||||
|
||||
PRINT_INFO("pool addr pool size used size free size max free alloc Count free Count\n");
|
||||
PRINT_INFO("0x%-8x 0x%-8x 0x%-8x 0x%-8x 0x%-8x 0x%-8x 0x%-8x\n",
|
||||
pool, heapMan->size, status.totalUsedSize, status.totalFreeSize, status.maxFreeNodeSize,
|
||||
status.usedNodeNum, status.freeNodeNum);
|
||||
}
|
||||
|
||||
/*
|
||||
* Description : collect heap statistics
|
||||
* Input : pool --- Pointer to the manager, to distinguish heap
|
||||
* Output : status --- heap statistics
|
||||
* Return : LOS_OK on success or error code on failure
|
||||
*/
|
||||
UINT32 OsHeapStatisticsGet(VOID *pool, LosHeapStatus *status)
|
||||
{
|
||||
UINT32 heapUsed = 0;
|
||||
UINT32 maxFreeNodeSize = 0;
|
||||
UINT32 freeNodeNum = 0;
|
||||
UINT32 usedNodeNum = 0;
|
||||
|
||||
struct LosHeapNode *node = NULL;
|
||||
struct LosHeapManager *ramHeap = HEAP_CAST(struct LosHeapManager *, pool);
|
||||
|
||||
if (ramHeap == NULL) {
|
||||
return LOS_NOK;
|
||||
}
|
||||
|
||||
if (status == NULL) {
|
||||
return LOS_NOK;
|
||||
}
|
||||
|
||||
/* heap mannager header use heap space */
|
||||
heapUsed += sizeof(struct LosHeapManager);
|
||||
|
||||
node = ramHeap->tail;
|
||||
while (node != NULL) {
|
||||
if (node->used) {
|
||||
heapUsed += (node->size + sizeof(struct LosHeapNode));
|
||||
usedNodeNum++;
|
||||
} else {
|
||||
if (node->size > maxFreeNodeSize) {
|
||||
maxFreeNodeSize = node->size;
|
||||
}
|
||||
freeNodeNum++;
|
||||
}
|
||||
node = node->prev;
|
||||
}
|
||||
|
||||
if (ramHeap->size < heapUsed) {
|
||||
return LOS_NOK;
|
||||
}
|
||||
|
||||
status->totalUsedSize = heapUsed;
|
||||
status->maxFreeNodeSize = maxFreeNodeSize;
|
||||
status->totalFreeSize = ramHeap->size - status->totalUsedSize;
|
||||
status->usedNodeNum = usedNodeNum;
|
||||
status->freeNodeNum = freeNodeNum;
|
||||
|
||||
return LOS_OK;
|
||||
}
|
||||
|
||||
#if (LOSCFG_HEAP_MEMORY_PEAK_STATISTICS == YES)
|
||||
UINT32 LOS_HeapGetHeapMemoryPeak(VOID)
|
||||
{
|
||||
return g_memMaxHeapUsed;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Description : get max free block size
|
||||
* Input : pool --- Pointer to the manager, to distinguish heap
|
||||
* Return : max free block size
|
||||
*/
|
||||
UINT32 OsHeapGetMaxFreeBlkSize(VOID *pool)
|
||||
{
|
||||
UINT32 size = 0;
|
||||
UINT32 temp;
|
||||
struct LosHeapNode *node = NULL;
|
||||
struct LosHeapManager *ramHeap = HEAP_CAST(struct LosHeapManager *, pool);
|
||||
|
||||
if (ramHeap == NULL) {
|
||||
return LOS_NOK;
|
||||
}
|
||||
|
||||
node = ramHeap->tail;
|
||||
while (node != NULL) {
|
||||
if (!(node->used)) {
|
||||
temp = node->size;
|
||||
if (temp > size) {
|
||||
size = temp;
|
||||
}
|
||||
}
|
||||
node = node->prev;
|
||||
}
|
||||
return size;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
6
kernel/base/mem/common/los_memstat.c
Normal file → Executable file
6
kernel/base/mem/common/los_memstat.c
Normal file → Executable file
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
@@ -123,4 +123,4 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsTaskSlabUsage(UINT32 taskID)
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
@@ -1,260 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef LOSCFG_MEM_RECORDINFO
|
||||
#include "los_binarytree_pri.h"
|
||||
#include "los_typedef.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
UINT32 OsBinTreeInsert(const VOID *node, UINT32 nodeLen, BinNode **leaf,
|
||||
BinNode *(*GetMyBinNode)(UINT32 *nodeID),
|
||||
INT32 (*CompareNode)(const VOID *node1, const VOID *node2))
|
||||
{
|
||||
UINT32 nodeID;
|
||||
INT32 result;
|
||||
BinNode **currentNode = leaf;
|
||||
|
||||
if (leaf == NULL) {
|
||||
return OS_INVALID;
|
||||
}
|
||||
|
||||
do {
|
||||
if (*currentNode != NULL) {
|
||||
result = CompareNode(node, (const VOID *)(*currentNode));
|
||||
if (result == 0) {
|
||||
return (*currentNode)->nodeID;
|
||||
} else if (result < 0) {
|
||||
currentNode = (BinNode **)(&((*currentNode)->left));
|
||||
} else {
|
||||
currentNode = (BinNode **)(&((*currentNode)->right));
|
||||
}
|
||||
} else {
|
||||
(*currentNode) = GetMyBinNode(&nodeID);
|
||||
if (*currentNode == NULL) {
|
||||
return OS_INVALID;
|
||||
}
|
||||
|
||||
(VOID)memcpy_s((*currentNode)->keyValue, (nodeLen - sizeof(BinNode)),
|
||||
((BinNode *)node)->keyValue, (nodeLen - sizeof(BinNode)));
|
||||
(*currentNode)->nodeID = nodeID;
|
||||
/* initialize the children to NULL */
|
||||
(*currentNode)->left = NULL;
|
||||
(*currentNode)->right = NULL;
|
||||
|
||||
return (*currentNode)->nodeID;
|
||||
}
|
||||
} while (1);
|
||||
}
|
||||
|
||||
/* LRNODE */
|
||||
LinkRegNode g_linkRegNode[LR_COUNT];
|
||||
UINT32 g_linkRegNodeIndex = 0;
|
||||
LinkRegNode *g_linkRegRoot = NULL;
|
||||
INT32 OsCompareLRNode(const VOID *node1, const VOID *node2)
|
||||
{
|
||||
LinkRegNode *linkRegNode1 = (LinkRegNode *)node1;
|
||||
LinkRegNode *linkRegNode2 = (LinkRegNode *)node2;
|
||||
if (linkRegNode1->linkReg1 < linkRegNode2->linkReg1) {
|
||||
return -1;
|
||||
} else if ((linkRegNode1->linkReg1 == linkRegNode2->linkReg1) &&
|
||||
(linkRegNode1->linkReg2 < linkRegNode2->linkReg2)) {
|
||||
return -1;
|
||||
} else if ((linkRegNode1->linkReg1 == linkRegNode2->linkReg1) &&
|
||||
(linkRegNode1->linkReg2 == linkRegNode2->linkReg2) &&
|
||||
(linkRegNode1->linkReg3 < linkRegNode2->linkReg3)) {
|
||||
return -1;
|
||||
} else if ((linkRegNode1->linkReg1 == linkRegNode2->linkReg1) &&
|
||||
(linkRegNode1->linkReg2 == linkRegNode2->linkReg2) &&
|
||||
(linkRegNode1->linkReg3 == linkRegNode2->linkReg3)) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
BinNode *OsGetLRBinNode(UINT32 *nodeID)
|
||||
{
|
||||
if (g_linkRegNodeIndex < LR_COUNT) {
|
||||
*nodeID = g_linkRegNodeIndex;
|
||||
return (BinNode *)(&g_linkRegNode[g_linkRegNodeIndex++]);
|
||||
} else {
|
||||
*nodeID = (UINT32)-1;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* ADDRNODE */
|
||||
AddrNode g_addrNode[ADDR_COUNT];
|
||||
UINT32 g_addrNodeIndex = 0;
|
||||
AddrNode *g_addrRoot = NULL;
|
||||
INT32 OsCompareAddrNode(const VOID *node1, const VOID *node2)
|
||||
{
|
||||
AddrNode *addrNode1 = (AddrNode *)node1;
|
||||
AddrNode *addrNode2 = (AddrNode *)node2;
|
||||
if (addrNode1->addr < addrNode2->addr) {
|
||||
return -1;
|
||||
} else if (addrNode1->addr == addrNode2->addr) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
BinNode *OsGetAddrBinNode(UINT32 *nodeID)
|
||||
{
|
||||
if (g_addrNodeIndex < ADDR_COUNT) {
|
||||
*nodeID = g_addrNodeIndex;
|
||||
return (BinNode *)(&g_addrNode[g_addrNodeIndex++]);
|
||||
} else {
|
||||
*nodeID = (UINT32)-1;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* REQSIZENODE */
|
||||
ReqSizeNode g_reqSizeNode[REQ_SIZE_COUNT];
|
||||
UINT32 g_reqSizeNodeIndex = 0;
|
||||
ReqSizeNode *g_reqSizeRoot = NULL;
|
||||
|
||||
INT32 OsCompareReqSizeNode(const VOID *node1, const VOID *node2)
|
||||
{
|
||||
ReqSizeNode *reqSizeNode1 = (ReqSizeNode *)node1;
|
||||
ReqSizeNode *reqSizeNode2 = (ReqSizeNode *)node2;
|
||||
if (reqSizeNode1->reqSize < reqSizeNode2->reqSize) {
|
||||
return -1;
|
||||
} else if (reqSizeNode1->reqSize == reqSizeNode2->reqSize) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
BinNode *OsGetReqSizeBinNode(UINT32 *nodeID)
|
||||
{
|
||||
if (g_reqSizeNodeIndex < REQ_SIZE_COUNT) {
|
||||
*nodeID = g_reqSizeNodeIndex;
|
||||
return (BinNode *)(&g_reqSizeNode[g_reqSizeNodeIndex++]);
|
||||
} else {
|
||||
*nodeID = (UINT32)-1;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* TASKIDNODE */
|
||||
STATIC TaskIDNode g_taskIDNode[TASK_ID_COUNT];
|
||||
STATIC UINT32 g_taskIDNodeIndex = 0;
|
||||
STATIC TaskIDNode *g_taskIDRoot = NULL;
|
||||
INT32 OsCompareTaskIDNode(const VOID *node1, const VOID *node2)
|
||||
{
|
||||
TaskIDNode *taskIDNode1 = (TaskIDNode *)node1;
|
||||
TaskIDNode *taskIDNode2 = (TaskIDNode *)node2;
|
||||
if (taskIDNode1->taskID < taskIDNode2->taskID) {
|
||||
return -1;
|
||||
} else if (taskIDNode1->taskID == taskIDNode2->taskID) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
BinNode *OsGetTaskIDBinNode(UINT32 *nodeID)
|
||||
{
|
||||
if (g_taskIDNodeIndex < TASK_ID_COUNT) {
|
||||
*nodeID = g_taskIDNodeIndex;
|
||||
return (BinNode *)(&g_taskIDNode[g_taskIDNodeIndex++]);
|
||||
} else {
|
||||
*nodeID = (UINT32)-1;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
#define BINARYTREE_TASKID_COUNT 11
|
||||
#define BINARYTREE_REQSIZE_COUNT 4
|
||||
STATIC const UINT32 g_binaryTreeTaskID[BINARYTREE_TASKID_COUNT] = { 33, 10, 20, 9, 42, 34, 45, 47, 46, 50, 49 };
|
||||
STATIC const UINT32 g_binaryTreeReqSize[BINARYTREE_REQSIZE_COUNT] = { 616, 136, 1708, 1580 };
|
||||
|
||||
VOID OsBinaryTreeInit(VOID)
|
||||
{
|
||||
INT32 index;
|
||||
LinkRegNode linkRegNode;
|
||||
AddrNode node;
|
||||
TaskIDNode taskNode;
|
||||
ReqSizeNode reqNode;
|
||||
UINT32 ret;
|
||||
|
||||
/* equal to the middle address of __text_start and __text_end */
|
||||
linkRegNode.linkReg1 = (UINTPTR)(((&__text_end - &__text_start) / 2) + &__text_start);
|
||||
linkRegNode.linkReg2 = linkRegNode.linkReg1;
|
||||
linkRegNode.linkReg3 = linkRegNode.linkReg1;
|
||||
ret = OsBinTreeInsert(&linkRegNode, sizeof(LinkRegNode), (BinNode **)&g_linkRegRoot,
|
||||
OsGetLRBinNode, OsCompareLRNode);
|
||||
if (ret == OS_INVALID) {
|
||||
PRINT_ERR("binary tree init failed\n");
|
||||
}
|
||||
|
||||
/* equal to the middle address of __bss_end and OS_SYS_FUNC_ADDR_END */
|
||||
node.addr = ((OS_SYS_FUNC_ADDR_END - (UINTPTR)(&__bss_end)) >> 1) + (UINTPTR)(&__bss_end);
|
||||
ret = OsBinTreeInsert(&node, sizeof(AddrNode), (BinNode **)&g_addrRoot,
|
||||
OsGetAddrBinNode, OsCompareAddrNode);
|
||||
if (ret == OS_INVALID) {
|
||||
PRINT_ERR("binary tree init failed\n");
|
||||
}
|
||||
|
||||
for (index = 0; index < BINARYTREE_TASKID_COUNT; index++) {
|
||||
taskNode.taskID = g_binaryTreeTaskID[index];
|
||||
ret = OsBinTreeInsert(&taskNode, sizeof(TaskIDNode), (BinNode **)&g_taskIDRoot,
|
||||
OsGetTaskIDBinNode, OsCompareTaskIDNode);
|
||||
if (ret == OS_INVALID) {
|
||||
PRINT_ERR("binary tree init failed\n");
|
||||
}
|
||||
}
|
||||
|
||||
for (index = 0; index < BINARYTREE_REQSIZE_COUNT; index++) {
|
||||
reqNode.reqSize = g_binaryTreeReqSize[index];
|
||||
ret = OsBinTreeInsert(&reqNode, sizeof(ReqSizeNode), (BinNode **)&g_reqSizeRoot,
|
||||
OsGetReqSizeBinNode, OsCompareReqSizeNode);
|
||||
if (ret == OS_INVALID) {
|
||||
PRINT_ERR("binary tree init failed\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
@@ -1,87 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_typedef.h"
|
||||
#include "los_printf.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/* array used for 64 binary conversion, include 64 characters */
|
||||
const CHAR g_base64Array[] = {
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
||||
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
|
||||
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
|
||||
'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D',
|
||||
'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
||||
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
|
||||
'Y', 'Z', '~', '!'
|
||||
};
|
||||
|
||||
#define LOGARITHM 6 /* the logarithm of 64 to base 2 */
|
||||
#define BASE64_MARK ((1U << LOGARITHM) - 1)
|
||||
|
||||
VOID OsDecTo64F(UINT32 num, CHAR *base64, INT32 base64Len)
|
||||
{
|
||||
INT32 len = base64Len - 1;
|
||||
UINT32 tempNum = num;
|
||||
if (base64 == NULL) {
|
||||
PRINT_ERR("%s:%d input null buf\n", __FUNCTION__, __LINE__);
|
||||
return;
|
||||
}
|
||||
|
||||
if (base64Len <= 0) {
|
||||
PRINT_ERR("%s:%d input illegal Len\n", __FUNCTION__, __LINE__);
|
||||
return;
|
||||
}
|
||||
|
||||
while (num) {
|
||||
if (len < 0) {
|
||||
PRINT_ERR("Len[%d] is too short, input num: %u\n", base64Len, tempNum);
|
||||
break;
|
||||
}
|
||||
base64[len--] = g_base64Array[num & BASE64_MARK];
|
||||
num >>= LOGARITHM;
|
||||
}
|
||||
for (; len >= 0; len--) {
|
||||
base64[len] = '0';
|
||||
}
|
||||
base64[base64Len] = '\0';
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
@@ -1,356 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_memrecord_pri.h"
|
||||
#include "stdio.h"
|
||||
#include "los_binarytree_pri.h"
|
||||
#include "los_event.h"
|
||||
#include "los_exc.h"
|
||||
#include "los_task_pri.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
|
||||
enum MemActType {
|
||||
OS_MEM_VALIDFREE,
|
||||
OS_MEM_INVALIDFREE,
|
||||
OS_MEM_ALLOC
|
||||
};
|
||||
|
||||
STATIC MemRecordInfo g_memRecord1[RECORD_LEN] = {0};
|
||||
STATIC MemRecordInfo g_memRecord2[RECORD_LEN] = {0};
|
||||
STATIC MemRecordInfo *g_saveMemRecord = g_memRecord1;
|
||||
STATIC MemRecordInfo *g_printMemRecord = NULL;
|
||||
STATIC MemRecordInfo *g_curPtr = NULL;
|
||||
|
||||
STATIC volatile UINT32 g_memRecordIndex = 0;
|
||||
STATIC volatile UINT32 g_memLastEndIndex = 0;
|
||||
STATIC EVENT_CB_S g_memShowEvent;
|
||||
|
||||
UINT32 g_memRecordShowEnable = 1;
|
||||
STATIC UINT32 g_lastAddrNodeIndex = 0;
|
||||
STATIC UINT32 g_lastReqSizeNodeIndex = 0;
|
||||
STATIC UINT32 g_lastlinkRegNodeIndex = 0;
|
||||
|
||||
#define INDEX_LENGTH 2
|
||||
#define ADDR_ID_LENGTH 3
|
||||
#define REQSIZE_ID_LENGTH 2
|
||||
#define ACTTYPE_LENGTH 4
|
||||
#define TASK_ID_LENGTH 2
|
||||
#define SYS_TICK_LENGTH 6
|
||||
#define LINK_REG_ID_LENGTH 2
|
||||
#define INFO_STR_LENGTH 20
|
||||
#define PRINT_STR_LENGTH 32
|
||||
#define NODE_VALUE_LENGTH 7
|
||||
#define READ_EVENT_MASK 0xFFF
|
||||
#define WRITE_EVENT 0x112
|
||||
|
||||
STATIC VOID OsMemRecordCompressInfo(VOID)
|
||||
{
|
||||
UINT32 count;
|
||||
CHAR infoStr[INFO_STR_LENGTH];
|
||||
|
||||
UINT32 currentIndex = g_addrNodeIndex;
|
||||
for (count = g_lastAddrNodeIndex; count < currentIndex; count++) {
|
||||
OsDecTo64F(g_addrNode[count].leaf.nodeID, infoStr, ADDR_ID_LENGTH);
|
||||
printf("~^%s%x^~\n", infoStr, g_addrNode[count].addr);
|
||||
}
|
||||
g_lastAddrNodeIndex = currentIndex;
|
||||
|
||||
currentIndex = g_reqSizeNodeIndex;
|
||||
for (count = g_lastReqSizeNodeIndex; count < currentIndex; count++) {
|
||||
OsDecTo64F(g_reqSizeNode[count].leaf.nodeID, infoStr, REQSIZE_ID_LENGTH);
|
||||
printf("*^%s%u^*\n", infoStr, g_reqSizeNode[count].reqSize);
|
||||
}
|
||||
g_lastReqSizeNodeIndex = currentIndex;
|
||||
|
||||
currentIndex = g_linkRegNodeIndex;
|
||||
for (count = g_lastlinkRegNodeIndex; count < currentIndex; count++) {
|
||||
OsDecTo64F(g_linkRegNode[count].leaf.nodeID, infoStr, LINK_REG_ID_LENGTH);
|
||||
printf("$^%s%x%x%x^$\n", infoStr, g_linkRegNode[count].linkReg1, g_linkRegNode[count].linkReg2,
|
||||
g_linkRegNode[count].linkReg3);
|
||||
}
|
||||
g_lastlinkRegNodeIndex = currentIndex;
|
||||
}
|
||||
|
||||
STATIC VOID PrintPtrAssign(CHAR *printStr, UINT32 strLen, UINT32 startIndex, UINT32 index)
|
||||
{
|
||||
CHAR nodeValue[NODE_VALUE_LENGTH];
|
||||
UINT32 tmpIndex = 0;
|
||||
|
||||
/* 3 bytes for ending "!~" and '\0'. */
|
||||
if (strLen < (INDEX_LENGTH + ADDR_ID_LENGTH + REQSIZE_ID_LENGTH + ACTTYPE_LENGTH +
|
||||
TASK_ID_LENGTH + SYS_TICK_LENGTH + LINK_REG_ID_LENGTH + index + 3)) {
|
||||
PRINT_ERR("printStr is not big enough\n");
|
||||
return;
|
||||
}
|
||||
|
||||
OsDecTo64F(startIndex, nodeValue, INDEX_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
tmpIndex = 0;
|
||||
OsDecTo64F(g_curPtr[startIndex].addrID, nodeValue, ADDR_ID_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
tmpIndex = 0;
|
||||
OsDecTo64F(g_curPtr[startIndex].reqSizeID, nodeValue, REQSIZE_ID_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
tmpIndex = 0;
|
||||
OsDecTo64F(g_curPtr[startIndex].actType, nodeValue, ACTTYPE_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
tmpIndex = 0;
|
||||
OsDecTo64F(g_curPtr[startIndex].taskID, nodeValue, TASK_ID_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
tmpIndex = 0;
|
||||
OsDecTo64F(g_curPtr[startIndex].sysTick, nodeValue, SYS_TICK_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
tmpIndex = 0;
|
||||
OsDecTo64F(g_curPtr[startIndex].linkRegID, nodeValue, LINK_REG_ID_LENGTH);
|
||||
printStr[index++] = nodeValue[tmpIndex++];
|
||||
printStr[index++] = nodeValue[tmpIndex];
|
||||
|
||||
printStr[index++] = '!';
|
||||
printStr[index++] = '~';
|
||||
printStr[index++] = '\0';
|
||||
|
||||
printf("%s\n", printStr);
|
||||
}
|
||||
|
||||
STATIC VOID OsMemRecordShow(VOID)
|
||||
{
|
||||
UINT32 index = 0;
|
||||
UINT32 startIndex = g_memLastEndIndex;
|
||||
UINT32 endIndex;
|
||||
MemRecordInfo *printMemRecord = g_printMemRecord;
|
||||
CHAR printStr[PRINT_STR_LENGTH];
|
||||
|
||||
if (g_curPtr == NULL) {
|
||||
g_curPtr = g_printMemRecord;
|
||||
}
|
||||
|
||||
OsMemRecordCompressInfo();
|
||||
|
||||
if (g_curPtr != NULL) {
|
||||
printStr[index++] = '~';
|
||||
printStr[index++] = '!';
|
||||
if (g_curPtr == printMemRecord) {
|
||||
while (startIndex < RECORD_LEN) {
|
||||
PrintPtrAssign(printStr, PRINT_STR_LENGTH, startIndex, index);
|
||||
startIndex++;
|
||||
}
|
||||
g_memLastEndIndex = 0;
|
||||
}
|
||||
}
|
||||
|
||||
startIndex = g_memLastEndIndex;
|
||||
endIndex = g_memRecordIndex;
|
||||
if ((g_curPtr == g_saveMemRecord) && (g_printMemRecord != NULL) && (startIndex >= endIndex)) {
|
||||
printf("Rec:error:the printf speed is low,Rnd\n");
|
||||
startIndex = 0;
|
||||
}
|
||||
|
||||
g_curPtr = g_saveMemRecord;
|
||||
index = 0;
|
||||
printStr[index++] = '~';
|
||||
printStr[index++] = '!';
|
||||
while (startIndex < endIndex) {
|
||||
PrintPtrAssign(printStr, PRINT_STR_LENGTH, startIndex, index);
|
||||
startIndex++;
|
||||
}
|
||||
|
||||
g_memLastEndIndex = endIndex;
|
||||
}
|
||||
|
||||
STATIC VOID OsMemRecordExchange(VOID)
|
||||
{
|
||||
if (g_saveMemRecord == g_memRecord1) {
|
||||
g_saveMemRecord = g_memRecord2;
|
||||
g_printMemRecord = g_memRecord1;
|
||||
} else {
|
||||
g_saveMemRecord = g_memRecord1;
|
||||
g_printMemRecord = g_memRecord2;
|
||||
}
|
||||
g_memRecordIndex = 0;
|
||||
(VOID)LOS_EventWrite(&g_memShowEvent, WRITE_EVENT);
|
||||
}
|
||||
|
||||
#define LINK_REG1_INDEX 1
|
||||
#define LINK_REG2_INDEX 2
|
||||
#define LINK_REG3_INDEX 3
|
||||
#define LINK_REG_NUM 3
|
||||
|
||||
STATIC INLINE VOID OsMemRecordLR(LinkRegNode *linkRegNode)
|
||||
{
|
||||
UINTPTR framePtr, framePtrTmp;
|
||||
UINT32 index = 0;
|
||||
|
||||
linkRegNode->linkReg1 = 0;
|
||||
linkRegNode->linkReg2 = 0;
|
||||
linkRegNode->linkReg3 = 0;
|
||||
|
||||
framePtr = Get_Fp();
|
||||
while ((framePtr > OS_SYS_FUNC_ADDR_START) &&
|
||||
(framePtr < OS_SYS_FUNC_ADDR_END) &&
|
||||
((framePtr % sizeof(CHAR *)) == 0)) {
|
||||
framePtrTmp = framePtr;
|
||||
if (index == LINK_REG1_INDEX) {
|
||||
linkRegNode->linkReg1 = *((UINTPTR *)(framePtrTmp));
|
||||
} else if (index == LINK_REG2_INDEX) {
|
||||
linkRegNode->linkReg2 = *((UINTPTR *)(framePtrTmp));
|
||||
} else if (index == LINK_REG3_INDEX) {
|
||||
linkRegNode->linkReg3 = *((UINTPTR *)(framePtrTmp));
|
||||
}
|
||||
framePtr = *((UINTPTR *)(framePtrTmp - sizeof(UINTPTR *)));
|
||||
index++;
|
||||
if (index == (LINK_REG_NUM + 1)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
STATIC VOID OsMemRecordTaskID(VOID)
|
||||
{
|
||||
LosTaskCB *runTask = OsCurrTaskGet();
|
||||
if (runTask != NULL) {
|
||||
g_saveMemRecord[g_memRecordIndex].taskID = LOS_CurTaskIDGet();
|
||||
} else {
|
||||
g_saveMemRecord[g_memRecordIndex].taskID = 0;
|
||||
}
|
||||
}
|
||||
|
||||
STATIC INLINE VOID OsMemRecord(const VOID *ptr, UINT32 size)
|
||||
{
|
||||
UINT64 tickCount = LOS_TickCountGet();
|
||||
UINT32 nodeID;
|
||||
LinkRegNode linkRegNode;
|
||||
AddrNode node;
|
||||
ReqSizeNode reqNode;
|
||||
|
||||
OsMemRecordLR(&linkRegNode);
|
||||
nodeID = OsBinTreeInsert(&linkRegNode, sizeof(linkRegNode), (BinNode **)&g_linkRegRoot, OsGetLRBinNode,
|
||||
OsCompareLRNode);
|
||||
if (nodeID == OS_INVALID) {
|
||||
PRINT_WARN("LIST g_linkRegRoot insert linkRegNode failed!\n");
|
||||
}
|
||||
g_saveMemRecord[g_memRecordIndex].linkRegID = nodeID;
|
||||
|
||||
node.addr = (UINTPTR)ptr;
|
||||
nodeID = OsBinTreeInsert(&node, sizeof(AddrNode), (BinNode **)&g_addrRoot, OsGetAddrBinNode,
|
||||
OsCompareAddrNode);
|
||||
if (nodeID == OS_INVALID) {
|
||||
PRINT_WARN("LIST g_addrRoot insert addrNode failed!\n");
|
||||
}
|
||||
g_saveMemRecord[g_memRecordIndex].addrID = nodeID;
|
||||
g_saveMemRecord[g_memRecordIndex].sysTick = tickCount;
|
||||
|
||||
OsMemRecordTaskID();
|
||||
|
||||
reqNode.reqSize = size;
|
||||
nodeID = OsBinTreeInsert(&reqNode, sizeof(ReqSizeNode), (BinNode **)&g_reqSizeRoot, OsGetReqSizeBinNode,
|
||||
OsCompareReqSizeNode);
|
||||
if (nodeID == OS_INVALID) {
|
||||
PRINT_WARN("LIST g_reqSizeRoot insert reqSizeNode failed!\n");
|
||||
}
|
||||
g_saveMemRecord[g_memRecordIndex].reqSizeID = nodeID;
|
||||
|
||||
g_memRecordIndex++;
|
||||
if (g_memRecordIndex == RECORD_LEN) {
|
||||
OsMemRecordExchange();
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef LOSCFG_MEM_RECORDINFO
|
||||
VOID OsMemRecordMalloc(const VOID *ptr, UINT32 size)
|
||||
{
|
||||
if (g_memRecordShowEnable == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
OsMemRecord(ptr, size);
|
||||
g_saveMemRecord[g_memRecordIndex].actType = OS_MEM_ALLOC;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef LOSCFG_MEM_RECORDINFO
|
||||
VOID OsMemRecordFree(const VOID *ptr, UINT32 size)
|
||||
{
|
||||
UINT32 actType;
|
||||
if (g_memRecordShowEnable == 0) {
|
||||
return;
|
||||
}
|
||||
actType = (size == 0) ? OS_MEM_INVALIDFREE : OS_MEM_VALIDFREE;
|
||||
OsMemRecord(ptr, size);
|
||||
g_saveMemRecord[g_memRecordIndex].actType = actType;
|
||||
}
|
||||
#endif
|
||||
|
||||
VOID OsMemRecordShowTask(VOID)
|
||||
{
|
||||
(VOID)LOS_EventInit(&g_memShowEvent);
|
||||
while (1) {
|
||||
(VOID)LOS_EventRead(&g_memShowEvent, READ_EVENT_MASK,
|
||||
LOS_WAITMODE_OR | LOS_WAITMODE_CLR, MEM_RECORDSHOW_TIMEOUT);
|
||||
if (g_memRecordShowEnable) {
|
||||
OsMemRecordShow();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VOID OsMemRecordShowSet(UINT32 value)
|
||||
{
|
||||
g_memRecordShowEnable = value;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* __cplusplus */
|
||||
@@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
|
||||
1995
kernel/base/mem/tlsf/los_memory.c
Executable file
1995
kernel/base/mem/tlsf/los_memory.c
Executable file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user