RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2024-12-29 04:50:03 +01:00
Code Releases Activity

sema: apply rename to function and type names

Browse Source
This commit is contained in:
Martine Lenders 2015-10-19 16:25:06 +02:00 committed by Martine Lenders
parent ee4f79482a
commit 5cef6bcc0a
4 changed files with 55 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
sys/include/sema.h
View File

@ -7,7 +7,7 @@
*/
/**
* @defgroup sys_sem Semaphores
* @defgroup sys_sema Semaphores
* @ingroup sys
* @brief Lightweight semaphore implementation
* @{
@ -22,6 +22,7 @@
#ifndef SEM_H_
#define SEM_H_
#include "msg.h"
#include "priority_queue.h"
#include "timex.h"
@ -35,7 +36,7 @@ extern "C" {
typedef struct {
volatile unsigned int value; /**< value of the semaphore */
priority_queue_t queue; /**< list of threads waiting for the semaphore */
} sem_t;
} sema_t;
/**
* @brief Creates semaphore.
@ -44,13 +45,13 @@ typedef struct {
* The Open Group Base Specifications Issue 7, sem_init()
* </a> (without `pshared` parameter)
*
* @param[out] sem The created semaphore.
* @param[out] sema The created semaphore.
* @param[in] value Initial value for the semaphore.
*
* @return 0 on success.
* @return -EINVAL, if semaphore is invalid.
*/
int sem_create(sem_t *sem, unsigned int value);
int sema_create(sema_t *sema, unsigned int value);
/**
* @brief Destroys a semaphore.
@ -59,19 +60,19 @@ int sem_create(sem_t *sem, unsigned int value);
* The Open Group Base Specifications Issue 7, sem_destroy()
* </a>
*
* @param[in] sem The semaphore to destroy.
* @param[in] sema The semaphore to destroy.
*
* @return 0 on success.
* @return -EINVAL, if semaphore is invalid.
*/
int sem_destroy(sem_t *sem);
int sema_destroy(sema_t *sema);
/**
* @brief Wait for a semaphore being posted.
*
* @pre Message queue of active thread is initialized (see @ref msg_init_queue()).
*
* @param[in] sem A semaphore.
* @param[in] sema A semaphore.
* @param[in] timeout Time until the semaphore times out. NULL for no timeout.
* @param[out] msg Container for a spurious message during the timed wait (result == -EAGAIN).
*
@ -81,12 +82,12 @@ int sem_destroy(sem_t *sem);
* @return -ECANCELED, if the semaphore was destroyed.
* @return -EAGAIN, if the thread received a message while waiting for the lock.
*/
int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg);
int sema_wait_timed_msg(sema_t *sema, timex_t *timeout, msg_t *msg);
/**
* @brief Wait for a semaphore being posted (without timeout).
*
* @param[in] sem A semaphore.
* @param[in] sema A semaphore.
* @param[out] msg Container for a spurious message during the timed wait (result == -EAGAIN).
*
* @return 0 on success
@ -94,16 +95,16 @@ int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg);
* @return -ECANCELED, if the semaphore was destroyed.
* @return -EAGAIN, if the thread received a message while waiting for the lock.
*/
static inline int sem_wait_msg(sem_t *sem, msg_t *msg)
static inline int sema_wait_msg(sema_t *sema, msg_t *msg)
{
return sem_wait_timed_msg(sem, NULL, msg);
return sema_wait_timed_msg(sema, NULL, msg);
}
/**
* @brief Wait for a semaphore being posted (dropping spurious messages).
* @details Any spurious messages received while waiting for the semaphore are silently dropped.
*
* @param[in] sem A semaphore.
* @param[in] sema A semaphore.
* @param[in] timeout Time until the semaphore times out. NULL for no timeout.
*
* @return 0 on success
@ -111,31 +112,31 @@ static inline int sem_wait_msg(sem_t *sem, msg_t *msg)
* @return -ETIMEDOUT, if the semaphore times out.
* @return -ECANCELED, if the semaphore was destroyed.
*/
int sem_wait_timed(sem_t *sem, timex_t *timeout);
int sema_wait_timed(sema_t *sema, timex_t *timeout);
/**
* @brief Wait for a semaphore being posted (without timeout, dropping spurious messages).
*
* @param[in] sem A semaphore.
* @param[in] sema A semaphore.
*
* @return 0 on success
* @return -EINVAL, if semaphore is invalid.
* @return -ECANCELED, if the semaphore was destroyed.
*/
static inline int sem_wait(sem_t *sem)
static inline int sema_wait(sema_t *sema)
{
return sem_wait_timed(sem, NULL);
return sema_wait_timed(sema, NULL);
}
/**
* @brief Signal semaphore.
*
* @param[in] sem A semaphore.
* @param[in] sema A semaphore.
*
* @return -EINVAL, if semaphore is invalid.
* @return -EOVERFLOW, if the semaphore's value would overflow.
*/
int sem_post(sem_t *sem);
int sema_post(sema_t *sema);
#ifdef __cplusplus
}

8
sys/posix/include/semaphore.h
View File

