X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Fcm_mem_wl.c;h=cd042a4335edb2f169b2a28db8e2068371ab2350;hb=cb811f8127971006aa5c345c71cb737e8be8dc10;hp=fc31831078e849798427a7a910de418b796edcac;hpb=d349ae65e1495488772f87e5cfa1ae71d9eab075;p=o-du%2Fl2.git diff --git a/src/cm/cm_mem_wl.c b/src/cm/cm_mem_wl.c index fc3183107..cd042a433 100755 --- a/src/cm/cm_mem_wl.c +++ b/src/cm/cm_mem_wl.c @@ -115,18 +115,18 @@ The following functions are provided in this file. #ifdef L2_L3_SPLIT #include "mt_plat_t33.h" -extern S32 clusterMode; +S32 clusterMode; #endif #include "cm_lte.x" - +#include "du_log.h" /* local defines */ /*ccpu00142274 - UL mem based flow control changes */ #ifdef TENB_T2K3K_SPECIFIC_CHANGES /* selva */ -U32 gMemoryAlarm; -PRIVATE U32 memoryCheckCounter; +uint32_t gMemoryAlarm; +static uint32_t memoryCheckCounter; #define NUM_CALLS_TO_CHECK_MEM_AGAIN 80 /* Number of calls after which need to check mem */ #ifndef L2_L3_SPLIT @@ -205,7 +205,7 @@ typedef struct cmMemFreeInfo #define NUM_FREE_BUFFERS 128 typedef struct cmBtInfo { - U32 btInfoIdx; + uint32_t btInfoIdx; CmMemFreeInfo btInfo[NUM_FREE_BUFFERS]; } CmBtInfo; @@ -220,137 +220,70 @@ typedef struct cmMemDoubleFree }CmMemDoubleFree; PTR prvAllocPtr[8]; -PUBLIC U8 stopBtInfo = FALSE; -PUBLIC Buffer *palBuffer; -EXTERN Buffer *mtTskBuffer1; -EXTERN Buffer *mtTskBuffer2; +uint8_t stopBtInfo = FALSE; +Buffer *palBuffer; +Buffer *mtTskBuffer1; +Buffer *mtTskBuffer2; #ifdef SS_USE_ICC_MEMORY -PRIVATE pthread_mutex_t iccAllocFreeLock; +static pthread_mutex_t iccAllocFreeLock; #else -PRIVATE pthread_mutex_t dynAllocFreeLock; +static pthread_mutex_t dynAllocFreeLock; #endif /* SS_USE_ICC_MEMORY */ #ifdef SS_MEM_WL_DEBUG -PRIVATE S16 cmInitBtInfo ARGS((void)); +static S16 cmInitBtInfo ARGS((void)); #endif #ifdef SS_USE_ICC_MEMORY #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmIccAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char*, U32)); -PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size,char*, U32)); -PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char*, U32)); -PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size,char*, U32)); -PUBLIC void InsertToT2kMemLeakInfo ARGS((U32 address, U32 size, U32 lineNo, char* fileName)); -void RemoveFromT2kMemLeakInfo ARGS((U32 address, char *file, U32 line)); -PRIVATE U32 getT2kMemLeakIndex ARGS((U32 address)); -#else -PRIVATE S16 cmIccAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr)); -PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size)); -PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr)); -PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size)); +static S16 cmIccAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char*, uint32_t)); +static S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t)); +static S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char*, uint32_t)); +static S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t)); +void InsertToT2kMemLeakInfo ARGS((uint32_t address, uint32_t size, uint32_t lineNo, char* fileName)); +void RemoveFromT2kMemLeakInfo ARGS((uint32_t address, char *file, uint32_t line)); +static uint32_t getT2kMemLeakIndex ARGS((uint32_t address)); +#else +static S16 cmIccAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr)); +static S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size)); +static S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr)); +static S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size)); #endif #else /* SS_USE_ICC_MEMORY */ -PRIVATE S16 cmDynAllocWithLock ARGS((Void *regionCb,Size *size,U32 flags,Data **ptr)); -PRIVATE S16 cmDynFreeWithLock ARGS((Void *regionCb,Data *ptr, Size size)); -PRIVATE S16 cmDynAlloc ARGS((Void *regionCb,Size *size,U32 flags,Data **ptr)); -PRIVATE S16 cmDynFree ARGS((Void *regionCb,Data *ptr, Size size)); +static S16 cmDynAllocWithLock ARGS((Void *regionCb,Size *size,uint32_t flags,Data **ptr)); +static S16 cmDynFreeWithLock ARGS((Void *regionCb,Data *ptr, Size size)); +static S16 cmDynAlloc ARGS((Void *regionCb,Size *size,uint32_t flags,Data **ptr)); +static S16 cmDynFree ARGS((Void *regionCb,Data *ptr, Size size)); #endif /* SS_USE_ICC_MEMORY */ #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,char*,U32)); -PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, U32)); +static S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,char*,uint32_t)); +static S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t)); -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,char*,U32)); -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size,char*, U32)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,char*,uint32_t)); +static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t)); #else -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)); -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr)); -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size)); +static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr)); +static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size)); #endif #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,char*,U32)); -PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, U32)); +static S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,char*,uint32_t); +static S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t); #else -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 #ifndef USE_PURE -PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size)); -PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size)); -#endif -PRIVATE S16 cmCtl ARGS((Void *regionCb, Event event, SMemCtl *memCtl)); -PRIVATE Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size)); -#if 0 -#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)); -/*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)); -#endif /* SSI_DEBUG_LEVEL1 */ - -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 line, - U8 *fileName, U8 entId, Bool hstReg)); - -PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size, - U32 line, U8 *fileName, U8 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)); -#else -PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size)); -#endif /* SSI_DEBUG_LEVEL1 */ -PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size)); -/* cm_mem_c_001.main_15 :Additions */ -#ifdef SSI_DEBUG_LEVEL1 -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType)); -#else -PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr)); -#endif /* SSI_DEBUG_LEVEL1 */ -PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size)); -#endif /* SS_HISTOGRAM_SUPPORT */ - -/*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)); -#endif - - -PRIVATE Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb, - CmMmRegCfg *cfg, U16 bktIdx, U16 *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, - Region region, Pool pool)); -PRIVATE S16 cmMmHashListDeinit ARGS((CmMmHashListCp *hashListCp, Region region, Pool pool)); -PRIVATE S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, U32 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)); -#endif /* SS_HISTOGRAM_SUPPORT */ +static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size)); +static S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size)); #endif +static S16 cmCtl ARGS((Void *regionCb, Event event, SMemCtl *memCtl)); +static Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size)); /* cm_mem_c_001.main_22: Fixing warnings on GCC compiler */ #ifdef __cplusplus @@ -378,15 +311,15 @@ MemLkCb memLkCb; /* cm_mem_c_008.104 - Addition for memory calculator tool */ #ifdef MEMCAL_DEBUG -PRIVATE Txt prntBuf[200]; /* print buffer */ -PRIVATE U8 tryHeap=0; +static Txt prntBuf[200]; /* print buffer */ +static uint8_t tryHeap=0; #endif /* cm_mem_c_001.main_12 - addition for ssi enhancements prints */ /* cm_mem_c_001.main_20 Additions */ #if (defined(SSI_DEBUG_LEVEL1) || defined(SS_HISTOGRAM_SUPPORT)) #ifdef DEBUGP -PRIVATE Txt dbgPrntBuf[200]; /* print buffer */ +static Txt dbgPrntBuf[200]; /* print buffer */ #endif /* DEBUGP */ #endif /*SSI_DEBUG_LEVEL1 || SS_HISTOGRAM_SUPPORT */ @@ -400,13 +333,10 @@ PRIVATE Txt dbgPrntBuf[200]; /* print buffer */ #define T2K_MEM_LEAK_START_ADDR 0x9d200000 /*New Sercomm Board*/ #endif -U32 num_times = 0; -EXTERN pthread_t tmpRegTidMap[20]; -#if 0 -EXTERN pthread_t tmpMainTid; -#endif -extern Bool g_usettitmr; -PUBLIC void DumpLayersDebugInformation() +uint32_t num_times = 0; +pthread_t tmpRegTidMap[20]; +Bool g_usettitmr; +void DumpLayersDebugInformation() { DumpSSIDemandQDebugInformation(); /* dump layers information only after we start receiving the TTIs */ @@ -433,7 +363,7 @@ PUBLIC void DumpLayersDebugInformation() #else //DumpPDCPDlDebugInformation(); //DumpPDCPUlDebugInformation(); -#ifdef CU_STUB +#ifndef ODU_TEST_STUB DumpRLCDlDebugInformation(); DumpRLCUlDebugInformation(); #endif @@ -458,37 +388,27 @@ PUBLIC void DumpLayersDebugInformation() * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE Void cmMmStatBktInit +static Void cmMmStatBktInit ( Data **memAddr, CmMmRegCb *regCb, CmMmRegCfg *cfg, -U16 bktIdx, -U16 *lstMapIdx +uint16_t bktIdx, +uint16_t *lstMapIdx ) -#else -PRIVATE Void cmMmStatBktInit (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 */ #ifdef SSI_DEBUG_LEVEL1 CmMmBlkHdr **nextBlk; - U32 sigCnt; + uint32_t sigCnt; #else Data **next; #endif /* SSI_DEBUG_LEVEL1 */ - TRC2(cmMmStatBktInit); size = cfg->bktCfg[bktIdx].size; @@ -596,7 +516,7 @@ U16 *lstMapIdx; cmHstGrmHashListInit(&(regCb->bktTbl[bktIdx].hstGrmHashListCp)); #endif /* SS_HISTOGRAM_SUPPORT */ - RETVOID; + return; } /* end of cmMmStatBktInit */ /* @@ -624,23 +544,16 @@ U16 *lstMapIdx; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S16 cmMmStatRegInit +S16 cmMmStatRegInit ( Region region, CmMmRegCb *regCb, CmMmRegCfg *cfg ) -#else -PUBLIC S16 cmMmStatRegInit(region, regCb, cfg) -Region region; -CmMmRegCb *regCb; -CmMmRegCfg *cfg; -#endif { Data *memAddr; - U16 bktIdx; - U16 lstMapIdx; + uint16_t bktIdx; + uint16_t lstMapIdx; #if (ERRCLASS & ERRCLS_INT_PAR) Size lstQnSize; @@ -648,21 +561,20 @@ CmMmRegCfg *cfg; Txt errMsg[256] = {'\0'}; #endif - TRC2(cmMmRegInit); #if (ERRCLASS & ERRCLS_INT_PAR) /* error check on parameters */ if ((regCb == NULLP) || (cfg == NULLP)) { - RETVALUE(RFAILED); + return RFAILED; } /* Error check on the configuration fields */ if ((!cfg->size) || (cfg->vAddr == NULLP) || (cfg->numBkts > CMM_MAX_BKT_ENT)) { - RETVALUE(RFAILED); + return RFAILED; } /* Check if the quantum size is power of 2 */ if ((cfg->numBkts) && @@ -671,7 +583,7 @@ CmMmRegCfg *cfg; /* cm_mem_c_001.main_20 Addition */ sprintf(errMsg,"\n cmMmRegInit() failed, check if BktQuantum size might not be power of 2 \n"); SPrint(errMsg); - RETVALUE(RFAILED); + return RFAILED; } /* @@ -697,7 +609,7 @@ CmMmRegCfg *cfg; \n",bktIdx,cfg->bktCfg[bktIdx].size,cfg->bktQnSize); #endif SPrint(errMsg); - RETVALUE(RFAILED); + return RFAILED; } if ((bktBlkSize = cfg->bktCfg[bktIdx].size) < lstQnSize) @@ -708,7 +620,7 @@ CmMmRegCfg *cfg; /* cm_mem_c_001.main_20 Addition */ sprintf(errMsg,"\n cmMmRegInit() failed, Two consecutive buckets are not separated by quantum size \n"); SPrint(errMsg); - RETVALUE(RFAILED); + return RFAILED; } /* cm_mem_c_001.main_20 Addition */ if (((cfg->bktCfg[bktIdx].size) /\ @@ -724,7 +636,7 @@ CmMmRegCfg *cfg; \n should be less than CMM_MAX_MAP_ENT:%d \n",cfg->bktQnSize,CMM_MAX_MAP_ENT); #endif SPrint(errMsg); - RETVALUE(RFAILED); + return RFAILED; } @@ -737,7 +649,7 @@ CmMmRegCfg *cfg; sprintf(errMsg,"\n cmMmRegInit() failed, Size of the memory region is less than the required size \n"); SPrint(errMsg); - RETVALUE(RFAILED); + return RFAILED; } lstQnSize = ((bktBlkSize / cfg->bktQnSize) + 1) * cfg->bktQnSize; @@ -855,127 +767,12 @@ CmMmRegCfg *cfg; /* Call SRegRegion to register the memory region with SSI */ if (SRegRegion(region, ®Cb->regInfo) != ROK) { - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ROK); + return ROK; } /* end of cmMmRegInit*/ -#if 0 -/* -* -* Fun: ssPutDynBufSet -* -* Desc: Puts the set of dynamic buffers into the global region -* -* -* Ret: ROK - successful, -* RFAILED - unsuccessful. -* -* Notes: -* -* File: cm_mem_wl.c -* -*/ -#ifdef ANSI -PUBLIC S16 ssPutDynBufSet -( -U8 bktIdx, -CmMmBktLstCb *bktLstCb -) -#else -PUBLIC S16 ssPutDynBufSet(bktIdx, bktLstCb) -U8 bktIdx; -CmMmBktLstCb *bktLstCb; -#endif -{ - CmMmGlobRegCb *globReg; - CmMmDynBktCb *bktCb; - - TRC1(ssPutDynBufSet); - - globReg = &osCp.globRegCb; - - if(bktIdx > CMM_MAX_BKT_ENT) - { - RETVALUE(RFAILED); - } - - bktCb = &(globReg->bktTbl[bktIdx]); - - /* Lock the global region first */ - SLock(&(globReg->regLock)); - - cmLListAdd2Tail(&(bktCb->listBktSet), bktLstCb); - - SUnlock(&(globReg->regLock)); - - RETVALUE(ROK); -} - -/* -* -* Fun: ssGetDynBufSet -* -* Desc: Gets the set of dynamic buffers into the global region -* -* -* Ret: ROK - successful, -* RFAILED - unsuccessful. -* -* Notes: -* -* File: cm_mem_wl.c -* -*/ -#ifdef ANSI -PUBLIC S16 ssGetDynBufSet -( -U8 bktIdx, -CmMmBktLstCb **bktLstCb -) -#else -PUBLIC S16 ssGetDynBufSet(bktIdx, bktLstCb) -U8 bktIdx; -CmMmBktLstCb **bktLstCb; -#endif -{ - CmMmGlobRegCb *globReg; - CmMmDynBktCb *bktCb; - CmLList *lstNode; - - TRC1(ssGetDynBufSet); - - globReg = &osCp.globRegCb; - - if(bktIdx > CMM_MAX_BKT_ENT) - { - RETVALUE(RFAILED); - } - - *bktLstCb = NULLP; - bktCb = &(globReg->bktTbl[bktIdx]); - - /* Lock the global region first */ - SLock(&(globReg->regLock)); - - lstNode = cmLListFirst(&(bktCb->listBktSet)); - - if(lstNode == NULLP) - { - SUnlock(&(globReg->regLock)); - RETVALUE(RFAILED); - } - - cmLListDelFrm(&(bktCb->listBktSet), lstNode); - SUnlock(&(globReg->regLock)); - - *bktLstCb = (CmMmBktLstCb *)lstNode->node; - - RETVALUE(ROK); -} -#endif - /* * @@ -994,24 +791,19 @@ CmMmBktLstCb **bktLstCb; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S16 cmMmGlobRegInit +S16 cmMmGlobRegInit ( CmMmGlobRegCb *regCb ) -#else -PUBLIC S16 cmMmGlobRegInit(regCb) -CmMmGlobRegCb *regCb; -#endif { Data **memAddr; Data **next; - U16 bktIdx; - U16 bucketSetSize; - U16 cnt; + uint16_t bktIdx; + uint16_t bucketSetSize; + uint16_t cnt; Size size; CmMmBlkSetElement *blkLstElem; - U16 numBlks; + uint16_t numBlks; #if (ERRCLASS & ERRCLS_INT_PAR) Size lstQnSize; @@ -1019,12 +811,11 @@ CmMmGlobRegCb *regCb; Txt errMsg[256] = {'\0'}; #endif - TRC2(cmMmGlobRegInit); #ifdef SS_MEM_WL_DEBUG if (cmInitBtInfo() == RFAILED) { - RETVALUE(RFAILED); + return RFAILED; } #endif for ( bktIdx = 0; bktIdx < regCb->numBkts; bktIdx++) @@ -1063,7 +854,7 @@ CmMmGlobRegCb *regCb; *next = NULLP; } - RETVALUE(ROK); + return ROK; } /* end of cmMmGlobRegInit*/ #ifdef SS_USE_ICC_MEMORY @@ -1087,46 +878,35 @@ CmMmGlobRegCb *regCb; * */ #ifdef T2K_MEM_LEAK_DBG -#ifdef ANSI -PRIVATE S16 cmIccAllocWithLock +static S16 cmIccAllocWithLock ( Void *regionCb, /* Pointer to a region */ Size *size, /* size needs to be allocated */ -U32 flags, /* Flags used */ +uint32_t flags, /* Flags used */ Data **ptr, /* Reference to pointer for which need to be allocate */ char *file, -U32 line +uint32_t line ) -#endif #else -#ifdef ANSI -PRIVATE S16 cmIccAllocWithLock +static S16 cmIccAllocWithLock ( Void *regionCb, /* Pointer to a region */ Size *size, /* size needs to be allocated */ -U32 flags, /* Flags used */ +uint32_t flags, /* Flags used */ Data **ptr /* Reference to pointer for which need to be allocate */ ) -#else -PRIVATE S16 cmIccAllocWithLock(regionCb, size, flags, ptr) -Void *regionCb; /* Pointer to a region */ -Size *size; /* size needs to be allocated */ -U32 flags; /* Flags used */ -Data **ptr; /* Reference to pointer for which need to be allocate */ -#endif #endif { CmMmDynRegCb *regCb; Data *memPtr; - TRC2(cmIccAllocWithLock); regCb = (CmMmDynRegCb *)regionCb; if((SLock(&iccAllocFreeLock)) != ROK) { printf("cmIccAllocWithLock: Failed to get the ICC lock\n"); - RETVALUE(RFAILED); + return RFAILED; } memPtr = (Data *)TL_Alloc(regCb->iccHdl, *size); @@ -1134,7 +914,7 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ if((SUnlock(&iccAllocFreeLock)) != ROK) { printf("cmIccAllocWithLock: Failed to unlock the ICC lock\n"); - RETVALUE(RFAILED); + return RFAILED; } if ((memPtr) == NULLP) @@ -1147,16 +927,16 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ } #ifdef T2K_MEM_LEAK_DBG - if(((U32)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0) + if(((uint32_t)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0) { printf("Address returned is %p size = %ld\n",memPtr,*size); } - InsertToT2kMemLeakInfo((U32)memPtr,*size,line,file); + InsertToT2kMemLeakInfo((uint32_t)memPtr,*size,line,file); #endif *ptr = memPtr; - RETVALUE(ROK); + return ROK; } /* end of cmIccAllocWithLock */ @@ -1180,46 +960,36 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ * */ #ifdef T2K_MEM_LEAK_DBG -#ifdef ANSI -PRIVATE S16 cmIccFreeWithLock +static S16 cmIccFreeWithLock ( Void *regionCb, /* Pointer to region cb */ Data *ptr, /* Memory block needs to be freed */ Size size, /* Size of the block */ char *file, -U32 line +uint32_t line ) -#endif #else -#ifdef ANSI -PRIVATE S16 cmIccFreeWithLock +static S16 cmIccFreeWithLock ( Void *regionCb, /* Pointer to region cb */ Data *ptr, /* Memory block needs to be freed */ Size size /* Size of the block */ ) -#else -PRIVATE S16 cmIccFreeWithLock(regionCb, ptr, size) -Void *regionCb; /* Pointer to region cb */ -Data *ptr; /* Memory block needs to be freed */ -Size size; /* Size of the block */ -#endif #endif { CmMmDynRegCb *regCb; - TRC2(cmIccFreeWithLock); regCb = (CmMmDynRegCb *)regionCb; if((SLock(&iccAllocFreeLock)) != ROK) { printf("cmIccFreeWithLock: Failed to get the ICC lock\n"); - RETVALUE(RFAILED); + return RFAILED; } #ifdef T2K_MEM_LEAK_DBG - RemoveFromT2kMemLeakInfo((U32)ptr - ((U32)ptr % 512),file,line); + RemoveFromT2kMemLeakInfo((uint32_t)ptr - ((uint32_t)ptr % 512),file,line); #endif TL_Free(regCb->iccHdl, ptr); @@ -1227,10 +997,10 @@ Size size; /* Size of the block */ if((SUnlock(&iccAllocFreeLock)) != ROK) { printf("cmIccFreeWithLock: Failed to unlock the ICC lock\n"); - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ROK); + return ROK; } /* end of cmIccFree */ /* @@ -1249,41 +1019,29 @@ Size size; /* Size of the block */ * */ #ifdef T2K_MEM_LEAK_DBG -#ifdef ANSI -PRIVATE S16 cmIccAlloc +static S16 cmIccAlloc ( Void *regionCb, /* Pointer to a region */ Size *size, /* size needs to be allocated */ -U32 flags, /* Flags used */ +uint32_t flags, /* Flags used */ Data **ptr, /* Reference to pointer for which need to be allocate */ char *file, -U32 line +uint32_t line ) #else -#endif -#else -#ifdef ANSI -PRIVATE S16 cmIccAlloc +static S16 cmIccAlloc ( Void *regionCb, /* Pointer to a region */ Size *size, /* size needs to be allocated */ -U32 flags, /* Flags used */ +uint32_t flags, /* Flags used */ Data **ptr /* Reference to pointer for which need to be allocate */ ) -#else -PRIVATE S16 cmIccAlloc(regionCb, size, flags, ptr) -Void *regionCb; /* Pointer to a region */ -Size *size; /* size needs to be allocated */ -U32 flags; /* Flags used */ -Data **ptr; /* Reference to pointer for which need to be allocate */ -#endif #endif { CmMmDynRegCb *regCb; Data *memPtr; - TRC2(cmIccAlloc); regCb = (CmMmDynRegCb *)regionCb; @@ -1298,12 +1056,12 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ *p = 10; } #ifdef T2K_MEM_LEAK_DBG - if(((U32)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0) + if(((uint32_t)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0) { printf("Address returned is %p size = %ld\n",memPtr,*size); } - InsertToT2kMemLeakInfo((U32)memPtr,*size,line,file); + InsertToT2kMemLeakInfo((uint32_t)memPtr,*size,line,file); #endif #ifdef YS_PHY_3_8_2 *ptr = memPtr;/*TL_VA2TRUEVA(regCb->iccHdl, memPtr); */ @@ -1311,7 +1069,7 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ *ptr = memPtr; /*TL_VA2TRUEVA(regCb->iccHdl, memPtr); */ #endif - RETVALUE(ROK); + return ROK; } /* end of cmIccAlloc */ @@ -1332,32 +1090,24 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ * */ #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmIccFree +static S16 cmIccFree ( Void *regionCb, /* Pointer to region cb */ Data *ptr, /* Memory block needs to be freed */ Size size, /* Size of the block */ char* file, -U32 line +uint32_t line ) #else -#ifdef ANSI -PRIVATE S16 cmIccFree +static S16 cmIccFree ( Void *regionCb, /* Pointer to region cb */ Data *ptr, /* Memory block needs to be freed */ Size size /* Size of the block */ ) -#else -PRIVATE S16 cmIccFree(regionCb, ptr, size) -Void *regionCb; /* Pointer to region cb */ -Data *ptr; /* Memory block needs to be freed */ -Size size; /* Size of the block */ -#endif #endif { CmMmDynRegCb *regCb; - TRC2(cmIccFree); regCb = (CmMmDynRegCb *)regionCb; @@ -1365,7 +1115,7 @@ Size size; /* Size of the block */ // memPtr = TL_TRUEVA2VA(regCb->iccHdl, ptr); { #ifdef T2K_MEM_LEAK_DBG - RemoveFromT2kMemLeakInfo((U32)ptr - ((U32)ptr % 512),file,line); + RemoveFromT2kMemLeakInfo((uint32_t)ptr - ((uint32_t)ptr % 512),file,line); #endif } @@ -1377,13 +1127,8 @@ Size size; /* Size of the block */ #endif /*TL_Free(regCb->iccHdl, ptr);*/ -#if 0 - if(a < 10) - printf("FREE -ICC Addr Before PA2VA %x After PA2VA %x\n", memPtr, ptr); - a++; -#endif - RETVALUE(ROK); + return ROK; } /* end of cmIccFree */ /* @@ -1411,15 +1156,10 @@ Size size; /* Size of the block */ * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S16 cmMmDynRegInit +S16 cmMmDynRegInit ( CmMmDynRegCb *regCb ) -#else -PUBLIC S16 cmMmDynRegInit(regCb) -CmMmDynRegCb *regCb; -#endif { SRegInfo regInfo; #ifdef T2200_2GB_DDR_CHANGES @@ -1428,19 +1168,12 @@ CmMmDynRegCb *regCb; Txt regIccStr[64] = {'\0'}; #endif - TRC2(cmMmDynRegInit); /* Register the region/memory with ICC and get the handler for same. The id is starting * from region+1 as the zero is used by PHY code */ #ifdef T2200_2GB_DDR_CHANGES sprintf(regIccStr, "RxID=%d", (regCb->region + 1)); #else -#if 0 - sprintf(regIccStr, "RxID=%d", (regCb->region + 1)); -#else - //snprintf(regIccStr, sizeof(regIccStr), "QueueSize=%u RxID=%u", 1024, (regCb->region + 1)); - - // snprintf(regIccStr, sizeof(regIccStr), "QueueSize=%u RxID=%u", 2048, (regCb->region + 1)); #ifdef L2_L3_SPLIT if(clusterMode == RADIO_CLUSTER_MODE) { @@ -1465,7 +1198,6 @@ CmMmDynRegCb *regCb; sprintf (regIccStr, "queuesize=%d rxid=%d", 512, (regCb->region) + 1); #endif #endif -#endif #endif printf(" %s \n",regIccStr); regCb->iccHdl = TL_Open(regIccStr, 0); @@ -1473,7 +1205,7 @@ CmMmDynRegCb *regCb; printf("\nICC Region is %d\n",regCb->region); /* Call SRegRegion to register the memory region with SSI */ - cmMemset((U8*)®Info, 0, sizeof(regInfo)); + memset(®Info, 0, sizeof(regInfo)); /* Register the lock region for SS_MAX_REGS - 1 region */ if((SS_MAX_REGS - 1) == regCb->region) @@ -1495,10 +1227,10 @@ CmMmDynRegCb *regCb; if (SRegDynRegion(regCb->region, ®Info) != ROK) { - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ROK); + return ROK; } /* end of cmMmDynRegInit*/ #else /* SS_USE_ICC_MEMORY */ @@ -1528,28 +1260,22 @@ CmMmDynRegCb *regCb; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S16 cmMmDynRegInit +S16 cmMmDynRegInit ( CmMmDynRegCb *regCb ) -#else -PUBLIC S16 cmMmDynRegInit(regCb) -CmMmDynRegCb *regCb; -#endif { Region region; - U16 lstMapIdx; - U16 cnt; + uint16_t lstMapIdx; + uint16_t cnt; Size size; CmMmBlkSetElement *blkLstElem; SRegInfo regInfo; Size bktQnSize = MT_BKTQNSIZE; - U16 idx; - U16 idx1; - U16 numBkts; + uint16_t idx; + uint16_t idx1; + uint16_t numBkts; - TRC2(cmMmDynRegInit); /* Initialize the region control block */ region = regCb->region; @@ -1593,22 +1319,6 @@ CmMmDynRegCb *regCb; } /* Initialize the bucket structure */ -#if 0 - regCb->bktTbl[bktIdx].numAlloc = 0; - regCb->bktTbl[bktIdx].maxAlloc = 0; - - /* Update the total bucket size */ - regCb->bktSize += (regCb->bktTbl[bktIdx].size * regCb->bktTbl[bktIdx].numBkt); - - regCb->bktTbl[bktIdx].bktFailCnt = 0; - regCb->bktTbl[bktIdx].bktNoFitCnt = 0; - - if(regCb->bktMaxBlkSize < regCb->bktTbl[bktIdx].size) - { - regCb->bktMaxBlkSize = regCb->bktTbl[bktIdx].size; - } -#endif - for(idx = 0; idx < numBkts; idx++) { regCb->bktTbl[idx].crntMemBlkSetElem = NULLP; @@ -1622,8 +1332,7 @@ CmMmDynRegCb *regCb; } /* Call SRegRegion to register the memory region with SSI */ - cmMemset((U8*)®Info, 0, sizeof(regInfo)); -#if 1 + memset(®Info, 0, sizeof(regInfo)); if((SS_MAX_REGS - 1) == regCb->region) { regInfo.alloc = cmDynAllocWithLock; @@ -1634,36 +1343,19 @@ CmMmDynRegCb *regCb; } } else -#endif { -#if 0 - static dynLockCreated; - regInfo.alloc = cmDynAllocWithLock; - regInfo.free = cmDynFreeWithLock; - if ( dynLockCreated == 0) - { - if((SInitLock((&dynAllocFreeLock), SS_LOCK_MUTEX)) != ROK) - { - printf("Failed to initialize the lock region lock\n"); - } - dynLockCreated = 1; - } -#endif - -#if 1 regInfo.alloc = cmDynAlloc; regInfo.free = cmDynFree; -#endif } regInfo.regCb = regCb; if (SRegDynRegion(region, ®Info) != ROK) { - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ROK); + return ROK; } /* end of cmMmDynRegInit*/ #endif /* SS_USE_ICC_MEMORY */ @@ -1694,26 +1386,17 @@ CmMmDynRegCb *regCb; * File: cm_mem_wl.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) /* error check on parameters */ if (regCb == NULLP) { - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -1723,7 +1406,7 @@ CmMmRegCb *regCb; /* Deinitialize the hash table used for debug info storage at region level */ if (cmMmHashListDeinit(®Cb->hashListCp, regCb->region, 0) != ROK) { - RETVALUE(RFAILED); + return RFAILED; } #endif /* SSI_DEBUG_LEVEL1 */ @@ -1767,7 +1450,7 @@ CmMmRegCb *regCb; #endif } - RETVALUE(ROK); + return ROK; } /* end of cmMmRegDeInit */ @@ -1794,17 +1477,11 @@ CmMmRegCb *regCb; * */ -#ifdef ANSI -PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForAlloc +static CmMmBlkSetElement* cmGetMemBlkSetForAlloc ( -U8 bucketIndex, /* Index to the bucket list */ +uint8_t bucketIndex, /* Index to the bucket list */ CmMmDynBktCb *bkt /* Bucket list control block */ ) -#else -PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForAlloc(bucketIndex, bkt) -U8 bucketIndex; /* Index to the bucket list */ -CmMmDynBktCb *bkt; /* Bucket list control block */ -#endif { CmMmBlkSetElement *memBlkSetElem; CmMmBlkSetElement *nextMemBlkSetElem; @@ -1822,13 +1499,13 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ /* Check if the element exits or not */ if((memSetNode == NULLP) || (memSetNode->node == NULLP)) { - RETVALUE(NULLP); + return (NULLP); } bkt->crntMemBlkSetElem = (CmMmBlkSetElement *)memSetNode->node; /* Get the new block set from the gloabl region and return the same */ ssGetDynMemBlkSet(bucketIndex, bkt->crntMemBlkSetElem, 0); - RETVALUE(bkt->crntMemBlkSetElem); + return (bkt->crntMemBlkSetElem); } /* If this is not the first time, take the bucket list CB from the * current index */ @@ -1850,19 +1527,13 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ /* if next node also empty, return failure */ if(memBlkSetElem->numFreeBlks == 0) { - RETVALUE(NULLP); + return (NULLP); } /* store the new index in the current node which will be * used in the next time. */ bkt->crntMemBlkSetElem = memBlkSetElem; } -#if 0 - if(memBlkSetElem->nextBktPtr == NULLP) - { - ssGetDynMemBlkSet(bucketIndex, memBlkSetElem); - } -#endif /* If we have reached the threshold value, get the next set of buckets from * the global region and place it */ if(memBlkSetElem->numFreeBlks < bkt->blkSetAcquireThreshold) @@ -1899,7 +1570,7 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ } /* On successful, return the bucket node to calling function */ - RETVALUE(memBlkSetElem); + return (memBlkSetElem); } /* cmGetMemBlkSetForAlloc */ @@ -1924,17 +1595,11 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ * */ -#ifdef ANSI -PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForFree +static CmMmBlkSetElement* cmGetMemBlkSetForFree ( -U8 bucketIndex, /* Index to the bucket list */ +uint8_t bucketIndex, /* Index to the bucket list */ CmMmDynBktCb *bkt /* Bucket list control block */ ) -#else -PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForFree(bucketIndex, bkt) -U8 bucketIndex; /* Index to the bucket list */ -CmMmDynBktCb *bkt; /* Bucket list control block */ -#endif { CmMmBlkSetElement *memBlkSetElem; CmMmBlkSetElement *nextMemBlkSetElem; @@ -1951,10 +1616,10 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ /* Check if the element exits or not */ if((memSetNode == NULLP) || (memSetNode->node == NULLP)) { - RETVALUE(NULLP); + return (NULLP); } bkt->crntMemBlkSetElem = (CmMmBlkSetElement *)memSetNode->node; - RETVALUE(bkt->crntMemBlkSetElem); + return (bkt->crntMemBlkSetElem); } /* If this is not the first time, take the bucket list CB from the * current index */ @@ -1976,7 +1641,7 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ /* if next node also empty, return failure */ if(memBlkSetElem->numFreeBlks >= bkt->bucketSetSize) { - RETVALUE(NULLP); + return (NULLP); } /* store the new index in the current node which will be * used in the next time. */ @@ -2013,15 +1678,11 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ */ ssPutDynMemBlkSet(bucketIndex, nextMemBlkSetElem, (bkt->bucketSetSize - memBlkSetElem->numFreeBlks - 1)); -#if 0 - nextMemBlkSetElem->numFreeBlks = 0; - nextMemBlkSetElem->nextBktPtr = NULLP; -#endif } } /* On successful, return the bucket node to calling function */ - RETVALUE(memBlkSetElem); + return (memBlkSetElem); } #endif /* SS_USE_ICC_MEMORY */ #endif /* USE_PURE */ @@ -2044,29 +1705,23 @@ CmMmDynBktCb *bkt; /* Bucket list control block */ * */ -#ifdef ANSI -PRIVATE S16 cmRemoveAllocPtrFromList +static S16 cmRemoveAllocPtrFromList ( CmMmDynRegCb *regionCb, /* Pointer to a region */ PTR ptr ) -#else -PRIVATE S16 cmRemoveAllocPtrFromList(regionCb, ptr) -CmMmDynRegCb *regionCb; /* Pointer to a region */ -PTR ptr; -#endif { CmMemDoubleFree *memNode = NULLP; SLock(&memDoubleFreeLock); - if((cmHashListFind(&(memDoubleFree), (U8*)&ptr, - sizeof(U32), 0, (PTR *)&memNode)) != ROK) + if((cmHashListFind(&(memDoubleFree), (uint8_t*)&ptr, + sizeof(uint32_t), 0, (PTR *)&memNode)) != ROK) { Void *tmpBtArr[10]; - U16 tmpBtSize; + uint16_t tmpBtSize; S8 **strings; - U16 idx; + uint16_t idx; tmpBtSize = backtrace(tmpBtArr, 10); strings = backtrace_symbols(tmpBtArr, tmpBtSize); @@ -2079,18 +1734,18 @@ PTR ptr; printf("Analysis from Array storing BT for freeing and allocation\n"); cmAnalyseBtInfo(ptr, regionCb->region); SUnlock(&memDoubleFreeLock); - RETVALUE(RFAILED); + return RFAILED; } if((cmHashListDelete(&(memDoubleFree), (PTR)memNode)) != ROK) { SUnlock(&memDoubleFreeLock); - RETVALUE(RFAILED); + return RFAILED; } SUnlock(&memDoubleFreeLock); - SPutSBuf(regionCb->region, 0, (Data *)memNode, sizeof(CmMemDoubleFree)); + SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,regionCb->region, 0, (Data *)memNode, sizeof(CmMemDoubleFree)); - RETVALUE(ROK); + return ROK; } /* @@ -2110,38 +1765,32 @@ PTR ptr; * */ -#ifdef ANSI -PRIVATE S16 cmInsertAllocPtrToList +static S16 cmInsertAllocPtrToList ( CmMmDynRegCb *regionCb, /* Pointer to a region */ PTR ptr ) -#else -PRIVATE S16 cmInsertAllocPtrToList(regionCb, ptr) -CmMmDynRegCb *regionCb; /* Pointer to a region */ -PTR ptr; -#endif { CmMemDoubleFree *memNode; - SGetSBuf(regionCb->region, 0, (Data **)&memNode, sizeof(CmMemDoubleFree)); + SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,regionCb->region, 0, (Data **)&memNode, sizeof(CmMemDoubleFree)); if(memNode == NULLP) { - RETVALUE(RFAILED); + return RFAILED; } memNode->memBlkPtr = ptr; SLock(&memDoubleFreeLock); - if((cmHashListInsert(&(memDoubleFree), (PTR)memNode, (U8*)&memNode->memBlkPtr, + if((cmHashListInsert(&(memDoubleFree), (PTR)memNode, (uint8_t*)&memNode->memBlkPtr, sizeof(PTR))) != ROK) { SUnlock(&memDoubleFreeLock); - RETVALUE(RFAILED); + return RFAILED; } SUnlock(&memDoubleFreeLock); - RETVALUE(ROK); + return ROK; } #endif @@ -2164,30 +1813,20 @@ PTR ptr; */ /* cm_mem_c_001.main_15 : Additions */ -#ifdef ANSI -PRIVATE S16 cmDynAllocWithLock +static S16 cmDynAllocWithLock ( Void *regionCb, /* Pointer to a region */ Size *size, /* size needs to be allocated */ -U32 flags, /* Flags used */ +uint32_t flags, /* Flags used */ Data **ptr /* Reference to pointer for which need to be allocate */ ) -#else -PRIVATE S16 cmDynAllocWithLock(regionCb, size, flags, ptr) -Void *regionCb; /* Pointer to a region */ -Size *size; /* size needs to be allocated */ -U32 flags; /* Flags used */ -Data **ptr; /* Reference to pointer for which need to be allocate */ -#endif { S16 ret; - TRC2(cmDynAlloc); - if((SLock(&dynAllocFreeLock)) != ROK) { printf("cmDynAllocWithLock: Failed to get the dyn lock\n"); - RETVALUE(RFAILED); + return RFAILED; } ret = cmDynAlloc (regionCb, size,flags,ptr); @@ -2195,10 +1834,10 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ if((SUnlock(&dynAllocFreeLock)) != ROK) { printf("cmDynAllocWithLock: Failed to unlock the Dyn lock\n"); - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ret); + return (ret); } /* end of cmDynAlloc */ /* @@ -2218,25 +1857,16 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ */ /* cm_mem_c_001.main_15 : Additions */ -#ifdef ANSI -PRIVATE S16 cmDynAlloc +static S16 cmDynAlloc ( Void *regionCb, /* Pointer to a region */ Size *size, /* size needs to be allocated */ -U32 flags, /* Flags used */ +uint32_t flags, /* Flags used */ Data **ptr /* Reference to pointer for which need to be allocate */ ) -#else -PRIVATE S16 cmDynAlloc(regionCb, size, flags, ptr) -Void *regionCb; /* Pointer to a region */ -Size *size; /* size needs to be allocated */ -U32 flags; /* Flags used */ -Data **ptr; /* Reference to pointer for which need to be allocate */ -#endif { CmMmDynRegCb *regCb; - TRC2(cmDynAlloc); regCb = (CmMmDynRegCb *)regionCb; @@ -2250,9 +1880,28 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ #if (ERRCLASS & ERRCLS_INT_PAR) /* error check on parameters */ - if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP)) + if(regCb == NULLP) + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory region pointer is null"); + return RFAILED; + } + + if(ptr == NULLP) + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block pointer is null"); + return RFAILED; + } + + if(size == NULLP) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory size pointer null"); + return RFAILED; + } + + if(!(*size)) + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block size is 0"); + return RFAILED; } #endif @@ -2269,9 +1918,9 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ if ( (*size) <= regCb->bktMaxBlkSize) #endif { - U32 idx; + uint32_t idx; CmMmBlkSetElement *dynMemElem; - U32 bktIdx; + uint32_t bktIdx; CmMmDynBktCb *bkt; /* Get the map to the mapping table */ @@ -2283,15 +1932,16 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ #if (ERRCLASS & ERRCLS_DEBUG) if (regCb->mapTbl[idx].bktIdx == 0xFF) - { - printf("Failed to get the buffer of size %d\n", *size); + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size); /* Some fatal error in the map table initialization. */ - RETVALUE(RFAILED); + return RFAILED; } #endif if (idx > 512) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM: cmDynAlloc(): idx value is greater than 512"); + return RFAILED; } /* Dequeue the memory block and return it to the user */ bktIdx = regCb->mapTbl[idx].bktIdx; @@ -2312,17 +1962,17 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ if(dynMemElem == NULLP) { #ifndef ALIGN_64BIT - printf("Failed to get the buffer of size %ld\n", *size); + DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %ld\n", *size); #else - printf("Failed to get the buffer of size %d\n", *size); + printf("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size); #endif - RETVALUE(RFAILED); + return RFAILED; } #ifdef SS_MEM_WL_DEBUG if(dynMemElem->nextBktPtr == prvAllocPtr[regCb->region]) { - U32 *tmpDump; + uint32_t *tmpDump; *tmpDump = 100; } #endif @@ -2330,29 +1980,25 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ *ptr = dynMemElem->nextBktPtr; if (*ptr == NULLP) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM: cmDynAlloc(): nextBktPtr is null"); + return RFAILED; } dynMemElem->nextBktPtr = *((CmMmEntry **)(*ptr)); dynMemElem->numFreeBlks--; #ifdef SS_MEM_WL_DEBUG prvAllocPtr[regCb->region] = *ptr; -#if 0 - if(regCb->region == 6) - printf("cmDynAlloc: PTR = %x\n", *ptr); - **ptr = (U32) ((bktIdx << 4) | 0x0f); -#endif - **ptr = (U8) bktIdx; + **ptr = (uint8_t) bktIdx; *(*ptr+1) = 0xde; *(*ptr+2) = 0xad; *(*ptr+3) = 0xbe; - *ptr += sizeof (U32); + *ptr += sizeof (uint32_t); if ((bktIdx == 0) && (!stopBtInfo)) { CmBtInfo *btInfo; - U32 btIdx; + uint32_t btIdx; btInfo = &allocBtInfo[regCb->region]; btIdx = btInfo->btInfoIdx; btInfo->btInfo[btIdx].ptr = (PTR) *ptr; @@ -2360,45 +2006,45 @@ Data **ptr; /* Reference to pointer for which need to be allocate */ btInfo->btInfo[btIdx].btSize = backtrace(btInfo->btInfo[btIdx].btArr, NUM_BT_TRACES); } gettimeofday(&(btInfo->btInfo[btIdx].timeStamp), NULLP); -#if 0 - cmInsertAllocPtrToList(regCb, (PTR)*ptr); -#endif btIdx++; btIdx &= (NUM_FREE_BUFFERS - 1); btInfo->btInfo[btIdx].ptr = (PTR)0; btInfo->btInfo[btIdx].btSize = 0; - cmMemset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr)); + memset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr)); btInfo->btInfoIdx = btIdx; } #endif - RETVALUE(ROK); + return ROK; } /* If the size is not matching, return failure to caller */ #ifndef ALIGN_64BIT - printf("Failed to get the buffer of size %ld\n", *size); + DU_LOG("\nERROR --> CM : cmDynAlloc(): Failed to get the buffer of size %ld\n", *size); #else - printf("Failed to get the buffer of size %d\n", *size); + DU_LOG("\nERROR --> CM: cmDynAlloc(): Failed to get the buffer of size %d\n", *size); #endif - RETVALUE(RFAILED); + return RFAILED; #else /* use pure is on */ #ifdef SS_4GMX_LCORE *ptr = (Data*) MxHeapAlloc(SsiHeap, *size); - cmMemset((U8*)ptr, 0, *size); + memset(ptr, 0, *size); #else /* *ptr = (Data*) malloc(*size); */ #endif *ptr = (Data *)malloc(*size); if ( (*ptr) == NULLP) - RETVALUE(RFAILED); + { + DU_LOG("\nERROR --> CM : cmDynAlloc(): Data ptr is null"); + return RFAILED; + } /* avail_size -= *size; */ - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ } /* end of cmDynAlloc */ @@ -2444,105 +2090,63 @@ int g_overused[5] = {0}; /* cm_mem_c_001.main_15 : Additions */ #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmAlloc +static S16 cmAlloc ( Void *regionCb, Size *size, - U32 flags, + uint32_t flags, Data **ptr , char* file, - U32 line + uint32_t line ) #else #ifdef SS_HISTOGRAM_SUPPORT #ifdef SSI_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( 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 -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, +uint32_t flags, Data **ptr, -U32 line, -U8 *fileName, -U8 entId, +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 SSI_DEBUG_LEVEL1 -#ifdef ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr, -U32 memType +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 ANSI -PRIVATE S16 cmAlloc +static S16 cmAlloc ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr ) -#else -PRIVATE S16 cmAlloc(regionCb, size, flags, ptr) -Void *regionCb; -Size *size; -U32 flags; -Data **ptr; -#endif #endif #endif /* SSI_DEBUG_LEVEL1 */ @@ -2552,14 +2156,14 @@ Data **ptr; { /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt; - U16 bktIdx; + uint16_t bktIdx; #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 */ #ifdef SS_MEM_LEAK_STS @@ -2574,7 +2178,6 @@ Data **ptr; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmAlloc); #ifndef USE_MEMCAL UNUSED(flags); @@ -2589,9 +2192,28 @@ Data **ptr; #if (ERRCLASS & ERRCLS_INT_PAR) /* error check on parameters */ - if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP)) + if(regCb == NULL) + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory region pointer is null"); + return RFAILED; + } + + if(ptr == NULLP) + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block pointer is null"); + return RFAILED; + } + + if(size == NULLP) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory size pointer null"); + return RFAILED; + } + + if(!(*size)) + { + DU_LOG("\nERROR --> CM: cmDynAlloc(): Received memory block size is 0"); + return RFAILED; } #endif @@ -2600,7 +2222,8 @@ Data **ptr; #if (ERRCLASS & ERRCLS_INT_PAR) if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG)) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmAlloc(): memType[%d] is invalid",memType); + return RFAILED; } #endif /* (ERRCLASS & ERRCLS_INT_PAR) */ #endif /* SSI_DEBUG_LEVEL1 */ @@ -2644,7 +2267,8 @@ Data **ptr; if (regCb->mapTbl[idx].bktIdx == 0xFF) { /* Some fatal error in the map table initialization. */ - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmAlloc(): bktIdx is invalid"); + return RFAILED; } #endif @@ -2721,7 +2345,7 @@ Data **ptr; (Void) SUnlock(&(bkt->bktLock)); #endif /* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */ - RETVALUE(RTRAMPLINGNOK); + return (RTRAMPLINGNOK); } else { @@ -2732,8 +2356,9 @@ Data **ptr; #else (Void) SUnlock(&(bkt->bktLock)); #endif + DU_LOG("\nERROR --> CM : cmAlloc(): Sanity check returns failure"); /* return RFAILED */ - RETVALUE(RFAILED); + return RFAILED; } } } @@ -2768,10 +2393,6 @@ Data **ptr; /*printf("cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */ } } -#if 0 - if(bkt->numAlloc < 100) - printf("cmAlloc: Allocated PTR = %x size = %d\n", *ptr, *size); -#endif /* cm_mem_c_001.main_12 - addition for header manipulation */ #ifdef SSI_DEBUG_LEVEL1 @@ -2851,7 +2472,7 @@ Data **ptr; (Void) SUnlock(&(bkt->bktLock)); #endif - RETVALUE(ROK); + return ROK; } else if (flags) { @@ -2918,34 +2539,38 @@ Data **ptr; #ifdef SS_HISTOGRAM_SUPPORT /* cm_mem_c_001.main_12 - addition for passing an extra parameter */ #ifdef SSI_DEBUG_LEVEL1 - RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg)); + return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg)); #else - RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg)); + return (cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg)); #endif /* SSI_DEBUG_LEVEL1 */ #else /* cm_mem_c_001.main_12 - addition for passing an extra parameter */ #ifdef SSI_DEBUG_LEVEL1 - RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType)); + return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType)); #else - RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size)); + return (cmHeapAlloc(&(regCb->heapCb), ptr, size)); #endif /* SSI_DEBUG_LEVEL1 */ #endif /* SS_HISTOGRAM_SUPPORT */ } /* No memory available */ - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmAlloc(): No memory available in heap"); + return RFAILED; #else /* use pure is on */ /*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 if ( (*ptr) == NULLP) - RETVALUE(RFAILED); + { + DU_LOG("\nERROR --> CM : cmAlloc(): ptr is null"); + return RFAILED; + } avail_size -= *size; - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ } /* end of cmAlloc */ @@ -2966,30 +2591,21 @@ Data **ptr; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S16 cmInitDoubleFreeList -( -Void -) -#else -PUBLIC S16 cmInitDoubleFreeList() -#endif +S16 cmInitDoubleFreeList(void) { - U16 offset; + uint16_t offset; CmMemDoubleFree memNode; - TRC2(cmInitDoubleFreeList); - - offset = (U16)((PTR)(&memNode.tmpListEnt) - (PTR)&memNode); + offset = (uint16_t)((PTR)(&memNode.tmpListEnt) - (PTR)&memNode); if((cmHashListInit(&(memDoubleFree), 1000, offset, 0, - CM_HASH_KEYTYPE_U32MOD, 0, 0)) != ROK); + CM_HASH_KEYTYPE_UINT32_MOD, 0, 0)) != ROK); { - RETVALUE(RFAILED); + return RFAILED; } SInitLock(&memDoubleFreeLock, SS_LOCK_MUTEX); - RETVALUE(ROK); + return ROK; } #ifdef SS_MEM_WL_DEBUG @@ -3009,26 +2625,20 @@ PUBLIC S16 cmInitDoubleFreeList() * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE S16 cmInitBtInfo -( -) -#else -PRIVATE S16 cmInitBtInfo (Void) -#endif +static S16 cmInitBtInfo() { regBtInfo = (CmBtInfo *)calloc(1, 8 * sizeof (CmBtInfo)); if (regBtInfo == NULLP) { - RETVALUE(RFAILED); + return RFAILED; } allocBtInfo = (CmBtInfo *)calloc(1, 8 * sizeof (CmBtInfo)); if(allocBtInfo == NULLP) { - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ROK); + return ROK; } #endif /* SS_MEM_WL_DEBUG */ /* @@ -3047,60 +2657,16 @@ PRIVATE S16 cmInitBtInfo (Void) * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC Void cmAnalyseBtInfo +Void cmAnalyseBtInfo ( PTR ptr, /* Memory block needs to be freed */ -U32 idx +uint32_t idx ) -#else -PUBLIC Void cmAnalyseBtInfo (ptr,idx) -PTR ptr; /* Memory block needs to be freed */ -U32 idx; -#endif { - U32 tmpCnt; - U32 btIdx; + uint32_t tmpCnt; + uint32_t btIdx; CmBtInfo *btInfo; - U8 regIdx; - -#if 0 - for(regIdx = 0; regIdx < 8; regIdx++) - { - btInfo = & regBtInfo[regIdx]; - btIdx = btInfo->btInfoIdx; - - for (tmpCnt = 0; tmpCnt < NUM_FREE_BUFFERS; tmpCnt++) - { -#if 0 - if ((btInfo->btInfo[btIdx].ptr >= ptr) && - (btInfo->btInfo[btIdx].ptr + 128 ) >= ptr) - -#endif - if(btInfo->btInfo[btIdx].btSize != 0) - { - U32 i; - char **strings; - strings = backtrace_symbols( btInfo->btInfo[btIdx].btArr,btInfo->btInfo[btIdx].btSize); - printf("*** Last Free Region = %d PTR %x Timestamp sec = (%ld) usec = (%ld) ***\n", idx, ptr, btInfo->btInfo[btIdx].timeStamp.tv_sec, btInfo->btInfo[btIdx].timeStamp.tv_usec); - for (i=0; i < btInfo->btInfo[btIdx].btSize; i++) - { - printf("%s\n", strings[i]); - } - printf("*******************************************************\n"); - - free(strings); - } - - btIdx--; - if (btIdx == 0) - { - btIdx = NUM_FREE_BUFFERS - 1; - } - } - } -#endif - + uint8_t regIdx; /* for(regIdx = 0; regIdx < 8; regIdx++) { */ @@ -3114,7 +2680,7 @@ U32 idx; (btInfo->btInfo[btIdx].ptr + 128 ) >= ptr) */ if(btInfo->btInfo[btIdx].btSize != 0) { - U32 i; + uint32_t i; char **strings; strings = backtrace_symbols( btInfo->btInfo[btIdx].btArr,btInfo->btInfo[btIdx].btSize); printf("*** Last Allocation Region = %d PTR %x Timestamp sec = (%ld) usec = (%ld) ***\n", idx, ptr, btInfo->btInfo[btIdx].timeStamp.tv_sec, btInfo->btInfo[btIdx].timeStamp.tv_usec); @@ -3135,7 +2701,7 @@ U32 idx; } /* } */ - RETVOID; + return; } #endif @@ -3156,26 +2722,19 @@ U32 idx; * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE S16 cmDynFreeWithLock +static S16 cmDynFreeWithLock ( Void *regionCb, /* Pointer to region cb */ Data *ptr, /* Memory block needs to be freed */ Size size /* Size of the block */ ) -#else -PRIVATE S16 cmDynFreeWithLock(regionCb, ptr, size) -Void *regionCb; /* Pointer to region cb */ -Data *ptr; /* Memory block needs to be freed */ -Size size; /* Size of the block */ -#endif { S16 ret; - + if((SLock(&dynAllocFreeLock)) != ROK) { printf("dynAllocWithLock: Failed to get the DYN lock\n"); - RETVALUE(RFAILED); + return RFAILED; } ret = cmDynFree(regionCb, ptr,size); @@ -3183,10 +2742,10 @@ Size size; /* Size of the block */ if((SUnlock(&dynAllocFreeLock)) != ROK) { printf("dynAllocWithLock: Failed to unlock the dyn lock\n"); - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ret); + return (ret); } /* end of cmDynFree */ @@ -3206,33 +2765,25 @@ Size size; /* Size of the block */ * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE S16 cmDynFree +static S16 cmDynFree ( Void *regionCb, /* Pointer to region cb */ Data *ptr, /* Memory block needs to be freed */ Size size /* Size of the block */ ) -#else -PRIVATE S16 cmDynFree(regionCb, ptr, size) -Void *regionCb; /* Pointer to region cb */ -Data *ptr; /* Memory block needs to be freed */ -Size size; /* Size of the block */ -#endif { CmMmDynRegCb *regCb; #ifndef USE_PURE - U32 idx; - U32 bktIdx; + uint32_t idx; + uint32_t bktIdx; CmMmDynBktCb *bkt = NULLP; CmMmBlkSetElement *dynMemElem; #endif #ifdef SS_MEM_WL_DEBUG - U8 tmpBktIdx; - U8 tmpVal; + uint8_t tmpBktIdx; + uint8_t tmpVal; #endif - TRC2(cmDynFree); regCb = (CmMmDynRegCb *)regionCb; #ifdef SS_MEM_WL_DEBUG @@ -3247,25 +2798,28 @@ Size size; /* Size of the block */ /* error check on parameters */ if ((regCb == NULLP) || (!size) || (ptr == NULLP)) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmDynFree(): Received memory region[%p] or size[%p] or block[%p] is invalid",regCb,size,ptr); + return RFAILED; } /* Check if the memory block is from the memory region */ if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start + ((CmMmRegCb *)regCb)->regInfo.size) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region); + return RFAILED; } /* cm_mem_c_001.main_20 Addition */ if (ptr < regCb->regInfo.start) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmDynFree(): Memory block[%p] not from region[%d]", ptr, ((CmMmRegCb *)regCb)->region); + return RFAILED; } #endif #ifdef SS_MEM_WL_DEBUG - ptr -= sizeof (U32); + ptr -= sizeof (uint32_t); size += 4; #endif /* The memory block was allocated from the bucket pool */ @@ -3276,8 +2830,9 @@ Size size; /* Size of the block */ #if (ERRCLASS & ERRCLS_DEBUG) if (regCb->mapTbl[idx].bktIdx == 0xFF) { + DU_LOG("\nERROR --> CM : cmDynFree(): bktIdx is not valid"); /* Some fatal error in the map table initialization. */ - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -3294,15 +2849,15 @@ Size size; /* Size of the block */ #ifdef SS_MEM_WL_DEBUG if (size > bkt->size) { - printf("Size = %d bucket size = %d\n", size, bkt->size); + DU_LOG("Size = %d bucket size = %d\n", size, bkt->size); exit(-1); bkt = &(regCb->bktTbl[bktIdx = regCb->mapTbl[++idx].bktIdx]); } if(size > bkt->size) { - printf("2nd time Size = %d bucket size = %d\n", size, bkt->size); + DU_LOG("2nd time Size = %d bucket size = %d\n", size, bkt->size); exit(-1); - U8 *tmpptr = NULLP; + uint8_t *tmpptr = NULLP; printf("Bucket Size wrong \n"); *tmpptr = 10; } @@ -3313,16 +2868,17 @@ Size size; /* Size of the block */ /* Check if the bucket index, if its not valid, return failure */ if(dynMemElem == NULLP) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmDynFree(): dynMemElem is null"); + return RFAILED; } #ifdef SS_MEM_WL_DEBUG - tmpBktIdx = (U8)*ptr; - tmpVal = (U8)*(ptr+1); + tmpBktIdx = (uint8_t)*ptr; + tmpVal = (uint8_t)*(ptr+1); if ((tmpBktIdx != bktIdx) || (tmpVal != 0xde)) { - U8 *tmpptr = NULLP; + uint8_t *tmpptr = NULLP; printf("bktIdx wrong \n"); *tmpptr = 10; } @@ -3330,16 +2886,13 @@ Size size; /* Size of the block */ if ((bktIdx == 0) && (!stopBtInfo)) { CmBtInfo *btInfo; - U32 btIdx; + uint32_t btIdx; btInfo = ®BtInfo[regCb->region]; btIdx = btInfo->btInfoIdx; btInfo->btInfo[btIdx].ptr = (PTR) ptr; { btInfo->btInfo[btIdx].btSize = backtrace(btInfo->btInfo[btIdx].btArr, NUM_BT_TRACES); } -#if 0 - cmRemoveAllocPtrFromList(regCb, (ptr + sizeof(U32))); -#endif gettimeofday(&(btInfo->btInfo[btIdx].timeStamp), NULLP); btIdx++; @@ -3347,7 +2900,7 @@ Size size; /* Size of the block */ btInfo->btInfo[btIdx].ptr = (PTR)0; btInfo->btInfo[btIdx].btSize = 0; - cmMemset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr)); + memset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr)); btInfo->btInfoIdx = btIdx; } @@ -3356,18 +2909,16 @@ Size size; /* Size of the block */ prvAllocPtr[regCb->region] = NULLP; } - cmMemset(ptr, (regCb->region+1), bkt->size); + memset(ptr, (regCb->region+1), bkt->size); #endif - /* Get the bucket node from the index returned and allocate the memory */ *((CmMmEntry **)ptr) = dynMemElem->nextBktPtr; dynMemElem->nextBktPtr = ptr; dynMemElem->numFreeBlks++; - RETVALUE(ROK); + return ROK; #else /* use pure is on */ - TRC2(cmDynFree); /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #ifdef SS_4GMX_LCORE (Void)MxHeapFree(SsiHeap, ptr); @@ -3377,7 +2928,7 @@ Size size; /* Size of the block */ /* avail_size += size; */ free(ptr); - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ @@ -3410,53 +2961,33 @@ Size size; /* Size of the block */ /* cm_mem_c_001.main_15 : Additions */ #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmFree +static S16 cmFree ( Void *regionCb, Data *ptr, Size size, char* file, - U32 line + uint32_t line ) #else #ifdef SS_HISTOGRAM_SUPPORT -#ifdef ANSI -PRIVATE S16 cmFree +static S16 cmFree ( Void *regionCb, Data *ptr, Size size, -U32 line, -U8 *fileName, -U8 entId, +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 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 */ @@ -3464,9 +2995,9 @@ Size size; { /* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */ #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt; - U16 bktIdx; + uint16_t bktIdx; #endif CmMmRegCb *regCb; /* cm_mem_c_001.main_12 - addition for holding the free pointer */ @@ -3478,7 +3009,6 @@ Size size; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmFree); regCb = (CmMmRegCb *)regionCb; @@ -3488,19 +3018,22 @@ Size size; /* error check on parameters */ if ((regCb == NULLP) || (!size) || (ptr == NULLP)) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmFree(): Received memory region[%p] or size[%p] or block[%p] is invalid",regCb,size,ptr); + return RFAILED; } /* Check if the memory block is from the memory region */ if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start + ((CmMmRegCb *)regCb)->regInfo.size) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmFree(): Memory block[%p] not from region[%d]",ptr,regCb.region); + return RFAILED; } /* cm_mem_c_001.main_20 Addition */ if (ptr < regCb->regInfo.start) { - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmFree(): Memory block[%p] not from region[%d]",ptr,regCb.region); + return RFAILED; } #endif @@ -3525,7 +3058,8 @@ Size size; if (regCb->mapTbl[idx].bktIdx == 0xFF) { /* Some fatal error in the map table initialization. */ - RETVALUE(RFAILED); + DU_LOG("\nERROR --> CM : cmFree(): Invalid bktIdx"); + return RFAILED; } #endif @@ -3592,7 +3126,7 @@ Size size; (Void) SUnlock(&(bkt->bktLock)); #endif - RETVALUE(ROK); + return ROK; } else { @@ -3608,7 +3142,8 @@ Size size; #endif /* handle RTRAMPLINGNOK in SFree/SPutSBuf */ - RETVALUE(RTRAMPLINGNOK); + DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure"); + return (RTRAMPLINGNOK); } } @@ -3640,7 +3175,8 @@ Size size; #endif /* handle RDBLFREE in SFree/SPutSBuf */ - RETVALUE(RDBLFREE); + DU_LOG("\nERROR --> CM : cmFree(): Memory block is already freed"); + return (RDBLFREE); } if (CMM_IS_STATIC(ptrHdr->memFlags)) { @@ -3680,7 +3216,7 @@ Size size; #else (Void) SUnlock(&(bkt->bktLock)); #endif - RETVALUE(ROK); + return ROK; } else { @@ -3696,7 +3232,8 @@ Size size; #endif /* handle RTRAMPLINGNOK in SFree/SPutSBuf */ - RETVALUE(RTRAMPLINGNOK); + DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure"); + return (RTRAMPLINGNOK); } } @@ -3705,31 +3242,10 @@ Size size; bkt->nextBlk = ptrHdr; #else /* MS_REMOVE */ -#if 0 - /* sriky: For debugging double deallocation */ - cmMemset(ptr, 0, 50); -#endif *((CmMmEntry **)ptr) = bkt->next; bkt->next = (CmMmEntry *)ptr; #endif /* SSI_DEBUG_LEVEL1 */ -#if 0 - if(bkt->numAlloc <= 0 || bkt->numAlloc > 12000) - { - void *array[10]; - size_t tmpsize, i; - char **strings; - - printf("\n cmFree: Freed pointer = %x and backtrace:\n", ptr); - printf("****************************************\n"); - tmpsize = backtrace(array, 10); - strings = backtrace_symbols(array, tmpsize); - for(i = 0; i < tmpsize; i++) - printf("%s\n", strings[i]); - printf("****************************************\n"); - free(strings); - } -#endif /* * Decrement the statistics variable of number of memory block * allocated @@ -3772,18 +3288,17 @@ Size size; (Void) SUnlock(&(bkt->bktLock)); #endif - RETVALUE(ROK); + return ROK; } /* The memory block was allocated from the heap pool */ /* cm_mem_c_001.main_15 : Additions */ #ifdef SS_HISTOGRAM_SUPPORT - RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg)); + return (cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg)); #else - RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, 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); @@ -3791,7 +3306,7 @@ Size size; (Void)free(ptr); #endif avail_size += size; - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ @@ -3815,41 +3330,32 @@ 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 T2K_MEM_LEAK_DBG -PRIVATE S16 cmAllocWL +static S16 cmAllocWL ( Void *regionCb, Size *size, -U32 flags, +uint32_t flags, Data **ptr , char* file, -U32 line +uint32_t line ) #else -#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 #endif { #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt = NULLP; #endif 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*/ @@ -3867,7 +3373,7 @@ Data **ptr; /* error check on parameters */ if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP)) { - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -3924,7 +3430,7 @@ Data **ptr; /* Update the size parameter */ *size = bkt->size; - RETVALUE(ROK); + return ROK; } } } @@ -3938,25 +3444,25 @@ Data **ptr; * heap pool. */ /*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/ - RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size)); + return (cmHeapAlloc(&(regCb->heapCb), ptr, size)); } /* No memory available */ - RETVALUE(RFAILED); + return RFAILED; #else /* use pure is on */ /*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 *ptr = (Data *)malloc(*size); if ( (*ptr) == NULLP) - RETVALUE(RFAILED); + return RFAILED; /* avail_size -= *size; */ - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ } /* end of cmAllocWL */ @@ -3978,38 +3484,30 @@ Data **ptr; */ #ifdef T2K_MEM_LEAK_DBG -PRIVATE S16 cmFreeWL +static S16 cmFreeWL ( Void *regionCb, Data *ptr, Size size, char* file, -U32 line +uint32_t line ) #else -#ifdef ANSI -PRIVATE S16 cmFreeWL +static S16 cmFreeWL ( Void *regionCb, Data *ptr, Size size ) -#else -PRIVATE S16 cmFreeWL(regionCb, ptr, size) -Void *regionCb; -Data *ptr; -Size size; -#endif #endif { #ifndef USE_PURE - U16 idx; + uint16_t idx; CmMmBkt *bkt = NULLP; #endif 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; @@ -4026,14 +3524,14 @@ Size size; /* error check on parameters */ if ((regCb == NULLP) || (!size) || (ptr == NULLP)) { - RETVALUE(RFAILED); + return RFAILED; } /* Check if the memory block is from the memory region */ if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start + ((CmMmRegCb *)regCb)->regInfo.size) { - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -4041,14 +3539,6 @@ Size size; /* * Check if the memory block was allocated from the bucket pool. */ -#if 0 - if(ptr < regCb->regInfo.start) - { - Buffer *tmpbuf = NULLP; - tmpbuf->b_cont = NULLP; - } -#endif - #ifdef MSPD_T2K_TRACK_BUG size += 4; #endif @@ -4064,7 +3554,7 @@ Size size; if (regCb->mapTbl[idx].bktIdx == 0xFF) { /* Some fatal error in the map table initialization. */ - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -4101,39 +3591,12 @@ Size size; */ bkt->numAlloc--; -#if 0 - if ((regCb->region == 2) && (bkt->numAlloc < 50)) - { - CmBtInfo *btInfo; - U32 btIdx; - btInfo = &allocBtInfo[regCb->region]; - btIdx = btInfo->btInfoIdx; - btInfo->btInfo[btIdx].ptr = (PTR) *ptr; - { - btInfo->btInfo[btIdx].btSize = backtrace(btInfo->btInfo[btIdx].btArr, NUM_BT_TRACES); - } -#if 0 - gettimeofday(&(btInfo->btInfo[btIdx].timeStamp), NULLP); - cmInsertAllocPtrToList(regCb, (PTR)*ptr); -#endif - - btIdx++; - btIdx &= (NUM_FREE_BUFFERS - 1); - - btInfo->btInfo[btIdx].ptr = (PTR)0; - btInfo->btInfo[btIdx].btSize = 0; - cmMemset(btInfo->btInfo[regCb->mapTbl[idx].bktIdx].btArr, 0, sizeof (btInfo->btInfo[regCb->mapTbl[idx].bktIdx].btArr)); - btInfo->btInfoIdx = btIdx; - } -#endif - - RETVALUE(ROK); + return ROK; } /* The memory block was allocated from the heap pool */ - RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size)); + 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); @@ -4143,7 +3606,7 @@ Size size; /* avail_size += size; */ free(ptr); - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ @@ -4173,23 +3636,15 @@ Size size; * */ -#ifdef ANSI -PRIVATE S16 cmCtl +static S16 cmCtl ( Void *regionCb, Event event, SMemCtl *memCtl ) -#else -PRIVATE S16 cmCtl(regionCb, event, memCtl) -Void *regionCb; -Event event; -SMemCtl *memCtl; -#endif { CmMmRegCb *regCb; - TRC2(cmCtl); regCb = (CmMmRegCb *)regionCb; @@ -4198,7 +3653,7 @@ SMemCtl *memCtl; /* error check on parameters */ if ((regCb == NULLP) || (memCtl == NULLP)) { - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -4213,7 +3668,7 @@ SMemCtl *memCtl; if ((memCtl->u.vtop.vaddr == NULLP) || (memCtl->u.vtop.paddr == NULLP)) { - RETVALUE(RFAILED); + return RFAILED; } #endif @@ -4223,7 +3678,7 @@ SMemCtl *memCtl; offset = memCtl->u.vtop.vaddr - regCb->regInfo.start; *(memCtl->u.vtop.paddr) = regCb->pAddr + offset; - RETVALUE(ROK); + return ROK; } break; } @@ -4235,16 +3690,16 @@ SMemCtl *memCtl; if (!(memCtl->u.chkres.size) || (memCtl->u.chkres.status == NULLP)) { - RETVALUE(RFAILED); + return RFAILED; } #endif #ifndef USE_PURE /* 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. @@ -4270,11 +3725,11 @@ SMemCtl *memCtl; (regCb->heapSize/10)); } - RETVALUE(ROK); + return ROK; #else /* use pure is on */ *(memCtl->u.chkres.status) = ((avail_size) / (regCb->regInfo.size/10)); - RETVALUE(ROK); + return ROK; #endif /* USE_PURE */ } @@ -4282,140 +3737,15 @@ SMemCtl *memCtl; default: { /* No other event is supported currently */ - RETVALUE(RFAILED); + return RFAILED; } } /* shouldn't reach here */ - RETVALUE(RFAILED); + return RFAILED; } /* end of cmCtl */ -#if 0 -/* -* -* Fun: cmMmBktInit -* -* Desc: Initialize the bucket and the map table. -* -* -* Ret: ROK - successful, -* RFAILED - unsuccessful. -* -* Notes: This function is called by the cmMmRegInit. -* -* File: cm_mem_wl.c -* -*/ -#ifdef ANSI -PRIVATE Void cmMmBktInit -( -Data **memAddr, -CmMmRegCb *regCb, -CmMmRegCfg *cfg, -U16 bktIdx, -U16 *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; - Size size; - Data **next; - U16 blkSetRelThreshold; - CmMmBktLstCb *bktLstCb; - - TRC2(cmMmBktInit); - - - size = cfg->bktCfg[bktIdx].size; - numBlks = cfg->bktCfg[bktIdx].numBlks; - - regCb->bktTbl[bktIdx].blkSetRelThreshold = cfg->bktCfg[bktIdx].blkSetRelThreshold; - regCb->bktTbl[bktIdx].blkSetAcquireThreshold = cfg->bktCfg[bktIdx].blkSetAcquireThreshold; - blkSetRelThreshold = cfg->bktCfg[bktIdx].blkSetRelThreshold; - - /* Initialize the bucket linked list */ - cmLListInit(®Cb->bktTbl[bktIdx].listBktSet); - - /* Reset the next pointer */ - regCb->bktTbl[bktIdx].next = NULLP; - - /* Initialize the link list of the memory block */ - next = &(regCb->bktTbl[bktIdx].next); - for (cnt = 0; cnt < numBlks; cnt++) - { - *next = *memAddr; - next = (CmMmEntry **)(*memAddr); - *memAddr = (*memAddr) + size; - - /* Maintain the list Cb */ - if((cnt != 0) && (!(cnt % blkSetRelThreshold))) - { - bktLstCb = calloc(1, sizeof(CmMmBktLstCb)); - bktLstCb->nextBktPtr = regCb->bktTbl[bktIdx].next; - bktLstCb->numBkt = blkSetRelThreshold; - cmLListAdd2Tail((®Cb->bktTbl[bktIdx].listBktSet), (&bktLstCb->memSetNode)); - next = &(regCb->bktTbl[bktIdx].next); - regCb->numBkts++; - } - } - *next = NULLP; - - bktLstCb = cmLListFirst((®Cb->bktTbl[bktIdx].listBktSet)); - regCb->bktTbl[bktIdx].next = bktLstCb->nextBktPtr; - cmLListDelFrm((®Cb->bktTbl[bktIdx].listBktSet), bktLstCb); - free(bktLstCb); - - /* Initialize the Map entry */ - idx = size / cfg->bktQnSize; - - /* - * Check if the size is multiple of quantum size. If not we need to initialize - * one more map table entry. - */ - if(size % cfg->bktQnSize) - { - idx++; - } - - while ( *lstMapIdx < idx) - { - regCb->mapTbl[*lstMapIdx].bktIdx = bktIdx; - -#if (ERRCLASS & ERRCLS_DEBUG) - regCb->mapTbl[*lstMapIdx].numReq = 0; - regCb->mapTbl[*lstMapIdx].numFailure = 0; -#endif - - (*lstMapIdx)++; - } - - /* Initialize the bucket structure */ - regCb->bktTbl[bktIdx].size = size; - regCb->bktTbl[bktIdx].numBlks = numBlks; - regCb->bktTbl[bktIdx].numAlloc = 0; - regCb->bktTbl[bktIdx].maxAlloc = 0; - - /* Update the total bucket size */ - regCb->bktSize += (size * numBlks); - - regCb->bktTbl[bktIdx].bktFailCnt = 0; - regCb->bktTbl[bktIdx].bktNoFitCnt = 0; - - RETVOID; -} /* end of cmMmBktInit */ -#endif - - /* * * Fun: cmMmHeapInit @@ -4431,25 +3761,17 @@ U16 *lstMapIdx; * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE Void cmMmHeapInit +static Void cmMmHeapInit ( Data *memAddr, CmMmHeapCb *heapCb, Size size ) -#else -PRIVATE Void cmMmHeapInit (memAddr, heapCb, size) -Data *memAddr; -CmMmHeapCb *heapCb; -Size size; -#endif { /* 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; @@ -4492,7 +3814,7 @@ Size size; /* Initialise the memory histogram hash list */ cmHstGrmHashListInit(&(heapCb->heapHstGrmHashListCp)); #endif /* SS_HISTOGRAM_SUPPORT */ - RETVOID; + return; } /* end of cmMmHeapInit */ @@ -4521,83 +3843,45 @@ Size size; /* cm_mem_c_001.main_15 : Additions */ #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 */ @@ -4614,14 +3898,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 */ @@ -4652,7 +3935,7 @@ Size *size; #else (Void) SUnlock (&(heapCb->heapLock)); #endif - RETVALUE(ROUTRES); + return (ROUTRES); } @@ -4746,7 +4029,7 @@ Size *size; (Void) SUnlock (&(heapCb->heapLock)); #endif /* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */ - RETVALUE(RTRAMPLINGNOK); + return (RTRAMPLINGNOK); } else { @@ -4758,7 +4041,7 @@ Size *size; #else (Void) SUnlock (&(heapCb->heapLock)); #endif - RETVALUE(RFAILED); + return RFAILED; } } } @@ -4829,7 +4112,7 @@ Size *size; #endif /* SS_HISTOGRAM_SUPPORT */ - RETVALUE(ROK); + return ROK; } } @@ -4847,7 +4130,7 @@ Size *size; (Void) SUnlock (&(heapCb->heapLock)); #endif - RETVALUE(ROUTRES); + return (ROUTRES); } /* end of cmHeapAlloc */ @@ -4877,41 +4160,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 */ { @@ -4927,7 +4192,6 @@ Size size; S8 hstGrmBuf[256]; #endif /* SS_HISTOGRAM_SUPPORT */ - TRC2(cmHeapFree); /* Roundup the requested size */ size = CMM_DATALIGN(size, (heapCb->minSize)); @@ -4994,7 +4258,7 @@ Size size; (Void) SUnlock (&(heapCb->heapLock)); #endif /* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */ - RETVALUE(RTRAMPLINGNOK); + return (RTRAMPLINGNOK); } else { @@ -5008,7 +4272,7 @@ Size size; (Void) SUnlock (&(heapCb->heapLock)); #endif - RETVALUE(ROK); + return ROK; } } @@ -5033,7 +4297,7 @@ Size size; (Void) SUnlock (&(heapCb->heapLock)); #endif - RETVALUE(RDBLFREE); + return (RDBLFREE); } #endif /* SSI_DEBUG_LEVEL1 */ @@ -5091,7 +4355,7 @@ Size size; #endif /* This block is already freed in the heap */ - RETVALUE(RDBLFREE); + return (RDBLFREE); } /* update the flags as it is a new node */ if (CMM_IS_STATIC(p->memFlags)) @@ -5152,7 +4416,7 @@ Size size; } }/* End of if */ #endif /* SS_HISTOGRAM_SUPPORT */ - RETVALUE(ROK); + return ROK; } } else if (p < curHBlk) @@ -5223,7 +4487,7 @@ Size size; } }/* End of if */ #endif /* SS_HISTOGRAM_SUPPORT */ - RETVALUE(ROK); + return ROK; } } @@ -5272,7 +4536,7 @@ Size size; } }/* End of if */ #endif /* SS_HISTOGRAM_SUPPORT */ - RETVALUE(ROK); + return ROK; } /* Release the lock */ @@ -5283,7 +4547,7 @@ Size size; (Void) SUnlock (&(heapCb->heapLock)); #endif - RETVALUE(RFAILED); + return RFAILED; } /* end of cmHeapFree */ /* cm_mem_c_001.main_15 : Additions */ #endif @@ -5295,7 +4559,7 @@ Size size; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5303,19 +4567,11 @@ Size size; * File: cm_mem_wl.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++) @@ -5324,7 +4580,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; } } @@ -5334,7 +4590,7 @@ PUBLIC Void cmInitMemLeakMdl (Void) } memLkCb.memLkMdlInit = TRUE; - RETVOID; + return; } /* cmInitMemLeakMdl */ /* cm_mem_c_002.main_21 Added for shutdown procedure */ /* @@ -5344,7 +4600,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. * @@ -5352,19 +4608,11 @@ PUBLIC Void cmInitMemLeakMdl (Void) * File: cm_mem_wl.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++) @@ -5376,7 +4624,7 @@ PUBLIC Void cmDeinitMemLeakMdl (Void) memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE; } } - RETVOID; + return; } /* * @@ -5385,7 +4633,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. * @@ -5393,20 +4641,11 @@ PUBLIC Void cmDeinitMemLeakMdl (Void) * File: cm_mem_wl.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; } /* @@ -5416,7 +4655,7 @@ S8 *msOptArg; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5424,27 +4663,19 @@ S8 *msOptArg; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC Void SLogLkInfo -( -Void -) -#else -PUBLIC Void SLogLkInfo (Void) -#endif +Void SLogLkInfo (Void) { - MemAllocInfo *oldMemInfo; - MemAllocInfo *newMemInfo; - U8 memMdl; - U8 hashIdx; - U8 idx; - Txt prntBuf[255]; - S8 **funcNm; - TRC3(SLogLkInfo); + MemAllocInfo *oldMemInfo; + MemAllocInfo *newMemInfo; + uint8_t memMdl; + uint8_t hashIdx; + uint8_t idx; + Txt prntBuf[255]; + S8 **funcNm; if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } sprintf(prntBuf, "\n------- START OF LEAK LOG -------\n"); fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog); @@ -5500,7 +4731,7 @@ PUBLIC Void SLogLkInfo (Void) } sprintf(prntBuf, "\n------- END OF LEAK LOG -------\n"); fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog); - RETVOID; + return; } /* @@ -5510,7 +4741,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. * @@ -5518,27 +4749,19 @@ PUBLIC Void SLogLkInfo (Void) * File: cm_mem_wl.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++) @@ -5564,7 +4787,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*/ @@ -5579,7 +4802,7 @@ PUBLIC Void SFlushLkInfo (Void) SUnlock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck); } } - RETVOID; + return; } /* @@ -5589,7 +4812,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. * @@ -5597,21 +4820,13 @@ PUBLIC Void SFlushLkInfo (Void) * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC Void cmStorAllocBlk +Void cmStorAllocBlk ( -U32 addr, +uint32_t addr, Size reqSz, Size allocSz, -U16 bktIdx +uint16_t bktIdx ) -#else -PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx) -U32 addr; -Size reqSz; -Size allocSz; -U16 bktIdx; -#endif /* ANSI */ { #ifndef SS_MEM_LEAK_SOL Ptr trace[CM_MAX_STACK_TRACE]; @@ -5619,12 +4834,11 @@ U16 bktIdx; S8 **funcNm; S32 traceSize; MemAllocInfo *allocInfo; - U8 moduleId; + uint8_t moduleId; - TRC3(cmStorAllocBlk); if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } #ifdef SS_MEM_LEAK_SOL @@ -5633,12 +4847,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 */ traceSize = backtrace(trace, CM_MAX_STACK_TRACE); @@ -5651,11 +4865,11 @@ U16 bktIdx; /*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/ #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 - /* SGetSBuf(DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */ + /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */ allocInfo->memAddr = addr; allocInfo->reqSz = reqSz; allocInfo->allocSz = allocSz; @@ -5665,12 +4879,12 @@ U16 bktIdx; 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)); - RETVOID; + return; } /* cmStorAllocBlk */ /* @@ -5680,7 +4894,7 @@ U16 bktIdx; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5688,21 +4902,15 @@ U16 bktIdx; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC U8 cmMemGetModuleId +uint8_t cmMemGetModuleId ( S8 **funNm, S32 traceSize ) -#else -PUBLIC U8 cmMemGetModuleId (funNm, traceSize) -S8 **funNm; -S32 traceSize; -#endif /* ANSI */ { - U8 idx; - U8 memStrIdx; - U32 len; + uint8_t idx; + uint8_t memStrIdx; + uint32_t len; S32 retVal; S16 memReqIdx; S16 mdlFunStrIdx; @@ -5710,7 +4918,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; @@ -5730,7 +4937,7 @@ S32 traceSize; funNm); if(memReqIdx >= 0) { - RETVALUE(mdlFunStrIdx); + return (mdlFunStrIdx); } mdlFunStrIdx++; } @@ -5741,13 +4948,13 @@ S32 traceSize; (const S8 *)memUsrMdlStr[mdlFunStrIdx].fPStr); if(retVal == NULLD) { - RETVALUE(mdlFunStrIdx); + return (mdlFunStrIdx); } mdlFunStrIdx++; } } - RETVALUE(0); + return (0); } /* cmMemGetModuleId */ /* @@ -5757,7 +4964,7 @@ S32 traceSize; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5765,30 +4972,21 @@ S32 traceSize; * File: cm_mem_wl.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] = '('; @@ -5818,9 +5016,9 @@ S8 **strLst; if(!found) { - RETVALUE(-1); + return (-1); } - RETVALUE(strtIdx); + return (strtIdx); } /* cmMemGetStrMtchIdx */ @@ -5831,7 +5029,7 @@ S8 **strLst; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5839,28 +5037,22 @@ S8 **strLst; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC Void cmRlsAllocBlk +Void cmRlsAllocBlk ( -U32 addr +uint32_t addr ) -#else -PUBLIC Void cmRlsAllocBlk(addr) -U32 addr; -#endif { Ptr trace[CM_MAX_STACK_TRACE]; S8 **funcNm; - U8 idx; - U8 i; + uint8_t idx; + uint8_t i; S16 retVal; S32 traceSize; MemAllocInfo *memAllocInfo; - TRC3(cmRlsAllocBlk); if( memLkCb.memLkMdlInit == FALSE) { - RETVOID; + return; } @@ -5868,7 +5060,7 @@ U32 addr; { SLock(&memLkCb.memUsrMdl[idx][addr & 0x3].memLck); retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp, - (U8 *)&addr, sizeof(U32), 0, + (uint8_t *)&addr, sizeof(uint32_t), 0, (PTR *)&memAllocInfo); if(retVal == ROK) { @@ -5959,7 +5151,7 @@ U32 addr; #endif /* SS_MEM_LEAK_SOL */ /*cm_mem_c_001.main_25 : */ - RETVOID; + return; } /* cmRlsAllocBlk */ @@ -5971,7 +5163,7 @@ U32 addr; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -5979,42 +5171,34 @@ U32 addr; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S32 cmAddrToSymStr +S32 cmAddrToSymStr ( Void *pc, S8 *buffer, S32 size ) -#else -PUBLIC S32 cmAddrToSymStr(pc, buffer, size) -Void *pc; -S8 *buffer; -S32 size; -#endif { Dl_info info; Sym *sym; - TRC3(cmAddrToSymStr); if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0) { - RETVALUE(snprintf(buffer, size, "[0x%p]", pc)); + return (snprintf(buffer, size, "[0x%p]", pc)); } if ((info.dli_fname != NULLP && info.dli_sname != NULLP) && ((uintptr_t)pc - (uintptr_t)info.dli_saddr < sym->st_size)) { - RETVALUE(snprintf(buffer, size, "%s(%s+0x%x) [0x%p]", + return (snprintf(buffer, size, "%s(%s+0x%x) [0x%p]", info.dli_fname, info.dli_sname, (unsigned long)pc - (unsigned long)info.dli_saddr, pc)); } else { - RETVALUE(snprintf(buffer, size, "%s(0x%p [0x%p]", + return (snprintf(buffer, size, "%s(0x%p [0x%p]", info.dli_fname, (unsigned long)pc - (unsigned long)info.dli_fbase, pc)); } @@ -6028,7 +5212,7 @@ S32 size; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -6036,38 +5220,30 @@ S32 size; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S32 cmLeakCallBack +S32 cmLeakCallBack ( uintptr_t pc, S32 sigNo, Void *arg ) -#else -PUBLIC S32 cmLeakCallBack(pc, sigNo, arg) -uintptr_t pc; -S32 sigNo; -Void *arg; -#endif { S8 *buffer; - TRC3(cmLeakCallBack); Backtrace_t *bt = (Backtrace_t *)arg; if (bt->bt_actcount >= bt->bt_maxcount) - RETVALUE(-1); + return (-1); /*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; - RETVALUE(0); + return (0); } /* cmLeakCallBack */ /* @@ -6077,7 +5253,7 @@ Void *arg; * Desc: Initializes the memory leak detection module * * -* Ret: RETVOID +* Ret: void * * Notes: This function initializes the memory leak detection module. * @@ -6085,19 +5261,12 @@ Void *arg; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S32 backtrace +S32 backtrace ( -Void **buffer, -S32 count +Void **buffer, +S32 count ) -#else -PUBLIC S32 backtrace(buffer, count) -Void **buffer; -S32 count; -#endif { - TRC3(backtrace); Backtrace_t bt; ucontext_t u; @@ -6107,9 +5276,9 @@ S32 count; bt.bt_actcount = 0; if (getcontext(&u) < 0) - RETVALUE(0); + return (0); (Void) walkcontext(&u, cmLeakCallBack, &bt); - RETVALUE(bt.bt_actcount); + return (bt.bt_actcount); } /* backtrace */ @@ -6141,20 +5310,11 @@ S32 count; * File: cm_mem_wl.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; + uint32_t blkCnt; - TRC2(cmMmBktSanityChk); bkt->trampleCount = 0; @@ -6168,7 +5328,7 @@ CmMmBkt *bkt; if (bkt->trampleCount > CMM_TRAMPLING_THRESHOLD) { /* Take action to invalidate the entire bucket */ - RETVALUE(RTRAMPLINGNOK); + return (RTRAMPLINGNOK); } } /* reach next memory block in this bucket manually */ @@ -6181,7 +5341,7 @@ CmMmBkt *bkt; SDisplay(0, dbgPrntBuf); #endif /* DEBUGP */ - RETVALUE(RTRAMPLINGOK); + return (RTRAMPLINGOK); } /* @@ -6203,28 +5363,18 @@ CmMmBkt *bkt; * File: cm_mem_wl.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++; if (heapCb->trampleCount > CMM_TRAMPLING_THRESHOLD) { - RETVALUE(RTRAMPLINGNOK); + return (RTRAMPLINGNOK); } - RETVALUE(RTRAMPLINGOK); + return (RTRAMPLINGOK); } /* @@ -6241,29 +5391,20 @@ CmMmHeapCb *heapCb; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC S16 cmMmRegIsBlkSane -( -CmMmBlkHdr *blkPtr -) -#else -PUBLIC S16 cmMmRegIsBlkSane(blkPtr) -CmMmBlkHdr *blkPtr; -#endif +S16 cmMmRegIsBlkSane(CmMmBlkHdr *blkPtr) { - U32 sigCnt; + uint32_t sigCnt; - TRC2(cmMmRegIsBlkSane); for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++) { if (blkPtr->trSignature[sigCnt] != 0xAB) { - RETVALUE(RFAILED); + return RFAILED; } } - RETVALUE(ROK); + return ROK; } /* @@ -6282,25 +5423,17 @@ CmMmBlkHdr *blkPtr; * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE S16 cmMmHashFunc +static S16 cmMmHashFunc ( CmMmHashListCp *hashListCp, -U32 key, -U16 *idx +uint32_t key, +uint16_t *idx ) -#else -PRIVATE S16 cmMmHashFunc (hashListCp, key, idx) -CmMmHashListCp *hashListCp; /* hash list control point */ -U32 key; /* key string */ -U16 *idx; /* idx to return */ -#endif { - TRC2(cmMmHashFunc); - *idx = (U16)(key % hashListCp->numOfbins); + *idx = (uint16_t)(key % hashListCp->numOfbins); - RETVALUE(ROK); + return ROK; } /* end of cmMmHashFunc () */ @@ -6325,26 +5458,17 @@ U16 *idx; /* idx to return */ * File: cm_mem_wl.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; @@ -6354,9 +5478,9 @@ 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) - RETVALUE(RFAILED); + return RFAILED; /* initialize bin pointers */ hl = hashListCp->hashList; @@ -6369,7 +5493,7 @@ Pool pool; /* memory pool to allocate bins */ hashListCp->numOfbins = nmbBins; } - RETVALUE(ROK); + return ROK; } /* @@ -6391,25 +5515,17 @@ Pool pool; /* memory pool to allocate bins */ * File: cm_mem_wl.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 */ ) -#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))); @@ -6418,7 +5534,7 @@ Pool pool; /* memory pool to allocate bins */ hashListCp->numOfbins = 0; hashListCp->numOfEntries = 0; - RETVALUE(ROK); + return ROK; } /* end of cmMmHashListDeinit */ /* @@ -6438,31 +5554,24 @@ Pool pool; /* memory pool to allocate bins */ * File: cm_mem_wl.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) - RETVALUE(ROK); + return ROK; /* compute index for insertion */ if (cmMmHashFunc(hashListCp, key, &idx) != ROK) - RETVALUE(RFAILED); + return RFAILED; hashListEnt = hashListCp->hashList; @@ -6498,11 +5607,11 @@ U32 key; /* pointer to key */ if (i == CMM_STAT_HASH_TBL_LEN) { /* there is no free slot for this key */ - RETVALUE(RFAILED); + return RFAILED; } } - RETVALUE(ROK); + return ROK; } /* end of cmMmHashListInsert */ #endif /* SSI_DEBUG_LEVEL1 */ @@ -6523,18 +5632,12 @@ U32 key; /* pointer to key */ * File: cm_mem_wl.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*/ @@ -6546,7 +5649,7 @@ CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ SDisplay(0, dbgPrntBuf); #endif /* DEBUGP */ memset(hashListCp, 0, sizeof(CmHstGrmHashListCp)); - RETVALUE(ROK); + return ROK; } /* @@ -6564,18 +5667,12 @@ CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ * File: cm_mem_wl.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*/ @@ -6587,7 +5684,7 @@ CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ SDisplay(0, dbgPrntBuf); #endif /* DEBUGP */ memset(hashListCp, 0, sizeof(CmHstGrmHashListCp)); - RETVALUE(ROK); + return ROK; } /* @@ -6609,31 +5706,21 @@ CmHstGrmHashListCp *hashListCp; /* hash list to initialize */ * File: cm_mem_wl.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 */ @@ -6646,14 +5733,14 @@ U8 entId; /* Tapa task which frees the memory */ { entry->freedBytes += blkSz; entry->bucketFreeReq++; - RETVALUE(ROK); + return ROK; } /* End of if */ /* 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"); - RETVALUE(RFAILED); + return RFAILED; } /* End of if */ /* Take the address of next free entry in the hash bin */ @@ -6671,7 +5758,7 @@ U8 entId; /* Tapa task which frees the memory */ /* Increase the total number of entries in the hash list */ hashListCp->totalNumEntries++; - RETVALUE(ROK); + return ROK; } /* end of cmHstGrmFreeInsert */ @@ -6692,32 +5779,21 @@ U8 entId; /* Tapa task which frees the memory */ * File: cm_mem_wl.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 */ @@ -6732,13 +5808,13 @@ U8 entId; entry->allocBytes += blkSz; entry->bucketAllocReq++; entry->wastedBytes += (blkSz - *reqSz); - RETVALUE(ROK); + return ROK; } /* End of if */ 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"); - RETVALUE(RFAILED); + return RFAILED; } /* End of if */ /* Take the address of next free entry in the hash bin */ @@ -6759,7 +5835,7 @@ U8 entId; /* Increase the total number of entries in the hash list */ hashListCp->totalNumEntries++; - RETVALUE(ROK); + return ROK; } /* end of cmHstGrmAllocInsert */ @@ -6780,25 +5856,16 @@ U8 entId; * File: cm_mem_wl.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++) @@ -6807,7 +5874,7 @@ U32 *key; }/* End of for */ *key += line; *binIdx = ( *key % CMM_HIST_MAX_MEM_BIN); - RETVALUE(ROK); + return ROK; } /* end of cmHstGrmFillEntry */ /* @@ -6830,27 +5897,17 @@ U32 *key; * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmFillEntry +static S16 cmHstGrmFillEntry ( CmMemEntries *entry, -U32 key, -U32 line, -U8 *fileName, -U8 entId +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; @@ -6859,7 +5916,7 @@ U8 entId; entry->fileName[idx] = fileName[idx]; } entry->fileName[idx] = '\0'; - RETVALUE(ROK); + return ROK; } /* end of cmHstGrmFillEntry */ /* @@ -6879,29 +5936,19 @@ U8 entId; * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE S16 cmHstGrmFindEntry +static S16 cmHstGrmFindEntry ( CmHstGrmHashListCp *hashListCp, -U32 key, -U32 *binIdx, +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++) { @@ -6914,7 +5961,7 @@ CmMemEntries **entry; if(tmpBin->entries[numEnt].key == key) { *entry = &(tmpBin->entries[numEnt]); - RETVALUE(ROK); + return ROK; }/* End of if (tmpBin->entries[numEnt].key) */ }/* end of for (numEnt = 0) */ @@ -6937,53 +5984,30 @@ CmMemEntries **entry; else { printf ("Unable to find the entry in hash list\n"); - RETVALUE(RFAILED); + return RFAILED; }/* End of else (numEnt) */ }/* end of for (numBin = 0) */ printf("Unable to find the entry in the hash list\n"); - RETVALUE(RFAILED); + return RFAILED; } /* end of cmHstGrmFindEntry */ #endif /* SS_HISTOGRAM_SUPPORT */ #ifdef T2K_MEM_LEAK_DBG T2kMeamLeakInfo gMemLeakInfo[T2K_MEM_LEAK_INFO_TABLE_SIZE]; -U32 getT2kMemLeakIndex(U32 address) +uint32_t getT2kMemLeakIndex(uint32_t address) { -#if 0 - /* - 1 2 3 4 5 6 7 - - XOR 7 with 3 and remove 7 - XOR 1 with 5 and remove 1 - */ - - address -= T2K_MEM_LEAK_START_ADDR; - - U8 Nib7 = address & 0x0000000f; - U8 Nib1 = (address & 0x0f000000) >>24; - U8 Nib3 = (address & 0x000f0000) >> 16; - U8 Nib5 = (address & 0x00000f00) >> 8; - - /* store 8 ^ 3 in 8Nib */ - Nib7 = Nib7 ^ Nib3; - /* store 1 ^ 6 in 6Nib */ - Nib5 = Nib5 ^ Nib1; - - return(((address & 0x000fff00) | (Nib7 << 20) | (Nib5 << 4)) >> 4); - -#endif return ((address - T2K_MEM_LEAK_START_ADDR) >> 8); } -static U32 t2kMemAllocTick; -static U32 smallTick; +static uint32_t t2kMemAllocTick; +static uint32_t smallTick; -void InsertToT2kMemLeakInfo(U32 address, U32 size, U32 lineNo, char* fileName) +void InsertToT2kMemLeakInfo(uint32_t address, uint32_t size, uint32_t lineNo, char* fileName) { - U32 idx = getT2kMemLeakIndex(address); + uint32_t idx = getT2kMemLeakIndex(address); - if(((U32)(address - T2K_MEM_LEAK_START_ADDR) & 0xff) !=0) + if(((uint32_t)(address - T2K_MEM_LEAK_START_ADDR) & 0xff) !=0) { printf("address in InsertToT2kMemLeakInfo is %lx size = %ld file is %s" "line is %ld \n", address, size, fileName, lineNo); @@ -7014,39 +6038,13 @@ void InsertToT2kMemLeakInfo(U32 address, U32 size, U32 lineNo, char* fileName) gMemLeakInfo[idx].address, gMemLeakInfo[idx].fileName, gMemLeakInfo[idx].lineNo, gMemLeakInfo[idx].size, gMemLeakInfo[idx].age, (t2kMemAllocTick-gMemLeakInfo[idx].age)); -#if 0 - /* Try inserting into some other location */ - int i; - int lastIndex = idx + 1; - Bool inserted = FALSE; - for(i = 2; lastIndex < T2K_MEM_LEAK_INFO_TABLE_SIZE && i < 30; i++) - { - if(gMemLeakInfo[lastIndex].address == 0) - { - gMemLeakInfo[lastIndex].address = address; - gMemLeakInfo[lastIndex].size = size; - gMemLeakInfo[lastIndex].lineNo = lineNo; - gMemLeakInfo[lastIndex].fileName = fileName; - gMemLeakInfo[lastIndex].age = (++t2kMemAllocTick) >> 14; /*For every 16384 memory block allocations,Alloc Tick is incremented by 1*/ - inserted = TRUE; - break; - } - lastIndex = idx + (i * i * i); - } -#if 1 - if(!inserted) - { - printf("Something is wrong, trying to insert %x idx = %d no free i = %d\n",address, idx, i); - } -#endif -#endif } } -void RemoveFromT2kMemLeakInfo(U32 address, char *file, U32 line) +void RemoveFromT2kMemLeakInfo(uint32_t address, char *file, uint32_t line) { - U32 idx = getT2kMemLeakIndex(address); + uint32_t idx = getT2kMemLeakIndex(address); if(idx >= T2K_MEM_LEAK_INFO_TABLE_SIZE) { @@ -7082,36 +6080,10 @@ void RemoveFromT2kMemLeakInfo(U32 address, char *file, U32 line) printf("Previous File:%s, Previous Line:%ld\n", gMemLeakInfo[idx].prevRemFileName, gMemLeakInfo[idx].prevRemLineNo); } -#if 0 - /* Try removing from some other location where it might have been stored*/ - int i; - int lastIndex = idx + 1; - Bool removed = FALSE; - for(i = 2; lastIndex < T2K_MEM_LEAK_INFO_TABLE_SIZE && i < 30; i++) - { - if(gMemLeakInfo[lastIndex].address == address) - { - gMemLeakInfo[lastIndex].address = 0; - gMemLeakInfo[lastIndex].size = 0; - gMemLeakInfo[lastIndex].lineNo = 0; - gMemLeakInfo[lastIndex].fileName = 0; - gMemLeakInfo[lastIndex].age = 0; /*For every 16384 memory block allocations,Alloc Tick is incremented by 1*/ - removed = TRUE; - break; - } - lastIndex = idx + (i*i*i); - } -#if 1 - if(!removed) - { - printf("Something is wrong, trying to remove %x idx = %d lastIndex = %d FreeCalled from File=%s, line=%d\n",address, idx, lastIndex,file,line); - } -#endif -#endif } } -PUBLIC void DumpT2kMemLeakInfoToFile() +void DumpT2kMemLeakInfoToFile() { int i; @@ -7150,26 +6122,20 @@ PUBLIC void DumpT2kMemLeakInfoToFile() #ifdef TENB_T2K3K_SPECIFIC_CHANGES /* For Updating SOC Specific Memory Information */ -#ifdef ANSI -PUBLIC S16 UpdateSocMemInfo +S16 UpdateSocMemInfo ( -U8 areaIndex, +uint8_t areaIndex, CmLteMemInfo *mInfo ) -#else -PUBLIC S16 UpdateSocMemInfo(areaIndex,mInfo) -U8 areaIndex; -CmLteMemInfo *mInfo; -#endif { - U8 idxReg; - U8 idxPool; - U16 numPool; + uint8_t idxReg; + uint8_t idxPool; + uint16_t numPool; void *iccHdl = NULLP; - U32 poolFreeCnt[4]; - U32 poolUsedCnt[4]; - U32 poolSize[4]; - U32 poolTotAvail[4]; + uint32_t poolFreeCnt[4]; + uint32_t poolUsedCnt[4]; + uint32_t poolSize[4]; + uint32_t poolTotAvail[4]; idxReg = mInfo->numRegions; mInfo->numRegions = mInfo->numRegions + 1; @@ -7217,7 +6183,7 @@ CmLteMemInfo *mInfo; } } - RETVALUE(ROK); + return ROK; } /* @@ -7236,19 +6202,14 @@ CmLteMemInfo *mInfo; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC U32 isL2MemUsageBelowLowerThreshold( +uint32_t isL2MemUsageBelowLowerThreshold( Region region ) -#else -PUBLIC U32 isL2MemUsageBelowLowerThreshold(region) -Region region; -#endif { void * iccHdl = ssGetIccHdl(region); - U32 poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE); - U32 poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE); + uint32_t poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE); + uint32_t poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE); /* We are below the threshold if free count in BOTH of the pools * is above the ICC_MEM_LOWER_THRESHOLD % */ @@ -7257,10 +6218,10 @@ Region region; ((poolOneFreeCnt * 100) > (ICC_MEM_LOWER_THRESHOLD * ICC_POOL_ONE_TOTAL_BLKS))) { - RETVALUE(TRUE); + return (TRUE); } - RETVALUE(FALSE); + return (FALSE); } @@ -7280,21 +6241,16 @@ Region region; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC U32 isMemUsageBelowLowerThreshold( +uint32_t isMemUsageBelowLowerThreshold( Region region ) -#else -PUBLIC U32 isMemUsageBelowLowerThreshold(region) -Region region; -#endif { void * iccHdl = ssGetIccHdl(region); - U32 poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE); - U32 poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE); - U32 poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE); - U32 poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE); + uint32_t poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE); + uint32_t poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE); + uint32_t poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE); + uint32_t poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE); /* We are below the threshold if free count in BOTH of the pools * is above the ICC_MEM_LOWER_THRESHOLD % */ @@ -7307,10 +6263,10 @@ Region region; ((poolThreeFreeCnt * 100) > (ICC_MEM_LOWER_THRESHOLD * ICC_POOL_THREE_TOTAL_BLKS))) { - RETVALUE(TRUE); + return (TRUE); } - RETVALUE(FALSE); + return (FALSE); } /* @@ -7329,21 +6285,16 @@ Region region; * File: cm_mem_wl.c * */ -#ifdef ANSI -PRIVATE U32 isMemUsageAboveUpperThreshold( +static uint32_t isMemUsageAboveUpperThreshold( Region region ) -#else -PRIVATE U32 isMemUsageAboveUpperThreshold(region) -Region region; -#endif { void * iccHdl = ssGetIccHdl(region); - U32 poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE); - U32 poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE); - U32 poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE); - U32 poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE); + uint32_t poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE); + uint32_t poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE); + uint32_t poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE); + uint32_t poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE); /* We are above the threshold if free count in either of the pools * is below the ICC_MEM_UPPER_THRESHOLD % */ @@ -7356,10 +6307,10 @@ Region region; ((poolThreeFreeCnt * 100) < (ICC_MEM_UPPER_THRESHOLD * ICC_POOL_THREE_TOTAL_BLKS))) { - RETVALUE(TRUE); + return (TRUE); } - RETVALUE(FALSE); + return (FALSE); } /* ccpu00142274- Function to check if we have reached the @@ -7392,20 +6343,14 @@ Region region; * File: cm_mem_wl.c * */ -#ifdef ANSI -PUBLIC U32 isMemThreshReached( +uint32_t isMemThreshReached( Region reg ) -#else -PUBLIC U32 isMemThreshReached(reg) -Region reg; -#endif { - TRC3(isMemThreshReached) if(gMemoryAlarm) { gMemoryAlarm = !(isMemUsageBelowLowerThreshold(reg)); - RETVALUE(RFAILED); + return RFAILED; } else { @@ -7415,200 +6360,10 @@ Region reg; memoryCheckCounter = 0; } } - RETVALUE(ROK); + return ROK; } #endif #endif /* SS_LOCKLESS_MEMORY */ -#if 0 -T2kMeamLeakInfo gMemLeakInfo[T2K_MEM_LEAK_INFO_TABLE_SIZE]; -U32 getT2kMemLeakIndex(U32 address) -{ -#if 0 - /* - 1 2 3 4 5 6 7 - - XOR 7 with 3 and remove 7 - XOR 1 with 5 and remove 1 - */ - - address -= T2K_MEM_LEAK_START_ADDR; - - U8 Nib7 = address & 0x0000000f; - U8 Nib1 = (address & 0x0f000000) >>24; - U8 Nib3 = (address & 0x000f0000) >> 16; - U8 Nib5 = (address & 0x00000f00) >> 8; - - /* store 8 ^ 3 in 8Nib */ - Nib7 = Nib7 ^ Nib3; - /* store 1 ^ 6 in 6Nib */ - Nib5 = Nib5 ^ Nib1; - - return(((address & 0x000fff00) | (Nib7 << 20) | (Nib5 << 4)) >> 4); - -#endif - return ((address - T2K_MEM_LEAK_START_ADDR) >> 8); -} - -static U32 t2kMemAllocTick; -static U32 smallTick; - -void InsertToT2kMemLeakInfo(U32 address, U32 size, U32 lineNo, char* fileName) -{ - U32 index = getT2kMemLeakIndex(address); - - if(((U32)(address - T2K_MEM_LEAK_START_ADDR) & 0xff) !=0) - { - printf("address in InsertToT2kMemLeakInfo is %x size = %d file is %s line is %d \n", address, size, fileName, lineNo); - } - - if(gMemLeakInfo[index].address == 0) - { - gMemLeakInfo[index].address = address; - gMemLeakInfo[index].size = size; - gMemLeakInfo[index].lineNo = lineNo; - gMemLeakInfo[index].fileName = fileName; - gMemLeakInfo[index].age = t2kMemAllocTick; - gMemLeakInfo[index].prevRemLineNo = 0; - gMemLeakInfo[index].prevRemFileName = '\0'; - - if(smallTick++ == 4096) - { - smallTick = 0; - gMemLeakInfo[index].age = (++t2kMemAllocTick); - } - } - else - { - printf("Something is wrong, trying to insert %x index = %d file is %s line is %d \n",address, index, fileName, lineNo); - printf("Address present :%x, from File:%s, Line:%d, Size:%d, Age:%d", - gMemLeakInfo[index].address, gMemLeakInfo[index].fileName, - gMemLeakInfo[index].lineNo, gMemLeakInfo[index].size, - gMemLeakInfo[index].age); -#if 0 - /* Try inserting into some other location */ - int i; - int lastIndex = index + 1; - Bool inserted = FALSE; - for(i = 2; lastIndex < T2K_MEM_LEAK_INFO_TABLE_SIZE && i < 30; i++) - { - if(gMemLeakInfo[lastIndex].address == 0) - { - gMemLeakInfo[lastIndex].address = address; - gMemLeakInfo[lastIndex].size = size; - gMemLeakInfo[lastIndex].lineNo = lineNo; - gMemLeakInfo[lastIndex].fileName = fileName; - gMemLeakInfo[lastIndex].age = (++t2kMemAllocTick) >> 14; /*For every 16384 memory block allocations,Alloc Tick is incremented by 1*/ - inserted = TRUE; - break; - } - lastIndex = index + (i * i * i); - } -#if 1 - if(!inserted) - { - printf("Something is wrong, trying to insert %x index = %d no free i = %d\n",address, index, i); - } -#endif -#endif - } -} - - -void RemoveFromT2kMemLeakInfo(U32 address, char *file, U32 line) -{ - U32 index = getT2kMemLeakIndex(address); - - if(index >= T2K_MEM_LEAK_INFO_TABLE_SIZE) - { - printf("Index out of range = %d address is %x file = %s line = %d. We are going to crash!!!\n", - index, - address, - file, - line); - } - if(gMemLeakInfo[index].address == address) - { - gMemLeakInfo[index].address = 0; - gMemLeakInfo[index].age = 0; - gMemLeakInfo[index].prevRemLineNo = gMemLeakInfo[index].lineNo; - gMemLeakInfo[index].prevRemFileName = gMemLeakInfo[index].fileName; - - /*printf("Something is wrong, Trying to double free Address = %x, Index = %d \n",address,index);*/ - } - else - { - printf("Something is wrong, trying to remove %x index = %d from File=%s, line=%d address present is %x\n",address, index, file,line, - gMemLeakInfo[index].address); - if(gMemLeakInfo[index].prevRemFileName != NULLP) - { - printf("Previous File:%s, Previous Line:%d\n", - gMemLeakInfo[index].prevRemFileName, gMemLeakInfo[index].prevRemLineNo); - } -#if 0 - /* Try removing from some other location where it might have been stored*/ - int i; - int lastIndex = index + 1; - Bool removed = FALSE; - for(i = 2; lastIndex < T2K_MEM_LEAK_INFO_TABLE_SIZE && i < 30; i++) - { - if(gMemLeakInfo[lastIndex].address == address) - { - gMemLeakInfo[lastIndex].address = 0; - gMemLeakInfo[lastIndex].size = 0; - gMemLeakInfo[lastIndex].lineNo = 0; - gMemLeakInfo[lastIndex].fileName = 0; - gMemLeakInfo[lastIndex].age = 0; /*For every 16384 memory block allocations,Alloc Tick is incremented by 1*/ - removed = TRUE; - break; - } - lastIndex = index + (i*i*i); - } -#if 1 - if(!removed) - { - printf("Something is wrong, trying to remove %x index = %d lastIndex = %d FreeCalled from File=%s, line=%d\n",address, index, lastIndex,file,line); - } -#endif -#endif - } -} - -void DumpT2kMemLeakInfoToFile() -{ - int i; - - FILE *fp = fopen("memLeakInfo.txt","wb"); - - if(fp == NULL) - { - printf("Could not open file for dumping mem leak info\n"); - return; - } - - for(i = 0; i< T2K_MEM_LEAK_INFO_TABLE_SIZE; i++) - { - if(gMemLeakInfo[i].address != 0) - { - char* onlyFileName = rindex(gMemLeakInfo[i].fileName,'/'); - if(onlyFileName == NULL) - { - onlyFileName = gMemLeakInfo[i].fileName; - } - - fprintf(fp, "%p s=%d a=%d l=%d f=%s\n",gMemLeakInfo[i].address, - gMemLeakInfo[i].size, - gMemLeakInfo[i].age, - gMemLeakInfo[i].lineNo, - onlyFileName); - } - } - - fprintf(fp,"Current t2kMemAllocTick = %d\n",t2kMemAllocTick); - - fclose(fp); -} -#endif - /********************************************************************** End of file **********************************************************************/