windlib.c

VXWORKS源代码

* Remove task from the delay queue and return to it ERROR.
*
* RETURNS: OK
*
* NOMANUAL
*/

STATUS windUndelay
    (
    WIND_TCB *pTcb
    )
    {
    if ((pTcb->status & WIND_DELAY) == 0)	/* in not delayed then done */
	return (OK);

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_WINDUNDELAY, (int) pTcb); 	/* log event */
#endif

    pTcb->status &= ~WIND_DELAY;		/* undelay status */

    Q_REMOVE (&tickQHead, &pTcb->tickNode);	/* remove from tick queue */

    taskRtnValueSet (pTcb, ERROR);		/* return ERROR */
    pTcb->errorStatus = S_taskLib_TASK_UNDELAYED;

    if (pTcb->status == WIND_READY)		/* if ready, enqueue */
	Q_PUT (&readyQHead, pTcb, pTcb->priority);

    return (OK);
    }

/*******************************************************************************
*
* windWdStart - start a watchdog timer
*
* This routine will start or restart a watchdog.  If the watchdog is already
* in the queue, it is resorted to the appropriate timeout.  If there are
* more windWdStart() jobs still in the kernel work queue, as counted by the
* variable deferStartCnt, then no action is taken.
*
* RETURNS: OK.
*
* NOMANUAL
*/

STATUS windWdStart
    (
    WDOG *wdId,         /* watch dog to start */
    int   timeout       /* timeout in ticks */
    )
    {
    int deferStartCnt;	/* temp variable to hold deferStartCnt */
    int level; 

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_WINDWDSTART, (int) wdId); 	/* log event */
#endif

    /* Protect the decrement from interrupts to avoid the race condition
       that spr 7070 describes */

    level = intLock ();
	deferStartCnt = -- wdId->deferStartCnt;
    intUnlock (level);

    if (deferStartCnt == 0)
	{
	if ((unsigned)(vxTicks + timeout) < vxTicks)	/* rollover? */
	    {
	    Q_CALIBRATE (&tickQHead, ~vxTicks + 1);
	    vxTicks = 0;
	    }

	if (wdId->status == WDOG_IN_Q)			/* resort if in queue */
	    Q_RESORT (&tickQHead, &wdId->tickNode, timeout + vxTicks);
	else
	    Q_PUT (&tickQHead, &wdId->tickNode, timeout + vxTicks);

	wdId->status = WDOG_IN_Q;
	}

    return (OK);
    }

/*******************************************************************************
*
* windWdCancel - cancel a watchdog timer
*
* This routine cancels a watchdog, removing it from the timer queue if needed.
*
* NOMANUAL
*/

void windWdCancel
    (
    WDOG *wdId          /* watch dog to cancel */
    )
    {

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_WINDWDCANCEL, (int) wdId); 	/* log event */
#endif 

    if (wdId->status == WDOG_IN_Q)
	{
	Q_REMOVE (&tickQHead, &wdId->tickNode);	/* remove from queue */
	wdId->status = WDOG_OUT_OF_Q;
	}
    }

/*******************************************************************************
*
* windPendQGet - remove and next task on pend queue and make ready
*
* Take the next task on the specified pend queue and unpend it.  It will either
* be ready or suspended.  If ready it is added to the ready queue.
*
* NOMANUAL
*/

void windPendQGet
    (
    Q_HEAD *pQHead      /* pend queue to get first task off */
    )
    {
    FAST WIND_TCB *pTcb = (WIND_TCB *) Q_GET (pQHead);

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_WINDPENDQGET, (int) pTcb); 	/* log event */
#endif

    pTcb->status &= ~WIND_PEND;			/* clear pended flag */
    taskRtnValueSet (pTcb, OK);			/* return OK */

    if (pTcb->status & WIND_DELAY)		/* task was timing out */
	{
	pTcb->status &= ~WIND_DELAY;
	Q_REMOVE (&tickQHead, &pTcb->tickNode);	/* remove from queue */
	}

    if (pTcb->status == WIND_READY)		/* task is now ready */
	Q_PUT (&readyQHead, pTcb, pTcb->priority);
    }

