siglib.c

VXWORKS源代码

		    {
		    *(struct sigpend **)pSigPend = _pSigQueueFreeHead;
		    _pSigQueueFreeHead = pSigPend;
		    }
		}
	    }

	windExit ();				/* KERNEL EXIT */
	}

    return (OK);
    }

/*******************************************************************************
*
* sigprocmask - examine and/or change the signal mask (POSIX)
*
* This routine allows the calling process to examine and/or change its
* signal mask.  If the value of <pSet> is not NULL, it points to a set of
* signals to be used to change the currently blocked set.
*
* The value of <how> indicates the manner in which the set is changed and
* consists of one of the following, defined in signal.h:
* .iP SIG_BLOCK 4
* the resulting set is the union of the current set and the signal set
* pointed to by <pSet>.
* .iP SIG_UNBLOCK
* the resulting set is the intersection of the current set and the complement
* of the signal set pointed to by <pSet>.
* .iP SIG_SETMASK
* the resulting set is the signal set pointed to by <pSset>.
*
* RETURNS: OK (0), or ERROR (-1) if <how> is invalid.
*
* ERRNO: EINVAL
*
* SEE ALSO: sigsetmask(), sigblock()
*/

int sigprocmask
    (
    int			how,	/* how signal mask will be changed */
    const sigset_t	*pSet,	/* location of new signal mask */
    sigset_t		*pOset	/* location to store old signal mask */
    )
    {
    struct sigtcb *pSigTcb;

    if ((pSigTcb = sigTcbGet()) == NULL)
	return (ERROR);				/* errno was set */

    kernelState = TRUE;				/* KERNEL ENTER */

    if (pOset != NULL)
	*pOset = pSigTcb->sigt_blocked;

    if (pSet != NULL)
	switch (how)
	    {
	    case SIG_BLOCK:
		pSigTcb->sigt_blocked |= *pSet;
		windExit ();			/* KERNEL EXIT */
		return (OK);

	    case SIG_UNBLOCK:
		pSigTcb->sigt_blocked &= ~*pSet;
		break;

	    case SIG_SETMASK:
		pSigTcb->sigt_blocked = *pSet;
		break;

	    default:
		windExit ();			/* KERNEL EXIT */
		errnoSet (EINVAL);
		return (ERROR);
	    }

    /*
     * check to see if we opened up any pending signals and run them.
     * sigpendrun has the horrible symantic of doing a windExit if
     * successful.
     */
    if (sigPendRun(pSigTcb) == FALSE)
	windExit ();				/* KERNEL EXIT */

    return (OK);
    }

/*******************************************************************************
*
* sigpending - retrieve the set of pending signals blocked from delivery (POSIX)
*
* This routine stores the set of signals that are blocked from delivery and
* that are pending for the calling process in the space pointed to by
* <pSet>.
*
* RETURNS: OK (0), or ERROR (-1) if the signal TCB cannot
* be allocated.
*
* ERRNO: ENOMEM
*/

int sigpending
    (
    sigset_t	*pSet		/* location to store pending signal set */
    )
    {
    struct sigtcb *pSigTcb;

    if ((pSigTcb = sigTcbGet ()) == NULL)
	return (ERROR);

    *pSet = pSigTcb->sigt_pending;
    return (OK);
    }

/*******************************************************************************
*
* sigsuspend - suspend the task until delivery of a signal (POSIX)
*
* This routine suspends the task until delivery of a signal.  While
* suspended, <pSet> is used as the set of masked signals.
*
* NOTE: Since the sigsuspend() function suspends thread execution
* indefinitely, there is no successful completion return value.
*
* RETURNS: -1, always.
*
* ERRNO: EINTR
*/

