}CmMemDoubleFree;
PTR prvAllocPtr[8];
-PUBLIC U8 stopBtInfo = FALSE;
-PUBLIC Buffer *palBuffer;
+U8 stopBtInfo = FALSE;
+Buffer *palBuffer;
EXTERN Buffer *mtTskBuffer1;
EXTERN Buffer *mtTskBuffer2;
PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char*, U32));
PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
-PUBLIC void InsertToT2kMemLeakInfo ARGS((U32 address, U32 size, U32 lineNo, char* fileName));
+void InsertToT2kMemLeakInfo ARGS((U32 address, U32 size, U32 lineNo, char* fileName));
void RemoveFromT2kMemLeakInfo ARGS((U32 address, char *file, U32 line));
PRIVATE U32 getT2kMemLeakIndex ARGS((U32 address));
#else
U32 num_times = 0;
EXTERN pthread_t tmpRegTidMap[20];
extern Bool g_usettitmr;
-PUBLIC void DumpLayersDebugInformation()
+void DumpLayersDebugInformation()
{
DumpSSIDemandQDebugInformation();
/* dump layers information only after we start receiving the TTIs */
Data **next;
#endif /* SSI_DEBUG_LEVEL1 */
- TRC2(cmMmStatBktInit);
size = cfg->bktCfg[bktIdx].size;
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmStatRegInit
+S16 cmMmStatRegInit
(
Region region,
CmMmRegCb *regCb,
CmMmRegCfg *cfg
)
#else
-PUBLIC S16 cmMmStatRegInit(region, regCb, cfg)
+S16 cmMmStatRegInit(region, regCb, cfg)
Region region;
CmMmRegCb *regCb;
CmMmRegCfg *cfg;
Txt errMsg[256] = {'\0'};
#endif
- TRC2(cmMmRegInit);
#if (ERRCLASS & ERRCLS_INT_PAR)
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmGlobRegInit
+S16 cmMmGlobRegInit
(
CmMmGlobRegCb *regCb
)
#else
-PUBLIC S16 cmMmGlobRegInit(regCb)
+S16 cmMmGlobRegInit(regCb)
CmMmGlobRegCb *regCb;
#endif
{
Txt errMsg[256] = {'\0'};
#endif
- TRC2(cmMmGlobRegInit);
#ifdef SS_MEM_WL_DEBUG
if (cmInitBtInfo() == RFAILED)
CmMmDynRegCb *regCb;
Data *memPtr;
- TRC2(cmIccAllocWithLock);
regCb = (CmMmDynRegCb *)regionCb;
{
CmMmDynRegCb *regCb;
- TRC2(cmIccFreeWithLock);
regCb = (CmMmDynRegCb *)regionCb;
CmMmDynRegCb *regCb;
Data *memPtr;
- TRC2(cmIccAlloc);
regCb = (CmMmDynRegCb *)regionCb;
#endif
{
CmMmDynRegCb *regCb;
- TRC2(cmIccFree);
regCb = (CmMmDynRegCb *)regionCb;
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmDynRegInit
+S16 cmMmDynRegInit
(
CmMmDynRegCb *regCb
)
#else
-PUBLIC S16 cmMmDynRegInit(regCb)
+S16 cmMmDynRegInit(regCb)
CmMmDynRegCb *regCb;
#endif
{
Txt regIccStr[64] = {'\0'};
#endif
- TRC2(cmMmDynRegInit);
/* Register the region/memory with ICC and get the handler for same. The id is starting
* from region+1 as the zero is used by PHY code */
printf("\nICC Region is %d\n",regCb->region);
/* Call SRegRegion to register the memory region with SSI */
- cmMemset((U8*)®Info, 0, sizeof(regInfo));
+ memset(®Info, 0, sizeof(regInfo));
/* Register the lock region for SS_MAX_REGS - 1 region */
if((SS_MAX_REGS - 1) == regCb->region)
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmDynRegInit
+S16 cmMmDynRegInit
(
CmMmDynRegCb *regCb
)
#else
-PUBLIC S16 cmMmDynRegInit(regCb)
+S16 cmMmDynRegInit(regCb)
CmMmDynRegCb *regCb;
#endif
{
U16 idx1;
U16 numBkts;
- TRC2(cmMmDynRegInit);
/* Initialize the region control block */
region = regCb->region;
}
/* Call SRegRegion to register the memory region with SSI */
- cmMemset((U8*)®Info, 0, sizeof(regInfo));
+ memset(®Info, 0, sizeof(regInfo));
if((SS_MAX_REGS - 1) == regCb->region)
{
regInfo.alloc = cmDynAllocWithLock;
*
*/
#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)
{
S16 ret;
- TRC2(cmDynAlloc);
if((SLock(&dynAllocFreeLock)) != ROK)
{
{
CmMmDynRegCb *regCb;
- TRC2(cmDynAlloc);
regCb = (CmMmDynRegCb *)regionCb;
btInfo->btInfo[btIdx].ptr = (PTR)0;
btInfo->btInfo[btIdx].btSize = 0;
- cmMemset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
+ memset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
btInfo->btInfoIdx = btIdx;
}
#endif
#ifdef SS_4GMX_LCORE
*ptr = (Data*) MxHeapAlloc(SsiHeap, *size);
- cmMemset((U8*)ptr, 0, *size);
+ memset(ptr, 0, *size);
#else
/* *ptr = (Data*) malloc(*size); */
#endif
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmAlloc);
#ifndef USE_MEMCAL
UNUSED(flags);
/*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
-PUBLIC S16 cmInitDoubleFreeList
+S16 cmInitDoubleFreeList
(
Void
)
#else
-PUBLIC S16 cmInitDoubleFreeList()
+S16 cmInitDoubleFreeList()
#endif
{
U16 offset;
CmMemDoubleFree memNode;
- TRC2(cmInitDoubleFreeList);
offset = (U16)((PTR)(&memNode.tmpListEnt) - (PTR)&memNode);
*
*/
#ifdef ANSI
-PUBLIC Void cmAnalyseBtInfo
+Void cmAnalyseBtInfo
(
PTR ptr, /* Memory block needs to be freed */
U32 idx
)
#else
-PUBLIC Void cmAnalyseBtInfo (ptr,idx)
+Void cmAnalyseBtInfo (ptr,idx)
PTR ptr; /* Memory block needs to be freed */
U32 idx;
#endif
U8 tmpVal;
#endif
- TRC2(cmDynFree);
regCb = (CmMmDynRegCb *)regionCb;
#ifdef SS_MEM_WL_DEBUG
btInfo->btInfo[btIdx].ptr = (PTR)0;
btInfo->btInfo[btIdx].btSize = 0;
- cmMemset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
+ memset(btInfo->btInfo[bktIdx].btArr, 0, sizeof (btInfo->btInfo[bktIdx].btArr));
btInfo->btInfoIdx = btIdx;
}
prvAllocPtr[regCb->region] = NULLP;
}
- cmMemset(ptr, (regCb->region+1), bkt->size);
+ memset(ptr, (regCb->region+1), bkt->size);
#endif
/* Get the bucket node from the index returned and allocate the memory */
return ROK;
#else /* use pure is on */
- TRC2(cmDynFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
(Void)MxHeapFree(SsiHeap, ptr);
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmFree);
regCb = (CmMmRegCb *)regionCb;
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);
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
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);
{
CmMmRegCb *regCb;
- TRC2(cmCtl);
regCb = (CmMmRegCb *)regionCb;
#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 */
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
- TRC2(cmHeapFree);
/* Roundup the requested size */
size = CMM_DATALIGN(size, (heapCb->minSize));
*
*/
#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 SLogLkInfo
+Void SLogLkInfo
(
Void
)
#else
-PUBLIC Void SLogLkInfo (Void)
+Void SLogLkInfo (Void)
#endif
{
U8 idx;
Txt prntBuf[255];
S8 **funcNm;
- TRC3(SLogLkInfo);
if( memLkCb.memLkMdlInit == FALSE)
{
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 Void cmStorAllocBlk
+Void cmStorAllocBlk
(
U32 addr,
Size reqSz,
U16 bktIdx
)
#else
-PUBLIC Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
+Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
U32 addr;
Size reqSz;
Size allocSz;
MemAllocInfo *allocInfo;
U8 moduleId;
- TRC3(cmStorAllocBlk);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
/*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
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
allocInfo = (MemAllocInfo *)MxHeapAlloc(SsiHeap, sizeof(MemAllocInfo));
- cmMemset((U8*)allocInfo, 0, sizeof(MemAllocInfo));
+ memset(allocInfo, 0, sizeof(MemAllocInfo));
#else
allocInfo = (MemAllocInfo *)calloc(1, sizeof(MemAllocInfo));
#endif
*
*/
#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;
*
*/
#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] = '(';
*
*/
#ifdef ANSI
-PUBLIC Void cmRlsAllocBlk
+Void cmRlsAllocBlk
(
U32 addr
)
#else
-PUBLIC Void cmRlsAllocBlk(addr)
+Void cmRlsAllocBlk(addr)
U32 addr;
#endif
{
S32 traceSize;
MemAllocInfo *memAllocInfo;
- TRC3(cmRlsAllocBlk);
if( memLkCb.memLkMdlInit == FALSE)
{
RETVOID;
*
*/
#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)
{
*
*/
#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)
/*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
*
*/
#ifdef ANSI
-PUBLIC S32 backtrace
+S32 backtrace
(
Void **buffer,
S32 count
)
#else
-PUBLIC S32 backtrace(buffer, count)
+S32 backtrace(buffer, count)
Void **buffer;
S32 count;
#endif
{
- TRC3(backtrace);
Backtrace_t bt;
ucontext_t u;
CmMmBlkHdr *ptrBlk;
U32 blkCnt;
- TRC2(cmMmBktSanityChk);
bkt->trampleCount = 0;
#endif
{
- TRC2(cmMmHeapSanityChk);
/* increment the trample count */
heapCb->trampleCount++;
*
*/
#ifdef ANSI
-PUBLIC S16 cmMmRegIsBlkSane
+S16 cmMmRegIsBlkSane
(
CmMmBlkHdr *blkPtr
)
#else
-PUBLIC S16 cmMmRegIsBlkSane(blkPtr)
+S16 cmMmRegIsBlkSane(blkPtr)
CmMmBlkHdr *blkPtr;
#endif
{
U32 sigCnt;
- TRC2(cmMmRegIsBlkSane);
for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++)
{
U16 *idx; /* idx to return */
#endif
{
- TRC2(cmMmHashFunc);
*idx = (U16)(key % hashListCp->numOfbins);
U16 i;
CmMmHashListEnt *hl;
- TRC2(cmMmHashListInit);
/* initialize control point fields */
hashListCp->hashList = NULLP;
Pool pool; /* memory pool to allocate bins */
#endif
{
- TRC2(cmMmHashListDeinit);
/* deallocate memory for bins */
if (hashListCp->numOfbins)
U16 idx; /* index for insertion into hash list */
U16 i;
- TRC2(cmMmHashListInsert);
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
#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*/
#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*/
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 */
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 */
{
U32 i = 0;
- TRC2(cmHstGrmGetHashIdxAndKey);
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
{
U32 idx = 0;
- TRC2(cmHstGrmFillEntry);
entry->key = key;
entry->line = line;
entry->entId = entId;
U32 numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
- TRC2(cmHstGrmFindEntry);
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
}
}
-PUBLIC void DumpT2kMemLeakInfoToFile()
+void DumpT2kMemLeakInfoToFile()
{
int i;
/* For Updating SOC Specific Memory Information */
#ifdef ANSI
-PUBLIC S16 UpdateSocMemInfo
+S16 UpdateSocMemInfo
(
U8 areaIndex,
CmLteMemInfo *mInfo
)
#else
-PUBLIC S16 UpdateSocMemInfo(areaIndex,mInfo)
+S16 UpdateSocMemInfo(areaIndex,mInfo)
U8 areaIndex;
CmLteMemInfo *mInfo;
#endif
*
*/
#ifdef ANSI
-PUBLIC U32 isL2MemUsageBelowLowerThreshold(
+U32 isL2MemUsageBelowLowerThreshold(
Region region
)
#else
-PUBLIC U32 isL2MemUsageBelowLowerThreshold(region)
+U32 isL2MemUsageBelowLowerThreshold(region)
Region region;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC U32 isMemUsageBelowLowerThreshold(
+U32 isMemUsageBelowLowerThreshold(
Region region
)
#else
-PUBLIC U32 isMemUsageBelowLowerThreshold(region)
+U32 isMemUsageBelowLowerThreshold(region)
Region region;
#endif
{
*
*/
#ifdef ANSI
-PUBLIC U32 isMemThreshReached(
+U32 isMemThreshReached(
Region reg
)
#else
-PUBLIC U32 isMemThreshReached(reg)
+U32 isMemThreshReached(reg)
Region reg;
#endif
{
- TRC3(isMemThreshReached)
if(gMemoryAlarm)
{
gMemoryAlarm = !(isMemUsageBelowLowerThreshold(reg));