/*ss014.301: SSI-4GMX related changes*/
#ifdef SS_4GMX_LCORE
-PUBLIC VOLATILE SsOs osCp; /* common OS control point */
+VOLATILE SsOs osCp; /* common OS control point */
#else
-PUBLIC SsOs osCp; /* common OS control point */
+SsOs osCp; /* common OS control point */
#endif
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
PRIVATE void InitializeForStaticMemLeak ARGS((void));
PRIVATE void InitializeStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo));
-PUBLIC U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
-PUBLIC void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo* memAllocInfo,U32 size, char*
+U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
+void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo* memAllocInfo,U32 size, char*
file, U32 line));
-PUBLIC void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char* file,
+void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char* file,
U32 line, U32 size, void* ptr, U32 idx));
PRIVATE void PrintStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo, FILE
*opFile));
#endif
/* ss001.301: additions */
-PUBLIC void DumpSSIDemandQDebugInformation()
+void DumpSSIDemandQDebugInformation()
{
U32 i,j;
RTLIN_DUMP_DEBUG("Demand Q Information\n");
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
pthread_mutex_t dumpingLock = PTHREAD_MUTEX_INITIALIZER;
-PUBLIC Void mtSigSegvHndlr()
+Void mtSigSegvHndlr()
{
int i;
sleep(5);
}
-PUBLIC Void mtSigUsr2Hndlr()
+Void mtSigUsr2Hndlr()
{
printf("Backtrace for thread Id (%lu) cause:SIGUSR2(%d)\n",(unsigned long) pthread_self(),SIGUSR2);
*
*/
#ifdef ANSI
-PUBLIC S16 SInit
+S16 SInit
(
void
)
#else
-PUBLIC S16 SInit()
+S16 SInit()
#endif
{
S16 ret;
SsDrvrTskEntry *drvrTsk;
#endif
/* ss002.301 : Modications */
- TRC1(SInit);
osCp.configFilePath = "/mnt/tmp/configFile";
#endif /* SS_MULTIPLE_PROCS */
#ifdef SS_THR_REG_MAP
- cmMemset(osCp.threadMemoryRegionMap, SS_INVALID_THREAD_REG_MAP,
+ memset(osCp.threadMemoryRegionMap, SS_INVALID_THREAD_REG_MAP,
(sizeof(Region) * SS_MAX_THREAD_REGION_MAP));
ssRegMainThread();
#endif
sprintf(prntBufLoc,"\n SInit(): ssdInitGen failed to initialize\
implementation specific general information \n");
SDisplay(1,prntBufLoc);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
ssdStart();
- RETVALUE(ROK);
+ return ROK;
/* clean up code */
ssdDeinitGen();
- RETVALUE(RFAILED);
+ return RFAILED;
}
\f
*
*/
#ifdef ANSI
-PUBLIC S16 SDeInit
+S16 SDeInit
(
void
)
#else
-PUBLIC S16 SDeInit()
+S16 SDeInit()
#endif
{
/* ss007.301 */
U16 regCnt;
- TRC1(SDeInit);
-
ssdDeinitTmr();
SDestroyLock(&osCp.tmrTblLock);
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS014, ERRZERO,
"Could not destroy the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS015, ERRZERO,
"Could not destroy the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SDestroyLock(&(osCp.logger.bufLock));
#endif /* SS_LOGGER_SUPPORT */
ssdDeinitLog();
- RETVALUE(ROK);
+ return ROK;
}
/* ss001.301: additions */
#ifdef SS_LOGGER_SUPPORT
#ifdef ANSI
-PUBLIC S16 SWrtLogBuf
+S16 SWrtLogBuf
(
Txt *buf /* buffer */
)
#else
-PUBLIC S16 SWrtLogBuf(buf)
+S16 SWrtLogBuf(buf)
Txt *buf; /* buffer */
#endif
{
S16 bufSz;
- TRC1(SWrtLogBuf);
/* buffer synchronisation*/
bufSz = cmStrlen((U8 *)buf);
SLock(&osCp.logger.bufLock);
if(osCp.logger.started == FALSE)
{
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
}
/*
* Append the buffer to the global buffer
{
SFlushBufToLog(osCp.logger.buffer);
osCp.logger.curBufSiz = 0;
- cmMemset((U8 *)osCp.logger.buffer, '\0', osCp.logger.maxBufSiz);
+ memset(osCp.logger.buffer, '\0', osCp.logger.maxBufSiz);
sprintf(osCp.logger.buffer, "%s", buf);
osCp.logger.curBufSiz += bufSz;
}
osCp.logger.curBufSiz += bufSz;
}
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_LOGGER_SUPPORT */
/*
*
*/
#ifdef ANSI
-PUBLIC S16 SPrint
+S16 SPrint
(
Txt *buf /* buffer */
)
#else
-PUBLIC S16 SPrint(buf)
+S16 SPrint(buf)
Txt *buf; /* buffer */
#endif
{
- TRC1(SPrint);
/* ss001.301: additions */
SDisplay(0, buf);
SWrtLogBuf(buf);
#endif /* SS_LOGGER_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
} /* end of SPrint */
*
*/
#ifdef ANSI
-PUBLIC S16 SError
+S16 SError
(
Seq seq, /* sequence */
Reason reason /* reason */
)
#else
-PUBLIC S16 SError(seq, reason)
+S16 SError(seq, reason)
Seq seq; /* sequence */
Reason reason; /* reason */
#endif
DateTime dt;
Txt errBuf[256];
-
- TRC1(SError);
-
-
SGetDateTime(&dt);
sprintf(errBuf, "\n\ndate: %02d/%02d/%04d time: %02d:%02d:%02d\n",
(int)dt.month,(int)dt.day,(int)dt.year + 1900,
ret = ssdError(seq, reason);
- RETVALUE(ret);
+ return (ret);
}
\f
*
*/
#ifdef ANSI
-PUBLIC Void SLogError
+Void SLogError
(
Ent ent, /* Calling layer's entity id */
Inst inst, /* Calling layer's instance id */
Txt *errDesc /* description of error */
)
#else
-PUBLIC Void SLogError(ent, inst, procId, file, line,
+Void SLogError(ent, inst, procId, file, line,
errCls, errCode, errVal, errDesc)
Ent ent; /* Calling layer's entity id */
Inst inst; /* Calling layer's instance id */
Txt errBuf[512];
- TRC1(SLogError);
-
/*ss014.301: SSI-4GMX related changes*/
#ifndef SS_4GMX_LCORE
SGetDateTime(&dt);
*
*/
#ifdef ANSI
-PUBLIC ProcId SFndProcId
+ProcId SFndProcId
(
void
)
#else
-PUBLIC ProcId SFndProcId()
+ProcId SFndProcId()
#endif
{
- TRC1(SFndProcId);
- RETVALUE(osCp.procId);
+ return (osCp.procId);
} /* end of SFndProcId */
\f
*
*/
#ifdef ANSI
-PUBLIC Void SSetProcId
+Void SSetProcId
(
ProcId procId
)
#else
-PUBLIC Void SSetProcId(procId)
+Void SSetProcId(procId)
ProcId procId;
#endif
{
- TRC1(SSetProcId);
osCp.procId = procId;
*
*/
#ifdef ANSI
-PUBLIC U16 SGetProcIdIdx
+U16 SGetProcIdIdx
(
ProcId proc
)
#else
-PUBLIC U16 SGetProcIdIdx(proc)
+U16 SGetProcIdIdx(proc)
ProcId proc;
#endif
{
U16 i;
U16 idx;
- TRC1(SGetProcIdIdx);
-
idx = SS_HASH_IDX(proc);
for (i = idx; i < SS_MAX_PROCS; i++)
if (osCp.procLst.procId[i] == proc)
return i;
- RETVALUE(SS_INV_PROCID_IDX);
+ return (SS_INV_PROCID_IDX);
} /* SGetProcIdIdx */
\f
U16 i;
U16 idx;
- TRC1(SInsProcId);
idx = SS_HASH_IDX(proc);
{
osCp.procLst.procId[i] = proc;
osCp.procLst.free--;
- RETVALUE(ROK);
+ return ROK;
}
/* search for free entry upto idx */
{
osCp.procLst.procId[i] = proc;
osCp.procLst.free--;
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* SInsProcId */
\f
U16 i;
U16 idx;
- TRC1(SRemProcId);
idx = SS_HASH_IDX(proc);
{
osCp.procLst.procId[i] = SS_INV_PROCID;
osCp.procLst.free++;
- RETVALUE(ROK);
+ return ROK;
}
/* search upto idx */
{
osCp.procLst.procId[i] = SS_INV_PROCID;
osCp.procLst.free++;
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* SRemProcId */
\f
{
S16 ret;
- TRC1(SLockOsCp);
ret = SLock(&osCp.sTskTblLock);
if (ret != ROK)
{
SSLOGERROR(ERRCLS_DEBUG, ESS016, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS018, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SLockOsCp */
PRIVATE S16 SULockOsCp(Void)
#endif
{
- TRC1(SULockOsCp);
/* unlock the table */
SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS019, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SULockOsCp */
*
*/
#ifdef ANSI
-PUBLIC S16 SAddProcIdLst
+S16 SAddProcIdLst
(
U16 numPIds,
ProcId *pIdLst
)
#else
-PUBLIC S16 SAddProcIdLst(numPIds, pIdLst)
+S16 SAddProcIdLst(numPIds, pIdLst)
U16 numPIds;
ProcId *pIdLst;
#endif
U16 i;
S16 ret;
- TRC1(SAddProcIdLst);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* range check */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS020, ERRZERO, "number of proc Ids exceeds\
limit");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* find if the entry exist in the table */
if (pIdLst[i] == SS_INV_PROCID)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS021, ERRZERO, "Invalid proc Ids");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if (SLockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#if (ERRCLASS & ERRCLS_INT_PAR)
for (i = 0; i < numPIds; i++)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS022, ERRZERO, "Duplicate proc id");
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (numPIds > osCp.procLst.free)
SSLOGERROR(ERRCLS_INT_PAR, ESS023, ERRZERO, "Total number of proc id \
exceeds");
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not insert the proc id");
#endif
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* unlock the table */
if (SULockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ret);
+ return (ret);
} /* SAddProcIdLst */
\f
*
*/
#ifdef ANSI
-PUBLIC S16 SRemProcIdLst
+S16 SRemProcIdLst
(
U16 numPIds,
ProcId *pIdLst
)
#else
-PUBLIC S16 SRemProcIdLst(numPIds, pIdLst)
+S16 SRemProcIdLst(numPIds, pIdLst)
U16 numPIds;
ProcId *pIdLst;
#endif
{
U16 i;
- TRC1(SRemProcIdLst);
#if (ERRCLASS & ERRCLS_INT_PAR)
/* range check */
if (numPIds > SS_MAX_PROCS)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
if (SLockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (numPIds > (SS_MAX_PROCS - osCp.procLst.free))
{
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* find if the entry exist in the table */
if (SGetProcIdIdx(pIdLst[i]) == SS_INV_PROCID_IDX)
{
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SRemProcId(pIdLst[i]);
if (SULockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
} /* SRemProcIdLst */
\f
*
*/
#ifdef ANSI
-PUBLIC S16 SGetProcIdLst
+S16 SGetProcIdLst
(
U16 *numPIds,
ProcId *pIdLst
)
#else
-PUBLIC S16 SGetProcIdLst(numPIds, pIdLst)
+S16 SGetProcIdLst(numPIds, pIdLst)
U16 *numPIds;
ProcId *pIdLst;
#endif
U16 i;
U16 count = 0;
- TRC1(SGetProcIdLst);
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((numPIds == NULLP) || (pIdLst == NULLP))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS025, ERRZERO, "Invalid numPIds/pIdLst");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (SLockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = 0; i < SS_MAX_PROCS; i++)
{
*numPIds = count;
if (SULockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (count == 0)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
} /* SGetProcIdLst */
\f
*
*/
#ifdef ANSI
-PUBLIC S16 SGetXxCb
+S16 SGetXxCb
(
ProcId proc,
Ent ent,
Void **xxCb
)
#else
-PUBLIC S16 SGetXxCb(proc, ent, inst, xxCb)
+S16 SGetXxCb(proc, ent, inst, xxCb)
ProcId proc;
Ent ent;
Inst inst;
U16 procIdIdx;
SsIdx idx;
- TRC1(SGetXxCb);
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS026, ERRZERO, "Invalid proc/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
SSLOGERROR(ERRCLS_INT_PAR, ESS027, ERRZERO, "Could not get proc table idx");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = osCp.tTskIds[procIdIdx][ent][inst];
if (idx == SS_TSKNC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* update the CB */
*xxCb = osCp.tTskTbl[idx].xxCb;
/*ss032.103 added a check for NULLP */
if (*xxCb == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
} /* SGetXxCb */
#endif /* SS_MULTIPLE_PROCS */
*
*/
#ifdef ANSI
-PUBLIC S16 SFillEntIds
+S16 SFillEntIds
(
Void
)
#else
-PUBLIC S16 SFillEntIds(Void)
+S16 SFillEntIds(Void)
#endif
{
W X Y Z */
{ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
/* K */ ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC, ENTNC,
- ENTKW, ENTNC, ENTNC, ENTNC},
+ ENTRLC, ENTNC, ENTNC, ENTNC},
/* A B C D E F G H I J K *
L M N O P Q R S T U V *
W X Y Z */
};
/*ss013.301 :Adding TRC MACRO*/
- TRC2(SFillEntIds)
memcpy((U8*)osCp.entId, (U8*)entInfo, sizeof(entInfo));
- RETVALUE(ROK);
+ return ROK;
} /* SFillEntIds */
*
*/
#ifdef ANSI
-PUBLIC S16 SGetEntInd
+S16 SGetEntInd
(
Ent *entId,
U8 *fileName
)
#else
-PUBLIC S16 SGetEntInd(entId, fileName)
+S16 SGetEntInd(entId, fileName)
Ent *entId;
U8 *fileName;
#endif
U8 firstIdx = 0;
U8 secondIdx = 0;
- TRC1(SGetEntInd);
/* ss002.301 Additions */
if ((strippedName = strrchr((const char *)fileName, '/')))
if (letter[1] == 'g' && letter[2] == 'u')
{
*entId = ENTGT;
- RETVALUE(ROK);
+ return ROK;
}
default:
break;
if(letter[count] < 'a' || letter[count] > 'z')
{
*entId = ENTNC;
- RETVALUE(ROK);
+ return ROK;
}
else
{
/* First two letter of file name are alphabets the get the
* entity id from the static data base which is loaded in sFillEntIds() */
*entId = osCp.entId[firstIdx][secondIdx];
- RETVALUE(ROK);
+ return ROK;
} /* SGetEntInd */
#endif /* SS_HISTOGRAM_SUPPORT */
*
*/
#ifdef ANSI
-PUBLIC S16 SLockNew
+S16 SLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SLockNew(lockId, lockType)
+S16 SLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
{
S16 retVal = ROK;
- TRC1(SLockNew);
if((retVal = ssdLockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SLockNew(): Failed to aquire the lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
*
*/
#ifdef ANSI
-PUBLIC S16 SInitLockNew
+S16 SInitLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SInitLockNew(lockId, lockType)
+S16 SInitLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
{
S16 retVal = ROK;
- TRC1(SInitLockNew);
if((retVal = ssdInitLockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SInitLockNew(): Initialization of lock Failed\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
*
*/
#ifdef ANSI
-PUBLIC S16 SUnlockNew
+S16 SUnlockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SUnlockNew(lockId, lockType)
+S16 SUnlockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
{
S16 retVal = ROK;
- TRC1(SUnlockNew);
if((retVal = ssdUnlockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SUnlockNew(): Failed to release the lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
*
*/
#ifdef ANSI
-PUBLIC S16 SDestroyLockNew
+S16 SDestroyLockNew
(
SLockInfo *lockId,
U8 lockType
)
#else
-PUBLIC S16 SDestroyLockNew(lockId, lockType)
+S16 SDestroyLockNew(lockId, lockType)
SLockInfo *lockId;
U8 lockType;
#endif
{
S16 retVal = ROK;
- TRC1(SDestroyLockNew);
if((retVal = ssdDestroyLockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SDestroyLockNew(): Failed to destroy the lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_LOCK_SUPPORT */
}
}
-PUBLIC void DumpStaticMemLeakFiles()
+void DumpStaticMemLeakFiles()
{
int i;
*
*/
#ifdef ANSI
-PUBLIC S16 SReInitTmr
+S16 SReInitTmr
(
void
)
#else
-PUBLIC S16 SReInitTmr()
+S16 SReInitTmr()
#endif
{
U8 ret = ROK;
{
/*ss012.301 : Fix log related issue to suite MT and NS implementations*/
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SReInitTmr(): Failed to Restart the Tmr\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
* File: ss_gen.c
*
*/
-PUBLIC S8* SGetConfigPath(Void)
+S8* SGetConfigPath(Void)
{
return osCp.configFilePath;
}