/*******************************************************************************
*
* windReadyQPut - put a task on the ready queue
*
* This routine adds a task previously blocked on a shared
* semaphore to the ready Queue.
*
* The shared TCB of this task has been removed from the shared semaphore
* pending queue by the CPU that gives the semaphore.
*
* NOMANUAL
*/

void windReadyQPut
    (
    WIND_TCB * pTcb              /* TCB to add to ready Q */
    )
    {

    pTcb->status &= ~WIND_PEND;                 /* clear pended flag */
    taskRtnValueSet (pTcb, OK);                 /* return OK */

    if (pTcb->status & WIND_DELAY)              /* task was timing out */
        {
        pTcb->status &= ~WIND_DELAY;
        Q_REMOVE (&tickQHead, &pTcb->tickNode); /* remove from queue */
        }

    if (pTcb->status == WIND_READY)             /* task is now ready */
        Q_PUT (&readyQHead, pTcb, pTcb->priority);
    }

/*******************************************************************************
*
* windReadyQRemove - remove pend task from the ready Q
*
* This routines removes the current task from the pend. The task must have
* been previously added to a shared semaphore pend Q by using  Q_PUT.
* If the task is timing out, also add the task to the delay queue. 
*
* RETURNS: N/A
*
* NOMANUAL
*/

void windReadyQRemove
    (
    Q_HEAD *pQHead,        /* pend queue to put taskIdCurrent on */
    int    timeout         /* timeout in ticks */
    )
    {

    Q_REMOVE (&readyQHead, taskIdCurrent);              /* out of ready q */

    taskIdCurrent->status |= WIND_PEND;                 /* update status */

    taskIdCurrent->pPendQ = pQHead;                     /* pQHead pended on */
    if (timeout != WAIT_FOREVER)                        /* timeout specified? */
        {
        if ((unsigned)(vxTicks + timeout) < vxTicks)    /* rollover? */
            {
            Q_CALIBRATE (&tickQHead, ~vxTicks + 1);
            vxTicks = 0;
            }

        Q_PUT (&tickQHead, &taskIdCurrent->tickNode, timeout + vxTicks);
        taskIdCurrent->status |= WIND_DELAY;
        }
    }

/*******************************************************************************
*
* windPendQFlush - flush all tasks off of pend queue making them ready
*
* Take all of the tasks on the specified pend queue and unpend them.  They will
* either be ready or suspended.  All ready tasks will be added to the ready
* queue.
*
* NOMANUAL
*/

void windPendQFlush
    (
    Q_HEAD *pQHead      /* pend queue to flush tasks from */
    )
    {
    FAST WIND_TCB *pTcb;

#if FALSE
#ifdef WV_INSTRUMENTATION
    int level = 0;
#endif
#endif /* FALSE */

    while ((pTcb = (WIND_TCB *) Q_GET (pQHead)) != NULL)/* get next task */
	{

#ifdef WV_INSTRUMENTATION
	/* windview - level 2 event logging */
	EVT_TASK_1 (EVENT_WINDPENDQFLUSH, (int) pTcb); 	
#endif

	pTcb->status &= ~WIND_PEND;			/* clear pended flag */
	taskRtnValueSet (pTcb, OK);			/* return OK */

	if (pTcb->status & WIND_DELAY)			/* task is timeout */
	    {
	    pTcb->status &= ~WIND_DELAY;
	    Q_REMOVE (&tickQHead, &pTcb->tickNode);	/* remove from queue */
	    }
	if (pTcb->status == WIND_READY)			/* task is now ready */
	    Q_PUT (&readyQHead, pTcb, pTcb->priority);
	}
    }

/*******************************************************************************
*
* windPendQPut - add current task to a pend queue
*
* Add a taskIdCurrent to a pend queue.  If the task is timing out, also add the
* task to the delay queue.  If the NO_WAIT value is passed for a timeout,
* return ERROR.
*
* RETURNS: OK, or ERROR if NO_WAIT timeout is specified.
*
* ERRNO: S_objLib_OBJ_UNAVAILABLE
*
* NOMANUAL
*/