int sigsuspend
    (
    const sigset_t	*pSet	/* signal mask while suspended */
    )
    {
    Q_HEAD qHead;
    sigset_t oldset;
    struct sigtcb *pSigTcb;
    int savtype;

    if ((pSigTcb = sigTcbGet ()) == NULL)
        return (ERROR);			/* errno was set */

#ifdef WV_INSTRUMENTATION
    /* windview - level 1 event logging */
    EVT_OBJ_SIG (EVENT_SIGSUSPEND, 1, (int) *pSet, 0);
#endif

    if (_func_pthread_setcanceltype != NULL)
        {
        _func_pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &savtype);
        }

    kernelState = TRUE;				/* KERNEL ENTER */

    /* save old set */
    oldset = pSigTcb->sigt_blocked;
    pSigTcb->sigt_blocked = *pSet;

    /* check for pending */
    if (sigPendRun (pSigTcb) == TRUE)
	{
	sigprocmask (SIG_SETMASK, &oldset, NULL);
	if (_func_pthread_setcanceltype != NULL)
            {
            _func_pthread_setcanceltype(savtype, NULL);
            }
	errnoSet (EINTR);
	return (ERROR);
	}

    /*
     * Put ourself to sleep until a signal comes in.
     */
    qInit (&qHead, Q_FIFO, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

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

    if (windPendQPut (&qHead, WAIT_FOREVER) != OK)
        {
	windExit ();				/* KERNEL EXIT */

        if (_func_pthread_setcanceltype != NULL)
            {
            _func_pthread_setcanceltype(savtype, NULL);
            }
	return (ERROR);
        }
    windExit ();				/* KERNEL EXIT */

    /*
     * Restore old mask set.
     */
    sigprocmask(SIG_SETMASK, &oldset, NULL);

    if (_func_pthread_setcanceltype != NULL)
        {
        _func_pthread_setcanceltype(savtype, NULL);
        }

    errnoSet (EINTR);

    return (ERROR);
    }

/*******************************************************************************
*
* pause - suspend the task until delivery of a signal (POSIX)
*
* This routine suspends the task until delivery of a signal.
*
* NOTE: Since the pause() function suspends thread execution indefinitely,
* there is no successful completion return value.
*
* RETURNS: -1, always.
*
* ERRNO: EINTR
*/

int pause (void)

    {
    Q_HEAD qHead;
    int savtype;

#ifdef WV_INSTRUMENTATION
    /* windview - level 1 event logging */
    EVT_OBJ_SIG (EVENT_PAUSE, 1, taskIdCurrent,0);
#endif

    if (_func_pthread_setcanceltype != NULL)
        {
        _func_pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &savtype);
        }

    /*
     * Put ourself to sleep until a signal comes in.
     */
    qInit (&qHead, Q_FIFO, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

    kernelState = TRUE;				/* KERNEL ENTER */

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_OBJ_SIGPAUSE, taskIdCurrent);  /* log event */
#endif

    if (windPendQPut (&qHead, WAIT_FOREVER) != OK)
        {
	windExit ();				/* KERNEL EXIT */
	if (_func_pthread_setcanceltype != NULL)
            {
            _func_pthread_setcanceltype(savtype, NULL);
            }
	return (ERROR);
        }

    windExit ();				/* KERNEL EXIT */

    if (_func_pthread_setcanceltype != NULL)
        {
        _func_pthread_setcanceltype(savtype, NULL);
        }
    errnoSet (EINTR);

    return (ERROR);
    }

/*******************************************************************************
*
* sigtimedwait - wait for a signal
*
* The function sigtimedwait() selects the pending signal from the set
* specified by <pSet>.  If multiple signals in <pSet> are pending, it will
* remove and return the lowest numbered one.  If no signal in <pSet> is pending
* at the
* time of the call, the task will be suspend until one of the signals in <pSet>
* become pending, it is interrupted by an unblocked caught signal, or
* until the time interval specified by <pTimeout> has expired.
* If <pTimeout> is NULL, then the timeout interval is forever.
*
* If the <pInfo> argument is non-NULL, the selected signal number is
* stored in the `si_signo' member, and the cause of the signal is
* stored in the `si_code' member.  If the signal is a queued signal,
* the value is stored in the `si_value' member of <pInfo>; otherwise
* the content of `si_value' is undefined.
*
* The following values are defined in signal.h for `si_code':
* .iP SI_USER
* the signal was sent by the kill() function.
* .iP SI_QUEUE
* the signal was sent by the sigqueue() function.
* .iP SI_TIMER
* the signal was generated by the expiration of a timer set by timer_settime().
* .iP SI_ASYNCIO
* the signal was generated by the completion of an asynchronous I/O request.
* .iP SI_MESGQ
* the signal was generated by the arrival of a message on an empty message
* queue.
* .LP
*
* The function sigtimedwait() provides a synchronous mechanism for tasks
* to wait for asynchromously generated signals.  A task should use
* sigprocmask() to block any signals it wants to handle synchronously and
* leave their signal handlers in the default state.  The task can then
* make repeated calls to sigtimedwait() to remove any signals that are
* sent to it.
*
* RETURNS: Upon successful completion (that is, one of the signals specified
* by <pSet> is pending or is generated) sigtimedwait() will return the selected
* signal number.  Otherwise, a value of -1 is returned and `errno' is set to
* indicate the error.
*
* ERRNO
* .iP EINTR
* The wait was interrupted by an unblocked, caught signal.
* .iP EAGAIN
* No signal specified by <pSet> was delivered within the specified timeout
* period.
* .iP EINVAL
* The <pTimeout> argument specified a `tv_nsec' value less than zero or greater
* than or equal to 1000 million.
*
* SEE ALSO: sigwait()
*/

