X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Fcm_mem.c;h=a507098dd8956931a8e4900b139b9a72963da948;hb=64580b61ab517a3c1fc09b3e0dc32109b913b726;hp=7568e6a39cb5076850ea612cd31ba382d46a1c2f;hpb=aee73991f728cc127d1ed76d5a52571d916235a4;p=o-du%2Fl2.git diff --git a/src/cm/cm_mem.c b/src/cm/cm_mem.c index 7568e6a39..a507098dd 100755 --- a/src/cm/cm_mem.c +++ b/src/cm/cm_mem.c @@ -114,10 +114,10 @@ The following functions are provided in this file. #ifdef SS_LIGHT_MEM_LEAK_STS MemLeakCb gmemLkCb; - U32 queueIndxAllocCnt =0; - U32 queueIndxFreeCnt =0; - U32 allocQueueFullCnt =0; - U32 allocQueueEmptyCnt =0; + uint32_t queueIndxAllocCnt =0; + uint32_t queueIndxFreeCnt =0; + uint32_t allocQueueFullCnt =0; + uint32_t allocQueueEmptyCnt =0; #endif /* local defines */ @@ -135,105 +135,105 @@ The following functions are provided in this file. #endif #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */ -PUBLIC U32 memFreeCount=0; -PUBLIC U32 cmFreeCaller[4]={0}; -PUBLIC U32 cmAllocCaller[4]={0}; -PUBLIC Data *startPtr256=NULLP; -PUBLIC Data *startPtr128=NULLP; -PUBLIC U32 cmMemInfo128[100000][2]={0, 0}; -PUBLIC U32 cmMemInfo256[100000][2]={0, 0}; -PUBLIC Data *startPtr512=NULLP; -PUBLIC Data *startPtr768=NULLP; -PUBLIC Data *startPtr1664=NULLP; -PUBLIC Data *startPtr4800=NULLP; -PUBLIC Data *startPtr9920=NULLP; -PUBLIC Size regMemSize=0; +uint32_t memFreeCount=0; +uint32_t cmFreeCaller[4]={0}; +uint32_t cmAllocCaller[4]={0}; +Data *startPtr256=NULLP; +Data *startPtr128=NULLP; +uint32_t cmMemInfo128[100000][2]={0, 0}; +uint32_t cmMemInfo256[100000][2]={0, 0}; +Data *startPtr512=NULLP; +Data *startPtr768=NULLP; +Data *startPtr1664=NULLP; +Data *startPtr4800=NULLP; +Data *startPtr9920=NULLP; +Size regMemSize=0; #endif #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 //extern CmMmRegCb *mtCMMRegCb[SS_MAX_REGS]; #endif #ifdef SS_HISTOGRAM_SUPPORT #ifdef SSI_DEBUG_LEVEL1 -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, - U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg)); -PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, + uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg)); +static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg)); /*cm_mem_c_001.main_20-added new functionto allocate memory from new region*/ #else -PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, - U32 line, U8 *fileName, U8 entId, Bool hstReg)); -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, - U32 line, U8 *fileName, U8 entId, Bool hstReg)); +static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, + uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, + uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg)); #endif /* SSI_DEBUG_LEVEL1 */ -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 line, - U8 *fileName, U8 entId, Bool hstReg)); +static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, uint32_t line, + uint8_t *fileName, uint8_t entId, Bool hstReg)); -PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size, - U32 line, U8 *fileName, U8 entId, Bool hstReg)); +static S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size, + uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg)); #else /* no histogram support */ /* cm_mem_c_001.main_12 - prototype is changed to accept memType(static/dynamic) */ #ifdef SSI_DEBUG_LEVEL1 -PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, U32 memType)); +static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, uint32_t memType)); #else #ifndef USE_PURE -PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size)); +static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size)); #endif/*USE_PURE*/ #endif /* SSI_DEBUG_LEVEL1 */ #ifndef USE_PURE -PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size)); +static S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size)); #endif/*USE_PURE*/ /* cm_mem_c_001.main_15 :Additions */ #ifdef SS_LIGHT_MEM_LEAK_STS -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType, U32 lineNo,U8 *funcName )); -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 lineNo, U8* funcName)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType, uint32_t lineNo,uint8_t *funcName )); +static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, uint32_t lineNo, uint8_t* funcName)); #else /*SS_LIGHT_MEM_LEAK_STS */ #if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1)) -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType)); #else #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char* file, U32 line)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char* file, uint32_t line)); #else -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr)); #endif #endif /* SSI_DEBUG_LEVEL1 */ #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, char* file, U32 line)); +static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, char* file, uint32_t line)); #else -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size)); +static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size)); #endif #endif /* SS_HISTOGRAM_SUPPORT */ #endif /*SS_LIGHT_MEM_LEAK_STS*/ /*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/ #ifdef SS_FAP -PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr)); -PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size)); +static S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr)); +static S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size)); #endif -PRIVATE S16 cmCtl ARGS((Void *regionCb, Event event, SMemCtl *memCtl)); +static S16 cmCtl ARGS((Void *regionCb, Event event, SMemCtl *memCtl)); -PRIVATE Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size)); -PRIVATE Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb, - CmMmRegCfg *cfg, U16 bktIdx, U16 *lstMapIdx)); +static Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size)); +static Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb, + CmMmRegCfg *cfg, uint16_t bktIdx, uint16_t *lstMapIdx)); /* cm_mem_c_001.main_12 - addition of protoypes for sanity check and hash list functions */ #ifdef SSI_DEBUG_LEVEL1 -PRIVATE S16 cmMmBktSanityChk ARGS((CmMmBkt *bkt)); -PRIVATE S16 cmMmHeapSanityChk ARGS((CmMmHeapCb *heapCb)); -PRIVATE S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, U32 key, U16 *idx )); -PRIVATE S16 cmMmHashListInit ARGS((CmMmHashListCp *hashListCp, U16 nmbBins, +static S16 cmMmBktSanityChk ARGS((CmMmBkt *bkt)); +static S16 cmMmHeapSanityChk ARGS((CmMmHeapCb *heapCb)); +static S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, uint32_t key, uint16_t *idx )); +static S16 cmMmHashListInit ARGS((CmMmHashListCp *hashListCp, uint16_t nmbBins, Region region, Pool pool)); -PRIVATE S16 cmMmHashListDeinit ARGS((CmMmHashListCp *hashListCp, Region region, Pool pool)); -PRIVATE S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, U32 key)); +static S16 cmMmHashListDeinit ARGS((CmMmHashListCp *hashListCp, Region region, Pool pool)); +static S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, uint32_t key)); #endif /* SSI_DEBUG_LEVEL1 */ /* cm_mem_c_001.main_15 : Addtions */ #ifdef SS_HISTOGRAM_SUPPORT -PRIVATE S16 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, U32 blkSz, U32 *reqSz, U32 line, U8 *fileName, U8 entId)); -PRIVATE S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, U32 blkSz, U32 line, U8 *fileName, U8 entId)); -PRIVATE S16 cmHstGrmHashListInit ARGS((CmHstGrmHashListCp *hashListCp)); -PRIVATE S16 cmHstGrmHashListDeInit ARGS((CmHstGrmHashListCp *hashListCp)); -PRIVATE S16 cmHstGrmGetHashIdxAndKey ARGS((U8 *fileName, U32 line, U32 *binIdx, U32 *key)); -PRIVATE S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, U32 key, U32 *binIdx, CmMemEntries **entry)); -PRIVATE S16 cmHstGrmFillEntry ARGS((CmMemEntries *entry, U32 key, U32 line, U8 *fileName, U8 entId)); +static S16 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, uint32_t blkSz, uint32_t *reqSz, uint32_t line, uint8_t *fileName, uint8_t entId)); +static S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, uint32_t blkSz, uint32_t line, uint8_t *fileName, uint8_t entId)); +static S16 cmHstGrmHashListInit ARGS((CmHstGrmHashListCp *hashListCp)); +static S16 cmHstGrmHashListDeInit ARGS((CmHstGrmHashListCp *hashListCp)); +static S16 cmHstGrmGetHashIdxAndKey ARGS((uint8_t *fileName, uint32_t line, uint32_t *binIdx, uint32_t *key)); +static S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, uint32_t key, uint32_t *binIdx, CmMemEntries **entry)); +static S16 cmHstGrmFillEntry ARGS((CmMemEntries *entry, uint32_t key, uint32_t line, uint8_t *fileName, uint8_t entId)); #endif /* SS_HISTOGRAM_SUPPORT */ /* cm_mem_c_001.main_22: Fixing warnings on GCC compiler */ @@ -267,34 +267,34 @@ MemLkInfo memLk; #ifdef T2K_MEM_LEAK_DBG typedef struct { -U8 minBktSzBitMask; /* minimum allocation size in Log(x)base 2, where X is minimum bucket size in region */ -U16 minBktSzMins1; /* X-1 */ +uint8_t minBktSzBitMask; /* minimum allocation size in Log(x)base 2, where X is minimum bucket size in region */ +uint16_t minBktSzMins1; /* X-1 */ }RegMinBktSzInfo; static RegMinBktSzInfo regMinBktSzInfo[SS_MAX_REGS] = {{8,0xFF},{7,0x7F},{7,0x7F},{7,0x7F}}; RegionMemLeakInfo regMemLeakInfo; -U32 getT2kMemLeakIndex(U64 address, Region region) +uint32_t getT2kMemLeakIndex(uint64_t address, Region region) { return ((address - regMemLeakInfo.regStartAddr[region]) >> regMinBktSzInfo[region].minBktSzBitMask); } -static U32 t2kMemAllocTick; -static U32 smallTick; +static uint32_t t2kMemAllocTick; +static uint32_t smallTick; -void InsertToT2kMemLeakInfo(U64 address, U32 size, U32 lineNo, char* fileName, Region region) +void InsertToT2kMemLeakInfo(uint64_t address, uint32_t size, uint32_t lineNo, char* fileName, Region region) { T2kMeamLeakInfo *leakInfo; /* if(!startMemLeak) { - RETVOID; + return; }*/ - U32 index1 = getT2kMemLeakIndex(address,region); + uint32_t index1 = getT2kMemLeakIndex(address,region); - if(((U64)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0) + if(((uint64_t)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0) { - printf("address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo); + DU_LOG("\nINFO --> address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo); } leakInfo = (((T2kMeamLeakInfo*)(regMemLeakInfo.gMemLeakInfo[region])) + index1); @@ -308,7 +308,8 @@ void InsertToT2kMemLeakInfo(U64 address, U32 size, U32 lineNo, char* fileName, R leakInfo->prevRemLineNo = 0; leakInfo->prevRemFileName = '\0'; - //printf("InsertToT2kMemLeakInfo the adress from List Address = %x, index1 = %d from File=%s, line=%d \n",address,index1,fileName,lineNo); + //DU_LOG("\nINFO --> InsertToT2kMemLeakInfo the adress from List Address = %x, index1 = %d \ + from File=%s, line=%d \n",address,index1,fileName,lineNo); if(smallTick++ == 4096) { smallTick = 0; @@ -317,8 +318,8 @@ void InsertToT2kMemLeakInfo(U64 address, U32 size, U32 lineNo, char* fileName, R } else { - printf("Something is wrong, trying to insert %ld index1 = %d file is %s line is %d \n",address, index1, fileName, lineNo); - printf("Address present :%ld, from File:%s, Line:%d, Size:%d, Age:%d", + DU_LOG("\nERROR --> Something is wrong, trying to insert %ld index1 = %d file is %s line is %d \n",address, index1, fileName, lineNo); + DU_LOG("\nINFO --> Address present :%ld, from File:%s, Line:%d, Size:%d, Age:%d", leakInfo->address, leakInfo->fileName, leakInfo->lineNo, leakInfo->size, leakInfo->age); @@ -326,7 +327,7 @@ void InsertToT2kMemLeakInfo(U64 address, U32 size, U32 lineNo, char* fileName, R } -void RemoveFromT2kMemLeakInfo(U64 address, char *file, U32 line,Region region) +void RemoveFromT2kMemLeakInfo(uint64_t address, char *file, uint32_t line,Region region) { T2kMeamLeakInfo *leakInfo; @@ -335,11 +336,11 @@ void RemoveFromT2kMemLeakInfo(U64 address, char *file, U32 line,Region region) return ROK; }*/ - U32 index1 = getT2kMemLeakIndex(address, region); + uint32_t index1 = getT2kMemLeakIndex(address, region); if(index1 >= T2K_MEM_LEAK_INFO_TABLE_SIZE) { - printf("index1 out of range = %d address is %ld file = %s line = %d. We are going to crash!!!\n", + DU_LOG("\nERROR --> index1 out of range = %d address is %ld file = %s line = %d. We are going to crash!!!\n", index1, address, file, @@ -358,14 +359,14 @@ void RemoveFromT2kMemLeakInfo(U64 address, char *file, U32 line,Region region) } else { - printf("Something is wrong, trying to remove %ld index1 = %d from File=%s, line=%d address present is %ld region%d \n",address, index1, file,line,leakInfo->address,region); + DU_LOG("\nERROR --> Something is wrong, trying to remove %ld index1 = %d from File=%s, line=%d address present is %ld region%d \n",address, index1, file,line,leakInfo->address,region); - printf("\n Last Del file %s line %d\n",leakInfo->lastDelFileName, + DU_LOG("\nINFO --> Last Del file %s line %d\n",leakInfo->lastDelFileName, leakInfo->lastDelLineNum); if(leakInfo->prevRemFileName != NULLP) { - printf("Previous File:%s, Previous Line:%d\n", + DU_LOG("\nINFO --> Previous File:%s, Previous Line:%d\n", leakInfo->prevRemFileName, leakInfo->prevRemLineNo); } } @@ -380,7 +381,7 @@ void DumpT2kMemLeakInfoToFile() if(fp == NULL) { - printf("Could not open file for dumping mem leak info\n"); + DU_LOG("\nERROR --> Could not open file for dumping mem leak info\n"); return; } for(reg=0; reg offset is %d region %d\n", offset, region); if(cmHashListInit(®Cb->brdcmSsiLstCp, 1000, offset, FALSE, - CM_HASH_KEYTYPE_U32MOD, region, 0) != ROK) + CM_HASH_KEYTYPE_UINT32_MOD, region, 0) != ROK) { return RFAILED; } @@ -798,19 +786,10 @@ CmMmRegCfg *cfg; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC S16 cmMmRegDeInit -( -CmMmRegCb *regCb -) -#else -PUBLIC S16 cmMmRegDeInit(regCb) -CmMmRegCb *regCb; -#endif +S16 cmMmRegDeInit(CmMmRegCb *regCb) { - U16 bktIdx; + uint16_t bktIdx; - TRC2(cmMmRegDeInit); #if (ERRCLASS & ERRCLS_INT_PAR) @@ -929,144 +908,82 @@ int regFreeBktSts[10][2][6]={{0}}; /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_HISTOGRAM_SUPPORT #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( -Void *regionCb, -Size *size, -U32 flags, -Data **ptr, -U32 memType, -U32 line, -U8 *fileName, -U8 entId, -Bool hstReg +Void *regionCb, +Size *size, +uint32_t flags, +Data **ptr, +uint32_t memType, +uint32_t line, +uint8_t *fileName, +uint8_t entId, +Bool hstReg ) #else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType, line, fileName, entId, hstReg) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif -#else -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( -Void *regionCb, -Size *size, -U32 flags, -Data **ptr, -U32 line, -U8 *fileName, -U8 entId, -Bool hstReg +Void *regionCb, +Size *size, +uint32_t flags, +Data **ptr, +uint32_t line, +uint8_t *fileName, +uint8_t entId, +Bool hstReg ) -#else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, line, fileName, entId, hstReg) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif #endif /* SSI_DEBUG_LEVEL1 */ #else #ifdef SS_LIGHT_MEM_LEAK_STS -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( -Void *regionCb, -Size *size, -U32 flags, -Data **ptr, -U32 memType, -U32 lineNo, -U8 *funcName +Void *regionCb, +Size *size, +uint32_t flags, +Data **ptr, +uint32_t memType, +uint32_t lineNo, +uint8_t *funcName ) -#else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr ,memType, lineNo, funcName) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -U32 lineNo; -U8 *funcName; -#endif #else /*SS_LIGHT_MEM_LEAK_STS */ #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( -Void *regionCb, -Size *size, -U32 flags, -Data **ptr, -U32 memType +Void *regionCb, +Size *size, +uint32_t flags, +Data **ptr, +uint32_t memType ) #else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -#endif -#else #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( -Void *regionCb, -Size *size, -U32 flags, -Data **ptr, -U32 memType +Void *regionCb, +Size *size, +uint32_t flags, +Data **ptr, +uint32_t memType ) #else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -#endif -#else #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmAlloc +static S16 cmAlloc ( - Void *regionCb, - Size *size, - U32 flags, - Data **ptr , - char* file, - U32 line + Void *regionCb, + Size *size, + uint32_t flags, + Data **ptr, + char* file, + uint32_t line ) #else -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( -Void *regionCb, -Size *size, -U32 flags, -Data **ptr +Void *regionCb, +Size *size, +uint32_t flags, +Data **ptr ) -#else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -#endif #endif #endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */ #endif /* SSI_DEBUG_LEVEL1 */ @@ -1077,13 +994,13 @@ Data **ptr; { /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt; #endif CmMmRegCb *regCb; /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 cnt; + uint16_t cnt; #endif /* cm_mem_c_001.main_15 : Additions */ #if (defined(SS_MEM_LEAK_STS) || defined( BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1)) @@ -1101,7 +1018,7 @@ Data **ptr; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */ - U16 memIndex=0; + uint16_t memIndex=0; Data *nextptr1; Data *prevptr1; Data **nextptr; @@ -1110,7 +1027,6 @@ Data **prevptr; prevptr=&prevptr1; #endif - TRC2(cmAlloc); #ifndef USE_MEMCAL UNUSED(flags); @@ -1288,9 +1204,9 @@ Data **prevptr; #endif #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 /* Initialize the elements with 0xAB */ - cmMemset((U8 *)*ptr, 0xAB, *size); + memset(*ptr, 0xAB, *size); #endif -// printf("Pointer allocated %8p size %d\n", *ptr, *size); +// DU_LOG("\nINFO --> Pointer allocated %8p size %d\n", *ptr, *size); /* Store this pointer in hash list */ if ((bkt->nextBlk) && *ptr) #elif SS_LIGHT_MEM_LEAK_STS @@ -1317,7 +1233,7 @@ Data **prevptr; memIndex = (*ptr - startPtr256) / 256; } #if 1 - if (*((U32 *)(*ptr + 4)) != 0xDEADDEAD && *((U32 *)(*ptr + 80)) != 0xDEADDEAD && *((U32 *)(*ptr + 24)) != 0xDEADDEAD) + if (*((uint32_t *)(*ptr + 4)) != 0xDEADDEAD && *((uint32_t *)(*ptr + 80)) != 0xDEADDEAD && *((uint32_t *)(*ptr + 24)) != 0xDEADDEAD) { } if(bkt->size == 256) @@ -1327,7 +1243,7 @@ Data **prevptr; #endif #endif /* MS_MBUF_CORRUPTION */ #ifdef SSI_MEM_CORR_PREVENTION - *(((U32 *)(*ptr)) + 2) = 0; + *(((uint32_t *)(*ptr)) + 2) = 0; #endif #ifdef T2K_MEM_LEAK_DBG @@ -1335,7 +1251,7 @@ Data **prevptr; { /* Lock before the transaction-start */ pthread_mutex_lock(&(regMemLeakInfo.memLock[regCb->region])); - InsertToT2kMemLeakInfo( (U64)*ptr,*size,line,file,regCb->region); + InsertToT2kMemLeakInfo( (uint64_t)*ptr,*size,line,file,regCb->region); /* UnLock after the transaction */ pthread_mutex_unlock(&(regMemLeakInfo.memLock[regCb->region])); } @@ -1344,7 +1260,7 @@ Data **prevptr; bkt->next = *((CmMmEntry **)(bkt->next)); #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */ *nextptr = bkt->next; - if (*((U32 *)(*nextptr + 4)) != 0xDEADDEAD && *((U32 *)(*nextptr + 80)) != 0xDEADDEAD && *((U32 *)(*nextptr + 24)) != 0xDEADDEAD) + if (*((uint32_t *)(*nextptr + 4)) != 0xDEADDEAD && *((uint32_t *)(*nextptr + 80)) != 0xDEADDEAD && *((uint32_t *)(*nextptr + 24)) != 0xDEADDEAD) { if(bkt->size == 128) *prevptr = startPtr128 + ((memIndex-1)*128); @@ -1368,12 +1284,12 @@ Data **prevptr; cmMemInfo256[memIndex][0] = cmAllocCaller[MxGetCpuID()]; } cmAllocCaller[MxGetCpuID()] = NULLP; - *((U32 *)(*ptr + 4)) = 0x00000000; - *((U32 *)(*ptr + 124)) = 0; - *((U32 *)(*ptr + 24)) = 0x00000000; - *((U32 *)(*ptr + 44)) = 0x00000000; - *((U32 *)(*ptr + 80)) = 0x00000000; - *((U32 *)(*ptr + 116)) = 0x00000000; + *((uint32_t *)(*ptr + 4)) = 0x00000000; + *((uint32_t *)(*ptr + 124)) = 0; + *((uint32_t *)(*ptr + 24)) = 0x00000000; + *((uint32_t *)(*ptr + 44)) = 0x00000000; + *((uint32_t *)(*ptr + 80)) = 0x00000000; + *((uint32_t *)(*ptr + 116)) = 0x00000000; #endif #endif /* SSI_DEBUG_LEVEL1 */ @@ -1395,7 +1311,7 @@ Data **prevptr; if (g_overused[bktIdx] == 0 && OVERUSED(bkt)) { g_overused[bktIdx] = 1; - /*printf("cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */ + /*DU_LOG("\nINFO --> cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */ } } #endif @@ -1575,7 +1491,7 @@ Data **prevptr; /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE *ptr = (Data*) MxHeapAlloc(SsiHeap, *size); - cmMemset((U8*)ptr, 0, *size); + memset(ptr, 0, *size); #else *ptr = (Data*) malloc(*size); #endif @@ -1612,71 +1528,44 @@ Data **prevptr; /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_LIGHT_MEM_LEAK_STS -#ifdef ANSI -PRIVATE S16 cmFree +static S16 cmFree ( -Void *regionCb, -Data *ptr, -Size size, -U32 lineNo, -U8 *funcName +Void *regionCb, +Data *ptr, +Size size, +uint32_t lineNo, +uint8_t *funcName ) -#else -PRIVATE S16 cmFree(regionCb, ptr, size, lineNo, funcName) -Void *regionCb; -Data *ptr; -Size size; -U32 lineNo; -U8 *funcName; -#endif #else /*SS_LIGHT_MEM_LEAK_STS */ #ifdef SS_HISTOGRAM_SUPPORT -#ifdef ANSI -PRIVATE S16 cmFree +static S16 cmFree ( -Void *regionCb, -Data *ptr, -Size size, -U32 line, -U8 *fileName, -U8 entId, -Bool hstReg +Void *regionCb, +Data *ptr, +Size size, +uint32_t line, +uint8_t *fileName, +uint8_t entId, +Bool hstReg ) -#else -PRIVATE S16 cmFree(regionCb, ptr, size, line, fileName, entId, hstReg) -Void *regionCb; -Data *ptr; -Size size; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif #else #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmFree +static S16 cmFree ( - Void *regionCb, - Data *ptr, - Size size, - char* file, - U32 line +Void *regionCb, +Data *ptr, +Size size, +char* file, +uint32_t line ) #else /* T2K_MEM_LEAK_DBG */ -#ifdef ANSI -PRIVATE S16 cmFree +static S16 cmFree ( Void *regionCb, Data *ptr, Size size ) -#else -PRIVATE S16 cmFree(regionCb, ptr, size) -Void *regionCb; -Data *ptr; -Size size; -#endif #endif /* cm_mem_c_001.main_15 : Additions */ #endif /* SS_HISTOGRAM_SUPPORT */ @@ -1685,7 +1574,7 @@ Size size; { /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt; #endif CmMmRegCb *regCb; @@ -1701,10 +1590,9 @@ Size size; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption*/ - U16 memIndex=0; + uint16_t memIndex=0; #endif - TRC2(cmFree); regCb = (CmMmRegCb *)regionCb; @@ -1750,7 +1638,7 @@ Size size; #ifdef T2K_MEM_LEAK_DBG { pthread_mutex_lock(&(regMemLeakInfo.memLock[regCb->region])); - RemoveFromT2kMemLeakInfo((U64)ptr , file,line,regCb->region); + RemoveFromT2kMemLeakInfo((uint64_t)ptr , file,line,regCb->region); pthread_mutex_unlock(&(regMemLeakInfo.memLock[regCb->region])); } #endif @@ -1816,13 +1704,13 @@ Size size; size(%d) %8p, Bucket Id:%03d\n", size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx); #endif - printf("Passed size (%d) does not match with allocated \ + DU_LOG("\nERROR --> Passed size (%d) does not match with allocated \ size(%d) %8p, Bucket Id:%03d\n", size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx); abort(); } /* Validate the tail part to see if there is any over run */ -// printf("Pointer free request %8p, size %d\n", ptr, size); +// DU_LOG("\nINFO --> Pointer free request %8p, size %d\n", ptr, size); #endif /* validate the block to be freed for trampling */ @@ -1883,7 +1771,7 @@ Size size; return (RTRAMPLINGNOK); } #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 - printf("Memory signature is invalid\n"); + DU_LOG("\nERROR --> Memory signature is invalid\n"); abort(); #endif } @@ -1892,7 +1780,7 @@ Size size; ptrHdr->requestedSize = 0; #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 /* Initialize the elements with 0xAB */ - cmMemset((U8 *)ptr, 0xAB, size); + memset(ptr, 0xAB, size); #endif /* check if the block to be freed is already having the state as FREE */ if (CMM_IS_FREE(ptrHdr->memFlags)) @@ -1919,7 +1807,7 @@ Size size; (Void) SUnlock(&(bkt->bktLock)); #endif #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 - printf("Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\ + DU_LOG("\nERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\ size %u bytes \n", ptr, regCb->mapTbl[idx].bktIdx, bkt->size); abort(); #endif @@ -2011,7 +1899,7 @@ Size size; #ifndef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */ #ifdef SSI_MEM_CORR_PREVENTION - if (*(((U32 *)(ptr)) + 2) == 0xdeaddead) + if (*(((uint32_t *)(ptr)) + 2) == 0xdeaddead) { /* Do not free an already freed block to avoid corruption */ cmDblFreeAttempts++; @@ -2022,7 +1910,7 @@ Size size; *((CmMmEntry **)bkt->last) = ptr; bkt->last = (CmMmEntry *)ptr; *((CmMmEntry **)ptr) = NULLP; - *(((U32 *)(ptr)) + 2) = 0xdeaddead; + *(((uint32_t *)(ptr)) + 2) = 0xdeaddead; } #else *((CmMmEntry **)ptr) = bkt->next; @@ -2089,36 +1977,36 @@ Size size; *crashPtr = 9; } } - if (*((U32 *)(ptr + 4)) != 0xDEADDEAD) + if (*((uint32_t *)(ptr + 4)) != 0xDEADDEAD) { - *(U32 *)(ptr + 4) = 0xDEADDEAD; + *(uint32_t *)(ptr + 4) = 0xDEADDEAD; } else { Data *crashPtr=NULLP; *crashPtr = 9; } - if (*((U32 *)(ptr + 24)) != 0xDEADDEAD) + if (*((uint32_t *)(ptr + 24)) != 0xDEADDEAD) { - *(U32 *)(ptr + 24) = 0xDEADDEAD; + *(uint32_t *)(ptr + 24) = 0xDEADDEAD; } else { Data *crashPtr=NULLP; *crashPtr = 9; } - if (*((U32 *)(ptr + 44)) != 0xDEADDEAD) + if (*((uint32_t *)(ptr + 44)) != 0xDEADDEAD) { - *(U32 *)(ptr + 44) = 0xDEADDEAD; + *(uint32_t *)(ptr + 44) = 0xDEADDEAD; } else { Data *crashPtr=NULLP; *crashPtr = 9; } - if (*((U32 *)(ptr + 80)) != 0xDEADDEAD) + if (*((uint32_t *)(ptr + 80)) != 0xDEADDEAD) { - *(U32 *)(ptr + 80) = 0xDEADDEAD; + *(uint32_t *)(ptr + 80) = 0xDEADDEAD; } else { @@ -2126,8 +2014,8 @@ Size size; *crashPtr = 9; /* Cause a crash to identify the caller */ } - *(U32 *)(ptr + 124) = memFreeCount++; - (*(U32 *)(ptr + 116)) = cmFreeCaller[MxGetCpuID()]; + *(uint32_t *)(ptr + 124) = memFreeCount++; + (*(uint32_t *)(ptr + 116)) = cmFreeCaller[MxGetCpuID()]; if(bkt->size == 128) { memIndex = (ptr - startPtr128) / 128; @@ -2201,7 +2089,6 @@ Size size; return (cmHeapFree (&(regCb->heapCb), ptr, size)); #endif /* SS_HISTOGRAM_SUPPORT */ #else /* use pure is on */ - TRC2(cmFree); /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE (Void)MxHeapFree(SsiHeap, ptr); @@ -2250,136 +2137,72 @@ Size size; /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_HISTOGRAM_SUPPORT #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PUBLIC S16 cmAllocNL +S16 cmAllocNL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr, -U32 memType, -U32 line, -U8 *fileName, -U8 entId, +uint32_t memType, +uint32_t line, +uint8_t *fileName, +uint8_t entId, Bool hstReg ) #else -PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType, - line, fileName, entId, hstReg) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif -#else -#ifdef ANSI -PUBLIC S16 cmAllocNL +S16 cmAllocNL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr, -U32 line, -U8 *fileName, -U8 entId, +uint32_t line, +uint8_t *fileName, +uint8_t entId, Bool hstReg ) -#else -PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, line, - fileName, entId, hstReg) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif #endif /* SSI_DEBUG_LEVEL1 */ #else #ifdef SS_LIGHT_MEM_LEAK_STS -#ifdef ANSI -PUBLIC S16 cmAllocNL +S16 cmAllocNL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr, -U32 memType, -U32 lineNo, -U8 *funcName +uint32_t memType, +uint32_t lineNo, +uint8_t *funcName ) -#else -PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -U32 lineNo; -U8 *funcName; -#endif #else /*SS_LIGHT_MEM_LEAK_STS */ #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PUBLIC S16 cmAllocNL +S16 cmAllocNL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr, -U32 memType +uint32_t memType ) #else -PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -#endif -#else #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 -#ifdef ANSI -PUBLIC S16 cmAllocNL +S16 cmAllocNL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr, -U32 memType +uint32_t memType ) #else -PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -U32 memType; -#endif -#else -#ifdef ANSI -PUBLIC S16 cmAllocNL +S16 cmAllocNL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr ) -#else -PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -#endif #endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */ #endif /* SSI_DEBUG_LEVEL1 */ /* cm_mem_c_001.main_15: Additions */ @@ -2389,13 +2212,13 @@ Data **ptr; { /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt; #endif CmMmRegCb *regCb; /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 cnt; + uint16_t cnt; #endif /* cm_mem_c_001.main_15 : Additions */ #if (defined(SS_MEM_LEAK_STS) || defined( BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1)) @@ -2413,7 +2236,6 @@ Data **ptr; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmAllocNL); #ifndef USE_MEMCAL UNUSED(flags); @@ -2570,7 +2392,7 @@ Data **ptr; #endif #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 /* Initialize the elements with 0xAB */ - cmMemset((U8 *)*ptr, 0xAB, *size); + memset(*ptr, 0xAB, *size); #endif if ((bkt->nextBlk) && *ptr) #elif SS_LIGHT_MEM_LEAK_STS @@ -2588,7 +2410,7 @@ Data **ptr; bkt->nextBlk = (CmMmBlkHdr *)(bkt->nextBlk->nextBlk); #else #ifdef SSI_MEM_CORR_PREVENTION - *(((U32 *)(*ptr)) + 2) = 0; + *(((uint32_t *)(*ptr)) + 2) = 0; #endif bkt->next = *((CmMmEntry **)(bkt->next)); #endif /* SSI_DEBUG_LEVEL1 */ @@ -2781,7 +2603,7 @@ Data **ptr; /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE *ptr = (Data*) MxHeapAlloc(SsiHeap, *size); - cmMemset((U8*)ptr, 0, *size); + memset(ptr, 0, *size); #else *ptr = (Data*) malloc(*size); #endif @@ -2818,70 +2640,42 @@ Data **ptr; /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_LIGHT_MEM_LEAK_STS -#ifdef ANSI -PUBLIC S16 cmFreeNL +S16 cmFreeNL ( Void *regionCb, Data *ptr, Size size, -U32 lineNo, -U8 *funcName +uint32_t lineNo, +uint8_t *funcName ) -#else -PUBLIC S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName) -Void *regionCb; -Data *ptr; -Size size; -U32 lineNo; -U8 *funcName; -#endif #else /*SS_LIGHT_MEM_LEAK_STS */ #ifdef SS_HISTOGRAM_SUPPORT -#ifdef ANSI -PUBLIC S16 cmFreeNL +S16 cmFreeNL ( Void *regionCb, Data *ptr, Size size, -U32 line, -U8 *fileName, -U8 entId, +uint32_t line, +uint8_t *fileName, +uint8_t entId, Bool hstReg ) #else -PUBLIC S16 cmFreeNL(regionCb, ptr, size, line, fileName, entId, hstReg) -Void *regionCb; -Data *ptr; -Size size; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif -#else - -#ifdef ANSI -PUBLIC S16 cmFreeNL +S16 cmFreeNL ( Void *regionCb, Data *ptr, Size size ) -#else -PUBLIC S16 cmFreeNL(regionCb, ptr, size) -Void *regionCb; -Data *ptr; -Size size; -#endif /* cm_mem_c_001.main_15 : Additions */ #endif /* SS_HISTOGRAM_SUPPORT */ #endif /*SS_LIGHT_MEM_LEAK_STS */ { #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt; #endif CmMmRegCb *regCb; @@ -2897,7 +2691,6 @@ Size size; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmFreeNL); regCb = (CmMmRegCb *)regionCb; @@ -2990,7 +2783,7 @@ Size size; sprintf(dbgPrntBuf, "Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n", size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx); #endif - printf("Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n", + DU_LOG("\nERROR --> Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n", size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx); abort(); } @@ -3034,7 +2827,7 @@ Size size; } #endif #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 - printf("Memory signature is invalid\n"); + DU_LOG("\nERROR --> Memory signature is invalid\n"); abort(); #endif } @@ -3042,7 +2835,7 @@ Size size; ptrHdr->requestedSize = 0; #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 /* Initialize the elements with 0XAB */ - cmMemset((U8 *)ptr, 0xAB, size); + memset(ptr, 0xAB, size); #endif /* check if the block to be freed is already having the state as FREE */ if (CMM_IS_FREE(ptrHdr->memFlags)) @@ -3064,7 +2857,7 @@ Size size; SDisplay(0, dbgPrntBuf); #endif /* DEBUGP */ #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 - printf("Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\ + DU_LOG("\nERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\ size %u bytes \n", ptr, regCb->mapTbl[idx].bktIdx, bkt->size); abort(); #endif @@ -3138,7 +2931,7 @@ Size size; #else #ifdef SSI_MEM_CORR_PREVENTION - if (*(((U32 *)(ptr)) + 2) == 0xdeaddead) + if (*(((uint32_t *)(ptr)) + 2) == 0xdeaddead) { /* Do not free an already freed block to avoid corruption */ cmDblFreeAttempts++; @@ -3149,7 +2942,7 @@ Size size; *((CmMmEntry **)bkt->last) = ptr; bkt->last = (CmMmEntry *)ptr; *((CmMmEntry **)ptr) = NULLP; - *(((U32 *)(ptr)) + 2) = 0xdeaddead; + *(((uint32_t *)(ptr)) + 2) = 0xdeaddead; } #else *((CmMmEntry **)ptr) = bkt->next; @@ -3197,7 +2990,6 @@ Size size; return (cmHeapFree (&(regCb->heapCb), ptr, size)); #endif /* SS_HISTOGRAM_SUPPORT */ #else /* use pure is on */ - TRC2(cmFreeNL); /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE (Void)MxHeapFree(SsiHeap, ptr); @@ -3227,28 +3019,19 @@ Size size; /*cm_mem_c_001.main_21-added new function*/ /*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/ #ifdef SS_FAP -#ifdef ANSI -PRIVATE S16 cmAllocWL +static S16 cmAllocWL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr ) -#else -PRIVATE S16 cmAllocWL(regionCb, size, flags, ptr) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -#endif { - U16 idx; + uint16_t idx; CmMmBkt *bkt; CmMmRegCb *regCb; /*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/ - TRC2(cmAllocWL); /*cm_mem_c_001.main_23 Removed support of USE_MEMCAL and MEMCAL_DEBUG support for SS_FAP*/ @@ -3323,7 +3106,7 @@ Data **ptr; /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE *ptr = (Data*) MxHeapAlloc(SsiHeap, *size); - cmMemset((U8*)ptr, 0, *size); + memset(ptr, 0, *size); #else *ptr = (Data*) malloc(*size); #endif @@ -3351,26 +3134,13 @@ Data **ptr; * */ -#ifdef ANSI -PRIVATE S16 cmFreeWL -( -Void *regionCb, -Data *ptr, -Size size -) -#else -PRIVATE S16 cmFreeWL(regionCb, ptr, size) -Void *regionCb; -Data *ptr; -Size size; -#endif +static S16 cmFreeWL(Void *regionCb,Data *ptr, Size size) { - U16 idx; + uint16_t idx; CmMmBkt *bkt; CmMmRegCb *regCb; /*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/ - TRC2(cmFreeWL); regCb = (CmMmRegCb *)regionCb; @@ -3442,7 +3212,6 @@ Size size; /* The memory block was allocated from the heap pool */ return (cmHeapFree (&(regCb->heapCb), ptr, size)); #else /* use pure is on */ - TRC2(cmFree); /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE (Void)MxHeapFree(SsiHeap, ptr); @@ -3481,23 +3250,10 @@ Size size; * */ -#ifdef ANSI -PRIVATE S16 cmCtl -( -Void *regionCb, -Event event, -SMemCtl *memCtl -) -#else -PRIVATE S16 cmCtl(regionCb, event, memCtl) -Void *regionCb; -Event event; -SMemCtl *memCtl; -#endif +static S16 cmCtl(Void *regionCb,Event event, SMemCtl *memCtl) { CmMmRegCb *regCb; - TRC2(cmCtl); regCb = (CmMmRegCb *)regionCb; @@ -3550,9 +3306,9 @@ SMemCtl *memCtl; /* Check if the Bucket pool is configured */ if (regCb->bktSize) { - U16 idx; + uint16_t idx; CmMmBkt *bkt; - U32 avlSize, totSize; + uint32_t avlSize, totSize; /* * The bucket pool is configured. The status value returned * does reflect on the memory availabilty in the bucket pool. @@ -3614,27 +3370,18 @@ SMemCtl *memCtl; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE Void cmMmBktInit +static Void cmMmBktInit ( -Data **memAddr, +Data **memAddr, CmMmRegCb *regCb, CmMmRegCfg *cfg, -U16 bktIdx, -U16 *lstMapIdx +uint16_t bktIdx, +uint16_t *lstMapIdx ) -#else -PRIVATE Void cmMmBktInit (memAddr, regCb, cfg, bktIdx, lstMapIdx) -Data **memAddr; -CmMmRegCb *regCb; -CmMmRegCfg *cfg; -U16 bktIdx; -U16 *lstMapIdx; -#endif { - U32 cnt; - U16 idx; - U32 numBlks; + uint32_t cnt; + uint16_t idx; + uint32_t numBlks; Size size; /* cm_mem_c_001.main_12 - addition for temporary variables */ #if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1) || defined (SS_LIGHT_MEM_LEAK_STS)) @@ -3642,7 +3389,7 @@ U16 *lstMapIdx; #ifdef SS_LIGHT_MEM_LEAK_STS CmMmBlkHdr *lastBlk; #endif /*SS_LIGHT_MEM_LEAK_STS */ - U32 sigCnt; + uint32_t sigCnt; #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 Data *tmpMemAddr; CmMmBlkTail *blkTail; @@ -3654,7 +3401,6 @@ U16 *lstMapIdx; #endif #endif /* SSI_DEBUG_LEVEL1 */ - TRC2(cmMmBktInit); size = cfg->bktCfg[bktIdx].size; @@ -3709,7 +3455,7 @@ U16 *lstMapIdx; *nextBlk = NULLP; #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 - tmpMemAddr = (Data *)((*memAddr) - ((sizeof(CmMmBlkHdr)) + sizeof(U32) + size)); + tmpMemAddr = (Data *)((*memAddr) - ((sizeof(CmMmBlkHdr)) + sizeof(uint32_t) + size)); regCb->bktTbl[bktIdx].lastBlk = (CmMmBlkHdr *)tmpMemAddr; #endif @@ -3769,15 +3515,15 @@ U16 *lstMapIdx; { *next = *memAddr; #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */ - (*(U32 *)(*next + 4)) = 0xdeaddead; - (*(U32 *)(*next + 124)) = 0; - (*(U32 *)(*next + 116)) = 0xdeaddead; - (*(U32 *)(*next + 24)) = 0xdeaddead; - (*(U32 *)(*next + 44)) = 0xdeaddead; - (*(U32 *)(*next + 80)) = 0xdeaddead; + (*(uint32_t *)(*next + 4)) = 0xdeaddead; + (*(uint32_t *)(*next + 124)) = 0; + (*(uint32_t *)(*next + 116)) = 0xdeaddead; + (*(uint32_t *)(*next + 24)) = 0xdeaddead; + (*(uint32_t *)(*next + 44)) = 0xdeaddead; + (*(uint32_t *)(*next + 80)) = 0xdeaddead; #endif #ifdef SSI_MEM_CORR_PREVENTION - *(((U32 *)(*next)) + 2) = 0xdeaddead; + *(((uint32_t *)(*next)) + 2) = 0xdeaddead; #endif next = (CmMmEntry **)(*memAddr); *memAddr = (*memAddr) + size; @@ -3827,7 +3573,7 @@ U16 *lstMapIdx; regCb->bktSize += ((size + sizeof(CmMmBlkHdr)) * numBlks); /* Addition for considering the header size and tail */ #elif BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 - regCb->bktSize += ((size + sizeof(CmMmBlkHdr) + sizeof(U32)) * numBlks); + regCb->bktSize += ((size + sizeof(CmMmBlkHdr) + sizeof(uint32_t)) * numBlks); #else regCb->bktSize += (size * numBlks); #endif /* SSI_DEBUG_LEVEL1 */ @@ -3851,7 +3597,7 @@ U16 *lstMapIdx; cmHstGrmHashListInit(&(regCb->bktTbl[bktIdx].hstGrmHashListCp)); #endif /* SS_HISTOGRAM_SUPPORT */ - RETVOID; + return; } /* end of cmMmBktInit */ @@ -3870,25 +3616,12 @@ U16 *lstMapIdx; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE Void cmMmHeapInit -( -Data *memAddr, -CmMmHeapCb *heapCb, -Size size -) -#else -PRIVATE Void cmMmHeapInit (memAddr, heapCb, size) -Data *memAddr; -CmMmHeapCb *heapCb; -Size size; -#endif +static Void cmMmHeapInit(Data *memAddr,CmMmHeapCb *heapCb,Size size) { /* cm_mem_c_001.main_12 - addition for ssi enhancements */ #ifdef SSI_DEBUG_LEVEL1 - U16 idx; + uint16_t idx; #endif /* SSI_DEBUG_LEVEL1 */ - TRC2(cmMmHeapInit); /* Initialize the heap control block */ heapCb->vStart = memAddr; @@ -3931,7 +3664,7 @@ Size size; /* Initialise the memory histogram hash list */ cmHstGrmHashListInit(&(heapCb->heapHstGrmHashListCp)); #endif /* SS_HISTOGRAM_SUPPORT */ - RETVOID; + return; } /* end of cmMmHeapInit */ @@ -3958,87 +3691,49 @@ Size size; /* cm_mem_c_001.main_12 - addition for taking another parameter memType(static/dynamic) */ /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_4GMX_LCORE -EXTERN U8 ysCellConfigDone; +uint8_t ysCellConfigDone; #endif #ifdef SS_HISTOGRAM_SUPPORT #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmHeapAlloc +static S16 cmHeapAlloc ( CmMmHeapCb *heapCb, Data **ptr, Size *size, -U32 memType, -U32 line, -U8 *fileName, -U8 entId, +uint32_t memType, +uint32_t line, +uint8_t *fileName, +uint8_t entId, Bool hstReg ) #else -PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, memType, line, fileName, entId, hstReg) -CmMmHeapCb *heapCb; -Data **ptr; -Size *size; -U32 memType; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif -#else -#ifdef ANSI -PRIVATE S16 cmHeapAlloc +static S16 cmHeapAlloc ( CmMmHeapCb *heapCb, Data **ptr, Size *size, -U32 line, -U8 *fileName, -U8 entId, +uint32_t line, +uint8_t *fileName, +uint8_t entId, Bool hstReg ) -#else -PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, line, fileName, entId, hstReg) -CmMmHeapCb *heapCb; -Data **ptr; -Size *size; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif #endif /* SSI_DEBUG_LEVEL1 */ #else #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmHeapAlloc +static S16 cmHeapAlloc ( CmMmHeapCb *heapCb, Data **ptr, Size *size, -U32 memType +uint32_t memType ) #else -PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, memType) -CmMmHeapCb *heapCb; -Data **ptr; -Size *size; -U32 memType; -#endif -#else -#ifdef ANSI -PRIVATE S16 cmHeapAlloc +static S16 cmHeapAlloc ( CmMmHeapCb *heapCb, Data **ptr, Size *size ) -#else -PRIVATE S16 cmHeapAlloc (heapCb, ptr, size) -CmMmHeapCb *heapCb; -Data **ptr; -Size *size; -#endif #endif /* SSI_DEBUG_LEVEL1 */ /* cm_mem_c_001.main_15 : Additions */ #endif /* SS_HISTOGRAM_SUPPORT */ @@ -4055,14 +3750,13 @@ Size *size; CmHEntry *alocHeapBlk; Size requestedSize; Size hdr; - U16 idx; + uint16_t idx; #endif /* SSI_DEBUG_LEVEL1 */ /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_HISTOGRAM_SUPPORT S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmHeapAlloc); /* cm_mem_c_001.main_15 : Additions */ /* Acquire the heap lock */ /* cm_mem_c_001.main_13 : Replaced SLock with WTLock for NT */ @@ -4330,41 +4024,23 @@ Size *size; */ /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_HISTOGRAM_SUPPORT -#ifdef ANSI -PRIVATE S16 cmHeapFree +static S16 cmHeapFree ( CmMmHeapCb *heapCb, Data *ptr, Size size, -U32 line, -U8 *fileName, -U8 entId, +uint32_t line, +uint8_t *fileName, +uint8_t entId, Bool hstReg ) #else -PRIVATE S16 cmHeapFree (heapCb, ptr, size, line, fileName, entId, hstReg) -CmMmHeapCb *heapCb; -Data *ptr; -Size size; -U32 line; -U8 *fileName; -U8 entId; -Bool hstReg; -#endif -#else -#ifdef ANSI -PRIVATE S16 cmHeapFree +static S16 cmHeapFree ( CmMmHeapCb *heapCb, Data *ptr, Size size ) -#else -PRIVATE S16 cmHeapFree (heapCb, ptr, size) -CmMmHeapCb *heapCb; -Data *ptr; -Size size; -#endif /* cm_mem_c_001.main_15 : Additions */ #endif /* SS_HISTOGRAM_SUPPORT */ { @@ -4380,7 +4056,6 @@ Size size; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmHeapFree); /* Roundup the requested size */ size = CMM_DATALIGN(size, (heapCb->minSize)); @@ -4740,14 +4415,7 @@ Size size; } /* end of cmHeapFree */ #endif/*USE_PURE*/ #ifdef SS_LIGHT_MEM_LEAK_STS -#ifdef ANSI -PUBLIC U32 cmGetFreeIndx -( -Void -) -#else -PUBLIC U32 cmGetFreeIndx(Void) -#endif +uint32_t cmGetFreeIndx(Void) { if(gmemLkCb.head == gmemLkCb.tail) @@ -4757,24 +4425,15 @@ PUBLIC U32 cmGetFreeIndx(Void) } else { - U32 allocQIndx = gmemLkCb.queue[gmemLkCb.head]; + uint32_t allocQIndx = gmemLkCb.queue[gmemLkCb.head]; gmemLkCb.head = (gmemLkCb.head +1) % CM_MAX_ALLOC_ENTERIES; return (allocQIndx); } } -#ifdef ANSI -PUBLIC U32 cmPutFreeIndx -( -U32 allocQIndx -) -#else -PUBLIC U32 cmPutFreeIndx(allocQIndx) -U32 allocQIndx; -#endif - +uint32_t cmPutFreeIndx(uint32_t allocQIndx) { - U32 tmpTail = (gmemLkCb.tail+1)% CM_MAX_ALLOC_ENTERIES; + uint32_t tmpTail = (gmemLkCb.tail+1)% CM_MAX_ALLOC_ENTERIES; if(tmpTail == gmemLkCb.head) { allocQueueFullCnt++; @@ -4794,7 +4453,7 @@ U32 allocQIndx; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -4802,18 +4461,10 @@ U32 allocQIndx; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void cmInitMemLeak -( -Void -) -#else -PUBLIC Void cmInitMemLeak (Void) -#endif +Void cmInitMemLeak (Void) { - U32 indx; + uint32_t indx; - TRC3(cmInitMemLeak); gmemLkCb.isStarted = FALSE; gmemLkCb.head = 0; @@ -4825,7 +4476,7 @@ PUBLIC Void cmInitMemLeak (Void) cmPutFreeIndx(indx); } - RETVOID; + return; } /* cmInitMemLeak */ /* * @@ -4834,7 +4485,7 @@ PUBLIC Void cmInitMemLeak (Void) * Desc: De-initializes the memory leak detection * * - * Ret: RETVOID + * Ret: void * * Notes: This function de-initializes the memory leak detection module. * @@ -4842,18 +4493,10 @@ PUBLIC Void cmInitMemLeak (Void) * File: cm_mem.c * **/ -#ifdef ANSI -PUBLIC Void cmDeinitMemLeak -( -Void -) -#else -PUBLIC Void cmDeinitMemLeak (Void) -#endif +Void cmDeinitMemLeak(Void) { - U32 indx; + uint32_t indx; - TRC3(cmDeinitMemLeak); for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++) { @@ -4863,7 +4506,7 @@ PUBLIC Void cmDeinitMemLeak (Void) gmemLkCb.isStarted = FALSE; gmemLkCb.head = 0; gmemLkCb.tail = 0; - RETVOID; + return; } /* * @@ -4872,7 +4515,7 @@ PUBLIC Void cmDeinitMemLeak (Void) * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -4880,18 +4523,9 @@ PUBLIC Void cmDeinitMemLeak (Void) * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC U32 cmStorAllocBlk -( -Void *addr -) -#else -PUBLIC U32 cmStorAllocBlk (addr) -Void *addr; -#endif /* ANSI */ - +uint32_t cmStorAllocBlk(Void *addr) { - U32 allocQIndx; + uint32_t allocQIndx; (Void) SLock(&gmemLkCb.memLock); allocQIndx = cmGetFreeIndx(); @@ -4914,7 +4548,7 @@ Void *addr; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -4922,17 +4556,8 @@ Void *addr; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void cmRlsAllocBlk -( -U32 allocQIndx -) -#else -PUBLIC Void cmRlsAllocBlk(allocQIndx) -U32 allocQIndx; -#endif +Void cmRlsAllocBlk(uint32_t allocQIndx) { - TRC3(cmRlsAllocBlk); if(allocQIndx < CM_MAX_ALLOC_ENTERIES) { @@ -4945,7 +4570,7 @@ U32 allocQIndx; (Void) SUnlock(&(gmemLkCb.memLock)); } } - RETVOID; + return; } /* cmRlsAllocBlk */ /* @@ -4959,27 +4584,20 @@ U32 allocQIndx; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void cmStartStopLeakLog -( -Void -) -#else -PUBLIC Void cmStartStopLeakLog(Void) -#endif +Void cmStartStopLeakLog(Void) { if (FALSE == gmemLkCb.isStarted) { - printf("!!leak capturing started\n"); + DU_LOG("\nINFO --> leak capturing started\n"); gmemLkCb.isStarted = TRUE; } else { gmemLkCb.isStarted = FALSE; - printf("!!leak capturing stopped\n"); + DU_LOG("\nINFO --> leak capturing stopped\n"); cmPrintLeakLog(); } - RETVOID; + return; } /* @@ -4995,34 +4613,26 @@ PUBLIC Void cmStartStopLeakLog(Void) * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void cmPrintLeakLog -( -Void -) -#else -PUBLIC Void cmPrintLeakLog(Void) -#endif +Void cmPrintLeakLog(Void) { - U32 indx; + uint32_t indx; CmMmBlkHdr *aBkt; - static U32 leakCount =0; + static uint32_t leakCount =0; - TRC3(cmPrintLeakLog); - printf("---- START OF LEAK LOG ----"); + DU_LOG("\nINFO --> START OF LEAK LOG "); SLock(&gmemLkCb.memLock); - printf("---- Lock Acquired ----"); + DU_LOG("\nINFO --> Lock Acquired"); for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++) { if(gmemLkCb.allocInfo[indx].used == TRUE) { leakCount++; aBkt =(CmMmBlkHdr *)gmemLkCb.allocInfo[indx].memAddr; - printf("LeakCnt(%ld)Addr(0x%p)RqSz(%ld)", + DU_LOG("LeakCnt(%ld)Addr(0x%p)RqSz(%ld)", leakCount,gmemLkCb.allocInfo[indx].memAddr, aBkt->requestedSize); - printf("LineNo(%ld)funcName(%s)\n", + DU_LOG("LineNo(%ld)funcName(%s)\n", aBkt->lineNo, aBkt->currFuncName); gmemLkCb.allocInfo[indx].used = FALSE; cmPutFreeIndx(indx); @@ -5030,11 +4640,11 @@ PUBLIC Void cmPrintLeakLog(Void) //if(leakCount % 10 == 0) // sleep(1); } - printf("---- END OF LEAK LOG ----"); + DU_LOG("\nINFO --> END OF LEAK LOG "); SUnlock(&gmemLkCb.memLock); - printf("---- Lock Released ----"); + DU_LOG("\nINFO --> Lock Released"); leakCount =0; - RETVOID; + return; } #endif @@ -5047,7 +4657,7 @@ PUBLIC Void cmPrintLeakLog(Void) * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5056,56 +4666,40 @@ PUBLIC Void cmPrintLeakLog(Void) * */ #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 -#ifdef ANSI -PUBLIC Void cmRlsAllocBlk +Void cmRlsAllocBlk ( CmMmBlkHdr *ptrHdr, CmMmRegCb *regCb ) #else -PUBLIC Void cmRlsAllocBlk(ptrHdr, regCb) -CmMmBlkHdr *ptrHdr; -CmMmRegCb *regCb; -#endif -#else -#ifdef ANSI -PUBLIC Void cmRlsAllocBlk +Void cmRlsAllocBlk ( #ifdef BIT_64 -U64 addr +uint64_t addr #else -U32 addr +uint32_t addr #endif ) -#else -PUBLIC Void cmRlsAllocBlk(addr) -#ifdef BIT_64 -U64 addr; -#else -U32 addr; -#endif -#endif #endif { Ptr trace[CM_MAX_STACK_TRACE]; S8 **funcNm; - U8 idx; - U8 i; + uint8_t idx; + uint8_t i; S16 retVal; S32 traceSize; #ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 MemAllocInfo *memAllocInfo; #endif - TRC3(cmRlsAllocBlk); #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 #ifdef BIT_64 - retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(U8 *)&ptrHdr, - (U16)sizeof(U64), 0, (PTR *)&ptrHdr); + retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(uint8_t *)&ptrHdr, + (uint16_t)sizeof(uint64_t), 0, (PTR *)&ptrHdr); #else - retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(U8 *)&ptrHdr, - (U16)sizeof(U32), 0, (PTR *)&ptrHdr); + retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(uint8_t *)&ptrHdr, + (uint16_t)sizeof(uint32_t), 0, (PTR *)&ptrHdr); #endif if(retVal == ROK) { @@ -5114,18 +4708,18 @@ U32 addr; #else if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } for(idx = 0; idx < CM_MEM_USR_MDL; idx++) { SLock(&memLkCb.memUsrMdl[idx][addr & 0x3].memLck); #ifdef BIT_64 retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp, - (U8 *)&addr, sizeof(U64), 0, + (uint8_t *)&addr, sizeof(uint64_t), 0, (PTR *)&memAllocInfo); #else retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp, - (U8 *)&addr, sizeof(U32), 0, + (uint8_t *)&addr, sizeof(uint32_t), 0, (PTR *)&memAllocInfo); #endif if(retVal == ROK) @@ -5217,7 +4811,7 @@ U32 addr; #endif /* SS_MEM_LEAK_SOL */ #endif/* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */ /*cm_mem_c_001.main_25 : */ - RETVOID; + return; } /* cmRlsAllocBlk */ @@ -5228,7 +4822,7 @@ U32 addr; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5237,66 +4831,44 @@ U32 addr; * */ #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 -#ifdef ANSI -PUBLIC Void cmStorAllocBlk +Void cmStorAllocBlk ( CmMmBlkHdr *ptrHdr, Size reqSz, Size allocSz, -U16 bktIdx, +uint16_t bktIdx, CmMmRegCb *regCb ) #else -PUBLIC Void cmStorAllocBlk (ptrHdr, reqSz, allocSz, bktIdx, regCb) -CmMmBlkHdr *ptrHdr; -Size reqSz; -Size allocSz; -U16 bktIdx; -CmMmRegCb *regCb; -#endif -#else -#ifdef ANSI -PUBLIC Void cmStorAllocBlk +Void cmStorAllocBlk ( #ifdef BIT_64 -U64 addr, +uint64_t addr, #else -U32 addr, +uint32_t addr, #endif Size reqSz, Size allocSz, -U16 bktIdx +uint16_t bktIdx ) -#else -PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx) -#ifdef BIT_64 -U64 addr; -#else -U32 addr; -#endif -Size reqSz; -Size allocSz; -U16 bktIdx; -#endif /* ANSI */ #endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */ { #ifndef SS_MEM_LEAK_SOL void *trace[CM_MAX_STACK_TRACE]; #endif /* SS_MEM_LEAK_SOL */ #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 - U8 btrIdx; + uint8_t btrIdx; #else MemAllocInfo *allocInfo; - U8 moduleId; + uint8_t moduleId; S8 **funcNm; S32 traceSize; #endif - TRC3(cmStorAllocBlk); #ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } #endif #ifdef SS_MEM_LEAK_SOL @@ -5305,12 +4877,12 @@ U16 bktIdx; * implementation. */ /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE - funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(U32) * CM_MAX_STACK_TRACE)); - cmMemset((U8*)funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE)); + funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(uint32_t) * CM_MAX_STACK_TRACE)); + memset(funcNm, 0, (sizeof(uint32_t) * CM_MAX_STACK_TRACE)); #else - funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE)); + funcNm = (S8 **)calloc(1, (sizeof(uint32_t) * CM_MAX_STACK_TRACE)); #endif - /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(U32) * CM_MAX_STACK_TRACE); */ + /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */ traceSize = backtrace((Void **)funcNm, CM_MAX_STACK_TRACE); #else /* SS_MEM_LEAK_SOL */ #ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 @@ -5328,12 +4900,12 @@ U16 bktIdx; #ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 #ifdef SS_4GMX_LCORE allocInfo = (MemAllocInfo *)MxHeapAlloc(SsiHeap, sizeof(MemAllocInfo)); - cmMemset((U8*)allocInfo, 0, sizeof(MemAllocInfo)); + memset(allocInfo, 0, sizeof(MemAllocInfo)); #else allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo)); #endif #endif - /* SGetSBuf(DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */ + /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */ #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 /* check if hashListCp is initialised yet */ if ( regCb->brdcmSsiLstCp.nmbBins == 0) @@ -5344,7 +4916,7 @@ U16 bktIdx; ptrHdr->allocSz = allocSz; ptrHdr->bktIdx = bktIdx; cmHashListInsert(®Cb->brdcmSsiLstCp, (PTR)ptrHdr, - (U8 *)&(ptrHdr), sizeof(PTR)); + (uint8_t *)&(ptrHdr), sizeof(PTR)); #else allocInfo->memAddr = addr; allocInfo->reqSz = reqSz; @@ -5354,18 +4926,18 @@ U16 bktIdx; allocInfo->moduleId = moduleId; allocInfo->bTrcSz = traceSize; cmHashListInsert(&memLkCb.memUsrMdl[moduleId][addr & 0x3].memHashCp, - (PTR)allocInfo, (U8 *)&(allocInfo->memAddr), + (PTR)allocInfo, (uint8_t *)&(allocInfo->memAddr), sizeof(allocInfo->memAddr)); memLkCb.memUsrMdl[moduleId][addr & 0x3].used = TRUE; (Void) SUnlock(&(memLkCb.memUsrMdl[moduleId][addr & 0x3].memLck)); #endif - RETVOID; + return; } /* cmStorAllocBlk */ /* * - RETVOID; + return; } /* cmStorAllocBlk */ /* @@ -5375,7 +4947,7 @@ U16 bktIdx; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5383,18 +4955,11 @@ U16 bktIdx; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void SLogLkInfo -( -Void -) -#else -PUBLIC Void SLogLkInfo (Void) -#endif +Void SLogLkInfo (Void) { #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2 - U8 idx; - U8 regionIdx; + uint8_t idx; + uint8_t regionIdx; Txt prntBuf[255]; S8 **funcNm; CmMmBlkHdr *newBlkHdr; @@ -5402,7 +4967,6 @@ PUBLIC Void SLogLkInfo (Void) CmMmRegCb *tmpRegCb; FILE *fp; - TRC3(SLogLkInfo); fp = fopen("meLeakLog.txt", "w"); if(fp == NULL) { @@ -5455,15 +5019,14 @@ PUBLIC Void SLogLkInfo (Void) #else MemAllocInfo *oldMemInfo; MemAllocInfo *newMemInfo; - U8 memMdl; - U8 hashIdx; - U8 idx; + uint8_t memMdl; + uint8_t hashIdx; + uint8_t idx; Txt prntBuf[255]; S8 **funcNm; - TRC3(SLogLkInfo); if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } sprintf(prntBuf, "\n------- START OF LEAK LOG -------\n"); fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog); @@ -5520,7 +5083,7 @@ PUBLIC Void SLogLkInfo (Void) sprintf(prntBuf, "\n------- END OF LEAK LOG -------\n"); fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog); #endif - RETVOID; + return; } #endif @@ -5534,7 +5097,7 @@ PUBLIC Void SLogLkInfo (Void) * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5542,19 +5105,11 @@ PUBLIC Void SLogLkInfo (Void) * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void cmInitMemLeakMdl -( -Void -) -#else -PUBLIC Void cmInitMemLeakMdl (Void) -#endif +Void cmInitMemLeakMdl (Void) { - U8 memMdl; - U8 hashIdx; + uint8_t memMdl; + uint8_t hashIdx; - TRC3(cmInitMemLeakMdl); memLkCb.memLkMdlInit = FALSE; for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++) @@ -5563,7 +5118,7 @@ PUBLIC Void cmInitMemLeakMdl (Void) { SInitLock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck, 1); cmHashListInit(&memLkCb.memUsrMdl[memMdl][hashIdx].memHashCp, - 500, 0, FALSE, CM_HASH_KEYTYPE_U32MOD, 0, 0); + 500, 0, FALSE, CM_HASH_KEYTYPE_UINT32_MOD, 0, 0); memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE; } } @@ -5573,7 +5128,7 @@ PUBLIC Void cmInitMemLeakMdl (Void) } memLkCb.memLkMdlInit = TRUE; - RETVOID; + return; } /* cmInitMemLeakMdl */ /* cm_mem_c_002.main_21 Added for shutdown procedure */ /* @@ -5583,7 +5138,7 @@ PUBLIC Void cmInitMemLeakMdl (Void) * Desc: De-initializes the memory leak detection module * * - * Ret: RETVOID + * Ret: void * * Notes: This function de-initializes the memory leak detection module. * @@ -5591,19 +5146,11 @@ PUBLIC Void cmInitMemLeakMdl (Void) * File: cm_mem.c * **/ -#ifdef ANSI -PUBLIC Void cmDeinitMemLeakMdl -( -Void -) -#else -PUBLIC Void cmDeinitMemLeakMdl (Void) -#endif +Void cmDeinitMemLeakMdl (Void) { - U8 memMdl; - U8 hashIdx; + uint8_t memMdl; + uint8_t hashIdx; - TRC3(cmDeinitMemLeakMdl); memLkCb.memLkMdlInit = FALSE; for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++) @@ -5615,7 +5162,7 @@ PUBLIC Void cmDeinitMemLeakMdl (Void) memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE; } } - RETVOID; + return; } /* * @@ -5624,7 +5171,7 @@ PUBLIC Void cmDeinitMemLeakMdl (Void) * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5632,20 +5179,11 @@ PUBLIC Void cmDeinitMemLeakMdl (Void) * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void cmMemOpenMemLkFile -( -S8 *arg -) -#else -PUBLIC Void cmMemOpenMemLkFile (arg) -S8 *msOptArg; -#endif +Void cmMemOpenMemLkFile(S8 *arg) { - TRC3(cmMemOpenMemLkFile); memLkCb.fileLkLog = NULLP; memLkCb.fileLkLog = fopen(arg, "w"); - RETVOID; + return; } /* * @@ -5654,7 +5192,7 @@ S8 *msOptArg; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5662,27 +5200,19 @@ S8 *msOptArg; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC Void SFlushLkInfo -( -Void -) -#else -PUBLIC Void SFlushLkInfo (Void) -#endif +Void SFlushLkInfo (Void) { - MemAllocInfo *newMemInfo; - U8 memMdl; - U8 hashIdx; - S8 **funcNm; + MemAllocInfo *newMemInfo; + uint8_t memMdl; + uint8_t hashIdx; + S8 **funcNm; #ifdef SS_MEM_LEAK_SOL - U8 i; + uint8_t i; #endif /* SS_MEM_LEAK_SOL */ - TRC3(SFlushLkInfo); if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++) @@ -5708,7 +5238,7 @@ PUBLIC Void SFlushLkInfo (Void) #else free(funcNm[i]); #endif - /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(U32) * CM_MAX_STACK_TRACE); */ + /* SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */ } #endif /* SS_MEM_LEAK_SOl */ /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ @@ -5723,7 +5253,7 @@ PUBLIC Void SFlushLkInfo (Void) SUnlock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck); } } - RETVOID; + return; } /* * @@ -5732,7 +5262,7 @@ PUBLIC Void SFlushLkInfo (Void) * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5740,21 +5270,11 @@ PUBLIC Void SFlushLkInfo (Void) * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC U8 cmMemGetModuleId -( -S8 **funNm, -S32 traceSize -) -#else -PUBLIC U8 cmMemGetModuleId (funNm, traceSize) -S8 **funNm; -S32 traceSize; -#endif /* ANSI */ +uint8_t cmMemGetModuleId(S8 **funNm,S32 traceSize) { - U8 idx; - U8 memStrIdx; - U32 len; + uint8_t idx; + uint8_t memStrIdx; + uint32_t len; S32 retVal; S16 memReqIdx; S16 mdlFunStrIdx; @@ -5762,7 +5282,6 @@ S32 traceSize; Txt *memFn[]={"SGetMsg", "SGetSBuf", "SGetDBuf", NULLP}; /*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/ - TRC3(cmMemGetModuleId) for(idx = 0; idx < traceSize; idx++) { memReqIdx = -1; @@ -5809,7 +5328,7 @@ S32 traceSize; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5817,30 +5336,21 @@ S32 traceSize; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC S16 cmMemGetStrMtchIdx +S16 cmMemGetStrMtchIdx ( -U8 strtIdx, -U8 endIdx, +uint8_t strtIdx, +uint8_t endIdx, S8 *str, S8 **strLst ) -#else -PUBLIC S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst) -U8 strtIdx; -U8 endIdx; -S8 *str; -S8 **strLst; -#endif { S8 cmpStr[255]; - U32 len; + uint32_t len; Bool found; - U32 tempLen; - U8 idx; + uint32_t tempLen; + uint8_t idx; S32 retVal; - TRC3(cmMemGetStrMtchIdx); len = strlen((const S8 *)str); cmpStr[0] = '('; @@ -5883,7 +5393,7 @@ S8 **strLst; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5891,25 +5401,12 @@ S8 **strLst; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC S32 cmAddrToSymStr -( -Void *pc, -S8 *buffer, -S32 size -) -#else -PUBLIC S32 cmAddrToSymStr(pc, buffer, size) -Void *pc; -S8 *buffer; -S32 size; -#endif +S32 cmAddrToSymStr(Void *pc, S8 *buffer, S32 size) { Dl_info info; Sym *sym; - TRC3(cmAddrToSymStr); if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0) { @@ -5940,7 +5437,7 @@ S32 size; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5948,22 +5445,9 @@ S32 size; * File: cm_mem.c * */ -#ifdef ANSI -PUBLIC S32 cmLeakCallBack -( -uintptr_t pc, -S32 sigNo, -Void *arg -) -#else -PUBLIC S32 cmLeakCallBack(pc, sigNo, arg) -uintptr_t pc; -S32 sigNo; -Void *arg; -#endif +S32 cmLeakCallBack(uintptr_t pc,S32 sigNo, Void *arg) { S8 *buffer; - TRC3(cmLeakCallBack); Backtrace_t *bt = (Backtrace_t *)arg; if (bt->bt_actcount >= bt->bt_maxcount) @@ -5971,11 +5455,11 @@ Void *arg; /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE buffer = (S8 *)MxHeapAlloc(SsiHeap, 510); - cmMemset((U8*)buffer, 0, 510); + memset(buffer, 0, 510); #else buffer = (S8 *)calloc(1, 510); #endif - /* SGetSBuf(DFLT_REGION, DFLT_POOL, &buffer, 510); */ + /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &buffer, 510); */ (void) cmAddrToSymStr((void *)pc, buffer, 505); bt->bt_buffer[bt->bt_actcount++] = (S8 *)buffer; @@ -6004,34 +5488,15 @@ Void *arg; * */ #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 -#ifdef ANSI -PUBLIC S16 cmMmRegIsBlkSane -( -CmMmBlkHdr *blkPtr, -Size size -) +S16 cmMmRegIsBlkSane(CmMmBlkHdr *blkPtr,Size size) #else -PUBLIC S16 cmMmRegIsBlkSane(blkPtr, size) -CmMmBlkHdr *blkPtr; -Size size; -#endif -#else -#ifdef ANSI -PUBLIC S16 cmMmRegIsBlkSane -( -CmMmBlkHdr *blkPtr -) -#else -PUBLIC S16 cmMmRegIsBlkSane(blkPtr) -CmMmBlkHdr *blkPtr; -#endif +S16 cmMmRegIsBlkSane(CmMmBlkHdr *blkPtr) #endif { - U32 sigCnt; + uint32_t sigCnt; #ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 CmMmBlkTail *tailPtr; #endif - TRC2(cmMmRegIsBlkSane); for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++) { @@ -6074,20 +5539,10 @@ CmMmBlkHdr *blkPtr; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmMmBktSanityChk -( -CmMmBkt *bkt -) -#else -PRIVATE S16 cmMmBktSanityChk(bkt) -CmMmBkt *bkt; -#endif +static S16 cmMmBktSanityChk(CmMmBkt *bkt) { CmMmBlkHdr *ptrBlk; - U32 blkCnt; - - TRC2(cmMmBktSanityChk); + uint32_t blkCnt; bkt->trampleCount = 0; @@ -6136,19 +5591,9 @@ CmMmBkt *bkt; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmMmHeapSanityChk -( -CmMmHeapCb *heapCb -) -#else -PRIVATE S16 cmMmHeapSanityChk(heapCb) -CmMmHeapCb *heapCb; -#endif +static S16 cmMmHeapSanityChk(CmMmHeapCb *heapCb) { - TRC2(cmMmHeapSanityChk); - /* increment the trample count */ heapCb->trampleCount++; @@ -6175,23 +5620,10 @@ CmMmHeapCb *heapCb; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmMmHashFunc -( -CmMmHashListCp *hashListCp, -U32 key, -U16 *idx -) -#else -PRIVATE S16 cmMmHashFunc (hashListCp, key, idx) -CmMmHashListCp *hashListCp; /* hash list control point */ -U32 key; /* key string */ -U16 *idx; /* idx to return */ -#endif +static S16 cmMmHashFunc(CmMmHashListCp *hashListCp,uint32_t key,uint16_t *idx) { - TRC2(cmMmHashFunc); - *idx = (U16)(key % hashListCp->numOfbins); + *idx = (uint16_t)(key % hashListCp->numOfbins); return ROK; @@ -6218,26 +5650,17 @@ U16 *idx; /* idx to return */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmMmHashListInit +static S16 cmMmHashListInit ( CmMmHashListCp *hashListCp, /* hash list to initialize */ -U16 nmbBins, /* number of hash list bins */ +uint16_t nmbBins, /* number of hash list bins */ Region region, /* memory region to allocate bins */ Pool pool /* memory pool to allocate bins */ ) -#else -PRIVATE S16 cmMmHashListInit(hashListCp, nmbBins, region, pool) -CmMmHashListCp *hashListCp; /* hash list to initialize */ -U16 nmbBins; /* number of hash list bins */ -Region region; /* memory region to allocate bins */ -Pool pool; /* memory pool to allocate bins */ -#endif { - U16 i; + uint16_t i; CmMmHashListEnt *hl; - TRC2(cmMmHashListInit); /* initialize control point fields */ hashListCp->hashList = NULLP; @@ -6247,7 +5670,7 @@ Pool pool; /* memory pool to allocate bins */ /* allocate memory for bins */ if (nmbBins) { - if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList, + if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data **) &hashListCp->hashList, (Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK) return RFAILED; @@ -6284,25 +5707,17 @@ Pool pool; /* memory pool to allocate bins */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmMmHashListDeinit +static S16 cmMmHashListDeinit ( CmMmHashListCp *hashListCp, /* hash list to deinitialize */ -Region region, /* memory region to allocate bins */ -Pool pool /* memory pool to allocate bins */ +Region region, /* memory region to allocate bins */ +Pool pool /* memory pool to allocate bins */ ) -#else -PRIVATE S16 cmMmHashListDeinit(hashListCp, region, pool) -CmMmHashListCp *hashListCp; /* hash list to deinitialize */ -Region region; /* memory region to allocate bins */ -Pool pool; /* memory pool to allocate bins */ -#endif { - TRC2(cmMmHashListDeinit); /* deallocate memory for bins */ if (hashListCp->numOfbins) - (Void) SPutSBuf(region, pool, + (Void) SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data *) hashListCp->hashList, (Size) (hashListCp->numOfbins * sizeof(CmMmHashListEnt))); @@ -6331,23 +5746,16 @@ Pool pool; /* memory pool to allocate bins */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmMmHashListInsert +static S16 cmMmHashListInsert ( CmMmHashListCp *hashListCp, /* hash list to add to */ -U32 key /* pointer to key */ +uint32_t key /* pointer to key */ ) -#else -PRIVATE S16 cmMmHashListInsert(hashListCp, key) -CmMmHashListCp *hashListCp; /* hash list to add to */ -U32 key; /* pointer to key */ -#endif { CmMmHashListEnt *hashListEnt; /* pointer to hash list entry header */ - U16 idx; /* index for insertion into hash list */ - U16 i; + uint16_t idx; /* index for insertion into hash list */ + uint16_t i; - TRC2(cmMmHashListInsert); /* check if hashListCp is initialised yet */ if ( hashListCp->numOfbins == 0) @@ -6416,18 +5824,12 @@ U32 key; /* pointer to key */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmHashListInit +static S16 cmHstGrmHashListInit ( CmHstGrmHashListCp *hashListCp /* hash list to initialize */ ) -#else -PRIVATE S16 cmHstGrmHashListInit(hashListCp) -CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ -#endif { /*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/ - TRC2(cmHstGrmHashListInit) #ifdef DEBUGP /* display an error message here */ /*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/ @@ -6457,18 +5859,12 @@ CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmHashListDeInit +static S16 cmHstGrmHashListDeInit ( CmHstGrmHashListCp *hashListCp /* hash list to initialize */ ) -#else -PRIVATE S16 cmHstGrmHashListDeInit(hashListCp) -CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ -#endif { /*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/ - TRC2(cmHstGrmHashListDeInit) #ifdef DEBUGP /* display an error message here */ /*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/ @@ -6502,31 +5898,21 @@ CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmFreeInsert +static S16 cmHstGrmFreeInsert ( CmHstGrmHashListCp* hashListCp, /* hash list cp */ -U32 blkSz, /* size of the block freed */ -U32 line, /* Line number */ -U8 *fileName, /* file name */ -U8 entId /* Tapa task which free the memory */ +uint32_t blkSz, /* size of the block freed */ +uint32_t line, /* Line number */ +uint8_t *fileName, /* file name */ +uint8_t entId /* Tapa task which free the memory */ ) -#else -PRIVATE S16 cmHstGrmFreeInsert(hashListCp, blkSz, line, fileName, entId) -CmHstGrmHashListCp* hashListCp; /* hash list cp */ -U32 blkSz; /* size of the block freed */ -U32 line; /* line number */ -U8 *fileName; /* file Name */ -U8 entId; /* Tapa task which frees the memory */ -#endif { - U32 binIdx = 0; /* Bin index to insert the entry into the hash list */ - U32 key = 0; /* Key to fine the bin index */ - U32 ret = 0; /* Return value */ - CmMemEntries *entry = NULLP; /* Entry which contains the information */ + uint32_t binIdx = 0; /* Bin index to insert the entry into the hash list */ + uint32_t key = 0; /* Key to fine the bin index */ + uint32_t ret = 0; /* Return value */ + CmMemEntries *entry = NULLP; /* Entry which contains the information */ - TRC2(cmHstGrmFreeInsert); /* check for the total number of entries in the hash list. * * If there is no place for new entry return failure */ @@ -6545,7 +5931,7 @@ U8 entId; /* Tapa task which frees the memory */ /* If hash list is full then print the error tna continue */ if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN)) { - printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n"); + DU_LOG("\nERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n"); return RFAILED; } /* End of if */ @@ -6585,32 +5971,21 @@ U8 entId; /* Tapa task which frees the memory */ * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmAllocInsert +static S16 cmHstGrmAllocInsert ( CmHstGrmHashListCp *hashListCp, -U32 blkSz, -U32 *reqSz, -U32 line, -U8 *fileName, -U8 entId +uint32_t blkSz, +uint32_t *reqSz, +uint32_t line, +uint8_t *fileName, +uint8_t entId ) -#else -PRIVATE S16 cmHstGrmAllocInsert(hashListCp, blkSz, reqSz, line, fileName, entId) -CmHstGrmHashListCp *hashListCp; -U32 blkSz; -U32 *reqSz; -U32 line; -U8 *fileName; -U8 entId; -#endif { - U32 binIdx = 0; - U32 key = 0; - U32 ret = 0; - CmMemEntries *entry = NULLP; + uint32_t binIdx = 0; + uint32_t key = 0; + uint32_t ret = 0; + CmMemEntries *entry = NULLP; - TRC2(cmHstGrmAllocInsert); /* check for the total number of entries in the hash list. * * If there is no place for new entry return failure */ @@ -6630,7 +6005,7 @@ U8 entId; if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN)) { - printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n"); + DU_LOG("\nERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n"); return RFAILED; } /* End of if */ @@ -6673,25 +6048,16 @@ U8 entId; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmGetHashIdxAndKey +static S16 cmHstGrmGetHashIdxAndKey ( -U8 *fileName, -U32 line, -U32 *binIdx, -U32 *key +uint8_t *fileName, +uint32_t line, +uint32_t *binIdx, +uint32_t *key ) -#else -PRIVATE S16 cmHstGrmGetHashIdxAndKey(fileName, line, binIdx, key) -U8 *fileName; -U32 line; -U32 *binIdx; -U32 *key; -#endif { - U32 i = 0; - TRC2(cmHstGrmGetHashIdxAndKey); + uint32_t i = 0; /* Calculate the key using file name and line number */ for(i = 0 ; fileName[i] != '\0'; i++) @@ -6723,27 +6089,17 @@ U32 *key; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmFillEntry +static S16 cmHstGrmFillEntry ( -CmMemEntries *entry, -U32 key, -U32 line, -U8 *fileName, -U8 entId +CmMemEntries *entry, +uint32_t key, +uint32_t line, +uint8_t *fileName, +uint8_t entId ) -#else -PRIVATE S16 cmHstGrmFillEntry(entry, key, line, fileName, entId) -CmMemEntries *entry; -U32 key; -U32 line; -U8 *fileName; -U8 entId; -#endif { - U32 idx = 0; - TRC2(cmHstGrmFillEntry); + uint32_t idx = 0; entry->key = key; entry->line = line; entry->entId = entId; @@ -6772,30 +6128,19 @@ U8 entId; * File: cm_mem.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmFindEntry +static S16 cmHstGrmFindEntry ( CmHstGrmHashListCp *hashListCp, -U32 key, -U32 *binIdx, -CmMemEntries **entry +uint32_t key, +uint32_t *binIdx, +CmMemEntries **entry ) -#else -PRIVATE S16 cmHstGrmFindEntry(hashListCp, key, binIdx, entry) -CmHstGrmHashListCp *hashListCp; -U32 key; -U32 *binIdx; -CmMemEntries **entry; -#endif { - U32 numEnt = 0; - U32 numBin = 0; + uint32_t numEnt = 0; + uint32_t numBin = 0; CmHstGrmHashListEnt *tmpBin = NULLP; - TRC2(cmHstGrmFindEntry); - - for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++) { /* find for the entry in the bin */ @@ -6829,12 +6174,12 @@ CmMemEntries **entry; } /* End of if (numEnt) */ else { - printf ("Unable to find the entry in hash list\n"); + DU_LOG("\nERROR --> Unable to find the entry in hash list\n"); return RFAILED; }/* End of else (numEnt) */ }/* end of for (numBin = 0) */ - printf("Unable to find the entry in the hash list\n"); + DU_LOG("\nERROR --> Unable to find the entry in the hash list\n"); return RFAILED; } /* end of cmHstGrmFindEntry */