if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS350, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check initialization function */
if (initFnct == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS351, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS352, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS355, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* check if entity and instance already registered */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS357, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS358, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SRegInit */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS359, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check activation function */
if (actvTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS360, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task type */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS361, ERRZERO, "Invalid task type");
/* ss021.103 - Addition of return fail for invalid task type */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task priority */
if (prior > PRIOR3)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS362, ERRZERO, "Invalid task priority");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS363, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* lock TAPA task table */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS364, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS365, ERRZERO,
"Could not lock TAPA task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Modification for SRegInit not called yet */
/* check if entity and instance already registered */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS366, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS367, ERRZERO, "Too many tasks");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS368, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS369, ERRZERO,
"ActvTask already registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS370, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SDeregTTsk(ent, inst);
- RETVALUE(ret);
+ return (ret);
}
}
- RETVALUE(ret);
+ return (ret);
} /* SRegActvTsk */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS373, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS374, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* lock the TAPA task table */
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS377, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS378, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
/* deregister the TAPA task */
if (SDeregTTsk(ent, inst) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = (SsIdx) sTskId;
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS380, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
/* check if the system task is dying already */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS381, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS382, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not destroy system task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* SDeregInitTskTmr */
#endif /* SS_MULTIPLE_PROCS */
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS384, ERRZERO, "Invalid proc/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS385, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
if (actvTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS386, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task type */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS387, ERRZERO, "Invalid task type");
/* ss021.103 - Addition of return fail for invalid task type */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task priority */
if (prior > PRIOR3)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS388, ERRZERO, "Invalid task priority");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not find proc table index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
{
SSLOGERROR(ERRCLS_DEBUG, ESS390, 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, ESS392, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS394, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* check if entity and instance already registered */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS396, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS397, ERRZERO,
"Could not give the Semaphore");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SRegTTsk */
/* ss002.301 Additions */
/*
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRegCbTsk() : Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cbTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, " SRegCbTsk() : Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
" SRegCbTsk() : Could not find proc table index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ERRZERO,
"SRegCbTsk() : Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MULTIPLE_PROCS
{
SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRegCbTsk() : Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tTsk = &osCp.tTskTbl[idx];
/* unlock the table */
SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
- RETVALUE(ROK);
+ return ROK;
}
\f
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS398, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS399, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
SSLOGERROR(ERRCLS_DEBUG, ESS400, ERRZERO,
"Could not find proc id index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
SSLOGERROR(ERRCLS_DEBUG, ESS401, ERRZERO,
"Could not lock timer table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (idx = 0; idx < SS_MAX_TMRS; idx++)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS402, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS403, ERRZERO,
"Could not deregister task's timer(s)");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS404, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
/* ss002.301 Additions */
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SSLOGERROR(ERRCLS_INT_PAR, ESS412, ERRZERO, "Unknown task");
/* ss002.301 Additions */
- RETVALUE(RFAILED);
+ return RFAILED;
}
tTsk = &osCp.tTskTbl[idx];
SSLOGERROR(ERRCLS_DEBUG, ESS415, ERRZERO, "Could not get a message");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update message*/
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_INT_PAR, ESS416, ERRZERO, "Could not write to demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* SDeregTTsk */
\f
if (tskId == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS417, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check system task priority */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS418, ERRZERO,
"Invalid system task priority");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS420, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_SINGLE_THREADED */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS421, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_ADD_RES, ESS422, ERRZERO, "Too many system tasks");
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS423, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not initialize demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* initialize the system task entry lock */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS425, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not initialize system task entry lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS427, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not create system task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* success, update the table */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS429, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SCreateSTsk */
/* Initialize the lock, return on failure */
if( SInitLock(&(osCp.logger.bufLock),SS_LOCK_MUTEX) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
} /* if */
SLock(&osCp.logger.bufLock);
if( osCp.logger.started == TRUE)
{
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set the mode of the logging */
{
SDisplay(0,"Error Opening Log File \n");
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
strcpy(osCp.logger.filePath,path);
}
{
SDisplay(0, "Error at WSAStartup!\n");
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
osCp.logger.socketdes = socket(AF_INET, SOCK_DGRAM, 0);
WSACleanup();
#endif
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* bind to local address */
localAddr.sin_family = AF_INET;
close(osCp.logger.socketdes);
#endif
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* remote address */
remoteAddr.sin_family = AF_INET;
close(osCp.logger.socketdes);
#endif
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
remoteAddr.sin_addr.s_addr = inet_addr(IPA);
osCp.logger.remoteAddr = remoteAddr;
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
} /* SRegLogCfg */
/*
{
writeNum = sendto(osCp.logger.socketdes, buffer, cmStrlen((U8 *)buffer), 0, (struct sockaddr*)&osCp.logger.remoteAddr, sizeof(osCp.logger.remoteAddr));
/*ss013.301 : Returned after sending to socket*/
- RETVALUE(ROK);
+ return ROK;
}
osCp.logger.curNumFlush++;
if(osCp.logger.curNumFlush == osCp.logger.maxNumFlush)
/*SPutSBuf(DFLT_REGION,DFLT_POOL,
(Data *)buffer, (Size)(osCp.logger.maxBufSiz * sizeof(S8)));*/
- RETVALUE(ROK);
+ return ROK;
} /* SFlushBufToLog */
/*
if(osCp.logger.started == FALSE)
{
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
}
if(osCp.logger.curBufSiz)
{
signal(SIGINT, App_SigExitCallBack);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of SCleanUp */
SCleanUp();
- RETVALUE(ROK);
+ return ROK;
} /* SDeregLogCfg */
cpuInfo->numCores < 1 || cpuInfo->threadsPerCore < 1 )
{
SSLOGERROR(ERRCLS_INT_PAR, ESS430, ERRZERO, "Invalid number of cores\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* lock mCInfo */
/* unlock mCInfo */
SUnlock(&osCp.mCILock);
- RETVALUE(ROK);
+ return ROK;
} /* SRegCpuInfo */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS431, ERRZERO, "Failed to get affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
- RETVALUE(ROK);
+ return ROK;
} /* SGetAffinity */
mode > SS_AFFINITY_MODE_EXCL)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS432, ERRZERO, "Invalid mode for setting core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* check the value of core id */
(coreId > osCp.mCInfo.cpuInfo.numCores || coreId < 0))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS433, ERRZERO, "Invalid core id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* set affinity according to the mode supplied */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS434, ERRZERO, \
"Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS436, ERRZERO,\
"Can not set core affinity, core is exclusively used for other task\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* call the implementation specific affinity function with the core id supplied by caller */
ret = ssdSetAffinity(tskId, coreId);
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS437, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS439, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS441, ERRZERO,
"Can not set core affinity, core is exclusively used for other task\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end else */
tskNotFound = FALSE;
break;
if (coreIndex == SS_MAX_CORES)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS442, ERRZERO, "Invalid core id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* if */
break;
} /* end case SS_AFFINITY_MODE_ASSOC */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS443, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS444, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS445, ERRZERO,
"Failed to set core affinity, no threads on cores available\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if no thrs on cores available */
} /* else if */
else
{
SSLOGERROR(ERRCLS_INT_PAR, ESS446, ERRZERO, "Can not set exclusive affinity for the core\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end else */
break;
} /* end case SS_AFFINITY_MODE_EXCL */
default:
{
SSLOGERROR(ERRCLS_INT_PAR, ESS447, ERRZERO, "Invalid mode for setting core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end default case */
} /* end of switch */
- RETVALUE(ROK);
+ return ROK;
} /* SSetAffinity */
if (tskId >= SS_MAX_STSKS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS448, (ErrVal) tskId, "Invalid task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS450, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS451, (ErrVal) idx,
"Invalid system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (sTsk->termPend != FALSE)
{
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS452, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS453, (ErrVal) idx,
"Invalid system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS454, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock system task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS456, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS457, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS459, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS460, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not destroy system task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* multi-core support */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS462, ERRZERO,
"Could not unlock the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* SDestroySTsk */
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS463, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
/* check entity and instance range */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS464, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS465, (ErrVal) sTskId,
"Invalid system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS466, ERRZERO,
"Could not find proc id index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS468, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS469, (ErrVal) sTskId,
"Unknown system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS470, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock system task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS472, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS473, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS474, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS475, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS477, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS478, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS479, ERRZERO, "Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS480, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS481, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS482, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS483, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
"Could not find proc table index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
(Void)(tTsk->initTsk)(tTsk->proc, tTsk->ent, tTsk->inst, sTsk->region, PWR_UP, &xxCb);
/*
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS484, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS485, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#else /* SS_MULTIPLE_PROCS */
SDetachTTsk(ent, inst);
#endif /* SS_MULTIPLE_PROCS */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SAttachTTsk */
\f
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS486, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
/* check entity and instance ranges */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS487, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS488, ERRZERO,
"Could not find proc id index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS490, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS492, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS493, ERRZERO, "Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS494, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS495, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock system task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS497, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
if ( SUnlock(&osCp.sTskTblLock) != ROK)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS498, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS500, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS501, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
*/
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SDetachTTsk */
\f
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS502, ERRZERO, "Invalid message buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check the pst structure */
{
SPutMsg(mBuf);
SSLOGERROR(ERRCLS_INT_PAR, ESS503, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to check for valid route */
/* ss023.103 - Modification to fix bug in route validation */
{
SPutMsg(mBuf);
SSLOGERROR(ERRCLS_INT_PAR, ESS504, ERRZERO, "No route defined");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS506, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS507, ERRZERO,
"Invalid source/destination entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS508, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not lock router task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* call the router activation function */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS510, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS511, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE((r == RFAILED) ? RFAILED : ROK);
+ return ((r == RFAILED) ? RFAILED : ROK);
}
}
#endif /* SS_RTR_SUPPORT */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS512, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS513, ERRZERO, "Unknown task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS514, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS515, ERRZERO, "Unknown task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS516, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not lock driver task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef L2_L3_SPLIT
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS519, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#ifdef L2_L3_SPLIT
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS520, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS521, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not find a driver task to handle this proc ID");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_DRVR_SUPPORT */
/* ss002.301 Modifications */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS512, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS513, ERRZERO, "call back function failed\n");
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_MULTIPLE_PROCS
dstIdx = osCp.tTskIds[dstProcIdIdx][tempPst.dstEnt][tempPst.dstInst];
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS527, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
if( ret != ROK )
{
/* No need to free the buffer, its already done in called fun */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate for the mBuf */
if( workPtr == NULLP )
{
SPutFpaMsg(wqBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Convert the pointers to physical address */
if( ret != ROK )
{
SPutFpaMsg(wqBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Assign the values for work ptr */
cvmx_pow_work_submit(workPtr, workPtr->tag, workPtr->tag_type, \
workPtr->qos, workPtr->grp);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_SEUM_CAVIUM */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS523, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Destination TAPA task is not attached");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_LOCKLESS_MEMORY
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS525, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not write to demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS527, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
*/
ssdPstTsk(tempPst, mBuf, tTsk);
- RETVALUE(ROK);
+ return ROK;
} /* SPstTsk */
/* ss001.301: additions */
ent[tskCnt] = osCp.tTskTbl[tskCnt].ent;
}
- RETVALUE(ROK);
+ return ROK;
} /* SGetTapaTskEntIds */
/*
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(tskCnt = 0; tskCnt < osCp.numTTsks; tskCnt++)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS639, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SGetTapaTskEntIds */
/*
*hstReg = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* SGetTapaTskEntIds */
#endif /* SS_HISTOGRAM_SUPPORT */
#endif
SPrint(prntBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
/* Implicit watchdog stop during dereg */
SStopHrtBt();
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
ssdStartWatchDgTmr(NULLP, SS_TMR_HRTBT, timeInterval);
ssdSndHrtBtMsg(TRUE, SS_WD_HB_REQ);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
osCp.wdCp.globWd.watchdogStop = 1;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
);
SPrint(prntBuf);
#endif /* DEBUGP */
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
#endif /* DEBUGP */
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_WATCHDOG */
if ((procId == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS463, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
/* check entity and instance range */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS464, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
#endif
ret = SLock(&osCp.sTskTblLock);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (procIdIdx == SS_INV_PROCID_IDX)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = osCp.tTskIds[procIdIdx][ent][inst];
if(tTsk == NULLP )
{
SUnlock(&osCp.sTskTblLock);
- RETVALUE(RFAILED);
+ return RFAILED;
}
*curEvent = osCp.tTskTbl[idx].curEvent;
*curEvtTime = osCp.tTskTbl[idx].curEvtTime;
*sTskId = osCp.tTskTbl[idx].sTsk->tskId;
SUnlock(&osCp.sTskTblLock);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_THREAD_PROFILE */