bool cFUSemaphore::Down(uint32 blockTime)
{
#if defined(WIN32)
return WaitForSingleObject(semaphoreHandle, blockTime) == WAIT_OBJECT_0;
#elif defined(FP_APPLE)
return MPWaitOnSemaphore(semaphoreHandle, (blockTime == (uint32)-1) ? kDurationForever : blockTime) == noErr;
#elif defined(LINUX) || defined(ANDROID) || defined(IOS)
if (blockTime == (uint32) -1)
{
return sem_wait(&semaphoreHandle) == 0;
}
else
{
#ifdef IOS
//f**k because I am f*****g lazy to implement this so...
return sem_wait(&semaphoreHandle) == 0;
#else
// The basic POSIX semaphore does not support a block time, but rather a deadline.
timespec deadline;
clock_gettime(CLOCK_REALTIME, &deadline);
deadline.tv_nsec += (blockTime * 1000);
return sem_timedwait(&semaphoreHandle, &deadline) == 0;
#endif
}
#endif
}
static int
do_test (void)
{
int res = 0;
int r;
struct timespec t = { -2, 0 };
pthread_t pth;
sem_init (&sem, 0, 0);
r = sem_timedwait (&sem, &t);
if (r != -1 || errno != ETIMEDOUT)
{
puts ("sem_timedwait did not fail with ETIMEDOUT");
res = 1;
}
pthread_mutex_lock (&m1);
pthread_rwlock_wrlock (&rw1);
pthread_rwlock_rdlock (&rw2);
pthread_mutex_lock (&m2);
if (pthread_create (&pth, 0, th, 0) != 0)
{
puts ("cannot create thread");
return 1;
}
r = pthread_cond_timedwait (&c, &m2, &t);
if (r != ETIMEDOUT)
{
puts ("pthread_cond_timedwait did not return ETIMEDOUT");
res = 1;
}
void *thres;
pthread_join (pth, &thres);
return res | (thres != NULL);
}
int DbDumperWriter::write_record(bool flush)
{
int ret = OB_SUCCESS;
RecordInfo * rec = NULL;
struct timespec timeout;
UNUSED(flush);
timeout.tv_sec = time(NULL) + kSemWaitTimeout;
timeout.tv_nsec = 0;
if (!records_.empty()) {
CThreadGuard gard(&records_lock_);
//no problem doing this, because only one thread is waiting on the queue
rec = records_.front();
} else if (running_) {
sem_timedwait(&sem_empty_, &timeout);
}
if (rec != NULL) {
CThreadGuard gard(&records_lock_);
if (file_ == NULL || (ret = file_->Append(rec->buf, rec->length)) != OB_SUCCESS) {
TBSYS_LOG(ERROR, "Write record failed, ret:%d, path:%s, len:%d", ret, path_.c_str(), rec->length);
} else {
writen_lines_++;
records_.pop_front();
free_record(rec);
}
}
return ret;
}
/*
* semaphore_posix_thrash()
* exercise the semaphore
*/
static void semaphore_posix_thrash(
const char *name,
const uint64_t max_ops,
uint64_t *counter)
{
do {
int i;
struct timespec timeout;
if (clock_gettime(CLOCK_REALTIME, &timeout) < 0) {
pr_fail_dbg(name, "clock_gettime");
return;
}
timeout.tv_sec++;
for (i = 0; i < 1000; i++) {
if (sem_timedwait(&shared->sem_posix.sem, &timeout) < 0) {
if (errno == ETIMEDOUT)
goto timed_out;
if (errno != EINTR)
pr_fail_dbg(name, "sem_wait");
break;
}
(*counter)++;
if (sem_post(&shared->sem_posix.sem) < 0) {
pr_fail_dbg(name, "sem_post");
break;
}
timed_out:
if (!opt_do_run)
break;
}
} while (opt_do_run && (!max_ops || *counter < max_ops));
}
///////////////////////////////////////////////////////////////////////
/// Function: TimedWait
///
/// Author: $author$
/// Date: 3/31/2012
///////////////////////////////////////////////////////////////////////
virtual XosError TimedWait
(const struct timespec& untilTime)
{
XosError error = XOS_ERROR_FAILED;
int err;
if ((m_isCreated))
if (!(err = sem_timedwait(&m_sem, &untilTime)))
error = XOS_ERROR_NONE;
else
if (ETIMEDOUT == err)
{
error = XOS_ERROR_TIMEDOUT;
XOS_DBT(("() timed out on sem_timedwait()\n"));
}
else
if (EINTR == err)
{
error = XOS_ERROR_INTERRUPTED;
XOS_DBT(("() interrupted on sem_timedwait()\n"));
}
else
{ XOS_DBE(("() failed (%d) on sem_timedwait()\n", err)); }
return error;
}
inline bool semaphore_timed_wait(sem_t *handle, const boost::posix_time::ptime &abs_time)
{
if(abs_time == boost::posix_time::pos_infin) {
semaphore_wait(handle);
return true;
}
#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
timespec tspec = ptime_to_timespec(abs_time);
for (;;) {
int res = sem_timedwait(handle, &tspec);
if(res == 0)
return true;
if (res > 0) {
//buggy glibc, copy the returned error code to errno
errno = res;
}
if(system_error_code() == ETIMEDOUT) {
return false;
}
throw interprocess_exception(system_error_code());
}
return false;
#else //#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
boost::posix_time::ptime now;
do {
if(semaphore_try_wait(handle))
return true;
thread_yield();
} while((now = microsec_clock::universal_time()) < abs_time);
return false;
#endif //#ifdef BOOST_INTERPROCESS_POSIX_TIMEOUTS
}
/* I have an XBee controlling relays for lights. It seems to become a little deaf when a number of
relays are on simultaneously, so I made safeTx(). safeTS() will retry the communication upto
retryCount times... seems to do the job :) */
int safeTx(struct xbee *xbee, struct xbee_con *con, int retryCount, struct xbee_pkt **pkt, char *format, ...) {
va_list ap;
sem_t *sem;
int ret;
if ((sem = xbee_conGetData(xbee, con)) == NULL) {
return 5;
}
/* send the request */
do {
va_start(ap, format);
ret = xbee_convTx(xbee, con, format, ap);
va_end(ap);
if (ret != 0) {
if (ret != 4) break;
} else {
/* if transmission succeeded, wait up to 5 seconds for the result (try again on timeout) */
struct timespec to;
clock_gettime(CLOCK_REALTIME, &to);
to.tv_sec += 5;
if (sem_timedwait(sem, &to)) {
printf("Timeout...\n");
ret = -1;
}
}
usleep(1000);
} while (ret && retryCount--);
*pkt = kPkt;
return ret;
}
bool CSem::Wait(int timeout)
{
#ifdef WIN32
if (timeout <= 0)
{
timeout = INFINITE;
}
if (WaitForSingleObject(m_hSem, timeout) != WAIT_OBJECT_0)
{
return false;
}
#else
if (timeout <= 0)
{
return (sem_wait(&m_semid) == 0);
}
else
{
timespec ts;
ts.tv_sec = time(NULL) + timeout/1000;
ts.tv_nsec = (timeout%1000)*1000000;
return (sem_timedwait(&m_semid, &ts) == 0);
}
#endif
return true;
}
static void *
tf (void *arg)
{
pthread_cleanup_push (cleanup, NULL);
int e = pthread_barrier_wait (&bar);
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
{
puts ("tf: 1st barrier_wait failed");
exit (1);
}
struct timeval tv;
(void) gettimeofday (&tv, NULL);
struct timespec ts;
TIMEVAL_TO_TIMESPEC (&tv, &ts);
/* Timeout in 5 seconds. */
ts.tv_sec += 5;
/* This call should block and be cancelable. */
sem_timedwait (&sem, &ts);
pthread_cleanup_pop (0);
puts ("sem_timedwait returned");
return NULL;
}
EXEC_RETURN sem_Lock(SEM sem,unsigned long msec){
#if defined(WIN32) || defined(_WIN64)
return WaitForSingleObject(sem,msec) == WAIT_OBJECT_0 ? EXEC_SUCCESS:EXEC_ERROR;
#else
int res;
if(!msec)
res = sem_trywait(sem);
else if(msec == ~0)
res = sem_wait(sem);
else{
#ifndef __APPLE__
struct timeval utc = {0};
struct timespec time_val = {0};
if(!gettimeofday(&utc,NULL)){
time_val.tv_sec = utc.tv_sec + msec / 1000;
msec %= 1000;
time_val.tv_nsec = utc.tv_usec * 1000 + msec * 1000000;
res = sem_timedwait(sem,&time_val);
}
#else
errno = EINVAL;
#endif
res = -1;
}
return res == 0 ? EXEC_SUCCESS:EXEC_ERROR;
#endif
}
WELS_THREAD_ERROR_CODE WelsEventWaitWithTimeOut (WELS_EVENT* event, uint32_t dwMilliseconds) {
if (dwMilliseconds != (uint32_t) - 1) {
return sem_wait (event);
} else {
#if defined(MACOS)
int32_t err = 0;
int32_t wait_count = 0;
do {
err = sem_trywait (event);
if (WELS_THREAD_ERROR_OK == err)
break;// WELS_THREAD_ERROR_OK;
else if (wait_count > 0)
break;
usleep (dwMilliseconds * 1000);
++ wait_count;
} while (1);
return err;
#else
struct timespec ts;
struct timeval tv;
gettimeofday (&tv, 0);
ts.tv_sec = tv.tv_sec + dwMilliseconds / 1000;
ts.tv_nsec = tv.tv_usec * 1000 + (dwMilliseconds % 1000) * 1000000;
return sem_timedwait (event, &ts);
#endif//MACOS
}
}
bool uHTTP::Semaphore::wait(time_t timeoutSec) {
if (!this->isInitialized)
return false;
bool isSuccess = true;
#if defined(__APPLE__)
if (0 < timeoutSec) {
mach_timespec_t machTimeout;
machTimeout.tv_sec = (unsigned int)timeoutSec;
machTimeout.tv_nsec = 0;
isSuccess = (semaphore_timedwait(semId, machTimeout) == KERN_SUCCESS) ? true : false;
}
else {
isSuccess = (semaphore_wait(semId) == KERN_SUCCESS) ? true : false;
}
#else
if (0 < timeoutSec) {
timespec absTimeout;
absTimeout.tv_sec = timeoutSec;
absTimeout.tv_nsec = 0;
isSuccess = (sem_timedwait(&semId, &absTimeout) == 0) ? true : false;
}
else {
isSuccess = (sem_wait(&semId) == 0) ? true : false;
}
#endif
return isSuccess;
}
static cs_error_t
reply_receive_in_buf (
struct ipc_instance *ipc_instance,
void **res_msg)
{
#if _POSIX_THREAD_PROCESS_SHARED < 1
struct sembuf sop;
#else
struct timespec timeout;
struct pollfd pfd;
#endif
int res;
#if _POSIX_THREAD_PROCESS_SHARED > 0
retry_semwait:
timeout.tv_sec = time(NULL) + IPC_SEMWAIT_TIMEOUT;
timeout.tv_nsec = 0;
res = sem_timedwait (&ipc_instance->control_buffer->sem1, &timeout);
if (res == -1 && errno == ETIMEDOUT) {
pfd.fd = ipc_instance->fd;
pfd.events = 0;
poll (&pfd, 1, 0);
if (pfd.revents == POLLERR || pfd.revents == POLLHUP) {
return (CS_ERR_LIBRARY);
}
goto retry_semwait;
}
if (res == -1 && errno == EINTR) {
goto retry_semwait;
}
#else
/*
* Wait for semaphore #1 indicating a new message from server
* to client in the response queue
*/
sop.sem_num = 1;
sop.sem_op = -1;
sop.sem_flg = 0;
retry_semop:
res = semop (ipc_instance->semid, &sop, 1);
if (res == -1 && errno == EINTR) {
return (CS_ERR_TRY_AGAIN);
} else
if (res == -1 && errno == EACCES) {
priv_change_send (ipc_instance);
goto retry_semop;
} else
if (res == -1) {
return (CS_ERR_LIBRARY);
}
#endif
*res_msg = (char *)ipc_instance->response_buffer;
return (CS_OK);
}
void *data_thread_function(void *arg) {
/* This thread reads data out of a ring buffer through a callback */
BufferSocket *bs = (BufferSocket *)arg;
RING_ITEM *this_slot;
struct timespec ts;
while (bs->run_threads) {
this_slot = bs->buf->read_ptr;
if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
fprintf(stderr, "Data: clock_gettime returned nonzero.\n");
bs->run_threads = 0;
continue;
}
ts.tv_nsec += 10000000; // 10 ms
// Wait for next buffer slot to fill up
if (sem_timedwait(&this_slot->read_mutex, &ts) == -1) continue;
//printf("Reading in a packet: size=%d slot=%d\n", this_slot->size, this_slot - bs->buf->list_ptr);
// Feed data from buffer slot to callback function
if (bs->callback((char *)this_slot->data,
this_slot->size, bs->userdata) != 0) {
fprintf(stderr, "Data: Callback returned nonzero.\n");
//bs->run_threads = 0;
} else {
// Release this slot for writing
sem_post(&this_slot->write_mutex);
bs->buf->read_ptr = this_slot->next;
}
}
return NULL;
}
// Wait for a component to transition to the specified state
OMX_ERRORTYPE COpenMax::WaitForState(OMX_STATETYPE state)
{
OMX_ERRORTYPE omx_error = OMX_ErrorNone;
OMX_STATETYPE test_state;
int tries = 0;
struct timespec timeout;
omx_error = OMX_GetState(m_omx_decoder, &test_state);
#if defined(OMX_DEBUG_VERBOSE)
CLog::Log(LOGDEBUG, "%s::%s - waiting for state(%d)\n", CLASSNAME, __func__, state);
#endif
while ((omx_error == OMX_ErrorNone) && (test_state != state))
{
clock_gettime(CLOCK_REALTIME, &timeout);
timeout.tv_sec += 1;
sem_timedwait(m_omx_decoder_state_change, &timeout);
if (errno == ETIMEDOUT)
tries++;
if (tries > 5)
return OMX_ErrorUndefined;
omx_error = OMX_GetState(m_omx_decoder, &test_state);
}
return omx_error;
}
static int sleep_until_start_request_or_inactivity()
{
SHOW_TIME("fifo > sleep_until_start_request_or_inactivity > ENTER");
int a_start_is_required=0;
// Wait for the start request (my_sem_start_is_required).
// Besides this, if the audio stream is still busy,
// check from time to time its end.
// The end of the stream is confirmed by several checks
// for filtering underflow.
//
int i=0;
while((i<= MAX_INACTIVITY_CHECK) && !a_start_is_required)
{
if (wave_is_busy( NULL) )
{
i = 0;
}
else
{
i++;
}
int err=0;
struct timespec ts;
struct timeval tv;
clock_gettime2( &ts);
#ifdef DEBUG_ENABLED
struct timespec to;
to.tv_sec = ts.tv_sec;
to.tv_nsec = ts.tv_nsec;
#endif
add_time_in_ms( &ts, INACTIVITY_TIMEOUT);
SHOW("fifo > sleep_until_start_request_or_inactivity > start sem_timedwait (start_is_required) from %d.%09lu to %d.%09lu \n",
to.tv_sec, to.tv_nsec,
ts.tv_sec, ts.tv_nsec);
while ((err = sem_timedwait(&my_sem_start_is_required, &ts)) == -1
&& errno == EINTR)
{
continue;
}
assert (gettimeofday(&tv, NULL) != -1);
SHOW("fifo > sleep_until_start_request_or_inactivity > stop sem_timedwait (start_is_required, err=%d) %d.%09lu \n", err,
tv.tv_sec, tv.tv_usec*1000);
if (err==0)
{
a_start_is_required = 1;
}
}
SHOW_TIME("fifo > sleep_until_start_request_or_inactivity > LEAVE");
return a_start_is_required;
}
bool Semaphore::wait(uint32_t timeout) {
timespec tsAbsTimeout;
clock_gettime(CLOCK_REALTIME, &tsAbsTimeout);
uint64_t absTimeout = ((uint64_t)tsAbsTimeout.tv_nsec) + (uint64_t)(timeout * 1000000LL);
tsAbsTimeout.tv_sec += absTimeout / 1000000000LL;
tsAbsTimeout.tv_nsec = absTimeout % 1000000000LL;
return (sem_timedwait(&mSemaphore, &tsAbsTimeout) == 0);
}
int main(int argc, char *argv[])
{
int rc;
sem_t sem;
struct timespec tp;
rc = sem_init(&sem, PTHREAD_PROCESS_PRIVATE, 1);
assert(rc == 0);
printf("sem_init passed\n");
/*
rc = sem_wait(sem);
assert(rc == 0);
printf("sem_wait passed\n");
*/
rc = sem_trywait(sem);
assert(rc == 0);
printf("sem_trywait passed\n");
arch_time_in_timespec(&tp);
tp.tv_sec += 1;
tp.tv_nsec += 15625000;
if (tp.tv_nsec >= POW10_9) {
tp.tv_nsec -= POW10_9;
tp.tv_sec += 1;
}
rc = sem_timedwait(sem, &tp);
assert(rc == -1);
assert(errno == ETIMEDOUT);
printf("sem_timedwait passed\n");
rc = sem_post(sem);
assert(rc == 0);
printf("sem_post passed\n");
rc = sem_destroy(sem);
assert(rc == 0);
printf("sem_destroy passed\n");
sem = sem_open("MySem", 0, 0, 1);
assert(sem == NULL);
printf("sem_open passed\n");
sem = sem_open("MySem", O_CREAT, 0, 1);
assert(sem != NULL);
printf("sem_open with create passed\n");
rc = sem_close(sem);
assert(rc == 0);
printf("sem_close passed\n");
rc = sem_unlink("MySem");
assert(rc == 0);
printf("sem_unlink passed\n");
return 0;
}
static int
do_test (void)
{
sem_t s;
if (sem_init (&s, 0, 0) == -1)
{
puts ("sem_init failed");
return 1;
}
struct timeval tv;
if (gettimeofday (&tv, NULL) != 0)
{
puts ("gettimeofday failed");
return 1;
}
struct timespec ts;
TIMEVAL_TO_TIMESPEC (&tv, &ts);
/* Set ts to yesterday. */
ts.tv_sec -= 86400;
int type_before;
if (pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &type_before) != 0)
{
puts ("first pthread_setcanceltype failed");
return 1;
}
errno = 0;
if (TEMP_FAILURE_RETRY (sem_timedwait (&s, &ts)) != -1)
{
puts ("sem_timedwait succeeded");
return 1;
}
if (errno != ETIMEDOUT)
{
printf ("sem_timedwait return errno = %d instead of ETIMEDOUT\n",
errno);
return 1;
}
int type_after;
if (pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &type_after) != 0)
{
puts ("second pthread_setcanceltype failed");
return 1;
}
if (type_after != PTHREAD_CANCEL_DEFERRED)
{
puts ("sem_timedwait changed cancellation type");
return 1;
}
return 0;
}
int lxclock(struct lxc_lock *l, int timeout)
{
int ret = -1, saved_errno = errno;
struct flock lk;
switch(l->type) {
case LXC_LOCK_ANON_SEM:
if (!timeout) {
ret = sem_wait(l->u.sem);
if (ret == -1)
saved_errno = errno;
} else {
struct timespec ts;
if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
ret = -2;
goto out;
}
ts.tv_sec += timeout;
ret = sem_timedwait(l->u.sem, &ts);
if (ret == -1)
saved_errno = errno;
}
break;
case LXC_LOCK_FLOCK:
ret = -2;
if (timeout) {
ERROR("Error: timeout not supported with flock");
ret = -2;
goto out;
}
if (!l->u.f.fname) {
ERROR("Error: filename not set for flock");
ret = -2;
goto out;
}
if (l->u.f.fd == -1) {
l->u.f.fd = open(l->u.f.fname, O_RDWR|O_CREAT,
S_IWUSR | S_IRUSR);
if (l->u.f.fd == -1) {
ERROR("Error opening %s", l->u.f.fname);
goto out;
}
}
lk.l_type = F_WRLCK;
lk.l_whence = SEEK_SET;
lk.l_start = 0;
lk.l_len = 0;
ret = fcntl(l->u.f.fd, F_SETLKW, &lk);
if (ret == -1)
saved_errno = errno;
break;
}
out:
errno = saved_errno;
return ret;
}
static int barrier_mutex_lock_to(struct tagged_barrier_entry *b, struct timespec *abs_timeout)
{
int err;
err = sem_timedwait(&b->mutex, abs_timeout);
if(err && errno == EINVAL) {
BLTS_LOGGED_PERROR("Sync: ERROR while locking barrier mutex");
}
return err?-errno:0;
}
void airport_takeoff_plane(airport *ap) {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5;
/* If we use sem_wait() here, we can get a deadlock while gracefully shutting down the application.
* Therefore, this blocks for a maximum of 5 seconds */
if (sem_timedwait(&ap->full, &ts) == 0) {
/* Acquire mutex lock to protect buffer */
pthread_mutex_lock(&(ap->baylock));
int bay_nr = get_random_alloc_bay_nr(ap);
plane *p = bay_unpark_plane(ap->bays[bay_nr]);
printf("After staying at bay %d for %.2f seconds, plane %s is taking off ...\n", bay_nr, bay_get_occupation_time(ap->bays[bay_nr]) / 1000.0f, plane_get_name(p));
bay_destroy(ap->bays[bay_nr]);
ap->bays[bay_nr] = NULL;
pthread_mutex_unlock(&(ap->baylock));
/* take-off time is 2 seconds */
int rw;
pthread_mutex_lock(&(ap->runwaylock));
if (sem_timedwait(&ap->runways, &ts) != 0) {
pthread_mutex_unlock(&(ap->runwaylock));
return;
}
sem_getvalue(&ap->runways, &rw);
pthread_mutex_unlock(&(ap->runwaylock));
/* landing time is 2 seconds */
msleep(2000);
sem_post(&ap->runways);
pthread_mutex_lock(&(ap->baylock));
printf("Plane %s has finished taking off on runway %d.\n", plane_get_name(p), rw);
plane_destroy(p);
pthread_mutex_unlock(&(ap->baylock));
sem_post(&ap->empty);
if (airport_is_empty(ap)) {
printf("The airport is empty\n");
}
}
}
static int audio_read_packet(AVFormatContext *context, AVPacket *pkt)
{
JackData *self = context->priv_data;
struct timespec timeout = {0, 0};
int test;
/* Activate the JACK client on first packet read. Activating the JACK client
* means that process_callback() starts to get called at regular interval.
* If we activate it in audio_read_header(), we're actually reading audio data
* from the device before instructed to, and that may result in an overrun. */
if (!self->activated) {
if (!jack_activate(self->client)) {
self->activated = 1;
av_log(context, AV_LOG_INFO,
"JACK client registered and activated (rate=%dHz, buffer_size=%d frames)\n",
self->sample_rate, self->buffer_size);
} else {
av_log(context, AV_LOG_ERROR, "Unable to activate JACK client\n");
return AVERROR(EIO);
}
}
/* Wait for a packet comming back from process_callback(), if one isn't available yet */
timeout.tv_sec = av_gettime() / 1000000 + 2;
if (sem_timedwait(&self->packet_count, &timeout)) {
if (errno == ETIMEDOUT) {
av_log(context, AV_LOG_ERROR,
"Input error: timed out when waiting for JACK process callback output\n");
} else {
av_log(context, AV_LOG_ERROR, "Error while waiting for audio packet: %s\n",
strerror(errno));
}
if (!self->client)
av_log(context, AV_LOG_ERROR, "Input error: JACK server is gone\n");
return AVERROR(EIO);
}
if (self->pkt_xrun) {
av_log(context, AV_LOG_WARNING, "Audio packet xrun\n");
self->pkt_xrun = 0;
}
if (self->jack_xrun) {
av_log(context, AV_LOG_WARNING, "JACK xrun\n");
self->jack_xrun = 0;
}
/* Retrieve the packet filled with audio data by process_callback() */
av_fifo_generic_read(self->filled_pkts, pkt, sizeof(*pkt), NULL);
if ((test = supply_new_packets(self, context)))
return test;
return 0;
}
u32_t sys_arch_sem_wait(sys_sem_t * sem, u32_t timeout)
{
lk_time_t start = current_time();
status_t err = sem_timedwait(sem, timeout ? timeout : INFINITE_TIME);
if (err == ERR_TIMED_OUT)
return SYS_ARCH_TIMEOUT;
return current_time() - start;
}
int Semaphore::lock( int interval )
{
TRACE(this);
if ( interval == 0 ) {
return sem_wait( &m_semaphore );
} else {
timespec tspec = intIntervalTotimespec( interval );
return sem_timedwait( &m_semaphore, &tspec );
}
}
void* test_semaphoreone_write(void* p) {
while(writecount) {
if (!sem_timedwait(&test_semaphoreone_semaphore,&test_semaphoreone_tval)) {
write(fd_out,(void*)&test_semaphoreone_val,4);
writecount--;
}
}
test_semaphoreone_halt=true;
return NULL;
}
int
ui_ipc_semtimedwait(enum UI_IPC_SEM e_sp, time_t tmout)
{
struct timespec ts;
if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
return -1;
}
ts.tv_sec += tmout;
return ( sem_timedwait(sems[e_sp], &ts) );
}
static acquire_result
acquire_lock(sem_t *sem, double timeout)
{
int err;
struct timespec deadline;
if (timeout > 0) {
if (deadline_from_timeout(timeout, &deadline)) {
PyErr_SetString(PyExc_OverflowError,
"timeout value is too large");
return ACQUIRE_ERROR;
}
}
/* First try non-blocking acquire without releasing the GIL. If this fails
* and we have a timeout, release the GIL and block until we get the lock
* or the timeout expires. */
do {
err = sem_trywait(sem);
} while (err != 0 && errno == EINTR);
if (err == 0)
return ACQUIRE_OK;
if (errno != EAGAIN) {
set_error(errno, "sem_trywait");
return ACQUIRE_ERROR;
}
if (timeout == 0)
return ACQUIRE_FAIL;
Py_BEGIN_ALLOW_THREADS;
do {
if (timeout > 0)
err = sem_timedwait(sem, &deadline);
else
err = sem_wait(sem);
} while (err != 0 && errno == EINTR);
Py_END_ALLOW_THREADS;
if (err != 0) {
if (timeout > 0 && errno == ETIMEDOUT)
return ACQUIRE_FAIL;
/* Should never happen */
set_error(errno, timeout > 0 ? "sem_timedwait" : "sem_wait");
return ACQUIRE_ERROR;
}
return ACQUIRE_OK;
}
int main(void) {
void *d;
struct xbee *xbee;
struct xbee_con *con;
xbee_err ret;
unsigned char txRet;
struct timespec to;
if (sem_init(&ndComplete, 0, 0) != 0) {
printf("sem_init() returned an error: %d - %s\n", errno, strerror(errno));
return -1;
}
if ((ret = xbee_setup(&xbee, "xbee1", "/dev/ttyUSB0", 57600)) != XBEE_ENONE) {
printf("ret: %d (%s)\n", ret, xbee_errorToStr(ret));
return ret;
}
if ((ret = xbee_conNew(xbee, &con, "Local AT", NULL)) != XBEE_ENONE) {
xbee_log(xbee, -1, "xbee_conNew() returned: %d (%s)", ret, xbee_errorToStr(ret));
return ret;
}
if ((ret = xbee_conCallbackSet(con, nodeCB, NULL)) != XBEE_ENONE) {
xbee_log(xbee, -1, "xbee_conCallbackSet() returned: %d", ret);
return ret;
}
if ((ret = xbee_conTx(con, &txRet, "ND")) != XBEE_ENONE && (ret != XBEE_ETX && ret != XBEE_ETIMEOUT)) {
xbee_log(xbee, -1, "xbee_conTx() returned: %d-%d", ret, txRet);
return ret;
}
printf("ND Sent!... waiting for completion\n");
clock_gettime(CLOCK_REALTIME, &to);
to.tv_sec += 10;
if (sem_timedwait(&ndComplete, &to) != 0) {
if (errno == ETIMEDOUT) {
printf("Timeout while waiting for ND command to complete...\n");
} else {
printf("Error calling sem_timedwait()... sleeping for 10 seconds instead\n");
sleep(10);
}
}
if ((ret = xbee_conEnd(con)) != XBEE_ENONE) {
xbee_log(xbee, -1, "xbee_conEnd() returned: %d", ret);
return ret;
}
xbee_shutdown(xbee);
return 0;
}
static void test_sem_null(void)
{
int rv;
int val;
struct timespec to;
rtems_test_assert( NULL == SEM_FAILED );
errno = 0;
rv = sem_init( NULL, 0, 0 );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_wait( NULL );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_post( NULL );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_wait( NULL );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_trywait( NULL );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
to.tv_sec = 1;
to.tv_nsec = 1;
errno = 0;
rv = sem_timedwait( NULL, &to );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_getvalue( NULL, &val );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_destroy( NULL );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
errno = 0;
rv = sem_close( NULL );
rtems_test_assert( rv == -1 );
rtems_test_assert( errno == EINVAL );
}