semmlib.c

VXWORKS源代码

#else
    objCoreInit (&pSemaphore->objCore, semClassId);
#endif

    return (OK);
    }

#ifdef semMLib_PORTABLE

/*******************************************************************************
*
* semMGive - give a semaphore
*
* Gives the semaphore.  If a higher priority task has already taken
* the semaphore (so that it is now pended waiting for it), that task
* will now become ready to run, and preempt the task that does the semGive().
* If the semaphore is already full (it has been given but not taken) this
* call is essentially a no-op.
*
* If deletion safe option is enabled, an implicit taskUnsafe() operation will
* occur.
*
* If priority inversion safe option is enabled, and this is the last priority
* inversion safe semaphore to be released, the calling task will revert to
* its normal priority.
*
* WARNING
* This routine may not be used from interrupt level.
*
* ERRNO: S_semLib_INVALID_OPERATION
*
* INTERNAL
* The use of the variables kernWork and semMGiveKernWork looks pretty lame.  It
* is, in fact, necessary to facilitate the optimized version of this routine.
* An optimized version would utilize a register for kernWork and stick the
* value in semMGiveKernWork as a parameter to semMGiveKern().  This form of
* parameter passing saves costly stack manipulation.
*
* NOMANUAL
*/

STATUS semMGive
    (
    FAST SEM_ID semId   /* semaphore ID to give */
    )
    {
    FAST int level;
    FAST int kernWork = 0;

    if (INT_RESTRICT () != OK)			/* restrict isr use */
	return (ERROR);

    level = intLock ();				/* LOCK INTERRUPTS */

    if (OBJ_VERIFY (semId, semClassId) != OK)	/* check validity */
	{
	intUnlock (level);
	return (ERROR);
	}

    if (taskIdCurrent != semId->semOwner)	/* check for ownership */
	{
	intUnlock (level);
	errnoSet (S_semLib_INVALID_OPERATION);
	return (ERROR);
	}

    if (semId->recurse > 0)			/* check recurse count */
	{
	semId->recurse --;			/* decrement recurse count */
	intUnlock (level);
	return (OK);
	}

    if ((semId->options & SEM_INVERSION_SAFE) &&
	(-- taskIdCurrent->priMutexCnt == 0))
        {
	if (taskIdCurrent->priority != taskIdCurrent->priNormal)
	    kernWork |= SEM_M_PRI_RESORT;
	}

    if ((semId->semOwner = (WIND_TCB *) Q_FIRST (&semId->qHead)) != NULL)
	kernWork |= SEM_M_Q_GET;
    else if (semId->events.taskId != (int)NULL)
	kernWork |= SEM_M_SEND_EVENTS;

    if ((semId->options & SEM_DELETE_SAFE) &&
 	(-- taskIdCurrent->safeCnt == 0) &&
	(Q_FIRST (&taskIdCurrent->safetyQHead) != NULL))
	kernWork |= SEM_M_SAFE_Q_FLUSH;

    if (kernWork == 0)
	{
	intUnlock (level);			/* UNLOCK INTERRUPTS */
	return (OK);
	}

    kernelState = TRUE;				/* KERNEL ENTER */
    intUnlock (level);				/* UNLOCK INTERRUPTS */

    semMGiveKernWork = kernWork;		/* setup the work to do */

    return (semMGiveKern (semId));		/* do the work */
    }

/*******************************************************************************
*
* semMTake - take a semaphore
*
* Takes the semaphore.  If the semaphore is empty, i.e., it has not been given
* since the last semTake() or semInit(), this task will become pended until
* the semaphore becomes available by some other task doing a semGive()
* of it.  If the semaphore is already available, this call will empty
* the semaphore, so that no other task can take it until this task gives
* it back, and this task will continue running.
*
* If deletion safe option is enabled, an implicit taskSafe() operation will
* occur.
*
* If priority inversion safe option is enabled, and the calling task blocks,
* and the priority of the calling task is greater than the semaphore owner,
* the owner will inherit the caller's priority.
*
* WARNING
* This routine may not be used from interrupt level.
*
* NOMANUAL
*/