int sigtimedwait
    (
    const sigset_t		*pSet,	/* the signal mask while suspended */
    struct siginfo		*pInfo,	/* return value */
    const struct timespec	*pTimeout
    )
    {
    struct sigtcb *pSigTcb;
    struct sigwait waitinfo;
    struct siginfo info;
    int signo;
    int wait;
    int status;
    int savtype;

    if ((pSigTcb = sigTcbGet()) == NULL)
	return (ERROR);			/* errno was set */

    if (_func_pthread_setcanceltype != NULL)
        {
        _func_pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &savtype);
        }

    if (pTimeout != 0)
	{
	int tickRate = sysClkRateGet();

	if ((pTimeout->tv_nsec < 0) || (pTimeout->tv_nsec > 1000000000))
	    {
	    errno = EINVAL;
	    if (_func_pthread_setcanceltype != NULL)
                {
                _func_pthread_setcanceltype(savtype, NULL);
                }
	    return (ERROR);
	    }

	wait = pTimeout->tv_sec * tickRate +
		pTimeout->tv_nsec / (1000000000 / tickRate);
	}
    else
	wait = WAIT_FOREVER;

    kernelState = TRUE;				/* KERNEL ENTER */

    if ((signo = sigPendGet(pSigTcb, pSet, &info)) > 0)
	{
	windExit ();				/* KERNEL EXIT */
	if (pInfo != NULL)
		*pInfo = info;

        if (_func_pthread_setcanceltype != NULL)
            {
            _func_pthread_setcanceltype(savtype, NULL);
            }
	
	return (signo);
	}

    waitinfo.sigw_set = *pSet;
    qInit (&waitinfo.sigw_wait, Q_FIFO, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
    pSigTcb->sigt_wait = &waitinfo;

#ifdef WV_INSTRUMENTATION
    /* windview - level 2 event logging */
    EVT_TASK_1 (EVENT_OBJ_SIGWAIT, waitinfo.sigw_wait);
#endif

    if (windPendQPut (&waitinfo.sigw_wait, wait) != OK)
        {
	windExit ();				/* KERNEL EXIT */
 
        if (_func_pthread_setcanceltype != NULL)
            {
            _func_pthread_setcanceltype(savtype, NULL);
            }

        return (ERROR);
        }

    status = windExit ();				/* KERNEL EXIT */

    pSigTcb->sigt_wait = 0;

    if (status != 0)
	{ 
	if (_func_pthread_setcanceltype != NULL)
            {
            _func_pthread_setcanceltype(savtype, NULL);
            }

	errnoSet ((status == RESTART) ? EINTR : EAGAIN);
	return (-1);
	}

    if (pInfo != NULL)
	*pInfo = waitinfo.sigw_info;

    if (_func_pthread_setcanceltype != NULL)
        {
        _func_pthread_setcanceltype(savtype, NULL);
        }
 
    return (waitinfo.sigw_info.si_signo);
    }

/*******************************************************************************
*
* sigwaitinfo - wait for real-time signals
*
* The function sigwaitinfo() is equivalent to calling sigtimedwait() with
* <pTimeout> equal to NULL.  See that manual entry for more information.
*
* RETURNS: Upon successful completion (that is, one of the signals specified
* by <pSet> is pending or is generated) sigwaitinfo() returns the selected
* signal number.  Otherwise, a value of -1 is returned and `errno' is set to
* indicate the error.
*
* ERRNO
* .iP EINTR
* The wait was interrupted by an unblocked, caught signal.
*/

int sigwaitinfo
    (
    const sigset_t	*pSet,	/* the signal mask while suspended */
    struct siginfo	*pInfo	/* return value */
    )
    {

    return (sigtimedwait (pSet, pInfo, (struct timespec *)NULL));
    }

/*******************************************************************************
*
* sigwait - wait for a signal to be delivered (POSIX)
*