This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Include dependency graph for sem.c:
Functions | |
void | rt_typed_sem_init (SEM *sem, int value, int type) |
Initialize a specifically typed (counting, binary, resource) semaphore. | |
void | rt_sem_init (SEM *sem, int value) |
Initialize a counting semaphore. | |
int | rt_sem_delete (SEM *sem) |
Delete a semaphore. | |
int | rt_sem_signal (SEM *sem) |
Signaling a semaphore. | |
int | rt_sem_broadcast (SEM *sem) |
Signaling a semaphore. | |
int | rt_sem_wait (SEM *sem) |
Take a semaphore. | |
int | rt_sem_wait_if (SEM *sem) |
Take a semaphore, only if the calling task is not blocked. | |
int | rt_sem_wait_until (SEM *sem, RTIME time) |
Wait a semaphore with timeout. | |
int | rt_sem_wait_timed (SEM *sem, RTIME delay) |
Wait a semaphore with timeout. | |
int | rt_sem_wait_barrier (SEM *sem) |
Wait on a semaphore barrier. | |
int | rt_cond_signal (CND *cnd) |
Wait for a signal to a conditional variable. | |
int | rt_cond_wait (CND *cnd, SEM *mtx) |
Wait for a signal to a conditional variable. | |
int | rt_cond_wait_until (CND *cnd, SEM *mtx, RTIME time) |
Wait a semaphore with timeout. | |
int | rt_cond_wait_timed (CND *cnd, SEM *mtx, RTIME delay) |
Wait a semaphore with timeout. | |
int | rt_rwl_init (RWL *rwl) |
Initialize a multi readers single writer lock. | |
int | rt_rwl_delete (RWL *rwl) |
destroys a multi readers single writer lock. | |
int | rt_rwl_rdlock (RWL *rwl) |
acquires a multi readers single writer lock for reading. | |
int | rt_rwl_rdlock_if (RWL *rwl) |
try to acquire a multi readers single writer lock just for reading. | |
int | rt_rwl_rdlock_until (RWL *rwl, RTIME time) |
try to acquire a multi readers single writer lock for reading within an absolute deadline time. | |
int | rt_rwl_rdlock_timed (RWL *rwl, RTIME delay) |
try to acquire a multi readers single writer lock for reading within a relative deadline time. | |
int | rt_rwl_wrlock (RWL *rwl) |
acquires a multi readers single writer lock for wrtiting. | |
int | rt_rwl_wrlock_if (RWL *rwl) |
acquires a multi readers single writer lock for writing. | |
int | rt_rwl_wrlock_until (RWL *rwl, RTIME time) |
try to acquire a multi readers single writer lock for writing within an absolute deadline time. | |
int | rt_rwl_wrlock_timed (RWL *rwl, RTIME delay) |
try to acquire a multi readers single writer lock for writing within a relative deadline time. | |
int | rt_rwl_unlock (RWL *rwl) |
unlock an acquired multi readers single writer lock. | |
int | rt_spl_init (SPL *spl) |
Initialize a spinlock. | |
int | rt_spl_delete (SPL *spl) |
Initialize a spinlock. | |
int | rt_spl_lock (SPL *spl) |
Acquire a spinlock. | |
int | rt_spl_lock_if (SPL *spl) |
Acquire a spinlock without waiting. | |
int | rt_spl_lock_timed (SPL *spl, unsigned long ns) |
Acquire a spinlock with timeout. | |
int | rt_spl_unlock (SPL *spl) |
Release an owned spinlock. | |
SEM * | _rt_typed_named_sem_init (unsigned long sem_name, int value, int type) |
Initialize a specifically typed (counting, binary, resource) semaphore identified by a name. | |
int | rt_named_sem_delete (SEM *sem) |
Delete a semaphore initialized in named mode. | |
RWL * | _rt_named_rwl_init (unsigned long rwl_name) |
Initialize a multi readers single writer lock identified by a name. | |
int | rt_named_rwl_delete (RWL *rwl) |
Delete a multi readers single writer lock in named mode. | |
SPL * | _rt_named_spl_init (unsigned long spl_name) |
Initialize a spinlock identified by a name. | |
int | rt_named_spl_delete (SPL *spl) |
Delete a spinlock in named mode. |
|
Wait for a signal to a conditional variable. rt_cond_signal resumes one of the tasks that are waiting on the condition semaphore cnd. Nothing happens if no task is waiting on cnd, while it resumed the first queued task blocked on cnd, according to the queueing method set at rt_cond_init.
|
|
Wait for a signal to a conditional variable. rt_cond_wait atomically unlocks mtx (as for using rt_sem_signal) and waits for the condition semaphore cnd to be signaled. The task execution is suspended until the condition semaphore is signalled. Mtx must be obtained by the calling task, before calling rt_cond_wait is called. Before returning to the calling task rt_cond_wait reacquires mtx by calling rt_sem_wait.
|
|
Wait a semaphore with timeout. rt_cond_wait_timed atomically unlocks mtx (as for using rt_sem_signal) and waits for the condition semaphore cnd to be signalled. The task execution is suspended until the condition semaphore is either signaled or a timeout expires. Mtx must be obtained by the calling task, before calling rt_cond_wait is called. Before returning to the calling task rt_cond_wait_until reacquires mtx by calling rt_sem_wait and returns a value to indicate if it has been signalled pr timedout.
|
|
Wait a semaphore with timeout. rt_cond_wait_until atomically unlocks mtx (as for using rt_sem_signal) and waits for the condition semaphore cnd to be signalled. The task execution is suspended until the condition semaphore is either signaled or a timeout expires. Mtx must be obtained by the calling task, before calling rt_cond_wait is called. Before returning to the calling task rt_cond_wait_until reacquires mtx by calling rt_sem_wait and returns a value to indicate if it has been signalled pr timedout.
|
|
Delete a semaphore initialized in named mode. rt_named_sem_delete deletes a semaphore previously created with _rt_typed_named_sem_init().
|
|
Signaling a semaphore. rt_sem_broadcast signals an event to a semaphore that unblocks all tasks waiting on it. It is used as a support for RTAI proper conditional variables but can be of help in many other instances. After the broadcast the semaphore counts is set to zero, thus all tasks waiting on it will blocked.
|
|
Delete a semaphore. rt_sem_delete deletes a semaphore previously created with rt_sem_init().
|
|
Signaling a semaphore. rt_sem_signal signals an event to a semaphore. It is typically called when the task leaves a critical region. The semaphore value is incremented and tested. If the value is not positive, the first task in semaphore's waiting queue is allowed to run. rt_sem_signal never blocks the caller task.
|
|
Take a semaphore. rt_sem_wait waits for a event to be signaled to a semaphore. It is typically called when a task enters a critical region. The semaphore value is decremented and tested. If it is still non-negative rt_sem_wait returns immediately. Otherwise the caller task is blocked and queued up. Queuing may happen in priority order or on FIFO base. This is determined by the compile time option SEM_PRIORD. In this case rt_sem_wait returns if:
|
|
Wait on a semaphore barrier. rt_sem_wait_barrier is a gang waiting in that a task issuing such a request will be blocked till a number of tasks equal to the semaphore count set at rt_sem_init is reached.
|
|
Take a semaphore, only if the calling task is not blocked. rt_sem_wait_if is a version of the semaphore wait operation is similar to rt_sem_wait() but it is never blocks the caller. If the semaphore is not free, rt_sem_wait_if returns immediately and the semaphore value remains unchanged.
|
|
Wait a semaphore with timeout. rt_sem_wait_timed, like rt_sem_wait_until(), is a timed version of the standard semaphore wait call. The semaphore value is decremented and tested. If it is still non-negative these functions return immediately. Otherwise the caller task is blocked and queued up. Queuing may happen in priority order or on FIFO base. This is determined by the compile time option SEM_PRIORD. In this case the function returns if:
In case of a timeout, the semaphore value is incremented before return.
|
|
Wait a semaphore with timeout. rt_sem_wait_until, like rt_sem_wait_timed() is a timed version of the standard semaphore wait call. The semaphore value is decremented and tested. If it is still non-negative these functions return immediately. Otherwise the caller task is blocked and queued up. Queuing may happen in priority order or on FIFO base. This is determined by the compile time option SEM_PRIORD. In this case the function returns if:
In case of a timeout, the semaphore value is incremented before return.
|