SyncSemWait(), SyncSemWait_r()

Wait on a semaphore

Synopsis:

#include <sys/neutrino.h>

int SyncSemWait( sync_t* sync, 
                 int try );

int SyncSemWait_r( sync_t* sync, 
                   int try );

Arguments:

sync: A pointer to the synchronization object for the semaphore that you want to wait on.
try: Nonzero if you want a conditional wait.

Library:

libc

Use the -l c option to qcc to link against this library. This library is usually included automatically.

The SyncSemWait() and SyncSemWait_r() kernel calls decrement the semaphore referred to by the sync argument. If the semaphore value isn't greater than zero and try is zero, then the calling process blocks until it can decrement the counter or the call is interrupted by signal.

These functions are identical, except in the way they indicate errors. See the Returns section for details.

Instead of using these kernel calls directly, consider calling sem_timedwait(), sem_trywait() or sem_wait().

If try is nonzero, the function acts as a conditional wait. If the call would block, the semaphore is unmodified, and the call returns with an error.

Returns:

The only difference between these functions is the way they indicate errors:

SyncSemWait(): If an error occurs, the function returns -1 and sets errno. Any other value returned indicates success (the semaphore was successfully decremented).
SyncSemWait_r(): Returns EOK on success (the semaphore was successfully decremented). This function does NOT set errno. If an error occurs, the function returns one of the values listed in the Errors section.

Errors:

EAGAIN: Call would have blocked and try was nonzero.
EDEADLK: A deadlock condition was detected.
EINTR: A signal interrupted this function.
EINVAL: The sync argument doesn't refer to a valid semaphore.

Classification:

QNX Neutrino

Safety:
Cancellation point	No
Interrupt handler	No
Signal handler	Yes
Thread	Yes