STATUS windPendQPut
    (
    FAST Q_HEAD *pQHead,        /* pend queue to put taskIdCurrent on */
    FAST int    timeout         /* timeout in ticks */
    )
    {
    if (timeout == NO_WAIT)				/* NO_WAIT = no block */
	{
	errno = S_objLib_OBJ_UNAVAILABLE;		/* resource gone */
	return (ERROR);
	}

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_0 (EVENT_WINDPENDQPUT); 	/* log event */
#endif

    Q_REMOVE (&readyQHead, taskIdCurrent);		/* out of ready q */

    taskIdCurrent->status |= WIND_PEND;			/* update status */

    taskIdCurrent->pPendQ = pQHead;			/* pQHead pended on */

    Q_PUT (pQHead, taskIdCurrent, taskIdCurrent->priority);

    if (timeout != WAIT_FOREVER)			/* timeout specified? */
	{
	if ((unsigned)(vxTicks + timeout) < vxTicks)	/* rollover? */
	    {
	    Q_CALIBRATE (&tickQHead, ~vxTicks + 1);
	    vxTicks = 0;
	    }

	Q_PUT (&tickQHead, &taskIdCurrent->tickNode, timeout + vxTicks);
	taskIdCurrent->status |= WIND_DELAY;
	}

    return (OK);
    }

/*******************************************************************************
*
* windPendQRemove - move a task out of the pend queue
*
* This routine removes a task from a pend queue.
*
* RETURNS: OK
*
* NOMANUAL
*/

STATUS windPendQRemove
    (
    WIND_TCB *pTcb              /* task to remove from pend queue */
    )
    {
    int status = Q_REMOVE (pTcb->pPendQ, pTcb);	/* out of pend queue */

    /*
     * When shared semaphore are used Q_REMOVE can return ERROR if lock
     * cannot be taken, or ALREADY_REMOVED if the shared tcb is currently
     * in the event list, ie removed from the shared semaphore pend Q.
     */

    pTcb->status   &= ~WIND_PEND;		/* turn off pend bit */
    pTcb->pPriMutex = NULL;			/* clear pPriMutex */

    if (pTcb->status & WIND_DELAY)		/* task was timing out */
	{
	pTcb->status &= ~WIND_DELAY;
	Q_REMOVE (&tickQHead, &pTcb->tickNode);	/* remove from queue */
	}

    return (status);
    }

/*******************************************************************************
*
* windPendQTerminate - flush all tasks off of pend queue making them ready
*
* Take all of the tasks on the specified pend queue and unpend them.  They will
* either be ready or suspended.  All ready tasks will be added to the ready
* queue.  Unlike windPendQFlush (2), this routine returns the ERROR
* S_objLib_OBJ_DELETED.
*
* NOMANUAL
*/

void windPendQTerminate
    (
    Q_HEAD *pQHead      /* pend queue to terminate */
    )
    {
    FAST WIND_TCB *pTcb;

    while ((pTcb = (WIND_TCB *) Q_GET (pQHead)) != NULL)/* get next task */
	{

#ifdef WV_INSTRUMENTATION
        /* windview - level 2 event logging */
	EVT_TASK_1 (EVENT_WINDPENDQTERMINATE, (int) pTcb);
#endif

	pTcb->status     &= ~WIND_PEND;			/* clear pended flag */
	pTcb->pPriMutex	  = NULL;			/* clear mutex pend */
	pTcb->errorStatus = S_objLib_OBJ_DELETED;	/* set error status */

	taskRtnValueSet (pTcb, ERROR);			/* return ERROR */

	if (pTcb->status & WIND_DELAY)			/* task is timeout */
	    {
	    pTcb->status &= ~WIND_DELAY;
	    Q_REMOVE (&tickQHead, &pTcb->tickNode);	/* remove from queue */
	    }

	if (pTcb->status == WIND_READY)			/* task is now ready */
	    Q_PUT (&readyQHead, pTcb, pTcb->priority);
	}
    }