#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;
+U32 memFreeCount=0;
+U32 cmFreeCaller[4]={0};
+U32 cmAllocCaller[4]={0};
+Data *startPtr256=NULLP;
+Data *startPtr128=NULLP;
+U32 cmMemInfo128[100000][2]={0, 0};
+U32 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];
/* if(!startMemLeak)
{
- RETVALUE(ROK);
+ return ROK;
}*/
U32 index1 = getT2kMemLeakIndex(address, region);
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegInit
+S16 cmMmRegInit
(
Region region,
CmMmRegCb *regCb,
CmMmRegCfg *cfg
)
#else
-PUBLIC S16 cmMmRegInit(region, regCb, cfg)
+S16 cmMmRegInit(region, regCb, cfg)
Region region;
CmMmRegCb *regCb;
CmMmRegCfg *cfg;
CmMmBlkHdr ptrHdr;
#endif
- TRC2(cmMmRegInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((regCb == NULLP) || (cfg == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Error check on the configuration fields */
if ((!cfg->size) || (cfg->vAddr == NULLP) ||
(cfg->numBkts > CMM_MAX_BKT_ENT))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the quantum size is power of 2 */
if ((cfg->numBkts) &&
/* cm_mem_c_001.main_20 Addition */
sprintf(errMsg,"\n cmMmRegInit() failed, check if BktQuantum size might not be power of 2 \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*
\n",bktIdx,cfg->bktCfg[bktIdx].size,cfg->bktQnSize);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((bktBlkSize = cfg->bktCfg[bktIdx].size) < lstQnSize)
/* cm_mem_c_001.main_20 Addition */
sprintf(errMsg,"\n cmMmRegInit() failed, Two consecutive buckets are not separated by quantum size \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (((cfg->bktCfg[bktIdx].size) /\
\n should be less than CMM_MAX_MAP_ENT:%d \n",cfg->bktQnSize,CMM_MAX_MAP_ENT);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
sprintf(errMsg,"\n cmMmRegInit() failed, Size of the memory region is less than the required size \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
lstQnSize = ((bktBlkSize / cfg->bktQnSize) + 1) * cfg->bktQnSize;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMmBktInit( &memAddr, regCb, cfg, bktIdx, &lstMapIdx);
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
regCb->heapFlag = TRUE;
/* Call SRegRegion to register the memory region with SSI */
if (SRegRegion(region, ®Cb->regInfo) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_12 - addition for initializing the hash table */
/* Initialize the region level hash table for debug info storage */
if (cmMmHashListInit(®Cb->hashListCp, CMM_STAT_HASH_TBL_LEN, region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
if(cmHashListInit(®Cb->brdcmSsiLstCp, 1000, offset, FALSE,
CM_HASH_KEYTYPE_U32MOD, region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegInit*/
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegDeInit
+S16 cmMmRegDeInit
(
CmMmRegCb *regCb
)
#else
-PUBLIC S16 cmMmRegDeInit(regCb)
+S16 cmMmRegDeInit(regCb)
CmMmRegCb *regCb;
#endif
{
U16 bktIdx;
- TRC2(cmMmRegDeInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if (regCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Deinitialize the hash table used for debug info storage at region level */
if (cmMmHashListDeinit(®Cb->hashListCp, regCb->region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* Deinitialize the hash table used for broadcom ssi instrumentation */
if (cmHashListDeinit(®Cb->brdcmSsiLstCp) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegDeInit */
prevptr=&prevptr1;
#endif
- TRC2(cmAlloc);
#ifndef USE_MEMCAL
UNUSED(flags);
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
#endif /* SSI_DEBUG_LEVEL1 */
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
/* return RFAILED */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#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);
/* Store this pointer in hash list */
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else if (flags)
{
#ifdef SS_HISTOGRAM_SUPPORT
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
#else
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
#endif /* SSI_DEBUG_LEVEL1 */
#endif /* SS_HISTOGRAM_SUPPORT */
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAlloc */
U16 memIndex=0;
#endif
- TRC2(cmFree);
regCb = (CmMmRegCb *)regionCb;
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
#endif
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
printf("Memory signature is invalid\n");
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))
abort();
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
if (CMM_IS_STATIC(ptrHdr->memFlags))
{
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
#endif
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
Bool hstReg
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType,
+S16 cmAllocNL(regionCb, size, flags, ptr, memType,
line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
Bool hstReg
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, line,
+S16 cmAllocNL(regionCb, size, flags, ptr, line,
fileName, entId, hstReg)
Void *regionCb;
Size *size;
#else
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
U8 *funcName
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
+S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
Void *regionCb;
Size *size;
U32 flags;
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
U32 memType
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType)
+S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
U32 flags;
#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
U32 memType
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr, memType)
+S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
U32 flags;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmAllocNL
+S16 cmAllocNL
(
Void *regionCb,
Size *size,
Data **ptr
)
#else
-PUBLIC S16 cmAllocNL(regionCb, size, flags, ptr)
+S16 cmAllocNL(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
U32 flags;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmAllocNL);
#ifndef USE_MEMCAL
UNUSED(flags);
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
#endif /* SSI_DEBUG_LEVEL1 */
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (cmMmBktSanityChk(bkt) == RTRAMPLINGNOK)
{
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
/* return RFAILED */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
#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
/* cm_mem_c_008.104 - Addition for memory calculator tool */
- RETVALUE(ROK);
+ return ROK;
}
else if (flags)
{
#ifdef SS_HISTOGRAM_SUPPORT
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size,
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size,
memType, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size,
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size,
line, fileName, entId, hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
#else
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
#endif /* SSI_DEBUG_LEVEL1 */
#endif /* SS_HISTOGRAM_SUPPORT */
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAllocNL */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
U8 *funcName
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
+S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
Void *regionCb;
Data *ptr;
Size size;
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Bool hstReg
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size, line, fileName, entId, hstReg)
+S16 cmFreeNL(regionCb, ptr, size, line, fileName, entId, hstReg)
Void *regionCb;
Data *ptr;
Size size;
#else
#ifdef ANSI
-PUBLIC S16 cmFreeNL
+S16 cmFreeNL
(
Void *regionCb,
Data *ptr,
Size size
)
#else
-PUBLIC S16 cmFreeNL(regionCb, ptr, size)
+S16 cmFreeNL(regionCb, ptr, size)
Void *regionCb;
Data *ptr;
Size size;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmFreeNL);
regCb = (CmMmRegCb *)regionCb;
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
else
{
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
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))
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
if (CMM_IS_STATIC(ptrHdr->memFlags))
{
{
/* do not add to the free list */
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
else
{
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
#endif
}
cmRlsAllocBlk((PTR)ptr);
#endif /* SS_MEM_LEAK_STS */
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
- TRC2(cmFreeNL);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmFreeNL */
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmAllocWL);
/*cm_mem_c_001.main_23 Removed support of USE_MEMCAL and MEMCAL_DEBUG support for SS_FAP*/
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Update the size parameter */
*size = bkt->size;
- RETVALUE(ROK);
+ return ROK;
}
}
}
* heap pool.
*/
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAllocWL */
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- TRC2(cmFreeWL);
regCb = (CmMmRegCb *)regionCb;
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*/
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#else /* use pure is on */
- TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
{
CmMmRegCb *regCb;
- TRC2(cmCtl);
regCb = (CmMmRegCb *)regionCb;
/* error check on parameters */
if ((regCb == NULLP) || (memCtl == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((memCtl->u.vtop.vaddr == NULLP) ||
(memCtl->u.vtop.paddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
offset = memCtl->u.vtop.vaddr - regCb->regInfo.start;
*(memCtl->u.vtop.paddr) = regCb->pAddr + offset;
- RETVALUE(ROK);
+ return ROK;
}
break;
}
if (!(memCtl->u.chkres.size) ||
(memCtl->u.chkres.status == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifndef USE_PURE
(regCb->heapSize/10));
}
- RETVALUE(ROK);
+ return ROK;
#else /* use pure is on */
*(memCtl->u.chkres.status) = ((avail_size) /
(regCb->regInfo.size/10));
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
}
default:
{
/* No other event is supported currently */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* shouldn't reach here */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmCtl */
\f
#endif
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmBktInit);
size = cfg->bktCfg[bktIdx].size;
#ifdef SSI_DEBUG_LEVEL1
U16 idx;
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmHeapInit);
/* Initialize the heap control block */
heapCb->vStart = memAddr;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapAlloc);
/* cm_mem_c_001.main_15 : Additions */
/* Acquire the heap lock */
/* cm_mem_c_001.main_13 : Replaced SLock with WTLock for NT */
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
} /* end of cmHeapAlloc */
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapFree);
/* Roundup the requested size */
size = CMM_DATALIGN(size, (heapCb->minSize));
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
#endif /* SSI_DEBUG_LEVEL1 */
#endif
/* This block is already freed in the heap */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
/* update the flags as it is a new node */
if (CMM_IS_STATIC(p->memFlags))
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
else if (p < curHBlk)
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
/* Release the lock */
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHeapFree */
#endif/*USE_PURE*/
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-PUBLIC U32 cmGetFreeIndx
+U32 cmGetFreeIndx
(
Void
)
#else
-PUBLIC U32 cmGetFreeIndx(Void)
+U32 cmGetFreeIndx(Void)
#endif
{
if(gmemLkCb.head == gmemLkCb.tail)
{
allocQueueEmptyCnt++;
- RETVALUE(CM_MAX_ALLOC_ENTERIES);
+ return (CM_MAX_ALLOC_ENTERIES);
}
else
{
U32 allocQIndx = gmemLkCb.queue[gmemLkCb.head];
gmemLkCb.head = (gmemLkCb.head +1) % CM_MAX_ALLOC_ENTERIES;
- RETVALUE(allocQIndx);
+ return (allocQIndx);
}
}
#ifdef ANSI
-PUBLIC U32 cmPutFreeIndx
+U32 cmPutFreeIndx
(
U32 allocQIndx
)
#else
-PUBLIC U32 cmPutFreeIndx(allocQIndx)
+U32 cmPutFreeIndx(allocQIndx)
U32 allocQIndx;
#endif
if(tmpTail == gmemLkCb.head)
{
allocQueueFullCnt++;
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
gmemLkCb.queue[gmemLkCb.tail] = allocQIndx;
gmemLkCb.tail = tmpTail;
- RETVALUE(ROK);
+ return ROK;
}
}
/*
*
*/
#ifdef ANSI
-PUBLIC Void cmInitMemLeak
+Void cmInitMemLeak
(
Void
)
#else
-PUBLIC Void cmInitMemLeak (Void)
+Void cmInitMemLeak (Void)
#endif
{
U32 indx;
- TRC3(cmInitMemLeak);
gmemLkCb.isStarted = FALSE;
gmemLkCb.head = 0;
*
**/
#ifdef ANSI
-PUBLIC Void cmDeinitMemLeak
+Void cmDeinitMemLeak
(
Void
)
#else
-PUBLIC Void cmDeinitMemLeak (Void)
+Void cmDeinitMemLeak (Void)
#endif
{
U32 indx;
- TRC3(cmDeinitMemLeak);
for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++)
{
*
*/
#ifdef ANSI
-PUBLIC U32 cmStorAllocBlk
+U32 cmStorAllocBlk
(
Void *addr
)
#else
-PUBLIC U32 cmStorAllocBlk (addr)
+U32 cmStorAllocBlk (addr)
Void *addr;
#endif /* ANSI */
}
(Void) SUnlock(&(gmemLkCb.memLock));
- RETVALUE(allocQIndx);
+ return (allocQIndx);
} /* cmStorAllocBlk */
*
*/
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
U32 allocQIndx
)
#else
-PUBLIC Void cmRlsAllocBlk(allocQIndx)
+Void cmRlsAllocBlk(allocQIndx)
U32 allocQIndx;
#endif
{
- TRC3(cmRlsAllocBlk);
if(allocQIndx < CM_MAX_ALLOC_ENTERIES)
{
*
*/
#ifdef ANSI
-PUBLIC Void cmStartStopLeakLog
+Void cmStartStopLeakLog
(
Void
)
#else
-PUBLIC Void cmStartStopLeakLog(Void)
+Void cmStartStopLeakLog(Void)
#endif
{
if (FALSE == gmemLkCb.isStarted)
*
*/
#ifdef ANSI
-PUBLIC Void cmPrintLeakLog
+Void cmPrintLeakLog
(
Void
)
#else
-PUBLIC Void cmPrintLeakLog(Void)
+Void cmPrintLeakLog(Void)
#endif
{
CmMmBlkHdr *aBkt;
static U32 leakCount =0;
- TRC3(cmPrintLeakLog);
printf("---- START OF LEAK LOG ----");
SLock(&gmemLkCb.memLock);
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
CmMmBlkHdr *ptrHdr,
CmMmRegCb *regCb
)
#else
-PUBLIC Void cmRlsAllocBlk(ptrHdr, regCb)
+Void cmRlsAllocBlk(ptrHdr, regCb)
CmMmBlkHdr *ptrHdr;
CmMmRegCb *regCb;
#endif
#else
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
#ifdef BIT_64
U64 addr
#endif
)
#else
-PUBLIC Void cmRlsAllocBlk(addr)
+Void cmRlsAllocBlk(addr)
#ifdef BIT_64
U64 addr;
#else
MemAllocInfo *memAllocInfo;
#endif
- TRC3(cmRlsAllocBlk);
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef BIT_64
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
CmMmBlkHdr *ptrHdr,
Size reqSz,
CmMmRegCb *regCb
)
#else
-PUBLIC Void cmStorAllocBlk (ptrHdr, reqSz, allocSz, bktIdx, regCb)
+Void cmStorAllocBlk (ptrHdr, reqSz, allocSz, bktIdx, regCb)
CmMmBlkHdr *ptrHdr;
Size reqSz;
Size allocSz;
#endif
#else
#ifdef ANSI
-PUBLIC Void cmStorAllocBlk
+Void cmStorAllocBlk
(
#ifdef BIT_64
U64 addr,
U16 bktIdx
)
#else
-PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
+Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
#ifdef BIT_64
U64 addr;
#else
S32 traceSize;
#endif
- TRC3(cmStorAllocBlk);
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
if( memLkCb.memLkMdlInit == FALSE)
{
/*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));
+ memset(funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
#else
funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE));
#endif
#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
/* check if hashListCp is initialised yet */
if ( regCb->brdcmSsiLstCp.nmbBins == 0)
{
- RETVALUE(ROK);
+ return ROK;
}
ptrHdr->reqSz = reqSz;
ptrHdr->allocSz = allocSz;
*
*/
#ifdef ANSI
-PUBLIC Void SLogLkInfo
+Void SLogLkInfo
(
Void
)
#else
-PUBLIC Void SLogLkInfo (Void)
+Void SLogLkInfo (Void)
#endif
{
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
CmMmRegCb *tmpRegCb;
FILE *fp;
- TRC3(SLogLkInfo);
fp = fopen("meLeakLog.txt", "w");
if(fp == NULL)
{
U8 idx;
Txt prntBuf[255];
S8 **funcNm;
- TRC3(SLogLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
*
*/
#ifdef ANSI
-PUBLIC Void cmInitMemLeakMdl
+Void cmInitMemLeakMdl
(
Void
)
#else
-PUBLIC Void cmInitMemLeakMdl (Void)
+Void cmInitMemLeakMdl (Void)
#endif
{
U8 memMdl;
U8 hashIdx;
- TRC3(cmInitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
*
**/
#ifdef ANSI
-PUBLIC Void cmDeinitMemLeakMdl
+Void cmDeinitMemLeakMdl
(
Void
)
#else
-PUBLIC Void cmDeinitMemLeakMdl (Void)
+Void cmDeinitMemLeakMdl (Void)
#endif
{
U8 memMdl;
U8 hashIdx;
- TRC3(cmDeinitMemLeakMdl);
memLkCb.memLkMdlInit = FALSE;
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
*
*/
#ifdef ANSI
-PUBLIC Void cmMemOpenMemLkFile
+Void cmMemOpenMemLkFile
(
S8 *arg
)
#else
-PUBLIC Void cmMemOpenMemLkFile (arg)
+Void cmMemOpenMemLkFile (arg)
S8 *msOptArg;
#endif
{
- TRC3(cmMemOpenMemLkFile);
memLkCb.fileLkLog = NULLP;
memLkCb.fileLkLog = fopen(arg, "w");
RETVOID;
*
*/
#ifdef ANSI
-PUBLIC Void SFlushLkInfo
+Void SFlushLkInfo
(
Void
)
#else
-PUBLIC Void SFlushLkInfo (Void)
+Void SFlushLkInfo (Void)
#endif
{
MemAllocInfo *newMemInfo;
U8 i;
#endif /* SS_MEM_LEAK_SOL */
- TRC3(SFlushLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
*
*/
#ifdef ANSI
-PUBLIC U8 cmMemGetModuleId
+U8 cmMemGetModuleId
(
S8 **funNm,
S32 traceSize
)
#else
-PUBLIC U8 cmMemGetModuleId (funNm, traceSize)
+U8 cmMemGetModuleId (funNm, traceSize)
S8 **funNm;
S32 traceSize;
#endif /* ANSI */
Txt *memFn[]={"SGetMsg", "SGetSBuf", "SGetDBuf", NULLP};
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC3(cmMemGetModuleId)
for(idx = 0; idx < traceSize; idx++)
{
memReqIdx = -1;
funNm);
if(memReqIdx >= 0)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
(const S8 *)memUsrMdlStr[mdlFunStrIdx].fPStr);
if(retVal == NULLD)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
}
- RETVALUE(0);
+ return (0);
} /* cmMemGetModuleId */
/*
*
*/
#ifdef ANSI
-PUBLIC S16 cmMemGetStrMtchIdx
+S16 cmMemGetStrMtchIdx
(
U8 strtIdx,
U8 endIdx,
S8 **strLst
)
#else
-PUBLIC S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
+S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
U8 strtIdx;
U8 endIdx;
S8 *str;
U32 tempLen;
U8 idx;
S32 retVal;
- TRC3(cmMemGetStrMtchIdx);
len = strlen((const S8 *)str);
cmpStr[0] = '(';
if(!found)
{
- RETVALUE(-1);
+ return (-1);
}
- RETVALUE(strtIdx);
+ return (strtIdx);
} /* cmMemGetStrMtchIdx */
#ifdef SS_MEM_LEAK_SOL
*
*/
#ifdef ANSI
-PUBLIC S32 cmAddrToSymStr
+S32 cmAddrToSymStr
(
Void *pc,
S8 *buffer,
S32 size
)
#else
-PUBLIC S32 cmAddrToSymStr(pc, buffer, size)
+S32 cmAddrToSymStr(pc, buffer, size)
Void *pc;
S8 *buffer;
S32 size;
Dl_info info;
Sym *sym;
- TRC3(cmAddrToSymStr);
if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0)
{
- RETVALUE(snprintf(buffer, size, "[0x%p]", pc));
+ return (snprintf(buffer, size, "[0x%p]", pc));
}
if ((info.dli_fname != NULLP && info.dli_sname != NULLP) &&
((uintptr_t)pc - (uintptr_t)info.dli_saddr < sym->st_size))
{
- RETVALUE(snprintf(buffer, size, "%s(%s+0x%x) [0x%p]",
+ return (snprintf(buffer, size, "%s(%s+0x%x) [0x%p]",
info.dli_fname,
info.dli_sname,
(unsigned long)pc - (unsigned long)info.dli_saddr, pc));
}
else
{
- RETVALUE(snprintf(buffer, size, "%s(0x%p [0x%p]",
+ return (snprintf(buffer, size, "%s(0x%p [0x%p]",
info.dli_fname,
(unsigned long)pc - (unsigned long)info.dli_fbase, pc));
}
*
*/
#ifdef ANSI
-PUBLIC S32 cmLeakCallBack
+S32 cmLeakCallBack
(
uintptr_t pc,
S32 sigNo,
Void *arg
)
#else
-PUBLIC S32 cmLeakCallBack(pc, sigNo, arg)
+S32 cmLeakCallBack(pc, sigNo, arg)
uintptr_t pc;
S32 sigNo;
Void *arg;
#endif
{
S8 *buffer;
- TRC3(cmLeakCallBack);
Backtrace_t *bt = (Backtrace_t *)arg;
if (bt->bt_actcount >= bt->bt_maxcount)
- RETVALUE(-1);
+ return (-1);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
buffer = (S8 *)MxHeapAlloc(SsiHeap, 510);
- cmMemset((U8*)buffer, 0, 510);
+ memset(buffer, 0, 510);
#else
buffer = (S8 *)calloc(1, 510);
#endif
(void) cmAddrToSymStr((void *)pc, buffer, 505);
bt->bt_buffer[bt->bt_actcount++] = (S8 *)buffer;
- RETVALUE(0);
+ return (0);
} /* cmLeakCallBack */
#endif /* SS_MEM_LEAK_SOL */
*/
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
+S16 cmMmRegIsBlkSane
(
CmMmBlkHdr *blkPtr,
Size size
)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr, size)
+S16 cmMmRegIsBlkSane(blkPtr, size)
CmMmBlkHdr *blkPtr;
Size size;
#endif
#else
#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
+S16 cmMmRegIsBlkSane
(
CmMmBlkHdr *blkPtr
)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr)
+S16 cmMmRegIsBlkSane(blkPtr)
CmMmBlkHdr *blkPtr;
#endif
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
CmMmBlkTail *tailPtr;
#endif
- TRC2(cmMmRegIsBlkSane);
for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++)
{
if (blkPtr->trSignature[sigCnt] != 0xAB)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
{
if (tailPtr->trSignature[sigCnt] != 0xFE)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif
#ifdef SSI_DEBUG_LEVEL1
CmMmBlkHdr *ptrBlk;
U32 blkCnt;
- TRC2(cmMmBktSanityChk);
-
bkt->trampleCount = 0;
/* scan the entire memory list of the bucket */
if (bkt->trampleCount > CMM_TRAMPLING_THRESHOLD)
{
/* Take action to invalidate the entire bucket */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
/* reach next memory block in this bucket manually */
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
#endif
{
- TRC2(cmMmHeapSanityChk);
/* increment the trample count */
heapCb->trampleCount++;
if (heapCb->trampleCount > CMM_TRAMPLING_THRESHOLD)
{
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
*
U16 *idx; /* idx to return */
#endif
{
- TRC2(cmMmHashFunc);
*idx = (U16)(key % hashListCp->numOfbins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashFunc () */
U16 i;
CmMmHashListEnt *hl;
- TRC2(cmMmHashListInit);
/* initialize control point fields */
hashListCp->hashList = NULLP;
{
if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList,
(Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
/* initialize bin pointers */
hl = hashListCp->hashList;
hashListCp->numOfbins = nmbBins;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
Pool pool; /* memory pool to allocate bins */
#endif
{
- TRC2(cmMmHashListDeinit);
/* deallocate memory for bins */
if (hashListCp->numOfbins)
hashListCp->numOfbins = 0;
hashListCp->numOfEntries = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListDeinit */
/*
U16 idx; /* index for insertion into hash list */
U16 i;
- TRC2(cmMmHashListInsert);
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
- RETVALUE(ROK);
+ return ROK;
/* compute index for insertion */
if (cmMmHashFunc(hashListCp, key, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
hashListEnt = hashListCp->hashList;
if (i == CMM_STAT_HASH_TBL_LEN)
{
/* there is no free slot for this key */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListInsert */
#endif /* SSI_DEBUG_LEVEL1 */
#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
#endif
{
/*cm_mem_c_001.main_25 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
- TRC2(cmHstGrmHashListDeInit)
#ifdef DEBUGP
/* display an error message here */
/*cm_mem_c_001.main_25: Fixed Warnings for 32/64 bit compilation*/
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
CmMemEntries *entry = NULLP; /* Entry which contains the information */
- TRC2(cmHstGrmFreeInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
{
entry->freedBytes += blkSz;
entry->bucketFreeReq++;
- RETVALUE(ROK);
+ return ROK;
} /* End of if */
/* If hash list is full then print the error tna continue */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* End of if */
/* Take the address of next free entry in the hash bin */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFreeInsert */
U32 ret = 0;
CmMemEntries *entry = NULLP;
- TRC2(cmHstGrmAllocInsert);
/* check for the total number of entries in the hash list. *
* If there is no place for new entry return failure */
entry->allocBytes += blkSz;
entry->bucketAllocReq++;
entry->wastedBytes += (blkSz - *reqSz);
- RETVALUE(ROK);
+ return ROK;
} /* End of if */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* End of if */
/* Take the address of next free entry in the hash bin */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmAllocInsert */
{
U32 i = 0;
- TRC2(cmHstGrmGetHashIdxAndKey);
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
}/* End of for */
*key += line;
*binIdx = ( *key % CMM_HIST_MAX_MEM_BIN);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
{
U32 idx = 0;
- TRC2(cmHstGrmFillEntry);
entry->key = key;
entry->line = line;
entry->entId = entId;
entry->fileName[idx] = fileName[idx];
}
entry->fileName[idx] = '\0';
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
U32 numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
- TRC2(cmHstGrmFindEntry);
-
-
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
{
/* find for the entry in the bin */
if(tmpBin->entries[numEnt].key == key)
{
*entry = &(tmpBin->entries[numEnt]);
- RETVALUE(ROK);
+ return ROK;
}/* End of if (tmpBin->entries[numEnt].key) */
}/* end of for (numEnt = 0) */
else
{
printf ("Unable to find the entry in hash list\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}/* End of else (numEnt) */
}/* end of for (numBin = 0) */
printf("Unable to find the entry in the hash list\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHstGrmFindEntry */
#endif /* SS_HISTOGRAM_SUPPORT */
Code Review / o-du / l2.git / blobdiff