#ifdef SS_LIGHT_MEM_LEAK_STS
MemLeakCb gmemLkCb;
- U32 queueIndxAllocCnt =0;
- U32 queueIndxFreeCnt =0;
- U32 allocQueueFullCnt =0;
- U32 allocQueueEmptyCnt =0;
+ uint32_t queueIndxAllocCnt =0;
+ uint32_t queueIndxFreeCnt =0;
+ uint32_t allocQueueFullCnt =0;
+ uint32_t allocQueueEmptyCnt =0;
#endif
\f
/* local defines */
#endif
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
-PUBLIC U32 memFreeCount=0;
-PUBLIC U32 cmFreeCaller[4]={0};
-PUBLIC U32 cmAllocCaller[4]={0};
-PUBLIC Data *startPtr256=NULLP;
-PUBLIC Data *startPtr128=NULLP;
-PUBLIC U32 cmMemInfo128[100000][2]={0, 0};
-PUBLIC U32 cmMemInfo256[100000][2]={0, 0};
-PUBLIC Data *startPtr512=NULLP;
-PUBLIC Data *startPtr768=NULLP;
-PUBLIC Data *startPtr1664=NULLP;
-PUBLIC Data *startPtr4800=NULLP;
-PUBLIC Data *startPtr9920=NULLP;
-PUBLIC Size regMemSize=0;
+uint32_t memFreeCount=0;
+uint32_t cmFreeCaller[4]={0};
+uint32_t cmAllocCaller[4]={0};
+Data *startPtr256=NULLP;
+Data *startPtr128=NULLP;
+uint32_t cmMemInfo128[100000][2]={0, 0};
+uint32_t cmMemInfo256[100000][2]={0, 0};
+Data *startPtr512=NULLP;
+Data *startPtr768=NULLP;
+Data *startPtr1664=NULLP;
+Data *startPtr4800=NULLP;
+Data *startPtr9920=NULLP;
+Size regMemSize=0;
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
//extern CmMmRegCb *mtCMMRegCb[SS_MAX_REGS];
#endif
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,
- U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg));
-PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg));
+static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,
+ uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
+static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
/*cm_mem_c_001.main_20-added new functionto allocate memory from new region*/
#else
-PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size,
- U32 line, U8 *fileName, U8 entId, Bool hstReg));
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,
- U32 line, U8 *fileName, U8 entId, Bool hstReg));
+static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size,
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
+static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 line,
- U8 *fileName, U8 entId, Bool hstReg));
+static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, uint32_t line,
+ uint8_t *fileName, uint8_t entId, Bool hstReg));
-PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size,
- U32 line, U8 *fileName, U8 entId, Bool hstReg));
+static S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size,
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#else /* no histogram support */
/* cm_mem_c_001.main_12 - prototype is changed to accept memType(static/dynamic) */
#ifdef SSI_DEBUG_LEVEL1
-PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, U32 memType));
+static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, uint32_t memType));
#else
#ifndef USE_PURE
-PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size));
+static S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size));
#endif/*USE_PURE*/
#endif /* SSI_DEBUG_LEVEL1 */
#ifndef USE_PURE
-PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size));
+static S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size));
#endif/*USE_PURE*/
/* cm_mem_c_001.main_15 :Additions */
#ifdef SS_LIGHT_MEM_LEAK_STS
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType, U32 lineNo,U8 *funcName ));
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 lineNo, U8* funcName));
+static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType, uint32_t lineNo,uint8_t *funcName ));
+static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, uint32_t lineNo, uint8_t* funcName));
#else /*SS_LIGHT_MEM_LEAK_STS */
#if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType));
+static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType));
#else
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char* file, U32 line));
+static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char* file, uint32_t line));
#else
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+static S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
#endif
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, char* file, U32 line));
+static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, char* file, uint32_t line));
#else
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size));
+static S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size));
#endif
#endif /* SS_HISTOGRAM_SUPPORT */
#endif /*SS_LIGHT_MEM_LEAK_STS*/
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
#ifdef SS_FAP
-PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
-PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size));
+static S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
+static S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size));
#endif
-PRIVATE S16 cmCtl ARGS((Void *regionCb, Event event, SMemCtl *memCtl));
+static S16 cmCtl ARGS((Void *regionCb, Event event, SMemCtl *memCtl));
-PRIVATE Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size));
-PRIVATE Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb,
- CmMmRegCfg *cfg, U16 bktIdx, U16 *lstMapIdx));
+static Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size));
+static Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb,
+ CmMmRegCfg *cfg, uint16_t bktIdx, uint16_t *lstMapIdx));
/* cm_mem_c_001.main_12 - addition of protoypes for sanity check and hash list functions */
#ifdef SSI_DEBUG_LEVEL1
-PRIVATE S16 cmMmBktSanityChk ARGS((CmMmBkt *bkt));
-PRIVATE S16 cmMmHeapSanityChk ARGS((CmMmHeapCb *heapCb));
-PRIVATE S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, U32 key, U16 *idx ));
-PRIVATE S16 cmMmHashListInit ARGS((CmMmHashListCp *hashListCp, U16 nmbBins,
+static S16 cmMmBktSanityChk ARGS((CmMmBkt *bkt));
+static S16 cmMmHeapSanityChk ARGS((CmMmHeapCb *heapCb));
+static S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, uint32_t key, uint16_t *idx ));
+static S16 cmMmHashListInit ARGS((CmMmHashListCp *hashListCp, uint16_t nmbBins,
Region region, Pool pool));
-PRIVATE S16 cmMmHashListDeinit ARGS((CmMmHashListCp *hashListCp, Region region, Pool pool));
-PRIVATE S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, U32 key));
+static S16 cmMmHashListDeinit ARGS((CmMmHashListCp *hashListCp, Region region, Pool pool));
+static S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, uint32_t key));
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_c_001.main_15 : Addtions */
#ifdef SS_HISTOGRAM_SUPPORT
-PRIVATE S16 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, U32 blkSz, U32 *reqSz, U32 line, U8 *fileName, U8 entId));
-PRIVATE S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, U32 blkSz, U32 line, U8 *fileName, U8 entId));
-PRIVATE S16 cmHstGrmHashListInit ARGS((CmHstGrmHashListCp *hashListCp));
-PRIVATE S16 cmHstGrmHashListDeInit ARGS((CmHstGrmHashListCp *hashListCp));
-PRIVATE S16 cmHstGrmGetHashIdxAndKey ARGS((U8 *fileName, U32 line, U32 *binIdx, U32 *key));
-PRIVATE S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, U32 key, U32 *binIdx, CmMemEntries **entry));
-PRIVATE S16 cmHstGrmFillEntry ARGS((CmMemEntries *entry, U32 key, U32 line, U8 *fileName, U8 entId));
+static S16 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, uint32_t blkSz, uint32_t *reqSz, uint32_t line, uint8_t *fileName, uint8_t entId));
+static S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, uint32_t blkSz, uint32_t line, uint8_t *fileName, uint8_t entId));
+static S16 cmHstGrmHashListInit ARGS((CmHstGrmHashListCp *hashListCp));
+static S16 cmHstGrmHashListDeInit ARGS((CmHstGrmHashListCp *hashListCp));
+static S16 cmHstGrmGetHashIdxAndKey ARGS((uint8_t *fileName, uint32_t line, uint32_t *binIdx, uint32_t *key));
+static S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, uint32_t key, uint32_t *binIdx, CmMemEntries **entry));
+static S16 cmHstGrmFillEntry ARGS((CmMemEntries *entry, uint32_t key, uint32_t line, uint8_t *fileName, uint8_t entId));
#endif /* SS_HISTOGRAM_SUPPORT */
/* cm_mem_c_001.main_22: Fixing warnings on GCC compiler */
#ifdef T2K_MEM_LEAK_DBG
typedef struct {
-U8 minBktSzBitMask; /* minimum allocation size in Log(x)base 2, where X is minimum bucket size in region */
-U16 minBktSzMins1; /* X-1 */
+uint8_t minBktSzBitMask; /* minimum allocation size in Log(x)base 2, where X is minimum bucket size in region */
+uint16_t minBktSzMins1; /* X-1 */
}RegMinBktSzInfo;
static RegMinBktSzInfo regMinBktSzInfo[SS_MAX_REGS] = {{8,0xFF},{7,0x7F},{7,0x7F},{7,0x7F}};
RegionMemLeakInfo regMemLeakInfo;
-U32 getT2kMemLeakIndex(U64 address, Region region)
+uint32_t getT2kMemLeakIndex(uint64_t address, Region region)
{
return ((address - regMemLeakInfo.regStartAddr[region]) >> regMinBktSzInfo[region].minBktSzBitMask);
}
-static U32 t2kMemAllocTick;
-static U32 smallTick;
+static uint32_t t2kMemAllocTick;
+static uint32_t smallTick;
-void InsertToT2kMemLeakInfo(U64 address, U32 size, U32 lineNo, char* fileName, Region region)
+void InsertToT2kMemLeakInfo(uint64_t address, uint32_t size, uint32_t lineNo, char* fileName, Region region)
{
T2kMeamLeakInfo *leakInfo;
/* if(!startMemLeak)
{
- RETVOID;
+ return;
}*/
- U32 index1 = getT2kMemLeakIndex(address,region);
+ uint32_t index1 = getT2kMemLeakIndex(address,region);
- if(((U64)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0)
+ if(((uint64_t)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0)
{
- printf("address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo);
+ DU_LOG("\nINFO --> address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo);
}
leakInfo = (((T2kMeamLeakInfo*)(regMemLeakInfo.gMemLeakInfo[region])) + index1);
leakInfo->prevRemLineNo = 0;
leakInfo->prevRemFileName = '\0';
- //printf("InsertToT2kMemLeakInfo the adress from List Address = %x, index1 = %d from File=%s, line=%d \n",address,index1,fileName,lineNo);
+ //DU_LOG("\nINFO --> InsertToT2kMemLeakInfo the adress from List Address = %x, index1 = %d \
+ from File=%s, line=%d \n",address,index1,fileName,lineNo);
if(smallTick++ == 4096)
{
smallTick = 0;
}
else
{
- printf("Something is wrong, trying to insert %ld index1 = %d file is %s line is %d \n",address, index1, fileName, lineNo);
- printf("Address present :%ld, from File:%s, Line:%d, Size:%d, Age:%d",
+ DU_LOG("\nERROR --> Something is wrong, trying to insert %ld index1 = %d file is %s line is %d \n",address, index1, fileName, lineNo);
+ DU_LOG("\nINFO --> Address present :%ld, from File:%s, Line:%d, Size:%d, Age:%d",
leakInfo->address, leakInfo->fileName,
leakInfo->lineNo, leakInfo->size,
leakInfo->age);
}
-void RemoveFromT2kMemLeakInfo(U64 address, char *file, U32 line,Region region)
+void RemoveFromT2kMemLeakInfo(uint64_t address, char *file, uint32_t line,Region region)
{
T2kMeamLeakInfo *leakInfo;
return ROK;
}*/
- U32 index1 = getT2kMemLeakIndex(address, region);
+ uint32_t index1 = getT2kMemLeakIndex(address, region);
if(index1 >= T2K_MEM_LEAK_INFO_TABLE_SIZE)
{
- printf("index1 out of range = %d address is %ld file = %s line = %d. We are going to crash!!!\n",
+ DU_LOG("\nERROR --> index1 out of range = %d address is %ld file = %s line = %d. We are going to crash!!!\n",
index1,
address,
file,
}
else
{
- printf("Something is wrong, trying to remove %ld index1 = %d from File=%s, line=%d address present is %ld region%d \n",address, index1, file,line,leakInfo->address,region);
+ DU_LOG("\nERROR --> Something is wrong, trying to remove %ld index1 = %d from File=%s, line=%d address present is %ld region%d \n",address, index1, file,line,leakInfo->address,region);
- printf("\n Last Del file %s line %d\n",leakInfo->lastDelFileName,
+ DU_LOG("\nINFO --> Last Del file %s line %d\n",leakInfo->lastDelFileName,
leakInfo->lastDelLineNum);
if(leakInfo->prevRemFileName != NULLP)
{
- printf("Previous File:%s, Previous Line:%d\n",
+ DU_LOG("\nINFO --> Previous File:%s, Previous Line:%d\n",
leakInfo->prevRemFileName, leakInfo->prevRemLineNo);
}
}
if(fp == NULL)
{
- printf("Could not open file for dumping mem leak info\n");
+ DU_LOG("\nERROR --> Could not open file for dumping mem leak info\n");
return;
}
for(reg=0; reg <regMemLeakInfo.numActvRegions; reg++)
/* 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 */
#if (defined(SSI_DEBUG_LEVEL1) || defined(SS_HISTOGRAM_SUPPORT) || \
defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
#ifdef DEBUGP
-PRIVATE Txt dbgPrntBuf[200]; /* print buffer */
+static Txt dbgPrntBuf[200]; /* print buffer */
#endif /* DEBUGP */
#endif /*SSI_DEBUG_LEVEL1 || SS_HISTOGRAM_SUPPORT */
-U32 num_times = 0;
+uint32_t num_times = 0;
#ifdef SSI_MEM_CORR_PREVENTION
-U32 cmDblFreeAttempts = 0;
+uint32_t cmDblFreeAttempts = 0;
#endif
/* private variable declarations */
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC S16 cmMmRegInit
-(
-Region region,
-CmMmRegCb *regCb,
-CmMmRegCfg *cfg
-)
-#else
-PUBLIC S16 cmMmRegInit(region, regCb, cfg)
-Region region;
-CmMmRegCb *regCb;
-CmMmRegCfg *cfg;
-#endif
+S16 cmMmRegInit(Region region,CmMmRegCb *regCb,CmMmRegCfg *cfg)
{
Data *memAddr;
- U16 bktIdx;
- U16 lstMapIdx;
+ uint16_t bktIdx;
+ uint16_t lstMapIdx;
#if (ERRCLASS & ERRCLS_INT_PAR)
Size lstQnSize;
Txt errMsg[256] = {'\0'};
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- U16 offset;
+ uint16_t offset;
CmMmBlkHdr ptrHdr;
#endif
- TRC2(cmMmRegInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* Initialize the hast list to maintain the SSI memory information for Broadcom */
- offset = (U16)((PTR)(&ptrHdr.ent) - (PTR) &ptrHdr);
- printf("###########offset is %d region %d\n", offset, region);
+ offset = (uint16_t)((PTR)(&ptrHdr.ent) - (PTR) &ptrHdr);
+ DU_LOG("\nINFO --> offset is %d region %d\n", offset, region);
if(cmHashListInit(®Cb->brdcmSsiLstCp, 1000, offset, FALSE,
- CM_HASH_KEYTYPE_U32MOD, region, 0) != ROK)
+ CM_HASH_KEYTYPE_UINT32_MOD, region, 0) != ROK)
{
return RFAILED;
}
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC S16 cmMmRegDeInit
-(
-CmMmRegCb *regCb
-)
-#else
-PUBLIC S16 cmMmRegDeInit(regCb)
-CmMmRegCb *regCb;
-#endif
+S16 cmMmRegDeInit(CmMmRegCb *regCb)
{
- U16 bktIdx;
+ uint16_t bktIdx;
- TRC2(cmMmRegDeInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-#ifdef ANSI
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
-Void *regionCb,
-Size *size,
-U32 flags,
-Data **ptr,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
-Bool hstReg
+Void *regionCb,
+Size *size,
+uint32_t flags,
+Data **ptr,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
+Bool hstReg
)
#else
-PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType, line, fileName, entId, hstReg)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
-#else
-#ifdef ANSI
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
-Void *regionCb,
-Size *size,
-U32 flags,
-Data **ptr,
-U32 line,
-U8 *fileName,
-U8 entId,
-Bool hstReg
+Void *regionCb,
+Size *size,
+uint32_t flags,
+Data **ptr,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
+Bool hstReg
)
-#else
-PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, line, fileName, entId, hstReg)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
#endif /* SSI_DEBUG_LEVEL1 */
#else
#ifdef SS_LIGHT_MEM_LEAK_STS
-#ifdef ANSI
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
-Void *regionCb,
-Size *size,
-U32 flags,
-Data **ptr,
-U32 memType,
-U32 lineNo,
-U8 *funcName
+Void *regionCb,
+Size *size,
+uint32_t flags,
+Data **ptr,
+uint32_t memType,
+uint32_t lineNo,
+uint8_t *funcName
)
-#else
-PRIVATE S16 cmAlloc(regionCb, size, flags, ptr ,memType, lineNo, funcName)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-U32 lineNo;
-U8 *funcName;
-#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
-#ifdef ANSI
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
-Void *regionCb,
-Size *size,
-U32 flags,
-Data **ptr,
-U32 memType
+Void *regionCb,
+Size *size,
+uint32_t flags,
+Data **ptr,
+uint32_t memType
)
#else
-PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-#endif
-#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
-#ifdef ANSI
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
-Void *regionCb,
-Size *size,
-U32 flags,
-Data **ptr,
-U32 memType
+Void *regionCb,
+Size *size,
+uint32_t flags,
+Data **ptr,
+uint32_t memType
)
#else
-PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-#endif
-#else
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
- Void *regionCb,
- Size *size,
- U32 flags,
- Data **ptr ,
- char* file,
- U32 line
+ Void *regionCb,
+ Size *size,
+ uint32_t flags,
+ Data **ptr,
+ char* file,
+ uint32_t line
)
#else
-#ifdef ANSI
-PRIVATE S16 cmAlloc
+static S16 cmAlloc
(
-Void *regionCb,
-Size *size,
-U32 flags,
-Data **ptr
+Void *regionCb,
+Size *size,
+uint32_t flags,
+Data **ptr
)
-#else
-PRIVATE S16 cmAlloc(regionCb, size, flags, ptr)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-#endif
#endif
#endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
#endif /* SSI_DEBUG_LEVEL1 */
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 cnt;
+ uint16_t cnt;
#endif
/* cm_mem_c_001.main_15 : Additions */
#if (defined(SS_MEM_LEAK_STS) || defined( BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
- U16 memIndex=0;
+ uint16_t memIndex=0;
Data *nextptr1;
Data *prevptr1;
Data **nextptr;
prevptr=&prevptr1;
#endif
- TRC2(cmAlloc);
#ifndef USE_MEMCAL
UNUSED(flags);
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0xAB */
- cmMemset((U8 *)*ptr, 0xAB, *size);
+ memset(*ptr, 0xAB, *size);
#endif
-// printf("Pointer allocated %8p size %d\n", *ptr, *size);
+// DU_LOG("\nINFO --> Pointer allocated %8p size %d\n", *ptr, *size);
/* Store this pointer in hash list */
if ((bkt->nextBlk) && *ptr)
#elif SS_LIGHT_MEM_LEAK_STS
memIndex = (*ptr - startPtr256) / 256;
}
#if 1
- if (*((U32 *)(*ptr + 4)) != 0xDEADDEAD && *((U32 *)(*ptr + 80)) != 0xDEADDEAD && *((U32 *)(*ptr + 24)) != 0xDEADDEAD)
+ if (*((uint32_t *)(*ptr + 4)) != 0xDEADDEAD && *((uint32_t *)(*ptr + 80)) != 0xDEADDEAD && *((uint32_t *)(*ptr + 24)) != 0xDEADDEAD)
{
}
if(bkt->size == 256)
#endif
#endif /* MS_MBUF_CORRUPTION */
#ifdef SSI_MEM_CORR_PREVENTION
- *(((U32 *)(*ptr)) + 2) = 0;
+ *(((uint32_t *)(*ptr)) + 2) = 0;
#endif
#ifdef T2K_MEM_LEAK_DBG
{
/* Lock before the transaction-start */
pthread_mutex_lock(&(regMemLeakInfo.memLock[regCb->region]));
- InsertToT2kMemLeakInfo( (U64)*ptr,*size,line,file,regCb->region);
+ InsertToT2kMemLeakInfo( (uint64_t)*ptr,*size,line,file,regCb->region);
/* UnLock after the transaction */
pthread_mutex_unlock(&(regMemLeakInfo.memLock[regCb->region]));
}
bkt->next = *((CmMmEntry **)(bkt->next));
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
*nextptr = bkt->next;
- if (*((U32 *)(*nextptr + 4)) != 0xDEADDEAD && *((U32 *)(*nextptr + 80)) != 0xDEADDEAD && *((U32 *)(*nextptr + 24)) != 0xDEADDEAD)
+ if (*((uint32_t *)(*nextptr + 4)) != 0xDEADDEAD && *((uint32_t *)(*nextptr + 80)) != 0xDEADDEAD && *((uint32_t *)(*nextptr + 24)) != 0xDEADDEAD)
{
if(bkt->size == 128)
*prevptr = startPtr128 + ((memIndex-1)*128);
cmMemInfo256[memIndex][0] = cmAllocCaller[MxGetCpuID()];
}
cmAllocCaller[MxGetCpuID()] = NULLP;
- *((U32 *)(*ptr + 4)) = 0x00000000;
- *((U32 *)(*ptr + 124)) = 0;
- *((U32 *)(*ptr + 24)) = 0x00000000;
- *((U32 *)(*ptr + 44)) = 0x00000000;
- *((U32 *)(*ptr + 80)) = 0x00000000;
- *((U32 *)(*ptr + 116)) = 0x00000000;
+ *((uint32_t *)(*ptr + 4)) = 0x00000000;
+ *((uint32_t *)(*ptr + 124)) = 0;
+ *((uint32_t *)(*ptr + 24)) = 0x00000000;
+ *((uint32_t *)(*ptr + 44)) = 0x00000000;
+ *((uint32_t *)(*ptr + 80)) = 0x00000000;
+ *((uint32_t *)(*ptr + 116)) = 0x00000000;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
if (g_overused[bktIdx] == 0 && OVERUSED(bkt))
{
g_overused[bktIdx] = 1;
- /*printf("cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */
+ /*DU_LOG("\nINFO --> cmAlloc: bktIdx %u overused %u numAlloc %u\n", bktIdx, g_overused[bktIdx], bkt->numAlloc); */
}
}
#endif
/*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
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_LIGHT_MEM_LEAK_STS
-#ifdef ANSI
-PRIVATE S16 cmFree
+static S16 cmFree
(
-Void *regionCb,
-Data *ptr,
-Size size,
-U32 lineNo,
-U8 *funcName
+Void *regionCb,
+Data *ptr,
+Size size,
+uint32_t lineNo,
+uint8_t *funcName
)
-#else
-PRIVATE S16 cmFree(regionCb, ptr, size, lineNo, funcName)
-Void *regionCb;
-Data *ptr;
-Size size;
-U32 lineNo;
-U8 *funcName;
-#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SS_HISTOGRAM_SUPPORT
-#ifdef ANSI
-PRIVATE S16 cmFree
+static S16 cmFree
(
-Void *regionCb,
-Data *ptr,
-Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
-Bool hstReg
+Void *regionCb,
+Data *ptr,
+Size size,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
+Bool hstReg
)
-#else
-PRIVATE S16 cmFree(regionCb, ptr, size, line, fileName, entId, hstReg)
-Void *regionCb;
-Data *ptr;
-Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
#else
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmFree
+static S16 cmFree
(
- Void *regionCb,
- Data *ptr,
- Size size,
- char* file,
- U32 line
+Void *regionCb,
+Data *ptr,
+Size size,
+char* file,
+uint32_t line
)
#else /* T2K_MEM_LEAK_DBG */
-#ifdef ANSI
-PRIVATE S16 cmFree
+static S16 cmFree
(
Void *regionCb,
Data *ptr,
Size size
)
-#else
-PRIVATE S16 cmFree(regionCb, ptr, size)
-Void *regionCb;
-Data *ptr;
-Size size;
-#endif
#endif
/* cm_mem_c_001.main_15 : Additions */
#endif /* SS_HISTOGRAM_SUPPORT */
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption*/
- U16 memIndex=0;
+ uint16_t memIndex=0;
#endif
- TRC2(cmFree);
regCb = (CmMmRegCb *)regionCb;
#ifdef T2K_MEM_LEAK_DBG
{
pthread_mutex_lock(&(regMemLeakInfo.memLock[regCb->region]));
- RemoveFromT2kMemLeakInfo((U64)ptr , file,line,regCb->region);
+ RemoveFromT2kMemLeakInfo((uint64_t)ptr , file,line,regCb->region);
pthread_mutex_unlock(&(regMemLeakInfo.memLock[regCb->region]));
}
#endif
size(%d) %8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
#endif
- printf("Passed size (%d) does not match with allocated \
+ DU_LOG("\nERROR --> Passed size (%d) does not match with allocated \
size(%d) %8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
abort();
}
/* Validate the tail part to see if there is any over run */
-// printf("Pointer free request %8p, size %d\n", ptr, size);
+// DU_LOG("\nINFO --> Pointer free request %8p, size %d\n", ptr, size);
#endif
/* validate the block to be freed for trampling */
return (RTRAMPLINGNOK);
}
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- printf("Memory signature is invalid\n");
+ DU_LOG("\nERROR --> Memory signature is invalid\n");
abort();
#endif
}
ptrHdr->requestedSize = 0;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0xAB */
- cmMemset((U8 *)ptr, 0xAB, size);
+ memset(ptr, 0xAB, size);
#endif
/* check if the block to be freed is already having the state as FREE */
if (CMM_IS_FREE(ptrHdr->memFlags))
(Void) SUnlock(&(bkt->bktLock));
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- printf("Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
+ DU_LOG("\nERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
size %u bytes \n", ptr, regCb->mapTbl[idx].bktIdx, bkt->size);
abort();
#endif
#ifndef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
#ifdef SSI_MEM_CORR_PREVENTION
- if (*(((U32 *)(ptr)) + 2) == 0xdeaddead)
+ if (*(((uint32_t *)(ptr)) + 2) == 0xdeaddead)
{
/* Do not free an already freed block to avoid corruption */
cmDblFreeAttempts++;
*((CmMmEntry **)bkt->last) = ptr;
bkt->last = (CmMmEntry *)ptr;
*((CmMmEntry **)ptr) = NULLP;
- *(((U32 *)(ptr)) + 2) = 0xdeaddead;
+ *(((uint32_t *)(ptr)) + 2) = 0xdeaddead;
}
#else
*((CmMmEntry **)ptr) = bkt->next;
*crashPtr = 9;
}
}
- if (*((U32 *)(ptr + 4)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 4)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 4) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 4) = 0xDEADDEAD;
}
else
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
- if (*((U32 *)(ptr + 24)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 24)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 24) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 24) = 0xDEADDEAD;
}
else
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
- if (*((U32 *)(ptr + 44)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 44)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 44) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 44) = 0xDEADDEAD;
}
else
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
- if (*((U32 *)(ptr + 80)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 80)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 80) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 80) = 0xDEADDEAD;
}
else
{
*crashPtr = 9;
/* Cause a crash to identify the caller */
}
- *(U32 *)(ptr + 124) = memFreeCount++;
- (*(U32 *)(ptr + 116)) = cmFreeCaller[MxGetCpuID()];
+ *(uint32_t *)(ptr + 124) = memFreeCount++;
+ (*(uint32_t *)(ptr + 116)) = cmFreeCaller[MxGetCpuID()];
if(bkt->size == 128)
{
memIndex = (ptr - startPtr128) / 128;
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);
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType,
- line, fileName, entId, hstReg)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
-#else
-#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
-#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, line,
- fileName, entId, hstReg)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
#endif /* SSI_DEBUG_LEVEL1 */
#else
#ifdef SS_LIGHT_MEM_LEAK_STS
-#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 lineNo,
-U8 *funcName
+uint32_t memType,
+uint32_t lineNo,
+uint8_t *funcName
)
-#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-U32 lineNo;
-U8 *funcName;
-#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
-#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-#endif
-#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
-#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-U32 memType;
-#endif
-#else
-#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
-#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-#endif
#endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_c_001.main_15: Additions */
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 cnt;
+ uint16_t cnt;
#endif
/* cm_mem_c_001.main_15 : Additions */
#if (defined(SS_MEM_LEAK_STS) || defined( BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmAllocNL);
#ifndef USE_MEMCAL
UNUSED(flags);
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0xAB */
- cmMemset((U8 *)*ptr, 0xAB, *size);
+ memset(*ptr, 0xAB, *size);
#endif
if ((bkt->nextBlk) && *ptr)
#elif SS_LIGHT_MEM_LEAK_STS
bkt->nextBlk = (CmMmBlkHdr *)(bkt->nextBlk->nextBlk);
#else
#ifdef SSI_MEM_CORR_PREVENTION
- *(((U32 *)(*ptr)) + 2) = 0;
+ *(((uint32_t *)(*ptr)) + 2) = 0;
#endif
bkt->next = *((CmMmEntry **)(bkt->next));
#endif /* SSI_DEBUG_LEVEL1 */
/*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
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_LIGHT_MEM_LEAK_STS
-#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Size size,
-U32 lineNo,
-U8 *funcName
+uint32_t lineNo,
+uint8_t *funcName
)
-#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
-Void *regionCb;
-Data *ptr;
-Size size;
-U32 lineNo;
-U8 *funcName;
-#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SS_HISTOGRAM_SUPPORT
-#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size, line, fileName, entId, hstReg)
-Void *regionCb;
-Data *ptr;
-Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
-#else
-
-#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Size size
)
-#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size)
-Void *regionCb;
-Data *ptr;
-Size size;
-#endif
/* cm_mem_c_001.main_15 : Additions */
#endif /* SS_HISTOGRAM_SUPPORT */
#endif /*SS_LIGHT_MEM_LEAK_STS */
{
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmFreeNL);
regCb = (CmMmRegCb *)regionCb;
sprintf(dbgPrntBuf, "Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
#endif
- printf("Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n",
+ DU_LOG("\nERROR --> Passed size (%d) does not match with allocated size(%d):%8p, Bucket Id:%03d\n",
size, ptrHdr->requestedSize, ptr, regCb->mapTbl[idx].bktIdx);
abort();
}
}
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- printf("Memory signature is invalid\n");
+ DU_LOG("\nERROR --> Memory signature is invalid\n");
abort();
#endif
}
ptrHdr->requestedSize = 0;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Initialize the elements with 0XAB */
- cmMemset((U8 *)ptr, 0xAB, size);
+ memset(ptr, 0xAB, size);
#endif
/* check if the block to be freed is already having the state as FREE */
if (CMM_IS_FREE(ptrHdr->memFlags))
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- printf("Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
+ DU_LOG("\nERROR --> Attempt to double deallocate memory at: %8p, Bucket Id:%03d,\
size %u bytes \n", ptr, regCb->mapTbl[idx].bktIdx, bkt->size);
abort();
#endif
#else
#ifdef SSI_MEM_CORR_PREVENTION
- if (*(((U32 *)(ptr)) + 2) == 0xdeaddead)
+ if (*(((uint32_t *)(ptr)) + 2) == 0xdeaddead)
{
/* Do not free an already freed block to avoid corruption */
cmDblFreeAttempts++;
*((CmMmEntry **)bkt->last) = ptr;
bkt->last = (CmMmEntry *)ptr;
*((CmMmEntry **)ptr) = NULLP;
- *(((U32 *)(ptr)) + 2) = 0xdeaddead;
+ *(((uint32_t *)(ptr)) + 2) = 0xdeaddead;
}
#else
*((CmMmEntry **)ptr) = bkt->next;
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
- TRC2(cmFreeNL);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
/*cm_mem_c_001.main_21-added new function*/
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
#ifdef SS_FAP
-#ifdef ANSI
-PRIVATE S16 cmAllocWL
+static S16 cmAllocWL
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
-#else
-PRIVATE S16 cmAllocWL(regionCb, size, flags, ptr)
-Void *regionCb;
-Size *size;
-U32 flags;
-Data **ptr;
-#endif
{
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmAllocWL);
/*cm_mem_c_001.main_23 Removed support of USE_MEMCAL and MEMCAL_DEBUG support for SS_FAP*/
/*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
*
*/
-#ifdef ANSI
-PRIVATE S16 cmFreeWL
-(
-Void *regionCb,
-Data *ptr,
-Size size
-)
-#else
-PRIVATE S16 cmFreeWL(regionCb, ptr, size)
-Void *regionCb;
-Data *ptr;
-Size size;
-#endif
+static S16 cmFreeWL(Void *regionCb,Data *ptr, Size size)
{
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmFreeWL);
regCb = (CmMmRegCb *)regionCb;
/* The memory block was allocated from the heap pool */
return (cmHeapFree (&(regCb->heapCb), ptr, size));
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
*
*/
-#ifdef ANSI
-PRIVATE S16 cmCtl
-(
-Void *regionCb,
-Event event,
-SMemCtl *memCtl
-)
-#else
-PRIVATE S16 cmCtl(regionCb, event, memCtl)
-Void *regionCb;
-Event event;
-SMemCtl *memCtl;
-#endif
+static S16 cmCtl(Void *regionCb,Event event, SMemCtl *memCtl)
{
CmMmRegCb *regCb;
- TRC2(cmCtl);
regCb = (CmMmRegCb *)regionCb;
/* 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.
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE Void cmMmBktInit
+static Void cmMmBktInit
(
-Data **memAddr,
+Data **memAddr,
CmMmRegCb *regCb,
CmMmRegCfg *cfg,
-U16 bktIdx,
-U16 *lstMapIdx
+uint16_t bktIdx,
+uint16_t *lstMapIdx
)
-#else
-PRIVATE Void cmMmBktInit (memAddr, regCb, cfg, bktIdx, lstMapIdx)
-Data **memAddr;
-CmMmRegCb *regCb;
-CmMmRegCfg *cfg;
-U16 bktIdx;
-U16 *lstMapIdx;
-#endif
{
- U32 cnt;
- U16 idx;
- U32 numBlks;
+ uint32_t cnt;
+ uint16_t idx;
+ uint32_t numBlks;
Size size;
/* cm_mem_c_001.main_12 - addition for temporary variables */
#if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1) || defined (SS_LIGHT_MEM_LEAK_STS))
#ifdef SS_LIGHT_MEM_LEAK_STS
CmMmBlkHdr *lastBlk;
#endif /*SS_LIGHT_MEM_LEAK_STS */
- U32 sigCnt;
+ uint32_t sigCnt;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
Data *tmpMemAddr;
CmMmBlkTail *blkTail;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmBktInit);
size = cfg->bktCfg[bktIdx].size;
*nextBlk = NULLP;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- tmpMemAddr = (Data *)((*memAddr) - ((sizeof(CmMmBlkHdr)) + sizeof(U32) + size));
+ tmpMemAddr = (Data *)((*memAddr) - ((sizeof(CmMmBlkHdr)) + sizeof(uint32_t) + size));
regCb->bktTbl[bktIdx].lastBlk = (CmMmBlkHdr *)tmpMemAddr;
#endif
{
*next = *memAddr;
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
- (*(U32 *)(*next + 4)) = 0xdeaddead;
- (*(U32 *)(*next + 124)) = 0;
- (*(U32 *)(*next + 116)) = 0xdeaddead;
- (*(U32 *)(*next + 24)) = 0xdeaddead;
- (*(U32 *)(*next + 44)) = 0xdeaddead;
- (*(U32 *)(*next + 80)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 4)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 124)) = 0;
+ (*(uint32_t *)(*next + 116)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 24)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 44)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 80)) = 0xdeaddead;
#endif
#ifdef SSI_MEM_CORR_PREVENTION
- *(((U32 *)(*next)) + 2) = 0xdeaddead;
+ *(((uint32_t *)(*next)) + 2) = 0xdeaddead;
#endif
next = (CmMmEntry **)(*memAddr);
*memAddr = (*memAddr) + size;
regCb->bktSize += ((size + sizeof(CmMmBlkHdr)) * numBlks);
/* Addition for considering the header size and tail */
#elif BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- regCb->bktSize += ((size + sizeof(CmMmBlkHdr) + sizeof(U32)) * numBlks);
+ regCb->bktSize += ((size + sizeof(CmMmBlkHdr) + sizeof(uint32_t)) * numBlks);
#else
regCb->bktSize += (size * numBlks);
#endif /* SSI_DEBUG_LEVEL1 */
cmHstGrmHashListInit(&(regCb->bktTbl[bktIdx].hstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmBktInit */
\f
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE Void cmMmHeapInit
-(
-Data *memAddr,
-CmMmHeapCb *heapCb,
-Size size
-)
-#else
-PRIVATE Void cmMmHeapInit (memAddr, heapCb, size)
-Data *memAddr;
-CmMmHeapCb *heapCb;
-Size size;
-#endif
+static Void cmMmHeapInit(Data *memAddr,CmMmHeapCb *heapCb,Size size)
{
/* cm_mem_c_001.main_12 - addition for ssi enhancements */
#ifdef SSI_DEBUG_LEVEL1
- U16 idx;
+ uint16_t idx;
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmHeapInit);
/* Initialize the heap control block */
heapCb->vStart = memAddr;
/* Initialise the memory histogram hash list */
cmHstGrmHashListInit(&(heapCb->heapHstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmHeapInit */
/* cm_mem_c_001.main_12 - addition for taking another parameter memType(static/dynamic) */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_4GMX_LCORE
-EXTERN U8 ysCellConfigDone;
+uint8_t ysCellConfigDone;
#endif
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-#ifdef ANSI
-PRIVATE S16 cmHeapAlloc
+static S16 cmHeapAlloc
(
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
-PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, memType, line, fileName, entId, hstReg)
-CmMmHeapCb *heapCb;
-Data **ptr;
-Size *size;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
-#else
-#ifdef ANSI
-PRIVATE S16 cmHeapAlloc
+static S16 cmHeapAlloc
(
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
-#else
-PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, line, fileName, entId, hstReg)
-CmMmHeapCb *heapCb;
-Data **ptr;
-Size *size;
-U32 line;
-U8 *fileName;
-U8 entId;
-Bool hstReg;
-#endif
#endif /* SSI_DEBUG_LEVEL1 */
#else
#ifdef SSI_DEBUG_LEVEL1
-#ifdef ANSI
-PRIVATE S16 cmHeapAlloc
+static S16 cmHeapAlloc
(
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 memType
+uint32_t memType
)
#else
-PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, memType)
-CmMmHeapCb *heapCb;
-Data **ptr;
-Size *size;
-U32 memType;
-#endif
-#else
-#ifdef ANSI
-PRIVATE S16 cmHeapAlloc
+static S16 cmHeapAlloc
(
CmMmHeapCb *heapCb,
Data **ptr,
Size *size
)
-#else
-PRIVATE S16 cmHeapAlloc (heapCb, ptr, size)
-CmMmHeapCb *heapCb;
-Data **ptr;
-Size *size;
-#endif
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_c_001.main_15 : Additions */
#endif /* SS_HISTOGRAM_SUPPORT */
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 */
*/
/* 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));
} /* end of cmHeapFree */
#endif/*USE_PURE*/
#ifdef SS_LIGHT_MEM_LEAK_STS
-#ifdef ANSI
-PUBLIC U32 cmGetFreeIndx
-(
-Void
-)
-#else
-PUBLIC U32 cmGetFreeIndx(Void)
-#endif
+uint32_t cmGetFreeIndx(Void)
{
if(gmemLkCb.head == gmemLkCb.tail)
}
else
{
- U32 allocQIndx = gmemLkCb.queue[gmemLkCb.head];
+ uint32_t allocQIndx = gmemLkCb.queue[gmemLkCb.head];
gmemLkCb.head = (gmemLkCb.head +1) % CM_MAX_ALLOC_ENTERIES;
return (allocQIndx);
}
}
-#ifdef ANSI
-PUBLIC U32 cmPutFreeIndx
-(
-U32 allocQIndx
-)
-#else
-PUBLIC U32 cmPutFreeIndx(allocQIndx)
-U32 allocQIndx;
-#endif
-
+uint32_t cmPutFreeIndx(uint32_t allocQIndx)
{
- U32 tmpTail = (gmemLkCb.tail+1)% CM_MAX_ALLOC_ENTERIES;
+ uint32_t tmpTail = (gmemLkCb.tail+1)% CM_MAX_ALLOC_ENTERIES;
if(tmpTail == gmemLkCb.head)
{
allocQueueFullCnt++;
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC Void cmInitMemLeak
-(
-Void
-)
-#else
-PUBLIC Void cmInitMemLeak (Void)
-#endif
+Void cmInitMemLeak (Void)
{
- U32 indx;
+ uint32_t indx;
- TRC3(cmInitMemLeak);
gmemLkCb.isStarted = FALSE;
gmemLkCb.head = 0;
cmPutFreeIndx(indx);
}
- RETVOID;
+ return;
} /* cmInitMemLeak */
/*
*
* Desc: De-initializes the memory leak detection
*
*
- * Ret: RETVOID
+ * Ret: void
*
* Notes: This function de-initializes the memory leak detection module.
*
* File: cm_mem.c
*
**/
-#ifdef ANSI
-PUBLIC Void cmDeinitMemLeak
-(
-Void
-)
-#else
-PUBLIC Void cmDeinitMemLeak (Void)
-#endif
+Void cmDeinitMemLeak(Void)
{
- U32 indx;
+ uint32_t indx;
- TRC3(cmDeinitMemLeak);
for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++)
{
gmemLkCb.isStarted = FALSE;
gmemLkCb.head = 0;
gmemLkCb.tail = 0;
- 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.c
*
*/
-#ifdef ANSI
-PUBLIC U32 cmStorAllocBlk
-(
-Void *addr
-)
-#else
-PUBLIC U32 cmStorAllocBlk (addr)
-Void *addr;
-#endif /* ANSI */
-
+uint32_t cmStorAllocBlk(Void *addr)
{
- U32 allocQIndx;
+ uint32_t allocQIndx;
(Void) SLock(&gmemLkCb.memLock);
allocQIndx = cmGetFreeIndx();
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
-(
-U32 allocQIndx
-)
-#else
-PUBLIC Void cmRlsAllocBlk(allocQIndx)
-U32 allocQIndx;
-#endif
+Void cmRlsAllocBlk(uint32_t allocQIndx)
{
- TRC3(cmRlsAllocBlk);
if(allocQIndx < CM_MAX_ALLOC_ENTERIES)
{
(Void) SUnlock(&(gmemLkCb.memLock));
}
}
- RETVOID;
+ return;
} /* cmRlsAllocBlk */
/*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC Void cmStartStopLeakLog
-(
-Void
-)
-#else
-PUBLIC Void cmStartStopLeakLog(Void)
-#endif
+Void cmStartStopLeakLog(Void)
{
if (FALSE == gmemLkCb.isStarted)
{
- printf("!!leak capturing started\n");
+ DU_LOG("\nINFO --> leak capturing started\n");
gmemLkCb.isStarted = TRUE;
}
else
{
gmemLkCb.isStarted = FALSE;
- printf("!!leak capturing stopped\n");
+ DU_LOG("\nINFO --> leak capturing stopped\n");
cmPrintLeakLog();
}
- RETVOID;
+ return;
}
/*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC Void cmPrintLeakLog
-(
-Void
-)
-#else
-PUBLIC Void cmPrintLeakLog(Void)
-#endif
+Void cmPrintLeakLog(Void)
{
- U32 indx;
+ uint32_t indx;
CmMmBlkHdr *aBkt;
- static U32 leakCount =0;
+ static uint32_t leakCount =0;
- TRC3(cmPrintLeakLog);
- printf("---- START OF LEAK LOG ----");
+ DU_LOG("\nINFO --> START OF LEAK LOG ");
SLock(&gmemLkCb.memLock);
- printf("---- Lock Acquired ----");
+ DU_LOG("\nINFO --> Lock Acquired");
for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++)
{
if(gmemLkCb.allocInfo[indx].used == TRUE)
{
leakCount++;
aBkt =(CmMmBlkHdr *)gmemLkCb.allocInfo[indx].memAddr;
- printf("LeakCnt(%ld)Addr(0x%p)RqSz(%ld)",
+ DU_LOG("LeakCnt(%ld)Addr(0x%p)RqSz(%ld)",
leakCount,gmemLkCb.allocInfo[indx].memAddr, aBkt->requestedSize);
- printf("LineNo(%ld)funcName(%s)\n",
+ DU_LOG("LineNo(%ld)funcName(%s)\n",
aBkt->lineNo, aBkt->currFuncName);
gmemLkCb.allocInfo[indx].used = FALSE;
cmPutFreeIndx(indx);
//if(leakCount % 10 == 0)
// sleep(1);
}
- printf("---- END OF LEAK LOG ----");
+ DU_LOG("\nINFO --> END OF LEAK LOG ");
SUnlock(&gmemLkCb.memLock);
- printf("---- Lock Released ----");
+ DU_LOG("\nINFO --> Lock Released");
leakCount =0;
- RETVOID;
+ return;
}
#endif
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
*
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
-#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
CmMmBlkHdr *ptrHdr,
CmMmRegCb *regCb
)
#else
-PUBLIC Void cmRlsAllocBlk(ptrHdr, regCb)
-CmMmBlkHdr *ptrHdr;
-CmMmRegCb *regCb;
-#endif
-#else
-#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
#ifdef BIT_64
-U64 addr
+uint64_t addr
#else
-U32 addr
+uint32_t addr
#endif
)
-#else
-PUBLIC Void cmRlsAllocBlk(addr)
-#ifdef BIT_64
-U64 addr;
-#else
-U32 addr;
-#endif
-#endif
#endif
{
Ptr trace[CM_MAX_STACK_TRACE];
S8 **funcNm;
- U8 idx;
- U8 i;
+ uint8_t idx;
+ uint8_t i;
S16 retVal;
S32 traceSize;
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
MemAllocInfo *memAllocInfo;
#endif
- TRC3(cmRlsAllocBlk);
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef BIT_64
- retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(U8 *)&ptrHdr,
- (U16)sizeof(U64), 0, (PTR *)&ptrHdr);
+ retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(uint8_t *)&ptrHdr,
+ (uint16_t)sizeof(uint64_t), 0, (PTR *)&ptrHdr);
#else
- retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(U8 *)&ptrHdr,
- (U16)sizeof(U32), 0, (PTR *)&ptrHdr);
+ retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(uint8_t *)&ptrHdr,
+ (uint16_t)sizeof(uint32_t), 0, (PTR *)&ptrHdr);
#endif
if(retVal == ROK)
{
#else
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
for(idx = 0; idx < CM_MEM_USR_MDL; idx++)
{
SLock(&memLkCb.memUsrMdl[idx][addr & 0x3].memLck);
#ifdef BIT_64
retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp,
- (U8 *)&addr, sizeof(U64), 0,
+ (uint8_t *)&addr, sizeof(uint64_t), 0,
(PTR *)&memAllocInfo);
#else
retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp,
- (U8 *)&addr, sizeof(U32), 0,
+ (uint8_t *)&addr, sizeof(uint32_t), 0,
(PTR *)&memAllocInfo);
#endif
if(retVal == ROK)
#endif /* SS_MEM_LEAK_SOL */
#endif/* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
/*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.
*
*
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
-#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
CmMmBlkHdr *ptrHdr,
Size reqSz,
Size allocSz,
-U16 bktIdx,
+uint16_t bktIdx,
CmMmRegCb *regCb
)
#else
-PUBLIC Void cmStorAllocBlk (ptrHdr, reqSz, allocSz, bktIdx, regCb)
-CmMmBlkHdr *ptrHdr;
-Size reqSz;
-Size allocSz;
-U16 bktIdx;
-CmMmRegCb *regCb;
-#endif
-#else
-#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
#ifdef BIT_64
-U64 addr,
+uint64_t addr,
#else
-U32 addr,
+uint32_t addr,
#endif
Size reqSz,
Size allocSz,
-U16 bktIdx
+uint16_t bktIdx
)
-#else
-PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
-#ifdef BIT_64
-U64 addr;
-#else
-U32 addr;
-#endif
-Size reqSz;
-Size allocSz;
-U16 bktIdx;
-#endif /* ANSI */
#endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
{
#ifndef SS_MEM_LEAK_SOL
void *trace[CM_MAX_STACK_TRACE];
#endif /* SS_MEM_LEAK_SOL */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
- U8 btrIdx;
+ uint8_t btrIdx;
#else
MemAllocInfo *allocInfo;
- U8 moduleId;
+ uint8_t moduleId;
S8 **funcNm;
S32 traceSize;
#endif
- TRC3(cmStorAllocBlk);
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
#endif
#ifdef SS_MEM_LEAK_SOL
* implementation. */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
- funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(U32) * CM_MAX_STACK_TRACE));
- cmMemset((U8*)funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
+ memset(funcNm, 0, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#else
- funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ funcNm = (S8 **)calloc(1, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(U32) * CM_MAX_STACK_TRACE); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
traceSize = backtrace((Void **)funcNm, CM_MAX_STACK_TRACE);
#else /* SS_MEM_LEAK_SOL */
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef SS_4GMX_LCORE
allocInfo = (MemAllocInfo *)MxHeapAlloc(SsiHeap, sizeof(MemAllocInfo));
- cmMemset((U8*)allocInfo, 0, sizeof(MemAllocInfo));
+ memset(allocInfo, 0, sizeof(MemAllocInfo));
#else
allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo));
#endif
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */
+ /* SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,DFLT_REGION, DFLT_POOL, &allocInfo, sizeof(MemAllocInfo)); */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* check if hashListCp is initialised yet */
if ( regCb->brdcmSsiLstCp.nmbBins == 0)
ptrHdr->allocSz = allocSz;
ptrHdr->bktIdx = bktIdx;
cmHashListInsert(®Cb->brdcmSsiLstCp, (PTR)ptrHdr,
- (U8 *)&(ptrHdr), sizeof(PTR));
+ (uint8_t *)&(ptrHdr), sizeof(PTR));
#else
allocInfo->memAddr = addr;
allocInfo->reqSz = reqSz;
allocInfo->moduleId = moduleId;
allocInfo->bTrcSz = traceSize;
cmHashListInsert(&memLkCb.memUsrMdl[moduleId][addr & 0x3].memHashCp,
- (PTR)allocInfo, (U8 *)&(allocInfo->memAddr),
+ (PTR)allocInfo, (uint8_t *)&(allocInfo->memAddr),
sizeof(allocInfo->memAddr));
memLkCb.memUsrMdl[moduleId][addr & 0x3].used = TRUE;
(Void) SUnlock(&(memLkCb.memUsrMdl[moduleId][addr & 0x3].memLck));
#endif
- RETVOID;
+ return;
} /* cmStorAllocBlk */
/*
*
- RETVOID;
+ return;
} /* cmStorAllocBlk */
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC Void SLogLkInfo
-(
-Void
-)
-#else
-PUBLIC Void SLogLkInfo (Void)
-#endif
+Void SLogLkInfo (Void)
{
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
- U8 idx;
- U8 regionIdx;
+ uint8_t idx;
+ uint8_t regionIdx;
Txt prntBuf[255];
S8 **funcNm;
CmMmBlkHdr *newBlkHdr;
CmMmRegCb *tmpRegCb;
FILE *fp;
- TRC3(SLogLkInfo);
fp = fopen("meLeakLog.txt", "w");
if(fp == NULL)
{
#else
MemAllocInfo *oldMemInfo;
MemAllocInfo *newMemInfo;
- U8 memMdl;
- U8 hashIdx;
- U8 idx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
+ uint8_t idx;
Txt prntBuf[255];
S8 **funcNm;
- TRC3(SLogLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
sprintf(prntBuf, "\n------- START OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
sprintf(prntBuf, "\n------- END OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
#endif
- RETVOID;
+ return;
}
#endif
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC Void cmInitMemLeakMdl
-(
-Void
-)
-#else
-PUBLIC Void cmInitMemLeakMdl (Void)
-#endif
+Void cmInitMemLeakMdl (Void)
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
- TRC3(cmInitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
{
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.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.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.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.c
*
*/
-#ifdef ANSI
-PUBLIC U8 cmMemGetModuleId
-(
-S8 **funNm,
-S32 traceSize
-)
-#else
-PUBLIC U8 cmMemGetModuleId (funNm, traceSize)
-S8 **funNm;
-S32 traceSize;
-#endif /* ANSI */
+uint8_t cmMemGetModuleId(S8 **funNm,S32 traceSize)
{
- U8 idx;
- U8 memStrIdx;
- U32 len;
+ uint8_t idx;
+ uint8_t memStrIdx;
+ uint32_t len;
S32 retVal;
S16 memReqIdx;
S16 mdlFunStrIdx;
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;
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC S16 cmMemGetStrMtchIdx
+S16 cmMemGetStrMtchIdx
(
-U8 strtIdx,
-U8 endIdx,
+uint8_t strtIdx,
+uint8_t endIdx,
S8 *str,
S8 **strLst
)
-#else
-PUBLIC S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
-U8 strtIdx;
-U8 endIdx;
-S8 *str;
-S8 **strLst;
-#endif
{
S8 cmpStr[255];
- U32 len;
+ uint32_t len;
Bool found;
- U32 tempLen;
- U8 idx;
+ uint32_t tempLen;
+ uint8_t idx;
S32 retVal;
- TRC3(cmMemGetStrMtchIdx);
len = strlen((const S8 *)str);
cmpStr[0] = '(';
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC S32 cmAddrToSymStr
-(
-Void *pc,
-S8 *buffer,
-S32 size
-)
-#else
-PUBLIC S32 cmAddrToSymStr(pc, buffer, size)
-Void *pc;
-S8 *buffer;
-S32 size;
-#endif
+S32 cmAddrToSymStr(Void *pc, S8 *buffer, S32 size)
{
Dl_info info;
Sym *sym;
- TRC3(cmAddrToSymStr);
if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0)
{
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PUBLIC S32 cmLeakCallBack
-(
-uintptr_t pc,
-S32 sigNo,
-Void *arg
-)
-#else
-PUBLIC S32 cmLeakCallBack(pc, sigNo, arg)
-uintptr_t pc;
-S32 sigNo;
-Void *arg;
-#endif
+S32 cmLeakCallBack(uintptr_t pc,S32 sigNo, Void *arg)
{
S8 *buffer;
- TRC3(cmLeakCallBack);
Backtrace_t *bt = (Backtrace_t *)arg;
if (bt->bt_actcount >= bt->bt_maxcount)
/*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;
*
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
-#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
-(
-CmMmBlkHdr *blkPtr,
-Size size
-)
+S16 cmMmRegIsBlkSane(CmMmBlkHdr *blkPtr,Size size)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr, size)
-CmMmBlkHdr *blkPtr;
-Size size;
-#endif
-#else
-#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
-(
-CmMmBlkHdr *blkPtr
-)
-#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr)
-CmMmBlkHdr *blkPtr;
-#endif
+S16 cmMmRegIsBlkSane(CmMmBlkHdr *blkPtr)
#endif
{
- U32 sigCnt;
+ uint32_t sigCnt;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
CmMmBlkTail *tailPtr;
#endif
- TRC2(cmMmRegIsBlkSane);
for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++)
{
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmMmBktSanityChk
-(
-CmMmBkt *bkt
-)
-#else
-PRIVATE S16 cmMmBktSanityChk(bkt)
-CmMmBkt *bkt;
-#endif
+static S16 cmMmBktSanityChk(CmMmBkt *bkt)
{
CmMmBlkHdr *ptrBlk;
- U32 blkCnt;
-
- TRC2(cmMmBktSanityChk);
+ uint32_t blkCnt;
bkt->trampleCount = 0;
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmMmHeapSanityChk
-(
-CmMmHeapCb *heapCb
-)
-#else
-PRIVATE S16 cmMmHeapSanityChk(heapCb)
-CmMmHeapCb *heapCb;
-#endif
+static S16 cmMmHeapSanityChk(CmMmHeapCb *heapCb)
{
- TRC2(cmMmHeapSanityChk);
-
/* increment the trample count */
heapCb->trampleCount++;
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmMmHashFunc
-(
-CmMmHashListCp *hashListCp,
-U32 key,
-U16 *idx
-)
-#else
-PRIVATE S16 cmMmHashFunc (hashListCp, key, idx)
-CmMmHashListCp *hashListCp; /* hash list control point */
-U32 key; /* key string */
-U16 *idx; /* idx to return */
-#endif
+static S16 cmMmHashFunc(CmMmHashListCp *hashListCp,uint32_t key,uint16_t *idx)
{
- TRC2(cmMmHashFunc);
- *idx = (U16)(key % hashListCp->numOfbins);
+ *idx = (uint16_t)(key % hashListCp->numOfbins);
return ROK;
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmMmHashListInit
+static S16 cmMmHashListInit
(
CmMmHashListCp *hashListCp, /* hash list to initialize */
-U16 nmbBins, /* number of hash list bins */
+uint16_t nmbBins, /* number of hash list bins */
Region region, /* memory region to allocate bins */
Pool pool /* memory pool to allocate bins */
)
-#else
-PRIVATE S16 cmMmHashListInit(hashListCp, nmbBins, region, pool)
-CmMmHashListCp *hashListCp; /* hash list to initialize */
-U16 nmbBins; /* number of hash list bins */
-Region region; /* memory region to allocate bins */
-Pool pool; /* memory pool to allocate bins */
-#endif
{
- U16 i;
+ uint16_t i;
CmMmHashListEnt *hl;
- TRC2(cmMmHashListInit);
/* initialize control point fields */
hashListCp->hashList = NULLP;
/* allocate memory for bins */
if (nmbBins)
{
- if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList,
+ if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool, (Data **) &hashListCp->hashList,
(Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK)
return RFAILED;
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmMmHashListDeinit
+static S16 cmMmHashListDeinit
(
CmMmHashListCp *hashListCp, /* hash list to deinitialize */
-Region region, /* memory region to allocate bins */
-Pool pool /* memory pool to allocate bins */
+Region region, /* memory region to allocate bins */
+Pool pool /* memory pool to allocate bins */
)
-#else
-PRIVATE S16 cmMmHashListDeinit(hashListCp, region, pool)
-CmMmHashListCp *hashListCp; /* hash list to deinitialize */
-Region region; /* memory region to allocate bins */
-Pool pool; /* memory pool to allocate bins */
-#endif
{
- TRC2(cmMmHashListDeinit);
/* deallocate memory for bins */
if (hashListCp->numOfbins)
- (Void) SPutSBuf(region, pool,
+ (Void) SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,region, pool,
(Data *) hashListCp->hashList,
(Size) (hashListCp->numOfbins * sizeof(CmMmHashListEnt)));
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmMmHashListInsert
+static S16 cmMmHashListInsert
(
CmMmHashListCp *hashListCp, /* hash list to add to */
-U32 key /* pointer to key */
+uint32_t key /* pointer to key */
)
-#else
-PRIVATE S16 cmMmHashListInsert(hashListCp, key)
-CmMmHashListCp *hashListCp; /* hash list to add to */
-U32 key; /* pointer to key */
-#endif
{
CmMmHashListEnt *hashListEnt; /* pointer to hash list entry header */
- U16 idx; /* index for insertion into hash list */
- U16 i;
+ uint16_t idx; /* index for insertion into hash list */
+ uint16_t i;
- TRC2(cmMmHashListInsert);
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmHashListInit
+static S16 cmHstGrmHashListInit
(
CmHstGrmHashListCp *hashListCp /* hash list to initialize */
)
-#else
-PRIVATE S16 cmHstGrmHashListInit(hashListCp)
-CmHstGrmHashListCp *hashListCp; /* hash list to initialize */
-#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmHashListDeInit
+static S16 cmHstGrmHashListDeInit
(
CmHstGrmHashListCp *hashListCp /* hash list to initialize */
)
-#else
-PRIVATE S16 cmHstGrmHashListDeInit(hashListCp)
-CmHstGrmHashListCp *hashListCp; /* hash list to initialize */
-#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListDeInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmFreeInsert
+static S16 cmHstGrmFreeInsert
(
CmHstGrmHashListCp* hashListCp, /* hash list cp */
-U32 blkSz, /* size of the block freed */
-U32 line, /* Line number */
-U8 *fileName, /* file name */
-U8 entId /* Tapa task which free the memory */
+uint32_t blkSz, /* size of the block freed */
+uint32_t line, /* Line number */
+uint8_t *fileName, /* file name */
+uint8_t entId /* Tapa task which free the memory */
)
-#else
-PRIVATE S16 cmHstGrmFreeInsert(hashListCp, blkSz, line, fileName, entId)
-CmHstGrmHashListCp* hashListCp; /* hash list cp */
-U32 blkSz; /* size of the block freed */
-U32 line; /* line number */
-U8 *fileName; /* file Name */
-U8 entId; /* Tapa task which frees the memory */
-#endif
{
- U32 binIdx = 0; /* Bin index to insert the entry into the hash list */
- U32 key = 0; /* Key to fine the bin index */
- U32 ret = 0; /* Return value */
- CmMemEntries *entry = NULLP; /* Entry which contains the information */
+ uint32_t binIdx = 0; /* Bin index to insert the entry into the hash list */
+ uint32_t key = 0; /* Key to fine the bin index */
+ uint32_t ret = 0; /* Return value */
+ CmMemEntries *entry = NULLP; /* Entry which contains the information */
- TRC2(cmHstGrmFreeInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
/* If hash list is full then print the error tna continue */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
- printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
+ DU_LOG("\nERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
return RFAILED;
} /* End of if */
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmAllocInsert
+static S16 cmHstGrmAllocInsert
(
CmHstGrmHashListCp *hashListCp,
-U32 blkSz,
-U32 *reqSz,
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t blkSz,
+uint32_t *reqSz,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
-#else
-PRIVATE S16 cmHstGrmAllocInsert(hashListCp, blkSz, reqSz, line, fileName, entId)
-CmHstGrmHashListCp *hashListCp;
-U32 blkSz;
-U32 *reqSz;
-U32 line;
-U8 *fileName;
-U8 entId;
-#endif
{
- U32 binIdx = 0;
- U32 key = 0;
- U32 ret = 0;
- CmMemEntries *entry = NULLP;
+ uint32_t binIdx = 0;
+ uint32_t key = 0;
+ uint32_t ret = 0;
+ CmMemEntries *entry = NULLP;
- TRC2(cmHstGrmAllocInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
- printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
+ DU_LOG("\nERROR --> No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
return RFAILED;
} /* End of if */
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmGetHashIdxAndKey
+static S16 cmHstGrmGetHashIdxAndKey
(
-U8 *fileName,
-U32 line,
-U32 *binIdx,
-U32 *key
+uint8_t *fileName,
+uint32_t line,
+uint32_t *binIdx,
+uint32_t *key
)
-#else
-PRIVATE S16 cmHstGrmGetHashIdxAndKey(fileName, line, binIdx, key)
-U8 *fileName;
-U32 line;
-U32 *binIdx;
-U32 *key;
-#endif
{
- U32 i = 0;
- TRC2(cmHstGrmGetHashIdxAndKey);
+ uint32_t i = 0;
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmFillEntry
+static S16 cmHstGrmFillEntry
(
-CmMemEntries *entry,
-U32 key,
-U32 line,
-U8 *fileName,
-U8 entId
+CmMemEntries *entry,
+uint32_t key,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
-#else
-PRIVATE S16 cmHstGrmFillEntry(entry, key, line, fileName, entId)
-CmMemEntries *entry;
-U32 key;
-U32 line;
-U8 *fileName;
-U8 entId;
-#endif
{
- U32 idx = 0;
- TRC2(cmHstGrmFillEntry);
+ uint32_t idx = 0;
entry->key = key;
entry->line = line;
entry->entId = entId;
* File: cm_mem.c
*
*/
-#ifdef ANSI
-PRIVATE S16 cmHstGrmFindEntry
+static S16 cmHstGrmFindEntry
(
CmHstGrmHashListCp *hashListCp,
-U32 key,
-U32 *binIdx,
-CmMemEntries **entry
+uint32_t key,
+uint32_t *binIdx,
+CmMemEntries **entry
)
-#else
-PRIVATE S16 cmHstGrmFindEntry(hashListCp, key, binIdx, entry)
-CmHstGrmHashListCp *hashListCp;
-U32 key;
-U32 *binIdx;
-CmMemEntries **entry;
-#endif
{
- U32 numEnt = 0;
- U32 numBin = 0;
+ uint32_t numEnt = 0;
+ uint32_t numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
- TRC2(cmHstGrmFindEntry);
-
-
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
{
/* find for the entry in the bin */
} /* End of if (numEnt) */
else
{
- printf ("Unable to find the entry in hash list\n");
+ DU_LOG("\nERROR --> Unable to find the entry in hash list\n");
return RFAILED;
}/* End of else (numEnt) */
}/* end of for (numBin = 0) */
- printf("Unable to find the entry in the hash list\n");
+ DU_LOG("\nERROR --> Unable to find the entry in the hash list\n");
return RFAILED;
} /* end of cmHstGrmFindEntry */
Code Review / o-du / l2.git / blobdiff