wait_queue_head_t osl_waitqueue_create
(
int options /* semaphore option modes */
)
{
SEM_ID semId;/*lint !e578 */
if ((semId = (SEM_ID) objAlloc (semClassId)) == NULL)
return (NULL);
/* initialize allocated semaphore */
if (semQueueInit (semId, options, 0) != OK)
{
objFree (semClassId, (char *) semId);
return (NULL);
}
/* mark object memory to be freed during automatic resource reclamation */
/*lint -save -e115*/
OBJ_SET_DEALLOC_MEM (&semId->objCore);
/*lint -restore +e115*/
#ifdef _WRS_CONFIG_SV_INSTRUMENTATION
/* system viewer - level 1 event logging */
EVT_OBJ_3 (semId, semClassId, EVENT_SEMCCREATE,
semId, options, initialCount);
#endif /* _WRS_CONFIG_SV_INSTRUMENTATION */
return (wait_queue_head_t)(semId);
}
STATUS semDestroy(SEM_ID semId, BOOL dealloc)
{
int level;
level = intLock();
if(!IS_CLASS(semId, semClassId))
{
return (ERROR);
}
objCoreTerminate(&semId->objCore);
kernelState = TRUE;
intUnlock(level);
kernelSemDelete(semId);
TASK_SAFE();
kernelExit();
if(dealloc)
{
objFree(semClassId, (char*)semId);
}
TASK_UNSAFE();
return (OK);
}
SEM_ID semBCreate(
int options,
SEM_B_STATE state
)
{
SEM_ID semId;
/* Check if lib is installed */
if (semBLibInstalled != TRUE)
{
errnoSet(S_semLib_NOT_INSTALLED);
semId = NULL;
}
else
{
/* Allocate memory */
semId = (SEM_ID) objAlloc(semClassId);
if (semId != NULL)
{
/* Initialze structure */
if (semBInit(semId, options, state) != OK)
{
objFree(semClassId, semId);
semId = NULL;
}
}
}
return semId;
}
STATUS vmContextDestroy(
VM_CONTEXT_ID context
)
{
STATUS status;
/* Verify object class */
if (OBJ_VERIFY(context, vmContextClassId) != OK)
{
status = ERROR;
}
else
{
semTake(&context->sem, WAIT_FOREVER);
if (MMU_TRANS_TABLE_DESTROY(context->mmuTransTable) != OK)
{
status = ERROR;
}
else
{
/* Free datastructure */
objFree(vmContextClassId, context);
status = OK;
}
}
return status;
}
WDOG_ID wdCreate (void)
{
WDOG_ID wdId;
#ifdef WV_INSTRUMENTATION
int level;
#endif
if ((!wdLibInstalled) && (wdLibInit () != OK))
return (NULL); /* package init problem */
wdId = (WDOG_ID) objAlloc (wdClassId);
/* initialize allocated watchdog */
if ((wdId != NULL) && (wdInit (wdId) != OK))
{
objFree (wdClassId, (char *) wdId);
return (NULL);
}
#ifdef WV_INSTRUMENTATION
/* windview - level 1 event logging */
level = intLock ();
EVT_OBJ_1 (OBJ, wdId, wdClassId, EVENT_WDCREATE, wdId);
intUnlock (level);
#endif
return (wdId);
}
SEM_ID semBCreate
(
int options, /* semaphore options */
SEM_B_STATE initialState /* initial semaphore state */
)
{
SEM_ID semId;
if ((!semBLibInstalled) && (semBLibInit () != OK)) /* initialize package */
{
return (NULL);
}
if ((semId = (SEM_ID) objAlloc (semClassId)) == NULL)
{
return (NULL);
}
/* initialize allocated semaphore */
if (semBInit (semId, options, initialState) != OK)
{
objFree (semClassId, (char *) semId);
return (NULL);
}
return (semId);
}
WDOG_ID wdCreate(
void
)
{
WDOG_ID wdId;
if (wdLibInstalled != TRUE)
{
wdId = NULL;
}
else
{
/* Allocate struct */
wdId = (WDOG_ID) objAlloc(wdClassId);
if (wdId != NULL)
{
/* Initialize object */
if (wdInit(wdId) != OK)
{
objFree(wdClassId, wdId);
wdId = NULL;
}
}
}
return wdId;
}
VM_CONTEXT_ID vmContextCreate(
void
)
{
VM_CONTEXT_ID context;
if (vmLibInstalled != TRUE)
{
errnoSet(S_vmLib_NOT_INSTALLED);
context = NULL;
}
else
{
/* Allocate object */
context = (VM_CONTEXT *) objAlloc(vmContextClassId);
if (context != NULL)
{
/* Initialize structure */
if (vmContextInit(context) != OK)
{
objFree(vmContextClassId, context);
context = NULL;
}
}
}
return context;
}
static STATUS msgQDestroy(MSG_Q_ID msgQId, BOOL dealloc)
{
Q_JOB_NODE* pNode;
FAST int timeout;
FAST int nMsgs;
/* TODO isr not allowed */
TASK_SAFE();
TASK_LOCK();
if(!IS_CLASS(msgQId, msgQClassId))
{
TASK_UNLOCK();
TASK_UNSAFE();
return (ERROR);
}
objCoreTerminate(&msgQId->objCore);
TASK_UNLOCK();
timeout = NO_WAIT;
nMsgs = 0;
while(nMsgs < msgQId->maxMsgs)
{
while(((pNode = qJobGet(msgQId, &msgQId->freeQ, timeout)) != NULL) &&
(pNode != (Q_JOB_NODE*)NONE))
{
nMsgs++;
}
while(((pNode = qJobGet(msgQId, &msgQId->msgQ, timeout)) != NULL) &&
(pNode != (Q_JOB_NODE*)NONE))
{
nMsgs++;
}
timeout = 1;
}
kernelState = TRUE;
qJobTerminate(&msgQId->msgQ);
qJobTerminate(&msgQId->freeQ);
kernelExit();
if(dealloc)
{
objFree(msgQClassId, (char*)msgQId);
}
TASK_UNSAFE();
return (OK);
}
STATUS wdDestroy(
WDOG_ID wdId,
BOOL dealloc
)
{
STATUS status;
int level;
/* Not callable from interrupts */
if (INT_RESTRICT() != OK)
{
status = ERROR;
}
else
{
/* Lock interrupts */
INT_LOCK(level);
/* Verify object */
if (OBJ_VERIFY(wdId, wdClassId) != OK )
{
INT_UNLOCK(level);
status = ERROR;
}
else
{
/* Terminate object */
objCoreTerminate(&wdId->objCore);
/* Enter kernel */
kernelState = TRUE;
/* Unlock interrupts */
INT_UNLOCK(level);
/* Cancel watchdog timer */
vmxWdCancel(wdId);
wdId->status = WDOG_DEAD;
taskSafe();
/* Exit kernel */
vmxExit();
/* Deallocate if requested */
if (dealloc == TRUE)
{
objFree(wdClassId, wdId);
}
taskUnsafe();
status = OK;
}
}
return status;
}
STATUS hashTblDestroy
(
HASH_ID hashId, /* id of hash table to destroy */
BOOL dealloc /* deallocate associated memory */
)
{
if (OBJ_VERIFY (hashId, hashClassId) != OK)
return (ERROR); /* invalid hash id */
objCoreTerminate (&hashId->objCore); /* terminate core */
if (dealloc)
return (objFree (hashClassId, (char *) hashId));
return (OK);
}
STATUS semDestroy(
SEM_ID semId,
BOOL deallocate
)
{
STATUS status;
int level;
if (INT_RESTRICT() != OK)
{
errnoSet(S_intLib_NOT_ISR_CALLABLE);
status = ERROR;
}
else
{
INT_LOCK(level);
if (OBJ_VERIFY(semId, semClassId) != OK)
{
INT_UNLOCK(level);
status = ERROR;
}
else
{
objCoreTerminate(&semId->objCore);
/* Delete it */
kernelState = TRUE;
INT_UNLOCK(level);
vmxSemDelete(semId);
taskSafe();
vmxExit();
if (deallocate == TRUE)
{
objFree(semClassId, semId);
}
taskUnsafe();
status = OK;
}
}
return status;
}
STATUS wdDestroy
(
WDOG_ID wdId, /* ID of watchdog to terminate */
BOOL dealloc /* dealloc associated memory */
)
{
int level;
if (INT_RESTRICT () != OK) /* restrict isr use */
return (ERROR);
level = intLock (); /* LOCK INTERRUPTS */
if (OBJ_VERIFY (wdId, wdClassId) != OK) /* validate watchdog ID */
{
intUnlock (level); /* UNLOCK INTERRUPTS */
return (ERROR);
}
#ifdef WV_INSTRUMENTATION
/* windview - level 1 event logging */
EVT_OBJ_1 (OBJ, wdId, wdClassId, EVENT_WDDELETE, wdId);
#endif
objCoreTerminate (&wdId->objCore); /* invalidate watchdog */
kernelState = TRUE; /* KERNEL ENTER */
intUnlock (level); /* UNLOCK INTERRUPTS */
windWdCancel (wdId); /* cancel watchdog */
wdId->status = WDOG_DEAD; /* dead dog */
TASK_SAFE (); /* TASK SAFE */
windExit (); /* EXIT KERNEL */
if (dealloc)
objFree (wdClassId, (char *) wdId); /* deallocate watchdog */
TASK_UNSAFE (); /* TASK UNSAFE */
return (OK);
}
MSG_Q_ID msgQCreate(int maxMsgs, int maxMsgLength, int options)
{
MSG_Q_ID msgQId;
void * pPool; /* pointer to memory for messages */
UINT size = (UINT) maxMsgs * MSG_NODE_SIZE (maxMsgLength);
/* TODO restrict ISR from calling */
if ((!msgQLibInstalled) && (msgQLibInit () != OK))
return (NULL); /* package init problem */
if ((msgQId = (MSG_Q_ID)objAllocExtra (msgQClassId, size, &pPool)) == NULL)
return (NULL);
if (msgQInit (msgQId, maxMsgs, maxMsgLength, options, pPool) != OK)
{
objFree (msgQClassId, (char *) msgQId);
return (NULL);
}
return ((MSG_Q_ID) msgQId);
}
static void testObjectSerialization(CuTest *tc, const char *sample,
int (*parse)(KSI_CTX *, unsigned char *, size_t, void **),
int (*serialize)(void *, unsigned char **, size_t *),
void (*objFree)(void *)) {
int res;
void *pdu = NULL;
unsigned char in[0xffff + 4];
size_t in_len;
unsigned char *out = NULL;
size_t out_len;
FILE *f = NULL;
char errm[1024];
f = fopen(sample, "rb");
KSI_snprintf(errm, sizeof(errm), "Unable to open pdu file: '%s'.", sample);
CuAssert(tc, errm, f != NULL);
in_len = (unsigned)fread(in, 1, sizeof(in), f);
fclose(f);
KSI_snprintf(errm, sizeof(errm), "Unable to read pdu file: '%s'.", sample);
CuAssert(tc, errm, in_len > 0);
res = parse(ctx, in, in_len, &pdu);
KSI_snprintf(errm, sizeof(errm), "Unable to parse pdu: '%s'.", sample);
CuAssert(tc, errm, res == KSI_OK && pdu != NULL);
res = serialize(pdu, &out, &out_len);
KSI_snprintf(errm, sizeof(errm), "Unable to serialize pdu: '%s'.", sample);
CuAssert(tc, errm, res == KSI_OK && out != NULL && out_len > 0);
KSI_snprintf(errm, sizeof(errm), "Serialized pdu length mismatch: '%s'.", sample);
CuAssert(tc, errm, res == KSI_OK && out_len == in_len);
KSI_snprintf(errm, sizeof(errm), "Serialised pdu content mismatch: '%s'.", sample);
CuAssert(tc, errm, !KSITest_memcmp(in, out, in_len));
KSI_free(out);
objFree(pdu);
}
int taskCreat(
const char *name,
unsigned priority,
int options,
unsigned stackSize,
FUNCPTR func,
ARG arg0,
ARG arg1,
ARG arg2,
ARG arg3,
ARG arg4,
ARG arg5,
ARG arg6,
ARG arg7,
ARG arg8,
ARG arg9
)
{
static char digits[] = "0123456789";
TCB_ID tcbId;
char *pTaskMem;
char *pStackBase;
char newName[20];
int value;
int nBytes;
int nPreBytes;
char *pBufStart;
char *pBufEnd;
char ch;
/* Check if task lib is installed */
if (taskLibInstalled != TRUE)
{
errnoSet(S_taskLib_NOT_INSTALLED);
tcbId = NULL;
}
else
{
/* If NULL name create default name for task */
if (name == NULL)
{
strcpy(newName, namelessPrefix);
nBytes = strlen(newName);
nPreBytes = nBytes;
value = ++namelessCount;
/* Do while value is non-zero */
do
{
newName[nBytes++] = digits[value % 10];
value /= 10;
} while(value != 0);
/* Calculate start/end positions in name */
pBufStart = newName + nPreBytes;
pBufEnd = newName + nBytes - 1;
/* While startbuffer lt. end buffer */
while (pBufStart < pBufEnd)
{
ch = *pBufStart;
*pBufStart = *pBufEnd;
*pBufEnd = ch;
pBufStart++;
pBufEnd--;
}
/* Terminate string */
newName[nBytes] = EOS;
/* Use this a the name for the task */
name = newName;
}
/* Round up stack size */
stackSize = STACK_ROUND_UP(stackSize);
/* Allocate new TCB plus stack */
pTaskMem = objAllocPad(
taskClassId,
(unsigned) stackSize,
(void **) NULL
);
if (pTaskMem == NULL)
{
/* errno set by objAllocPad() */
tcbId = NULL;
}
else
{
/* Setup stack vars */
#if (_STACK_DIR == _STACK_GROWS_DOWN)
pStackBase = pTaskMem + stackSize;
tcbId = (TCB_ID) pStackBase;
#else /* _STACK_GROWS_UP */
tcbId = (TCB_ID) (pTaskMem + TASK_EXTRA_BYTES);
pStackBase = STACK_ROUND_UP(
pTaskMem + TASK_EXTRA_BYTES + sizeof(TCB)
);
#endif /* _STACK_DIR */
/* Initialize task */
if (taskInit(
tcbId,
name,
priority,
options,
pStackBase,
stackSize,
func,
arg0,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
arg7,
arg8,
arg9
) != OK)
{
/* errno set by taskInit() */
objFree(taskClassId, tcbId);
tcbId = NULL;
}
}
}
return (int) tcbId;
}
STATUS taskDestroy(
int taskId,
BOOL freeStack,
unsigned timeout,
BOOL forceDestroy
)
{
STATUS status;
int i, level;
TCB_ID tcbId;
if (INT_RESTRICT() != OK)
{
errnoSet (S_intLib_NOT_ISR_CALLABLE);
return ERROR;
}
/* Get task context */
tcbId = taskTcb(taskId);
if (tcbId == NULL)
return ERROR;
/* If task self destruct and excption lib installed */
if (tcbId == taskIdCurrent) {
/* Wait for safe to destroy */
while (tcbId->safeCount > 0)
taskUnsafe();
/* Kill it */
status = excJobAdd(
(VOIDFUNCPTR) taskDestroy,
(ARG) tcbId,
(ARG) freeStack,
(ARG) WAIT_NONE,
(ARG) FALSE,
(ARG) 0,
(ARG) 0
);
/* Block here and suspend */
while(status == OK)
taskSuspend(0);
} /* End if task self destruct and exception lib installed */
taskDestroyLoop:
/* Lock interrupts */
INT_LOCK(level);
/* Check id */
if (TASK_ID_VERIFY(tcbId) != OK)
{
/* errno set by taskIdVerify() */
/* Unlock interrupts */
INT_UNLOCK(level);
return ERROR;
}
/* Mask all signals */
if (tcbId->pSignalInfo != NULL)
tcbId->pSignalInfo->sigt_blocked = 0xffffffff;
/* Block here for safe and running locked tasks */
while ( (tcbId->safeCount > 0) ||
( (tcbId->status == TASK_READY) && (tcbId->lockCount > 0) )
)
{
/* Enter kernel mode */
kernelState = TRUE;
/* Unlock interrupts */
INT_UNLOCK(level);
/* Check if force deletion, or suicide */
if (forceDestroy || (tcbId == taskIdCurrent))
{
/* Remove protections */
tcbId->safeCount = 0;
tcbId->lockCount = 0;
/* Check if flush of safety queue is needed */
if (Q_FIRST(&tcbId->safetyQ) != NULL)
vmxPendQFlush(&tcbId->safetyQ);
/* Exit trough kernel */
vmxExit();
}
else
{
/* Not forced deletion or suicide */
/* Put task on safe queue */
if (vmxPendQPut(&tcbId->safetyQ, timeout) != OK)
{
/* Exit trough kernel */
vmxExit();
errnoSet (S_taskLib_INVALID_TIMEOUT);
return ERROR;
}
/* Exit trough kernel */
status = vmxExit();
/* Check for restart */
if (status == SIG_RESTART)
{
timeout = (sigTimeoutRecalc)(timeout);
goto taskDestroyLoop;
}
/* Check if unsuccessful */
if (status == ERROR)
{
/* timer should have set errno to S_objLib_TIMEOUT */
return ERROR;
}
} /* End else forced or suicide */
/* Lock interrupts */
INT_LOCK(level);
/* Now verify class id again */
if (TASK_ID_VERIFY(tcbId) != OK)
{
/* errno set by taskIdVerify() */
/* Unlock interrupts */
INT_UNLOCK(level);
return ERROR;
}
} /* End while blocked by safety */
/* Now only one cadidate is selected for deletion */
/* Make myself safe */
taskSafe();
/* Protet deletion cadidate */
tcbId->safeCount++;
/* Check if not suicide */
if (tcbId != taskIdCurrent)
{
/* Enter kernel mode */
kernelState = TRUE;
/* Unlock interrupts */
INT_UNLOCK(level);
/* Suspend victim */
vmxSuspend(tcbId);
/* Exit trough kernel */
vmxExit();
}
else
{
/* Unlock interrupts */
INT_UNLOCK(level);
}
/* Run deletion hooks */
for (i = 0; i < MAX_TASK_DELETE_HOOKS; i++)
if (taskDeleteHooks[i] != NULL)
(*taskDeleteHooks[i])(tcbId);
/* Lock task */
taskLock();
/* If dealloc and options dealloc stack */
if ( freeStack && (tcbId->options & TASK_OPTIONS_DEALLOC_STACK) ) {
#if (_STACK_DIR == _STACK_GROWS_DOWN)
objFree(taskClassId, tcbId->pStackEnd);
#else /* _STACK_GROWS_UP */
objFree(taskClassId, tbcId - TASK_EXTRA_BYTES);
#endif /* _STACK_DIR */
}
/* Lock interrupts */
INT_LOCK(level);
/* Invalidate id */
objCoreTerminate(&tcbId->objCore);
/* Enter kernel mode */
kernelState = TRUE;
/* Unlock interrupts */
INT_UNLOCK(level);
/* Delete task */
status = vmxDelete(tcbId);
/* Check if safe quque needs to be flushed */
if (Q_FIRST(&tcbId->safetyQ) != NULL)
vmxPendQFlush(&tcbId->safetyQ);
/* Exit trough kernel */
vmxExit();
/* Unprotect */
taskUnlock();
taskUnsafe();
return OK;
}
void delObject(Object* Obj)
{
objFree(Obj);
free(Obj);
}