STATUS semMTake
    (
    FAST SEM_ID semId,  /* semaphore ID to take */
    int timeout         /* timeout in ticks */
    )
    {
    int level;
    int status;

    if (INT_RESTRICT () != OK)
	return (ERROR);

again:
    level = intLock ();				/* LOCK INTERRUPTS */

    if (OBJ_VERIFY (semId, semClassId) != OK)
	{
	intUnlock (level);			/* UNLOCK INTERRUPTS */
	return (ERROR);
	}

    if (semId->semOwner == NULL)
	{
	semId->semOwner = taskIdCurrent;	/* update semaphore state */

	if (semId->options & SEM_INVERSION_SAFE)
	    taskIdCurrent->priMutexCnt ++;	/* update inherit count */

	if (semId->options & SEM_DELETE_SAFE)
	    taskIdCurrent->safeCnt ++;		/* update safety count */

	intUnlock (level);			/* UNLOCK INTERRUPTS */
	return (OK);
	}

    if (semId->semOwner == taskIdCurrent)	/* check for recursion */
	{
	semId->recurse ++;			/* keep recursion count */
	intUnlock (level);			/* UNLOCK INTERRUPTS */
	return (OK);
	}

    kernelState = TRUE;				/* KERNEL ENTER */
    intUnlock (level);				/* UNLOCK INTERRUPTS */
	
    if (semMPendQPut (semId, timeout) != OK)
	{
	windExit ();				/* windPendQPut failed */
	return (ERROR);
	}

    if ((status = windExit ()) == RESTART)	/* KERNEL EXIT */
	{
	timeout = SIG_TIMEOUT_RECALC(timeout);
	goto again;				/* we got signalled */
	}

    return (status);
    }

#endif	/* semMLib_PORTABLE */

/*******************************************************************************
*
* semMGiveForce - give a mutual-exclusion semaphore without restrictions
*
* This routine gives a mutual-exclusion semaphore, regardless of semaphore
* ownership.  It is intended as a debugging aid only.
*
* The routine is particularly useful when a task dies while holding some
* mutual-exclusion semaphore, because the semaphore can be resurrected.  The
* routine will give the semaphore to the next task in the pend queue or make
* the semaphore full if no tasks are pending.  In effect, execution will
* continue as if the task owning the semaphore had actually given the
* semaphore.
*
* CAVEATS
* This routine should be used only as a debugging aid, when the condition of
* the semaphore is known.
*
* RETURNS: OK, or ERROR if the semaphore ID is invalid.
*
* SEE ALSO: semGive()
*/

STATUS semMGiveForce
    (
    FAST SEM_ID semId   /* semaphore ID to give */
    )
    {
    STATUS status = OK;
    int oldErrno = errno;

    if (INT_RESTRICT () != OK)			/* restrict isr use */
	return (ERROR);
    if (OBJ_VERIFY (semId, semClassId) != OK)	/* check validity */
	return (ERROR);

#ifdef WV_INSTRUMENTATION
    /* windview - level 1 event logging */
    EVT_OBJ_3 (OBJ, semId, semClassId,
	       EVENT_SEMMGIVEFORCE, semId, semId->options, semId->state);
#endif

    /* if semaphore is not taken, nothing has to be done. */

    if (semId->semOwner == NULL)
	return OK;

    /* first see if we are giving away one of calling task's semaphores */

    if (semId->semOwner == taskIdCurrent)	/* give semaphore until avail */
	{
	while (semId->semOwner == taskIdCurrent)/* loop until recurse == 0 */
	    semGive (semId);			/* give semaphore */

	return (OK);				/* done */
	}

    /* give another task's semaphore away.  Djkstra be damned... */

    kernelState = TRUE;				/* KERNEL ENTER */
    semId->recurse = 0;				/* initialize recurse count */

    if ((semId->semOwner = (WIND_TCB *) Q_FIRST (&semId->qHead)) != NULL)
	{

#ifdef WV_INSTRUMENTATION
    	/* windview - level 2 event logging */
	EVT_TASK_1 (EVENT_OBJ_SEMGIVE, semId);
#endif

	windPendQGet (&semId->qHead);		/* unblock receiver */

	semId->semOwner->pPriMutex = NULL;	/* receiver no longer pended */

	if (semId->options & SEM_DELETE_SAFE)
	    semId->semOwner->safeCnt ++;	/* increment receiver safety */

	if (semId->options & SEM_INVERSION_SAFE)
	    semId->semOwner->priMutexCnt ++;	/* update inherit count */
	}
    else
	{
	if (semId->events.taskId != (int)NULL)	/* sem is free, send events */
	    {
	    if (eventRsrcSend (semId->events.taskId,
			       semId->events.registered) != OK)
		{
		if ((semId->options & SEM_EVENTSEND_ERR_NOTIFY) != 0x0)
		    {
		    status = ERROR;
		    }

		semId->events.taskId = (int)NULL;
		}
	    else if ((semId->events.options & EVENTS_SEND_ONCE) != 0x0)
		semId->events.taskId = (int)NULL;
	    }
	}

    if (status == ERROR)
	{
	windExit ();			/* KERNEL EXIT */
	errnoSet (S_eventLib_EVENTSEND_FAILED);
	}
    else
	{
	errnoSet (oldErrno);
	return (windExit ());		/* KERNEL EXIT */
	}

    return (status);
    }

