#ifdef L2_L3_SPLIT
#include "mt_plat_t33.h"
-extern S32 clusterMode;
+S32 clusterMode;
#endif
#include "cm_lte.x"
-
+#include "du_log.h"
\f
/* 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
#define NUM_FREE_BUFFERS 128
typedef struct cmBtInfo
{
- U32 btInfoIdx;
+ uint32_t btInfoIdx;
CmMemFreeInfo btInfo[NUM_FREE_BUFFERS];
} CmBtInfo;
}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
/* 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 */
#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 */
#else
//DumpPDCPDlDebugInformation();
//DumpPDCPUlDebugInformation();
-#ifdef CU_STUB
+#ifndef ODU_TEST_STUB
DumpRLCDlDebugInformation();
DumpRLCUlDebugInformation();
#endif
* 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;
cmHstGrmHashListInit(&(regCb->bktTbl[bktIdx].hstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmStatBktInit */
/*
* 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;
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) &&
/* 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;
}
/*
\n",bktIdx,cfg->bktCfg[bktIdx].size,cfg->bktQnSize);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((bktBlkSize = cfg->bktCfg[bktIdx].size) < lstQnSize)
/* 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) /\
\n should be less than CMM_MAX_MAP_ENT:%d \n",cfg->bktQnSize,CMM_MAX_MAP_ENT);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
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;
/* 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
-
/*
*
* 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;
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++)
*next = NULLP;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmGlobRegInit*/
#ifdef SS_USE_ICC_MEMORY
*
*/
#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);
if((SUnlock(&iccAllocFreeLock)) != ROK)
{
printf("cmIccAllocWithLock: Failed to unlock the ICC lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((memPtr) == NULLP)
}
#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 */
*
*/
#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);
if((SUnlock(&iccAllocFreeLock)) != ROK)
{
printf("cmIccFreeWithLock: Failed to unlock the ICC lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmIccFree */
/*
*
*/
#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;
*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); */
*ptr = memPtr; /*TL_VA2TRUEVA(regCb->iccHdl, memPtr); */
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of cmIccAlloc */
*
*/
#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;
// 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
}
#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 */
/*
* 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
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)
{
sprintf (regIccStr, "queuesize=%d rxid=%d", 512, (regCb->region) + 1);
#endif
#endif
-#endif
#endif
printf(" %s \n",regIccStr);
regCb->iccHdl = TL_Open(regIccStr, 0);
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)
if (SRegDynRegion(regCb->region, ®Info) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmDynRegInit*/
#else /* SS_USE_ICC_MEMORY */
* 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;
}
/* 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;
}
/* 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;
}
}
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 */
* 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
/* 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 */
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegDeInit */
*
*/
-#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;
/* 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 */
/* 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)
}
/* On successful, return the bucket node to calling function */
- RETVALUE(memBlkSetElem);
+ return (memBlkSetElem);
} /* cmGetMemBlkSetForAlloc */
*
*/
-#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;
/* 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 */
/* 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. */
*/
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 */
*
*/
-#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);
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;
}
/*
*
*/
-#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
*/
/* 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);
if((SUnlock(&dynAllocFreeLock)) != ROK)
{
printf("cmDynAllocWithLock: Failed to unlock the Dyn lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* end of cmDynAlloc */
/*
*/
/* 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;
#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
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 */
#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;
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
*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;
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 */
/* 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 */
{
/* 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
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmAlloc);
#ifndef USE_MEMCAL
UNUSED(flags);
#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
#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 */
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
(Void) SUnlock(&(bkt->bktLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
+ DU_LOG("\nERROR --> CM : cmAlloc(): Sanity check returns failure");
/* return RFAILED */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
/*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
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else if (flags)
{
#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 */
* 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
* 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 */
/*
* 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++)
{ */
(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);
}
/* } */
- RETVOID;
+ return;
}
#endif
* 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);
if((SUnlock(&dynAllocFreeLock)) != ROK)
{
printf("dynAllocWithLock: Failed to unlock the dyn lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* end of cmDynFree */
* 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
/* 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 */
#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
#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;
}
/* 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;
}
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++;
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;
}
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);
/* avail_size += size; */
free(ptr);
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/* 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 */
{
/* 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 */
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmFree);
regCb = (CmMmRegCb *)regionCb;
/* 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
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
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
{
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure");
+ return (RTRAMPLINGNOK);
}
}
#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))
{
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
{
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ DU_LOG("\nERROR --> CM : cmFree(): Sanity check returns failure");
+ return (RTRAMPLINGNOK);
}
}
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
(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);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/*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*/
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Update the size parameter */
*size = bkt->size;
- RETVALUE(ROK);
+ return ROK;
}
}
}
* 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 */
*/
#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;
/* 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
/*
* 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
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*/
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);
/* avail_size += size; */
free(ptr);
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
*
*/
-#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;
/* error check on parameters */
if ((regCb == NULLP) || (memCtl == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((memCtl->u.vtop.vaddr == NULLP) ||
(memCtl->u.vtop.paddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
offset = memCtl->u.vtop.vaddr - regCb->regInfo.start;
*(memCtl->u.vtop.paddr) = regCb->pAddr + offset;
- RETVALUE(ROK);
+ return ROK;
}
break;
}
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.
(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 */
}
default:
{
/* No other event is supported currently */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* shouldn't reach here */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmCtl */
\f
-#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
-
-\f
/*
*
* Fun: cmMmHeapInit
* 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;
/* Initialise the memory histogram hash list */
cmHstGrmHashListInit(&(heapCb->heapHstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmHeapInit */
/* 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 */
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 */
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
} /* end of cmHeapAlloc */
*/
/* 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 */
{
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapFree);
/* Roundup the requested size */
size = CMM_DATALIGN(size, (heapCb->minSize));
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
#endif /* SSI_DEBUG_LEVEL1 */
#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))
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
else if (p < curHBlk)
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
/* Release the lock */
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHeapFree */
/* cm_mem_c_001.main_15 : Additions */
#endif
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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++)
{
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;
}
}
}
memLkCb.memLkMdlInit = TRUE;
- RETVOID;
+ return;
} /* cmInitMemLeakMdl */
/* cm_mem_c_002.main_21 Added for shutdown procedure */
/*
* Desc: De-initializes the memory leak detection module
*
*
- * Ret: RETVOID
+ * Ret: void
*
* Notes: This function de-initializes the memory leak detection module.
*
* 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++)
memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE;
}
}
- RETVOID;
+ return;
}
/*
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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;
}
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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);
}
sprintf(prntBuf, "\n------- END OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
- RETVOID;
+ return;
}
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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++)
#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*/
SUnlock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck);
}
}
- RETVOID;
+ return;
}
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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];
S8 **funcNm;
S32 traceSize;
MemAllocInfo *allocInfo;
- U8 moduleId;
+ uint8_t moduleId;
- TRC3(cmStorAllocBlk);
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
#ifdef SS_MEM_LEAK_SOL
* 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);
/*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;
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 */
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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;
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;
funNm);
if(memReqIdx >= 0)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
(const S8 *)memUsrMdlStr[mdlFunStrIdx].fPStr);
if(retVal == NULLD)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
}
- RETVALUE(0);
+ return (0);
} /* cmMemGetModuleId */
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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] = '(';
if(!found)
{
- RETVALUE(-1);
+ return (-1);
}
- RETVALUE(strtIdx);
+ return (strtIdx);
} /* cmMemGetStrMtchIdx */
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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;
}
{
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)
{
#endif /* SS_MEM_LEAK_SOL */
/*cm_mem_c_001.main_25 : */
- RETVOID;
+ return;
} /* cmRlsAllocBlk */
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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));
}
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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 */
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* 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;
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 */
* 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;
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 */
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
* 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);
}
/*
* 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;
}
/*
* 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 () */
* 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;
/* 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;
hashListCp->numOfbins = nmbBins;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
* 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)));
hashListCp->numOfbins = 0;
hashListCp->numOfEntries = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListDeinit */
/*
* 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;
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 */
* 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*/
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
* 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*/
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
* 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 */
{
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 */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFreeInsert */
* 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 */
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 */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmAllocInsert */
* 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++)
}/* End of for */
*key += line;
*binIdx = ( *key % CMM_HIST_MAX_MEM_BIN);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
* 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;
entry->fileName[idx] = fileName[idx];
}
entry->fileName[idx] = '\0';
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
* 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++)
{
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) */
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);
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)
{
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;
#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;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
* 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 % */
((poolOneFreeCnt * 100) >
(ICC_MEM_LOWER_THRESHOLD * ICC_POOL_ONE_TOTAL_BLKS)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
* 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 % */
((poolThreeFreeCnt * 100) >
(ICC_MEM_LOWER_THRESHOLD * ICC_POOL_THREE_TOTAL_BLKS)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/*
* 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 % */
((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
* 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
{
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
**********************************************************************/
Code Review / o-du / l2.git / blobdiff