}/********************************************************************************* semBInit - initialize a declared binary semaphore** The initialization of a static binary semaphore, or a binary semaphore* embedded in some larger object need not deal with allocation.* This routine may be called to initialize such a semaphore.  The semaphore* is initialized to the specified initial state of either SEM_FULL or SEM_EMPTY.** Binary semaphore options include the queuing style for blocked tasks.* Tasks can be queued on the basis of their priority or first-in-first-out.* These options are SEM_Q_PRIORITY and SEM_Q_FIFO respectively.** SEE ALSO: semBCreate()** NOMANUAL*/STATUS semBInit    (    SEMAPHORE  *pSemaphore,             /* pointer to semaphore to initialize */    int         options,                /* semaphore options */    SEM_B_STATE initialState            /* initial semaphore state */    )    {    if ((!semBLibInstalled) && (semBLibInit () != OK))	/* initialize package */	return (ERROR);    if (semQInit (pSemaphore, options) != OK)		/* initialize queue */	return (ERROR);    return (semBCoreInit (pSemaphore, options, initialState));    }/********************************************************************************* semBCoreInit - initialize a binary semaphore with queue already initialized** To initialize a semaphore with some special queuing algorithm, this routine* is used.  This routine will initialize a binary semaphore without* initializing the queue.** ERRNO: S_semLib_INVALID_OPTION, S_semLib_INVALID_STATE** NOMANUAL*/STATUS semBCoreInit    (    SEMAPHORE  *pSemaphore,             /* pointer to semaphore to initialize */    int         options,                /* semaphore options */    SEM_B_STATE initialState            /* initial semaphore state */    )    {    if ((options & SEM_INVERSION_SAFE) || (options & SEM_DELETE_SAFE))	{	errno = S_semLib_INVALID_OPTION;	return (ERROR);	}    switch (initialState)	{	case SEM_EMPTY:	    pSemaphore->semOwner = taskIdCurrent;	/* semaphore empty */	    break;	case SEM_FULL:	    pSemaphore->semOwner = NULL;		/* semaphore full */	    break;	default:	    errno = S_semLib_INVALID_STATE;	    return (ERROR);	}    pSemaphore->recurse = 0;				/* no recursive takes */    pSemaphore->options = options;			/* stow away options */    pSemaphore->semType = SEM_TYPE_BINARY;		/* type is binary */    eventInit (&pSemaphore->events);			/* initialize events */#ifdef WV_INSTRUMENTATION    /* windview - connect instrumented class for level 1 event logging */    if (wvObjIsEnabled)        objCoreInit (&pSemaphore->objCore, semInstClassId);    else #endif    objCoreInit (&pSemaphore->objCore, semClassId); /* initialize core */    return (OK);    }#ifdef semBLib_PORTABLE/********************************************************************************* semBGive - give 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.** NOMANUAL*/STATUS semBGive    (    SEM_ID semId        /* semaphore ID to give */    )    {    int level = intLock ();			/* LOCK INTERRUPTS */    WIND_TCB * pOwner;    if (OBJ_VERIFY (semId, semClassId) != OK)	{	intUnlock (level);			/* UNLOCK INTERRUPTS */	return (ERROR);	}    pOwner = semId->semOwner;    if ((semId->semOwner = (WIND_TCB *) Q_FIRST (&semId->qHead)) == NULL)	{	int    	oldErrno;	STATUS  evStatus;	STATUS 	retStatus;	retStatus = OK;	/* check change of state; if so, send events */	if ((semId->events.taskId != (int)NULL) && (pOwner != NULL))	    {	    kernelState = TRUE;	    intUnlock (level);			/* UNLOCK INTERRUPTS */	    oldErrno = errno;	    evStatus = eventRsrcSend(semId->events.taskId,				     semId->events.registered);	    if (evStatus != OK)		{		if ((semId->options & SEM_EVENTSEND_ERR_NOTIFY) != 0x0)		    {		    retStatus = ERROR;		    oldErrno = S_eventLib_EVENTSEND_FAILED;		    }		semId->events.taskId = (int)NULL;		}	    else if ((semId->events.options & EVENTS_SEND_ONCE) != 0x0)		semId->events.taskId = (int)NULL;	    windExit ();	    errno = oldErrno;	    return (retStatus);	    }	else	    intUnlock (level);	}    else	{	kernelState = TRUE;			/* KERNEL ENTER */ 	intUnlock (level);			/* UNLOCK INTERRUPTS */#ifdef WV_INSTRUMENTATION	/* windview - level 2 event logging */	EVT_TASK_1 (EVENT_OBJ_SEMGIVE, semId);#endif	windPendQGet (&semId->qHead);		/* unblock a task */	windExit ();				/* KERNEL EXIT */	}    return (OK);    }/********************************************************************************* semBTake - take 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.** WARNING* This routine may not be used from interrupt level.** NOMANUAL*/STATUS semBTake    (    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 */	intUnlock (level);			/* UNLOCK INTERRUPTS */	return (OK);	}    kernelState = TRUE;				/* KERNEL ENTER */    intUnlock (level);				/* UNLOCK INTERRUPTS */#ifdef WV_INSTRUMENTATION    /* windview - level 2 event logging */    EVT_TASK_1 (EVENT_OBJ_SEMTAKE, semId);#endif    if (windPendQPut (&semId->qHead, timeout) != OK)	{	windExit ();				/* KERNEL EXIT */	return (ERROR);	}    if ((status = windExit ()) == RESTART)	/* KERNEL EXIT */	{	timeout = SIG_TIMEOUT_RECALC(timeout);	goto again;	}    return (status);    }#endif	/* semBLib_PORTABLE *//********************************************************************************* semBGiveDefer - give semaphore as deferred work** 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.** NOMANUAL*/void semBGiveDefer    ( SEM_ID semId        /* semaphore ID to give */    )    {    WIND_TCB * pOwner = semId->semOwner;    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 a task */	}    else /* check for change of state, send events if registered */	{	if ((semId->events.taskId != (int)NULL) && (pOwner != NULL))	    {	    if (eventRsrcSend(semId->events.taskId,			      semId->events.registered) != OK)		{		semId->events.taskId = (int)NULL;		}	    else if ((semId->events.options & EVENTS_SEND_ONCE) != 0x0 )		semId->events.taskId = (int)NULL;	    }	}    }