/*******************************************************************************
*
* semMGiveKern - put current task on mutex semaphore pend queue
*
* This routine is called if something of consequence occured in giving the
* mutual exclusion semaphore that involved more lengthy processing.  Things
* of consequence are: task to be unblocked, priority to be uninherited, or
* task safety queue of deleters to be flushed.
*
* INTERNAL
* The use of the variables kernWork and semMGiveKernWork looks pretty lame.
* It is, in fact, necessary to facilitate the optimized version of this routine.
* An optimized version would utilize a register for kernWork and stick the
* value in semMGiveKernWork as a parameter to semMGiveKern().  This form of
* parameter passing saves costly stack manipulation.
*
* NOMANUAL
*/

STATUS semMGiveKern
    (
    FAST SEM_ID semId   /* semaphore ID to take */
    )
    {
    STATUS evStatus;
    STATUS retStatus = OK;
    int oldErrno = errno;

    if (semMGiveKernWork & SEM_M_Q_GET)
	{

#ifdef WV_INSTRUMENTATION
    	/* windview - level 2 event logging */
	EVT_TASK_1 (EVENT_OBJ_SEMGIVE, semId);
#endif

	windPendQGet (&semId->qHead);		/* unblock receiver */

	semId->semOwner->pPriMutex = NULL;	/* receiver no longer pended */

	if (semId->options & SEM_DELETE_SAFE)
	    semId->semOwner->safeCnt ++;	/* increment receiver safety */

	if (semId->options & SEM_INVERSION_SAFE)
	semId->semOwner->priMutexCnt ++;	/* update inherit count */
	}

    if (semMGiveKernWork & SEM_M_PRI_RESORT)
	{
	windPrioritySet (taskIdCurrent, taskIdCurrent->priNormal);
	}

    if (semMGiveKernWork & SEM_M_SAFE_Q_FLUSH)
	{

#ifdef WV_INSTRUMENTATION
    	/* windview - level 2 event logging */
	EVT_TASK_1 (EVENT_OBJ_SEMGIVE, semId);
#endif
	windPendQFlush (&taskIdCurrent->safetyQHead);
	}

    if ((semMGiveKernWork & SEM_M_SEND_EVENTS) != 0x0)	/* send events */
	{
	evStatus = eventRsrcSend (semId->events.taskId,
			          semId->events.registered);

	if (evStatus != OK)
	    {
	    if ((semId->options & SEM_EVENTSEND_ERR_NOTIFY) != 0x0)
		{
		oldErrno = S_eventLib_EVENTSEND_FAILED;
		retStatus = ERROR;
		}

	    semId->events.taskId = (int)NULL;
	    }
	else if ((semId->events.options & EVENTS_SEND_ONCE) != 0x0)
	    semId->events.taskId = (int)NULL;
	}

    if (retStatus == ERROR)
	{
	windExit ();
	errnoSet (oldErrno);
	}
    else
	{
	errnoSet (oldErrno);
	retStatus = windExit ();			/* KERNEL EXIT */
	}

    return (retStatus);
    }

/*******************************************************************************
*
* semMPendQPut - put current task on mutex semaphore pend queue
*
* This routine is called if the mutex semaphore is empty and the caller must
* pend.  It is called inside the kernel with kernelState == TRUE!  It is
* pulled out of semMTake so optimized versions need not bother with the
* following code.
*
* RETURNS: OK, or ERROR if windPendQPut failed.
* NOMANUAL
*/

STATUS semMPendQPut
    (
    FAST SEM_ID semId,  /* semaphore ID to take */
    int timeout         /* timeout in ticks */
    )
    {

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_OBJ_SEMTAKE, semId);
#endif

    if (windPendQPut (&semId->qHead, timeout) != OK)
	return (ERROR);

    /* if taskIdCurrent is of a higher priority than the task that owns
     * this semaphore, reprioritize the owner.
     */

    if (semId->options & SEM_INVERSION_SAFE)
	{
	taskIdCurrent->pPriMutex = semId;	/* track mutex we pend on */

        if (taskIdCurrent->priority < semId->semOwner->priority)
	    {
	    windPrioritySet (semId->semOwner, taskIdCurrent->priority);
	    }
	}

    return (OK);
    }