@ -32,6 +32,8 @@
extern "C" {
#endif
typedef sema_t sem_t;
/**
* @brief Value returned if `sem_open' failed.
*/
@ -58,7 +60,11 @@ extern "C" {
* @return 0 on success.
* @return -EINVAL, if semaphore is invalid.
*/
#define sem_init(sem, pshared, value) sem_create(sem, value)
#define sem_init(sem, pshared, value) sema_create((sema_t *)(sem), (value))
#define sem_destroy(sem) sema_destroy((sema_t *)(sem))
#define sem_post(sem) sema_post((sema_t *)(sem))
#define sem_wait(sem) sema_wait((sema_t *)(sem))
/**
* @brief Open a named semaphore @p name with open flags @p oflag.

2
sys/posix/semaphore/posix_semaphore.c
View File

@ -42,7 +42,7 @@ int sem_timedwait(sem_t *sem, const struct timespec *abstime)
return -ETIMEDOUT;
}
timeout = timex_sub(timeout, now);
res = sem_wait_timed(sem, &timeout);
res = sema_wait_timed(sem, &timeout);
if (res < 0) {
errno = -res;
}

61
sys/sema/sema.c
View File

@ -33,45 +33,39 @@
#define MSG_TIMEOUT (0x0502)
#define MSG_DESTROYED (0x0503)
int sem_create(sem_t *sem, unsigned int value)
int sema_create(sema_t *sema, unsigned int value)
{
if (sem == NULL) {
#ifdef MODULE_POSIX_SEMAPHORE
errno = EINVAL;
#endif
if (sema == NULL) {
return -EINVAL;
}
sem->value = value;
sema->value = value;
/* waiters for the mutex */
sem->queue.first = NULL;
sema->queue.first = NULL;
return 0;
}
int sem_destroy(sem_t *sem)
int sema_destroy(sema_t *sema)
{
unsigned int old_state;
priority_queue_node_t *next;
if (sem == NULL) {
#ifdef MODULE_POSIX_SEMAPHORE
errno = EINVAL;
#endif
if (sema == NULL) {
return -EINVAL;
}
old_state = disableIRQ();
while ((next = priority_queue_remove_head(&sem->queue)) != NULL) {
while ((next = priority_queue_remove_head(&sema->queue)) != NULL) {
msg_t msg;
kernel_pid_t pid = (kernel_pid_t)next->data;
msg.type = MSG_DESTROYED;
msg.content.ptr = (void *) sem;
msg.content.ptr = (void *) sema;
msg_send_int(&msg, pid);
}
restoreIRQ(old_state);
return 0;
}
int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg)
int sema_wait_timed_msg(sema_t *sema, timex_t *timeout, msg_t *msg)
{
if (sem == NULL) {
if (sema == NULL) {
return -EINVAL;
}
while (1) {
@ -79,9 +73,9 @@ int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg)
priority_queue_node_t n;
vtimer_t timeout_timer;
unsigned value = sem->value;
unsigned value = sema->value;
if (value != 0) {
sem->value = value - 1;
sema->value = value - 1;
restoreIRQ(old_state);
return 0;
}
@ -90,14 +84,14 @@ int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg)
n.priority = (uint32_t)sched_active_thread->priority;
n.data = (unsigned int)sched_active_pid;
n.next = NULL;
priority_queue_add(&sem->queue, &n);
priority_queue_add(&sema->queue, &n);
DEBUG("sem_wait: %" PRIkernel_pid ": Adding node to semaphore queue: prio: %" PRIu32 "\n",
DEBUG("sema_wait: %" PRIkernel_pid ": Adding node to semaphore queue: prio: %" PRIu32 "\n",
sched_active_thread->pid, sched_active_thread->priority);
if (timeout != NULL) {
vtimer_set_msg(&timeout_timer, *timeout, sched_active_pid,
MSG_TIMEOUT, sem);
MSG_TIMEOUT, sema);
}
restoreIRQ(old_state);
@ -107,7 +101,7 @@ int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg)
vtimer_remove(&timeout_timer); /* remove timer just to be sure */
}
if (msg->content.ptr != (void *) sem) {
if (msg->content.ptr != (void *) sema) {
return -EAGAIN;
}
@ -124,41 +118,42 @@ int sem_wait_timed_msg(sem_t *sem, timex_t *timeout, msg_t *msg)
}
}
int sem_wait_timed(sem_t *sem, timex_t *timeout)
int sema_wait_timed(sema_t *sema, timex_t *timeout)
{
int result;
do {
msg_t msg;
result = sem_wait_timed_msg(sem, timeout, &msg);
DEBUG("sem_wait: %" PRIkernel_pid ": Discarding message from %" PRIkernel_pid "\n",
result = sema_wait_timed_msg(sema, timeout, &msg);
DEBUG("sema_wait: %" PRIkernel_pid ": Discarding message from %" PRIkernel_pid "\n",
sched_active_thread->pid, msg->sender_pid);
} while (result == -EAGAIN);
}
while (result == -EAGAIN);
return result;
}
int sem_post(sem_t *sem)
int sema_post(sema_t *sema)
{
unsigned int old_state, value;
priority_queue_node_t *next;
if (sem == NULL) {
if (sema == NULL) {
return -EINVAL;
}
old_state = disableIRQ();
value = sem->value;
value = sema->value;
if (value == UINT_MAX) {
restoreIRQ(old_state);
return -EOVERFLOW;
}
++sem->value;
next = priority_queue_remove_head(&sem->queue);
++sema->value;
next = priority_queue_remove_head(&sema->queue);
if (next) {
uint16_t prio = (uint16_t)next->priority;
kernel_pid_t pid = (kernel_pid_t) next->data;
msg_t msg;
DEBUG("sem_post: %" PRIkernel_pid ": waking up %" PRIkernel_pid "\n",
DEBUG("sema_post: %" PRIkernel_pid ": waking up %" PRIkernel_pid "\n",
sched_active_thread->pid, next_process->pid);
msg.type = MSG_SIGNAL;
msg.content.ptr = (void *) sem;
msg.content.ptr = (void *) sema;
msg_send_int(&msg, pid);
restoreIRQ(old_state);
sched_switch(prio);