#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 */
-U32 memFreeCount=0;
-U32 cmFreeCaller[4]={0};
-U32 cmAllocCaller[4]={0};
+uint32_t memFreeCount=0;
+uint32_t cmFreeCaller[4]={0};
+uint32_t cmAllocCaller[4]={0};
Data *startPtr256=NULLP;
Data *startPtr128=NULLP;
-U32 cmMemInfo128[100000][2]={0, 0};
-U32 cmMemInfo256[100000][2]={0, 0};
+uint32_t cmMemInfo128[100000][2]={0, 0};
+uint32_t cmMemInfo256[100000][2]={0, 0};
Data *startPtr512=NULLP;
Data *startPtr768=NULLP;
Data *startPtr1664=NULLP;
#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));
+PRIVATE 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));
+PRIVATE 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));
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
+PRIVATE 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));
+PRIVATE 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));
+ 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));
+PRIVATE 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));
#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));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType, uint32_t lineNo,uint8_t *funcName ));
+PRIVATE 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));
+PRIVATE 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));
+PRIVATE 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));
+PRIVATE 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));
+PRIVATE 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));
#endif
#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 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size));
#endif
PRIVATE Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size));
PRIVATE Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb,
- CmMmRegCfg *cfg, U16 bktIdx, U16 *lstMapIdx));
+ 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,
+PRIVATE S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, uint32_t key, uint16_t *idx ));
+PRIVATE 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));
+PRIVATE 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 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, uint32_t blkSz, uint32_t *reqSz, uint32_t line, uint8_t *fileName, uint8_t entId));
+PRIVATE S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, uint32_t blkSz, uint32_t line, uint8_t *fileName, uint8_t 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));
+PRIVATE S16 cmHstGrmGetHashIdxAndKey ARGS((uint8_t *fileName, uint32_t line, uint32_t *binIdx, uint32_t *key));
+PRIVATE S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, uint32_t key, uint32_t *binIdx, CmMemEntries **entry));
+PRIVATE 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);
}
}
-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)
{
/* cm_mem_c_008.104 - Addition for memory calculator tool */
#ifdef MEMCAL_DEBUG
PRIVATE Txt prntBuf[200]; /* print buffer */
-PRIVATE U8 tryHeap=0;
+PRIVATE uint8_t tryHeap=0;
#endif
/* cm_mem_c_001.main_12 - addition for ssi enhancements prints */
#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 */
#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
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- U16 offset;
+ uint16_t offset;
CmMmBlkHdr ptrHdr;
#endif
#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);
+ offset = (uint16_t)((PTR)(&ptrHdr.ent) - (PTR) &ptrHdr);
printf("###########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;
}
CmMmRegCb *regCb;
#endif
{
- U16 bktIdx;
+ uint16_t bktIdx;
#if (ERRCLASS & ERRCLS_INT_PAR)
(
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;
+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;
#endif
#else
(
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;
+uint32_t flags;
Data **ptr;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
(
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
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr ,memType, lineNo, funcName)
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;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
(
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;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
(
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;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef T2K_MEM_LEAK_DBG
(
Void *regionCb,
Size *size,
- U32 flags,
+ uint32_t flags,
Data **ptr ,
char* file,
- U32 line
+ uint32_t line
)
#else
#ifdef ANSI
(
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;
+uint32_t flags;
Data **ptr;
#endif
#endif
{
/* 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;
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 */
Void *regionCb,
Data *ptr,
Size size,
-U32 lineNo,
-U8 *funcName
+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;
+uint32_t lineNo;
+uint8_t *funcName;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SS_HISTOGRAM_SUPPORT
Void *regionCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
Void *regionCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
Data *ptr,
Size size,
char* file,
- U32 line
+ uint32_t line
)
#else /* T2K_MEM_LEAK_DBG */
#ifdef ANSI
{
/* 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
#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
#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;
(
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
line, fileName, entId, hstReg)
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;
#endif
#else
(
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
fileName, entId, hstReg)
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;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
(
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
S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
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;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef ANSI
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
#endif
#endif /* BRDCM_SSI_MEM_LEAK_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))
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 */
Void *regionCb,
Data *ptr,
Size size,
-U32 lineNo,
-U8 *funcName
+uint32_t lineNo,
+uint8_t *funcName
)
#else
S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
Void *regionCb;
Data *ptr;
Size size;
-U32 lineNo;
-U8 *funcName;
+uint32_t lineNo;
+uint8_t *funcName;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
Void *regionCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
Void *regionCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
{
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
#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;
(
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;
+uint32_t 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*/
Size size;
#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*/
/* 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.
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;
+uint16_t bktIdx;
+uint16_t *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;
*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
{
/* cm_mem_c_001.main_12 - addition for ssi enhancements */
#ifdef SSI_DEBUG_LEVEL1
- U16 idx;
+ uint16_t idx;
#endif /* SSI_DEBUG_LEVEL1 */
/* Initialize the heap control block */
/* 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;
+EXTERN uint8_t ysCellConfigDone;
#endif
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
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
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;
#endif
#else
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
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;
+uint32_t memType;
#endif
#else
#ifdef ANSI
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
CmMmHeapCb *heapCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
#endif/*USE_PURE*/
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-U32 cmGetFreeIndx
+uint32_t cmGetFreeIndx
(
Void
)
#else
-U32 cmGetFreeIndx(Void)
+uint32_t cmGetFreeIndx(Void)
#endif
{
}
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
-U32 cmPutFreeIndx
+uint32_t cmPutFreeIndx
(
-U32 allocQIndx
+uint32_t allocQIndx
)
#else
-U32 cmPutFreeIndx(allocQIndx)
-U32 allocQIndx;
+uint32_t cmPutFreeIndx(allocQIndx)
+uint32_t allocQIndx;
#endif
{
- 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.
*
Void cmInitMemLeak (Void)
#endif
{
- U32 indx;
+ uint32_t indx;
gmemLkCb.isStarted = FALSE;
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.
*
Void cmDeinitMemLeak (Void)
#endif
{
- U32 indx;
+ uint32_t indx;
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.
*
*
*/
#ifdef ANSI
-U32 cmStorAllocBlk
+uint32_t cmStorAllocBlk
(
Void *addr
)
#else
-U32 cmStorAllocBlk (addr)
+uint32_t cmStorAllocBlk (addr)
Void *addr;
#endif /* ANSI */
{
- 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.
*
#ifdef ANSI
Void cmRlsAllocBlk
(
-U32 allocQIndx
+uint32_t allocQIndx
)
#else
Void cmRlsAllocBlk(allocQIndx)
-U32 allocQIndx;
+uint32_t allocQIndx;
#endif
{
(Void) SUnlock(&(gmemLkCb.memLock));
}
}
- RETVOID;
+ return;
} /* cmRlsAllocBlk */
/*
printf("!!leak capturing stopped\n");
cmPrintLeakLog();
}
- RETVOID;
+ return;
}
/*
#endif
{
- U32 indx;
+ uint32_t indx;
CmMmBlkHdr *aBkt;
- static U32 leakCount =0;
+ static uint32_t leakCount =0;
printf("---- START OF LEAK LOG ----");
SUnlock(&gmemLkCb.memLock);
printf("---- 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.
*
Void cmRlsAllocBlk
(
#ifdef BIT_64
-U64 addr
+uint64_t addr
#else
-U32 addr
+uint32_t addr
#endif
)
#else
Void cmRlsAllocBlk(addr)
#ifdef BIT_64
-U64 addr;
+uint64_t addr;
#else
-U32 addr;
+uint32_t 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
#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.
*
CmMmBlkHdr *ptrHdr,
Size reqSz,
Size allocSz,
-U16 bktIdx,
+uint16_t bktIdx,
CmMmRegCb *regCb
)
#else
CmMmBlkHdr *ptrHdr;
Size reqSz;
Size allocSz;
-U16 bktIdx;
+uint16_t bktIdx;
CmMmRegCb *regCb;
#endif
#else
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
Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
#ifdef BIT_64
-U64 addr;
+uint64_t addr;
#else
-U32 addr;
+uint32_t addr;
#endif
Size reqSz;
Size allocSz;
-U16 bktIdx;
+uint16_t bktIdx;
#endif /* ANSI */
#endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
{
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
#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));
- memset(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); */
+ /* SGetSBuf(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
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.
*
#endif
{
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
- U8 idx;
- U8 regionIdx;
+ uint8_t idx;
+ uint8_t regionIdx;
Txt prntBuf[255];
S8 **funcNm;
CmMmBlkHdr *newBlkHdr;
#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;
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.
*
Void cmInitMemLeakMdl (Void)
#endif
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
memLkCb.memLkMdlInit = FALSE;
{
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.
*
Void cmDeinitMemLeakMdl (Void)
#endif
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
memLkCb.memLkMdlInit = FALSE;
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.
*
{
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.
*
#endif
{
MemAllocInfo *newMemInfo;
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
S8 **funcNm;
#ifdef SS_MEM_LEAK_SOL
- U8 i;
+ uint8_t i;
#endif /* SS_MEM_LEAK_SOL */
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); */
+ /* SPutSBuf(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.
*
*
*/
#ifdef ANSI
-U8 cmMemGetModuleId
+uint8_t cmMemGetModuleId
(
S8 **funNm,
S32 traceSize
)
#else
-U8 cmMemGetModuleId (funNm, traceSize)
+uint8_t 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;
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#ifdef ANSI
S16 cmMemGetStrMtchIdx
(
-U8 strtIdx,
-U8 endIdx,
+uint8_t strtIdx,
+uint8_t endIdx,
S8 *str,
S8 **strLst
)
#else
S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
-U8 strtIdx;
-U8 endIdx;
+uint8_t strtIdx;
+uint8_t 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;
len = strlen((const S8 *)str);
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#endif
#endif
{
- U32 sigCnt;
+ uint32_t sigCnt;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
CmMmBlkTail *tailPtr;
#endif
#endif
{
CmMmBlkHdr *ptrBlk;
- U32 blkCnt;
+ uint32_t blkCnt;
bkt->trampleCount = 0;
PRIVATE 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 */
+uint32_t key; /* key string */
+uint16_t *idx; /* idx to return */
#endif
{
- *idx = (U16)(key % hashListCp->numOfbins);
+ *idx = (uint16_t)(key % hashListCp->numOfbins);
return ROK;
PRIVATE 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 */
+uint16_t 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;
PRIVATE 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 */
+uint32_t 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;
/* check if hashListCp is initialised yet */
PRIVATE 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 */
+uint32_t blkSz; /* size of the block freed */
+uint32_t line; /* line number */
+uint8_t *fileName; /* file Name */
+uint8_t 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 */
+ 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 */
PRIVATE 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;
+uint32_t blkSz;
+uint32_t *reqSz;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
{
- U32 binIdx = 0;
- U32 key = 0;
- U32 ret = 0;
+ uint32_t binIdx = 0;
+ uint32_t key = 0;
+ uint32_t ret = 0;
CmMemEntries *entry = NULLP;
#ifdef ANSI
PRIVATE 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;
+uint8_t *fileName;
+uint32_t line;
+uint32_t *binIdx;
+uint32_t *key;
#endif
{
- U32 i = 0;
+ uint32_t i = 0;
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
PRIVATE 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;
+uint32_t key;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
entry->key = key;
entry->line = line;
entry->entId = entId;
PRIVATE 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;
+uint32_t key;
+uint32_t *binIdx;
CmMemEntries **entry;
#endif
{
- U32 numEnt = 0;
- U32 numBin = 0;
+ uint32_t numEnt = 0;
+ uint32_t numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
Code Review / o-du / l2.git / blobdiff