rem: * is not documented (perhaps, as above, it's possible it * bubbles up from _lwp_cond_timedwait???).  Anyway, unlike * the ETIME case above, we'll assume the wakeup is truely
add: * is not documented.  We assume the wakeup is truely
context: Ns_CondTimedWait(Ns_Cond *condPtr, Ns_Mutex *mutexPtr, Ns_Time *timePtr){    pthread_cond_t  *cond = GETCOND(condPtr);    pthread_mutex_t *lock = (pthread_mutex_t *) *mutexPtr;    int              err, status;    struct timespec  ts;    if (timePtr == NULL) {	Ns_CondWait(condPtr, mutexPtr);	return NS_OK;    }    /*     * Convert the microsecond-based Ns_Time to a nanosecond-based     * struct timespec.     */    ts.tv_sec = timePtr->sec;    ts.tv_nsec = timePtr->usec * 1000;    /*     * As documented on Linux, pthread_cond_timedwait may return     * EINTR if a signal arrives.  We have noticed that      * EINTR can be returned on Solaris as well although this     * is not documented (perhaps, as above, it's possible it     * bubbles up from _lwp_cond_timedwait???).  Anyway, unlike     * the ETIME case above, we'll assume the wakeup is truely     * spurious and simply restart the wait knowing that the     * ts structure has not been modified.     */    do {    	err = pthread_cond_timedwait(cond, lock, &ts);    } while (err == EINTR);#ifdef HAVE_ETIME_BUG    /*     * See comments above and note that here ETIME is still considered     * a spurious wakeup, not an indication of timeout because we're     * not making any assumptions about the nature or this bug.     * While we're less certain, this should still be ok as properly     * written condition code should tolerate the wakeup.     */    if (err == ETIME) {	err = 0;    }#endif    if (err == ETIMEDOUT) {	status = NS_TIMEOUT;    } else if (err != 0) {	NsThreadFatal("Ns_CondTimedWait", "pthread_cond_timedwait", err);    } else {	status = NS_OK;    }    return status;}