nuttx/nuttx-mirror
1
2
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2025-01-13 06:18:40 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

use rmutex inside of all repeated implementation

Browse source 
Signed-off-by: anjiahao <anjiahao@xiaomi.com>
This commit is contained in:
anjiahao 2022-05-29 23:59:14 +08:00 committed by Xiang Xiao
parent 56e8bb1759
commit b88a8cf39f
27 changed files with 189 additions and 993 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

108
drivers/1wire/1wire.c
View file

@ -103,32 +103,6 @@ static inline uint32_t onewire_leuint32(uint32_t x)
}
#endif
/****************************************************************************
* Name: onewire_sem_init
*
* Description:
*
****************************************************************************/
static inline void onewire_sem_init(FAR struct onewire_sem_s *sem)
{
sem->holder = NO_HOLDER;
sem->count = 0;
nxsem_init(&sem->sem, 0, 1);
}
/****************************************************************************
* Name: onewire_sem_destroy
*
* Description:
*
****************************************************************************/
static inline void onewire_sem_destroy(FAR struct onewire_sem_s *sem)
{
nxsem_destroy(&sem->sem);
}
/****************************************************************************
* Name: onewire_pm_prepare
*
@ -211,80 +185,6 @@ static int onewire_pm_prepare(FAR struct pm_callback_s *cb, int domain,
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: onewire_sem_wait
*
* Description:
* Take the exclusive access, waiting as necessary
*
****************************************************************************/
int onewire_sem_wait(FAR struct onewire_master_s *master)
{
pid_t me;
int ret;
/* Do we already hold the semaphore? */
me = getpid();
if (me == master->devsem.holder)
{
/* Yes... just increment the count */
master->devsem.count++;
DEBUGASSERT(master->devsem.count > 0);
}
/* Take the semaphore (perhaps waiting) */
else
{
ret = nxsem_wait(&master->devsem.sem);
if (ret < 0)
{
return ret;
}
/* Now we hold the semaphore */
master->devsem.holder = me;
master->devsem.count = 1;
}
return OK;
}
/****************************************************************************
* Name: onewire_sem_post
*
* Description:
* Release the mutual exclusion semaphore
*
****************************************************************************/
void onewire_sem_post(FAR struct onewire_master_s *master)
{
DEBUGASSERT(master->devsem.holder == getpid());
/* Is this our last count on the semaphore? */
if (master->devsem.count > 1)
{
/* No.. just decrement the count */
master->devsem.count--;
}
/* Yes.. then we can really release the semaphore */
else
{
master->devsem.holder = NO_HOLDER;
master->devsem.count = 0;
nxsem_post(&master->devsem.sem);
}
}
/****************************************************************************
* Name: onewire_reset_resume
*
@ -529,7 +429,7 @@ int onewire_search(FAR struct onewire_master_s *master,
/* Make complete search on the bus mutal exclusive */
ret = onewire_sem_wait(master);
ret = nxrmutex_lock(&master->devlock);
if (ret < 0)
{
return ret;
@ -663,7 +563,7 @@ int onewire_search(FAR struct onewire_master_s *master,
}
unlock:
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return (ret < 0) ? ret : nslaves_match;
}
@ -743,7 +643,7 @@ onewire_initialize(FAR struct onewire_dev_s *dev, int maxslaves)
/* Initialize the device structure */
master->dev = dev;
onewire_sem_init(&master->devsem);
nxrmutex_init(&master->devlock);
master->nslaves = 0;
master->maxslaves = maxslaves;
master->insearch = false;
@ -780,7 +680,7 @@ int onewire_uninitialize(FAR struct onewire_master_s *master)
/* Release resources. This does not touch the underlying onewire_dev_s */
onewire_sem_destroy(&master->devsem);
nxrmutex_destroy(&master->devlock);
kmm_free(master);
return OK;
}

14
drivers/1wire/1wire_internal.h
View file

@ -28,7 +28,7 @@
#include <nuttx/config.h>
#include <stdbool.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include <nuttx/power/pm.h>
/****************************************************************************
@ -37,17 +37,10 @@
struct onewire_dev_s;
struct onewire_sem_s
{
sem_t sem;
pid_t holder; /* The current holder of the semaphore */
int16_t count; /* Number of counts held */
};
struct onewire_master_s
{
FAR struct onewire_dev_s *dev; /* 1-Wire lower half */
struct onewire_sem_s devsem; /* Re-entrant semaphore */
rmutex_t devlock; /* Re-entrant lock */
int nslaves; /* Number of 1-wire slaves */
int maxslaves; /* Maximum number of 1-wire slaves */
bool insearch; /* If we are in middle of 1-wire search */
@ -72,9 +65,6 @@ bool onewire_valid_rom(uint64_t rom);
/* Rest are from 1wire.c */
int onewire_sem_wait(FAR struct onewire_master_s *master);
void onewire_sem_post(FAR struct onewire_master_s *master);
int onewire_addslave(FAR struct onewire_master_s *master,
FAR struct onewire_slave_s *slave);
int onewire_removeslave(FAR struct onewire_master_s *master,

4
drivers/1wire/1wire_read.c
View file

@ -69,7 +69,7 @@ int onewire_read(FAR struct onewire_master_s *master,
return -EAGAIN;
}
ret = onewire_sem_wait(master);
ret = nxrmutex_lock(&master->devlock);
if (ret < 0)
{
return ret;
@ -86,6 +86,6 @@ int onewire_read(FAR struct onewire_master_s *master,
ret = ONEWIRE_READ(master->dev, buffer, buflen);
err_unlock:
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return ret;
}

4
drivers/1wire/1wire_write.c
View file

@ -70,7 +70,7 @@ int onewire_write(FAR struct onewire_master_s *master,
return -EAGAIN;
}
ret = onewire_sem_wait(master);
ret = nxrmutex_lock(&master->devlock);
if (ret < 0)
{
return ret;
@ -87,6 +87,6 @@ int onewire_write(FAR struct onewire_master_s *master,
ret = ONEWIRE_WRITE(master->dev, buffer, buflen);
err_unlock:
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return ret;
}

4
drivers/1wire/1wire_writeread.c
View file

@ -74,7 +74,7 @@ int onewire_writeread(FAR struct onewire_master_s *master,
return -EAGAIN;
}
ret = onewire_sem_wait(master);
ret = nxrmutex_lock(&master->devlock);
if (ret < 0)
{
return ret;
@ -97,6 +97,6 @@ int onewire_writeread(FAR struct onewire_master_s *master,
ret = ONEWIRE_READ(master->dev, rbuffer, rbuflen);
err_unlock:
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return ret;
}

16
drivers/1wire/ds28e17.c
View file

@ -155,7 +155,7 @@ static inline int ds_i2c_sem_wait(FAR struct i2c_master_s *i2cdev)
FAR struct ds_i2c_inst_s *inst = (FAR struct ds_i2c_inst_s *)i2cdev;
FAR struct onewire_master_s *master = inst->master;
return onewire_sem_wait(master);
return nxrmutex_lock(&master->devlock);
}
/****************************************************************************
@ -171,7 +171,7 @@ static inline void ds_i2c_sem_post(FAR struct i2c_master_s *i2cdev)
FAR struct ds_i2c_inst_s *inst = (FAR struct ds_i2c_inst_s *)i2cdev;
FAR struct onewire_master_s *master = inst->master;
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
}
static int ds_error(uint8_t buf[])
@ -917,7 +917,7 @@ FAR struct i2c_master_s *
/* We need a recursive lock as this may be called from a search callback. */
ret = onewire_sem_wait(master);
ret = nxrmutex_lock(&master->devlock);
if (ret < 0)
{
kmm_free(inst);
@ -929,7 +929,7 @@ FAR struct i2c_master_s *
{
kmm_free(inst);
i2cerr("ERROR: Failed to add slave\n");
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return NULL;
}
@ -947,7 +947,7 @@ FAR struct i2c_master_s *
ds28e17_selftest(inst);
}
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return (struct i2c_master_s *)inst;
}
@ -973,7 +973,7 @@ int ds28e17_lower_half_unregister(FAR struct ds28e17_dev_s *priv,
FAR struct onewire_master_s *master = inst->master;
int ret;
ret = onewire_sem_wait(master);
ret = nxrmutex_lock(&master->devlock);
if (ret < 0)
{
return ret;
@ -984,12 +984,12 @@ int ds28e17_lower_half_unregister(FAR struct ds28e17_dev_s *priv,
{
kmm_free(inst);
i2cerr("ERROR: Failed to remove slave\n");
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return ret;
}
kmm_free(inst);
onewire_sem_post(master);
nxrmutex_unlock(&master->devlock);
return OK;
}

2
drivers/clk/clk.c
View file

@ -45,7 +45,7 @@
* Private Datas
****************************************************************************/
static mutex_t g_clk_list_lock = MUTEX_INITIALIZER;
static mutex_t g_clk_list_lock = NXMUTEX_INITIALIZER;
static struct list_node g_clk_root_list
= LIST_INITIAL_VALUE(g_clk_root_list);

2
drivers/clk/clk_rpmsg.c
View file

@ -192,7 +192,7 @@ static int clk_rpmsg_set_phase(FAR struct clk_s *clk, int degrees);
* Private Datas
****************************************************************************/
static mutex_t g_clk_rpmsg_lock = MUTEX_INITIALIZER;
static mutex_t g_clk_rpmsg_lock = NXMUTEX_INITIALIZER;
static struct list_node g_clk_rpmsg_priv =
LIST_INITIAL_VALUE(g_clk_rpmsg_priv);

2
drivers/power/pm.h
View file

@ -29,7 +29,7 @@
#include <queue.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include <nuttx/clock.h>
#include <nuttx/power/pm.h>
#include <nuttx/wdog.h>

2
drivers/power/regulator_rpmsg.c
View file

@ -153,7 +153,7 @@ static int regulator_rpmsg_is_enabled(FAR struct regulator_dev_s *rdev);
* Private Data
****************************************************************************/
static mutex_t g_regulator_rpmsg_lock = MUTEX_INITIALIZER;
static mutex_t g_regulator_rpmsg_lock = NXMUTEX_INITIALIZER;
static struct list_node g_regulator_rpmsg_priv =
LIST_INITIAL_VALUE(g_regulator_rpmsg_priv);

61
drivers/rptun/rptun.c
View file

@ -32,6 +32,7 @@
#include <nuttx/board.h>
#include <nuttx/kmalloc.h>
#include <nuttx/kthread.h>
#include <nuttx/mutex.h>
#include <nuttx/semaphore.h>
#include <nuttx/rptun/openamp.h>
#include <nuttx/rptun/rptun.h>
@ -53,8 +54,10 @@
# define ALIGN_UP(s, a) (((s) + (a) - 1) & ~((a) - 1))
#endif
#define rptun_lock() nxrmutex_lock(&g_rptunlock)
#define rptun_unlock() nxrmutex_unlock(&g_rptunlock)
#define RPTUNIOC_NONE 0
#define NO_HOLDER (INVALID_PROCESS_ID)
#define RPTUN_OPS_START 0
#define RPTUN_OPS_DUMP 1
@ -197,9 +200,7 @@ static struct image_store_ops g_rptun_storeops =
};
#endif
static sem_t g_rptunlock = SEM_INITIALIZER(1);
static pid_t g_holder = NO_HOLDER;
static unsigned int g_count;
static rmutex_t g_rptunlock = NXRMUTEX_INITIALIZER;
static METAL_DECLARE_LIST(g_rptun_cb);
static METAL_DECLARE_LIST(g_rptun_priv);
@ -208,58 +209,6 @@ static METAL_DECLARE_LIST(g_rptun_priv);
* Private Functions
****************************************************************************/
static int rptun_lock(void)
{
pid_t me = getpid();
int ret = OK;
/* Does this thread already hold the semaphore? */
if (g_holder == me)
{
/* Yes.. just increment the reference count */
g_count++;
}
else
{
/* No.. take the semaphore (perhaps waiting) */
ret = nxsem_wait_uninterruptible(&g_rptunlock);
if (ret >= 0)
{
/* Now this thread holds the semaphore */
g_holder = me;
g_count = 1;
}
}
return ret;
}
static void rptun_unlock(void)
{
DEBUGASSERT(g_holder == getpid() && g_count > 0);
/* If the count would go to zero, then release the semaphore */
if (g_count == 1)
{
/* We no longer hold the semaphore */
g_holder = NO_HOLDER;
g_count = 0;
nxsem_post(&g_rptunlock);
}
else
{
/* We still hold the semaphore. Just decrement the count */
g_count--;
}
}
#ifdef CONFIG_RPTUN_PM
static inline void rptun_pm_action(FAR struct rptun_priv_s *priv,
bool stay)

79
drivers/syslog/syslog_device.c
View file

@ -38,7 +38,7 @@
#include <nuttx/arch.h>
#include <nuttx/kmalloc.h>
#include <nuttx/fs/fs.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include <nuttx/syslog/syslog.h>
#include <nuttx/compiler.h>
@ -54,10 +54,8 @@
*/
#define SYSLOG_OFLAGS (O_WRONLY | O_CREAT | O_APPEND)
/* An invalid thread ID */
#define NO_HOLDER (INVALID_PROCESS_ID)
#define syslog_dev_takesem(s) nxrmutex_lock(&(s)->sl_lock)
#define syslog_dev_givesem(s) nxrmutex_unlock(&(s)->sl_lock)
/****************************************************************************
* Private Types
@ -83,8 +81,7 @@ struct syslog_dev_s
uint8_t sl_state; /* See enum syslog_dev_state */
uint8_t sl_oflags; /* Saved open mode (for re-open) */
uint16_t sl_mode; /* Saved open flags (for re-open) */
sem_t sl_sem; /* Enforces mutually exclusive access */
pid_t sl_holder; /* PID of the thread that holds the semaphore */
rmutex_t sl_lock; /* Enforces mutually exclusive access */
struct file sl_file; /* The syslog file structure */
FAR char *sl_devpath; /* Full path to the character device */
};
@ -123,63 +120,6 @@ static const uint8_t g_syscrlf[2] =
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: syslog_dev_takesem
****************************************************************************/
static inline int syslog_dev_takesem(FAR struct syslog_dev_s *syslog_dev)
{
pid_t me = getpid();
int ret;
/* Does this thread already hold the semaphore? That could happen if
* we were called recursively, i.e., if the logic kicked off by
* file_write() where to generate more debug output. Return an
* error in that case.
*/
if (syslog_dev->sl_holder == me)
{
/* Return an error (instead of deadlocking) */
return -EWOULDBLOCK;
}
/* Either the semaphore is available or is currently held by another
* thread. Wait for it to become available.
*/
ret = nxsem_wait(&syslog_dev->sl_sem);
if (ret < 0)
{
return ret;
}
/* We hold the semaphore. We can safely mark ourself as the holder
* of the semaphore.
*/
syslog_dev->sl_holder = me;
return OK;
}
/****************************************************************************
* Name: syslog_dev_givesem
****************************************************************************/
static inline void syslog_dev_givesem(FAR struct syslog_dev_s *syslog_dev)
{
#ifdef CONFIG_DEBUG_ASSERTIONS
pid_t me = getpid();
DEBUGASSERT(syslog_dev->sl_holder == me);
#endif
/* Relinquish the semaphore */
syslog_dev->sl_holder = NO_HOLDER;
nxsem_post(&syslog_dev->sl_sem);
}
/****************************************************************************
* Name: syslog_dev_open
*
@ -272,9 +212,8 @@ static int syslog_dev_open(FAR struct syslog_dev_s *syslog_dev,
/* The SYSLOG device is open and ready for writing. */
nxsem_init(&syslog_dev->sl_sem, 0, 1);
syslog_dev->sl_holder = NO_HOLDER;
syslog_dev->sl_state = SYSLOG_OPENED;
nxrmutex_init(&syslog_dev->sl_lock);
syslog_dev->sl_state = SYSLOG_OPENED;
return OK;
}
@ -303,7 +242,7 @@ static int syslog_dev_open(FAR struct syslog_dev_s *syslog_dev,
* close the device, and set it for later re-opening.
*
* NOTE: That the third case is different. It applies only to the thread
* that currently holds the sl_sem semaphore. Other threads should wait.
* that currently holds the sl_lock. Other threads should wait.
* that is why that case is handled in syslog_semtake().
*
* Input Parameters:
@ -352,7 +291,7 @@ static int syslog_dev_outputready(FAR struct syslog_dev_s *syslog_dev)
if (syslog_dev->sl_state == SYSLOG_FAILURE)
{
file_close(&syslog_dev->sl_file);
nxsem_destroy(&syslog_dev->sl_sem);
nxrmutex_destroy(&syslog_dev->sl_lock);
syslog_dev->sl_state = SYSLOG_REOPEN;
}
@ -795,7 +734,7 @@ void syslog_dev_uninitialize(FAR struct syslog_channel_s *channel)
syslog_dev->sl_state == SYSLOG_FAILURE)
{
file_close(&syslog_dev->sl_file);
nxsem_destroy(&syslog_dev->sl_sem);
nxrmutex_destroy(&syslog_dev->sl_lock);
}
/* Set the device in UNINITIALIZED state. */

80
drivers/usbhost/usbhost_max3421e.c
View file

@ -45,6 +45,7 @@
#include <nuttx/kmalloc.h>
#include <nuttx/clock.h>
#include <nuttx/signal.h>
#include <nuttx/mutex.h>
#include <nuttx/semaphore.h>
#include <nuttx/wqueue.h>
#include <nuttx/spi/spi.h>
@ -130,6 +131,11 @@
#define TRENTRY(id,fmt1,string) {string}
/* Lock *********************************************************************/
#define max3421e_take_exclsem(s) nxrmutex_lock(&(s)->lock)
#define max3421e_give_exclsem(s) nxrmutex_unlock(&(s)->lock);
/****************************************************************************
* Private Types
****************************************************************************/
@ -211,11 +217,9 @@ struct max3421e_usbhost_s
uint8_t xfrtype; /* See enum mx3421e_hxfrdn_e */
uint8_t inflight; /* Number of Tx bytes "in-flight" (<= 128) */
uint8_t result; /* The result of the transfer */
uint8_t exclcount; /* Number of nested exclem locks */
uint16_t buflen; /* Buffer length (at start of transfer) */
uint16_t xfrd; /* Bytes transferred (at end of transfer) */
pid_t holder; /* Current hold of the exclsem */
sem_t exclsem; /* Support mutually exclusive access */
rmutex_t lock; /* Support mutually exclusive access */
sem_t pscsem; /* Semaphore to wait for a port event */
sem_t waitsem; /* Channel wait semaphore */
FAR uint8_t *buffer; /* Transfer buffer pointer */
@ -1126,71 +1130,6 @@ static int max3421e_takesem(FAR sem_t *sem)
return nxsem_wait_uninterruptible(sem);
}
/****************************************************************************
* Name: max3421e_take_exclsem and max3421e_give_exclsem
*
* Description:
* Implements a mutual re-entrant mutex for exclsem.
*
****************************************************************************/
static int max3421e_take_exclsem(FAR struct max3421e_usbhost_s *priv)
{
pid_t me = getpid();
int ret = OK;
/* Does this thread already hold the mutual exclusion mutex? */
if (priv->holder == me)
{
/* Yes.. just increment the count */
DEBUGASSERT(priv->exclcount < UINT8_MAX);
priv->exclcount++;
}
else
{
/* No.. take the semaphore */
ret = max3421e_takesem(&priv->exclsem);
if (ret >= 0)
{
/* Now this thread is the holder with a count of one */
priv->holder = me;
priv->exclcount = 1;
}
}
return ret;
}
static void max3421e_give_exclsem(FAR struct max3421e_usbhost_s *priv)
{
#ifdef CONFIG_DEBUG_ASSERTIONS
pid_t me = getpid();
DEBUGASSERT(priv->holder == me);
#endif
/* Is the lock nested? */
if (priv->exclcount > 0)
{
/* Yes.. just decrement the count */
priv->exclcount--;
}
else
{
/* No.. give the semaphore */
priv->holder = NO_HOLDER;
priv->exclcount = 0;
max3421e_givesem(&priv->exclsem);
}
}
/****************************************************************************
* Name: max3421e_getle16
*
@ -4784,9 +4723,12 @@ static inline int max3421e_sw_initialize(FAR struct max3421e_usbhost_s *priv,
/* Initialize semaphores */
nxsem_init(&priv->pscsem, 0, 0);
nxsem_init(&priv->exclsem, 0, 1);
nxsem_init(&priv->waitsem, 0, 0);
/* Initialize lock */
nxrmutex_init(&priv->lock);
/* The pscsem and waitsem semaphores are used for signaling and, hence,
* should not have
* priority inheritance enabled.

53
fs/aio/aio_initialize.c
View file

@ -29,7 +29,7 @@
#include <queue.h>
#include <nuttx/sched.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include "aio/aio.h"
@ -52,14 +52,12 @@ static dq_queue_t g_aioc_free;
static sem_t g_aioc_freesem = NXSEM_INITIALIZER(CONFIG_FS_NAIOC,
PRIOINHERIT_FLAGS_DISABLE);
/* This binary semaphore supports exclusive access to the list of pending
/* This binary lock supports exclusive access to the list of pending
* asynchronous I/O. g_aio_holder and a_aio_count support the reentrant
* lock.
*/
static sem_t g_aio_exclsem = SEM_INITIALIZER(1);
static pid_t g_aio_holder = INVALID_PROCESS_ID;
static uint16_t g_aio_count;
static rmutex_t g_aio_lock = NXRMUTEX_INITIALIZER;
/****************************************************************************
* Public Data
@ -119,53 +117,12 @@ void aio_initialize(void)
int aio_lock(void)
{
pid_t me = getpid();
int ret = OK;
/* Does this thread already hold the semaphore? */
if (g_aio_holder == me)
{
/* Yes, just increment the counts held */
DEBUGASSERT(g_aio_count > 0 && g_aio_count < UINT16_MAX);
g_aio_count++;
}
else
{
ret = nxsem_wait_uninterruptible(&g_aio_exclsem);
if (ret >= 0)
{
/* And mark it as ours */
g_aio_holder = me;
g_aio_count = 1;
}
}
return ret;
return nxrmutex_lock(&g_aio_lock);
}
void aio_unlock(void)
{
DEBUGASSERT(g_aio_holder == getpid() && g_aio_count > 0);
/* Would decrementing the count release the lock? */
if (g_aio_count <= 1)
{
/* Yes.. that we will no longer be the holder */
g_aio_holder = INVALID_PROCESS_ID;
g_aio_count = 0;
nxsem_post(&g_aio_exclsem);
}
else
{
/* Otherwise, just decrement the count. We still hold the lock. */
g_aio_count--;
}
nxrmutex_unlock(&g_aio_lock);
}
/****************************************************************************

74
fs/inode/fs_inode.c
View file

@ -29,7 +29,7 @@
#include <errno.h>
#include <nuttx/fs/fs.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include "inode/inode.h"
@ -37,35 +37,15 @@
* Pre-processor Definitions
****************************************************************************/
#define NO_HOLDER (INVALID_PROCESS_ID)
/****************************************************************************
* Private Types
****************************************************************************/
/* Implements a re-entrant mutex for inode access. This must be re-entrant
* because there can be cycles. For example, it may be necessary to destroy
* a block driver inode on umount() after a removable block device has been
* removed. In that case umount() holds the inode semaphore, but the block
* driver may callback to unregister_blockdriver() after the un-mount,
* requiring the semaphore again.
*/
struct inode_sem_s
{
sem_t sem; /* The semaphore */
pid_t holder; /* The current holder of the semaphore */
int16_t count; /* Number of counts held */
};
/****************************************************************************
* Private Data
****************************************************************************/
static struct inode_sem_s g_inode_sem =
{
SEM_INITIALIZER(1), NO_HOLDER, 0
};
static rmutex_t g_inode_lock = NXRMUTEX_INITIALIZER;
/****************************************************************************
* Public Functions
@ -97,35 +77,7 @@ void inode_initialize(void)
int inode_semtake(void)
{
pid_t me;
int ret = OK;
/* Do we already hold the semaphore? */
me = getpid();
if (me == g_inode_sem.holder)
{
/* Yes... just increment the count */
g_inode_sem.count++;
DEBUGASSERT(g_inode_sem.count > 0);
}
/* Take the semaphore (perhaps waiting) */
else
{
ret = nxsem_wait_uninterruptible(&g_inode_sem.sem);
if (ret >= 0)
{
/* No we hold the semaphore */
g_inode_sem.holder = me;
g_inode_sem.count = 1;
}
}
return ret;
return nxrmutex_lock(&g_inode_lock);
}
/****************************************************************************
@ -138,23 +90,5 @@ int inode_semtake(void)
void inode_semgive(void)
{
DEBUGASSERT(g_inode_sem.holder == getpid());
/* Is this our last count on the semaphore? */
if (g_inode_sem.count > 1)
{
/* No.. just decrement the count */
g_inode_sem.count--;
}
/* Yes.. then we can really release the semaphore */
else
{
g_inode_sem.holder = NO_HOLDER;
g_inode_sem.count = 0;
nxsem_post(&g_inode_sem.sem);
}
DEBUGVERIFY(nxrmutex_unlock(&g_inode_lock));
}

17
fs/spiffs/src/spiffs.h
View file

@ -57,7 +57,7 @@ extern "C"
#include <sys/mount.h>
#include <queue.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include <nuttx/mtd/mtd.h>
/****************************************************************************
@ -68,10 +68,6 @@ extern "C"
#define SFO_FLAG_UNLINKED (1 << 0)
/* Re-entrant semaphore definitions */
#define SPIFFS_NO_HOLDER (INVALID_PROCESS_ID)
/****************************************************************************
* Public Types
****************************************************************************/
@ -110,15 +106,6 @@ typedef int32_t(*spiffs_write_t)(uint32_t addr,
typedef int32_t(*spiffs_erase_t)(uint32_t addr, uint32_t size);
/* Re-entrant semaphore */
struct spiffs_sem_s
{
sem_t sem; /* The actual semaphore */
pid_t holder; /* Current older (-1 if not held) */
uint16_t count; /* Number of counts held */
};
/* spiffs SPI configuration struct */
/* This structure represents the current state of an SPIFFS volume */
@ -128,7 +115,7 @@ struct spiffs_file_s; /* Forward reference */
struct spiffs_s
{
struct mtd_geometry_s geo; /* FLASH geometry */
struct spiffs_sem_s exclsem; /* Supports mutually exclusive access */
rmutex_t lock; /* Supports mutually exclusive access */
dq_queue_t objq; /* A doubly linked list of open file objects */
FAR struct mtd_dev_s *mtd; /* The contained MTD interface */
FAR uint8_t *lu_work; /* Primary work buffer, size of a logical page */

77
fs/spiffs/src/spiffs_vfs.c
View file

@ -72,18 +72,13 @@
* Pre-processor Definitions
****************************************************************************/
#define spiffs_lock_volume(fs) (spiffs_lock_reentrant(&fs->exclsem))
#define spiffs_unlock_volume(fs) (spiffs_unlock_reentrant(&fs->exclsem))
#define spiffs_lock_volume(fs) (nxrmutex_lock(&fs->lock))
#define spiffs_unlock_volume(fs) (nxrmutex_unlock(&fs->lock))
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* SPIFFS helpers */
static int spiffs_lock_reentrant(FAR struct spiffs_sem_s *sem);
static void spiffs_unlock_reentrant(FAR struct spiffs_sem_s *sem);
/* File system operations */
static int spiffs_open(FAR struct file *filep, FAR const char *relpath,
@ -175,70 +170,6 @@ static inline int spiffs_map_errno(int errcode)
return errcode < SPIFFS_ERR_INTERNAL ? -EFTYPE : errcode;
}
/****************************************************************************
* Name: spiffs_lock_reentrant
****************************************************************************/
static int spiffs_lock_reentrant(FAR struct spiffs_sem_s *rsem)
{
pid_t me;
int ret = OK;
/* Do we already hold the semaphore? */
me = getpid();
if (me == rsem->holder)
{
/* Yes... just increment the count */
rsem->count++;
DEBUGASSERT(rsem->count > 0);
}
/* Take the semaphore (perhaps waiting) */
else
{
ret = nxsem_wait_uninterruptible(&rsem->sem);
if (ret >= 0)
{
/* No we hold the semaphore */
rsem->holder = me;
rsem->count = 1;
}
}
return ret;
}
/****************************************************************************
* Name: spiffs_unlock_reentrant
****************************************************************************/
static void spiffs_unlock_reentrant(FAR struct spiffs_sem_s *rsem)
{
DEBUGASSERT(rsem->holder == getpid());
/* Is this our last count on the semaphore? */
if (rsem->count > 1)
{
/* No.. just decrement the count */
rsem->count--;
}
/* Yes.. then we can really release the semaphore */
else
{
rsem->holder = SPIFFS_NO_HOLDER;
rsem->count = 0;
nxsem_post(&rsem->sem);
}
}
/****************************************************************************
* Name: spiffs_consistency_check
****************************************************************************/
@ -1505,7 +1436,7 @@ static int spiffs_bind(FAR struct inode *mtdinode, FAR const void *data,
fs->lu_work = &work[SPIFFS_GEO_PAGE_SIZE(fs)];
fs->mtd_work = &work[2 * SPIFFS_GEO_PAGE_SIZE(fs)];
nxsem_init(&fs->exclsem.sem, 0, 1);
nxrmutex_init(&fs->lock);
/* Check the file system */
@ -1608,7 +1539,7 @@ static int spiffs_unbind(FAR void *handle, FAR struct inode **mtdinode,
/* Free the volume memory (note that the semaphore is now stale!) */
nxsem_destroy(&fs->exclsem.sem);
nxrmutex_destroy(&fs->lock);
kmm_free(fs);
ret = OK;

151
fs/tmpfs/fs_tmpfs.c
View file

@ -55,14 +55,22 @@
# warning CONFIG_FS_TMPFS_FILE_FREEGUARD needs to be > ALLOCGUARD
#endif
#define tmpfs_lock(fs) \
nxrmutex_lock(&fs->tfs_lock)
#define tmpfs_lock_object(to) \
nxrmutex_lock(&to->to_lock)
#define tmpfs_lock_file(tfo) \
(tmpfs_lock_object((FAR struct tmpfs_object_s *)tfo))
nxrmutex_lock(&tfo->tfo_lock)
#define tmpfs_lock_directory(tdo) \
(tmpfs_lock_object((FAR struct tmpfs_object_s *)tdo))
nxrmutex_lock(&tdo->tdo_lock)
#define tmpfs_unlock(fs) \
nxrmutex_unlock(&fs->tfs_lock)
#define tmpfs_unlock_object(to) \
nxrmutex_unlock(&to->to_lock)
#define tmpfs_unlock_file(tfo) \
(tmpfs_unlock_object((FAR struct tmpfs_object_s *)tfo))
nxrmutex_unlock(&tfo->tfo_lock)
#define tmpfs_unlock_directory(tdo) \
(tmpfs_unlock_object((FAR struct tmpfs_object_s *)tdo))
nxrmutex_unlock(&tdo->tdo_lock)
/****************************************************************************
* Private Function Prototypes
@ -70,12 +78,6 @@
/* TMPFS helpers */
static int tmpfs_lock_reentrant(FAR struct tmpfs_sem_s *sem);
static int tmpfs_lock(FAR struct tmpfs_s *fs);
static void tmpfs_unlock_reentrant(FAR struct tmpfs_sem_s *sem);
static void tmpfs_unlock(FAR struct tmpfs_s *fs);
static int tmpfs_lock_object(FAR struct tmpfs_object_s *to);
static void tmpfs_unlock_object(FAR struct tmpfs_object_s *to);
static int tmpfs_realloc_directory(FAR struct tmpfs_directory_s *tdo,
unsigned int nentries);
static int tmpfs_realloc_file(FAR struct tmpfs_file_s *tfo,
@ -193,106 +195,6 @@ const struct mountpt_operations tmpfs_operations =
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: tmpfs_lock_reentrant
****************************************************************************/
static int tmpfs_lock_reentrant(FAR struct tmpfs_sem_s *sem)
{
pid_t me;
int ret = OK;
/* Do we already hold the semaphore? */
me = getpid();
if (me == sem->ts_holder)
{
/* Yes... just increment the count */
sem->ts_count++;
DEBUGASSERT(sem->ts_count > 0);
}
/* Take the semaphore (perhaps waiting) */
else
{
ret = nxsem_wait_uninterruptible(&sem->ts_sem);
if (ret >= 0)
{
/* No we hold the semaphore */
sem->ts_holder = me;
sem->ts_count = 1;
}
}
return ret;
}
/****************************************************************************
* Name: tmpfs_lock
****************************************************************************/
static int tmpfs_lock(FAR struct tmpfs_s *fs)
{
return tmpfs_lock_reentrant(&fs->tfs_exclsem);
}
/****************************************************************************
* Name: tmpfs_lock_object
****************************************************************************/
static int tmpfs_lock_object(FAR struct tmpfs_object_s *to)
{
return tmpfs_lock_reentrant(&to->to_exclsem);
}
/****************************************************************************
* Name: tmpfs_unlock_reentrant
****************************************************************************/
static void tmpfs_unlock_reentrant(FAR struct tmpfs_sem_s *sem)
{
DEBUGASSERT(sem->ts_holder == getpid());
/* Is this our last count on the semaphore? */
if (sem->ts_count > 1)
{
/* No.. just decrement the count */
sem->ts_count--;
}
/* Yes.. then we can really release the semaphore */
else
{
sem->ts_holder = TMPFS_NO_HOLDER;
sem->ts_count = 0;
nxsem_post(&sem->ts_sem);
}
}
/****************************************************************************
* Name: tmpfs_unlock
****************************************************************************/
static void tmpfs_unlock(FAR struct tmpfs_s *fs)
{
tmpfs_unlock_reentrant(&fs->tfs_exclsem);
}
/****************************************************************************
* Name: tmpfs_unlock_object
****************************************************************************/
static void tmpfs_unlock_object(FAR struct tmpfs_object_s *to)
{
tmpfs_unlock_reentrant(&to->to_exclsem);
}
/****************************************************************************
* Name: tmpfs_realloc_directory
****************************************************************************/
@ -435,7 +337,7 @@ static void tmpfs_release_lockedfile(FAR struct tmpfs_file_s *tfo)
if (tfo->tfo_refs == 1 && (tfo->tfo_flags & TFO_FLAG_UNLINKED) != 0)
{
nxsem_destroy(&tfo->tfo_exclsem.ts_sem);
nxrmutex_destroy(&tfo->tfo_lock);
kmm_free(tfo->tfo_data);
kmm_free(tfo);
}
@ -612,9 +514,8 @@ static FAR struct tmpfs_file_s *tmpfs_alloc_file(void)
tfo->tfo_size = 0;
tfo->tfo_data = NULL;
tfo->tfo_exclsem.ts_holder = getpid();
tfo->tfo_exclsem.ts_count = 1;
nxsem_init(&tfo->tfo_exclsem.ts_sem, 0, 0);
nxrmutex_init(&tfo->tfo_lock);
tmpfs_lock_file(tfo);
return tfo;
}
@ -727,7 +628,7 @@ static int tmpfs_create_file(FAR struct tmpfs_s *fs,
/* Error exits */
errout_with_file:
nxsem_destroy(&newtfo->tfo_exclsem.ts_sem);
nxrmutex_destroy(&newtfo->tfo_lock);
kmm_free(newtfo);
errout_with_parent:
@ -760,9 +661,7 @@ static FAR struct tmpfs_directory_s *tmpfs_alloc_directory(void)
tdo->tdo_nentries = 0;
tdo->tdo_entry = NULL;
tdo->tdo_exclsem.ts_holder = TMPFS_NO_HOLDER;
tdo->tdo_exclsem.ts_count = 0;
nxsem_init(&tdo->tdo_exclsem.ts_sem, 0, 1);
nxrmutex_init(&tdo->tdo_lock);
return tdo;
}
@ -880,7 +779,7 @@ static int tmpfs_create_directory(FAR struct tmpfs_s *fs,
/* Error exits */
errout_with_directory:
nxsem_destroy(&newtdo->tdo_exclsem.ts_sem);
nxrmutex_destroy(&newtdo->tdo_lock);
kmm_free(newtdo);
errout_with_parent:
@ -1251,7 +1150,7 @@ static int tmpfs_free_callout(FAR struct tmpfs_directory_s *tdo,
/* Free the object now */
nxsem_destroy(&to->to_exclsem.ts_sem);
nxrmutex_destroy(&to->to_lock);
kmm_free(to);
return TMPFS_DELETED;
}
@ -2107,9 +2006,7 @@ static int tmpfs_bind(FAR struct inode *blkdriver, FAR const void *data,
/* Initialize the file system state */
fs->tfs_exclsem.ts_holder = TMPFS_NO_HOLDER;
fs->tfs_exclsem.ts_count = 0;
nxsem_init(&fs->tfs_exclsem.ts_sem, 0, 1);
nxrmutex_init(&fs->tfs_lock);
/* Return the new file system handle */
@ -2147,11 +2044,11 @@ static int tmpfs_unbind(FAR void *handle, FAR struct inode **blkdriver,
/* Now we can destroy the root file system and the file system itself. */
nxsem_destroy(&tdo->tdo_exclsem.ts_sem);
nxrmutex_destroy(&tdo->tdo_lock);
kmm_free(tdo->tdo_entry);
kmm_free(tdo);
nxsem_destroy(&fs->tfs_exclsem.ts_sem);
nxrmutex_destroy(&fs->tfs_lock);
kmm_free(fs);
return ret;
}
@ -2314,7 +2211,7 @@ static int tmpfs_unlink(FAR struct inode *mountpt, FAR const char *relpath)
else
{
nxsem_destroy(&tfo->tfo_exclsem.ts_sem);
nxrmutex_destroy(&tfo->tfo_lock);
kmm_free(tfo->tfo_data);
kmm_free(tfo);
}
@ -2456,7 +2353,7 @@ static int tmpfs_rmdir(FAR struct inode *mountpt, FAR const char *relpath)
/* Free the directory object */
nxsem_destroy(&tdo->tdo_exclsem.ts_sem);
nxrmutex_destroy(&tdo->tdo_lock);
kmm_free(tdo->tdo_entry);
kmm_free(tdo);

23
fs/tmpfs/fs_tmpfs.h
View file

@ -30,16 +30,12 @@
#include <stdint.h>
#include <nuttx/fs/fs.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Indicates that there is no holder of the re-entrant semaphore */
#define TMPFS_NO_HOLDER -1
/* Bit definitions for file object flags */
#define TFO_FLAG_UNLINKED (1 << 0) /* Bit 0: File is unlinked */
@ -66,15 +62,6 @@ enum tmpfs_foreach_e
TMPFS_UNLINKED /* Only the directory entry was deleted */
};
/* Re-entrant semaphore */
struct tmpfs_sem_s
{
sem_t ts_sem; /* The actual semaphore */
pid_t ts_holder; /* Current older (-1 if not held) */
uint16_t ts_count; /* Number of counts held */
};
/* The form of one directory entry */
struct tmpfs_dirent_s
@ -87,7 +74,7 @@ struct tmpfs_dirent_s
struct tmpfs_object_s
{
struct tmpfs_sem_s to_exclsem;
rmutex_t to_lock;
size_t to_alloc; /* Allocated size of the memory object */
uint8_t to_type; /* See enum tmpfs_objtype_e */
@ -100,7 +87,7 @@ struct tmpfs_directory_s
{
/* First fields must match common TMPFS object layout */
struct tmpfs_sem_s tdo_exclsem;
rmutex_t tdo_lock;
size_t tdo_alloc; /* Allocated size of the directory object */
uint8_t tdo_type; /* See enum tmpfs_objtype_e */
@ -126,7 +113,7 @@ struct tmpfs_file_s
{
/* First fields must match common TMPFS object layout */
struct tmpfs_sem_s tfo_exclsem;
rmutex_t tfo_lock;
size_t tfo_alloc; /* Allocated size of the file object */
uint8_t tfo_type; /* See enum tmpfs_objtype_e */
@ -146,7 +133,7 @@ struct tmpfs_s
/* The root directory */
FAR struct tmpfs_dirent_s tfs_root;
struct tmpfs_sem_s tfs_exclsem;
rmutex_t tfs_lock;
};
/* This is the type used the tmpfs_statfs_callout to accumulate memory

5
include/nuttx/fs/fs.h
View file

@ -34,6 +34,7 @@
#include <stdbool.h>
#include <time.h>
#include <nuttx/mutex.h>
#include <nuttx/semaphore.h>
/****************************************************************************
@ -461,9 +462,7 @@ struct file_struct
FAR struct file_struct *fs_next; /* Pointer to next file stream */
int fs_fd; /* File descriptor associated with stream */
#ifndef CONFIG_STDIO_DISABLE_BUFFERING
sem_t fs_sem; /* For thread safety */
pid_t fs_holder; /* Holder of sem */
int fs_counts; /* Number of times sem is held */
rmutex_t fs_lock; /* Recursive lock */
FAR unsigned char *fs_bufstart; /* Pointer to start of buffer */
FAR unsigned char *fs_bufend; /* Pointer to 1 past end of buffer */
FAR unsigned char *fs_bufpos; /* Current position in buffer */

70
include/nuttx/mutex.h
View file

@ -29,15 +29,15 @@
#include <errno.h>
#include <assert.h>
#include <unistd.h>
#include <nuttx/sched.h>
#include <nuttx/semaphore.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define MUTEX_INITIALIZER SEM_INITIALIZER(1)
#define RMUTEX_INITIALIZER {SEM_INITIALIZER(1), INVALID_PROCESS_ID, 0}
#define NXRMUTEX_NO_HOLDER (pid_t)-1
#define NXMUTEX_INITIALIZER SEM_INITIALIZER(1)
#define NXRMUTEX_INITIALIZER {SEM_INITIALIZER(1), NXRMUTEX_NO_HOLDER, 0}
/****************************************************************************
* Public Type Definitions
@ -89,7 +89,14 @@ extern "C"
static inline int nxmutex_init(FAR mutex_t *mutex)
{
return nxsem_init(mutex, 0, 1);
int ret = _SEM_INIT(mutex, 0, 1);
if (ret < 0)
{
return _SEM_ERRVAL(ret);
}
return ret;
}
/****************************************************************************
@ -113,7 +120,14 @@ static inline int nxmutex_init(FAR mutex_t *mutex)
static inline int nxmutex_destroy(FAR mutex_t *mutex)
{
return nxsem_destroy(mutex);
int ret = _SEM_DESTROY(mutex);
if (ret < 0)
{
return _SEM_ERRVAL(ret);
}
return ret;
}
/****************************************************************************
@ -138,7 +152,26 @@ static inline int nxmutex_destroy(FAR mutex_t *mutex)
static inline int nxmutex_lock(FAR mutex_t *mutex)
{
return nxsem_wait_uninterruptible(mutex);
int ret;
for (; ; )
{
/* Take the semaphore (perhaps waiting) */
ret = _SEM_WAIT(mutex);
if (ret >= 0)
{
break;
}
ret = _SEM_ERRVAL(ret);
if (ret != -EINTR && ret != -ECANCELED)
{
break;
}
}
return ret;
}
/****************************************************************************
@ -164,7 +197,14 @@ static inline int nxmutex_lock(FAR mutex_t *mutex)
static inline int nxmutex_trylock(FAR mutex_t *mutex)
{
return nxsem_trywait(mutex);
int ret = _SEM_TRYWAIT(mutex);
if (ret < 0)
{
return _SEM_ERRVAL(ret);
}
return ret;
}
/****************************************************************************
@ -185,7 +225,7 @@ static inline bool nxmutex_is_locked(FAR mutex_t *mutex)
int cnt;
int ret;
ret = nxsem_get_value(mutex, &cnt);
ret = _SEM_GETVALUE(mutex, &cnt);
DEBUGASSERT(ret == OK);
@ -214,7 +254,15 @@ static inline bool nxmutex_is_locked(FAR mutex_t *mutex)
static inline int nxmutex_unlock(FAR mutex_t *mutex)
{
return nxsem_post(mutex);
int ret;
ret = _SEM_POST(mutex);
if (ret < 0)
{
return _SEM_ERRVAL(ret);
}
return ret;
}
/****************************************************************************
@ -240,7 +288,7 @@ static inline int nxmutex_unlock(FAR mutex_t *mutex)
static inline int nxrmutex_init(FAR rmutex_t *rmutex)
{
rmutex->count = 0;
rmutex->holder = INVALID_PROCESS_ID;
rmutex->holder = NXRMUTEX_NO_HOLDER;
return nxmutex_init(&rmutex->mutex);
}
@ -406,7 +454,7 @@ static inline int nxrmutex_unlock(FAR rmutex_t *rmutex)
if (rmutex->count == 1)
{
rmutex->count = 0;
rmutex->holder = INVALID_PROCESS_ID;
rmutex->holder = NXRMUTEX_NO_HOLDER;
ret = nxmutex_unlock(&rmutex->mutex);
}
else

73
libs/libc/modlib/modlib_registry.c
View file

@ -29,36 +29,22 @@
#include <debug.h>
#include <errno.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include <nuttx/lib/modlib.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define NO_HOLDER (INVALID_PROCESS_ID)
/****************************************************************************
* Private Types
****************************************************************************/
struct mod_registrylock_s
{
sem_t lock; /* The actual registry lock */
pid_t holder; /* The PID of the current holder of the lock */
int16_t count; /* The number of nested calls to modlib_registry_lock */
};
/****************************************************************************
* Private Data
****************************************************************************/
static struct mod_registrylock_s g_modlock =
{
SEM_INITIALIZER(1), /* lock */
NO_HOLDER, /* pid */
0 /* count */
};
static rmutex_t g_modlock = NXRMUTEX_INITIALIZER;
static FAR struct module_s *g_mod_registry;
@ -82,40 +68,7 @@ static FAR struct module_s *g_mod_registry;
void modlib_registry_lock(void)
{
pid_t me;
int ret;
/* Do we already hold the semaphore? */
me = getpid();
if (me == g_modlock.holder)
{
/* Yes... just increment the count */
g_modlock.count++;
DEBUGASSERT(g_modlock.count > 0);
}
/* Take the semaphore (perhaps waiting) */
else
{
while ((ret = _SEM_WAIT(&g_modlock.lock)) < 0)
{
/* The only case that an error should occur here is if
* the wait was awakened by a signal.
*/
DEBUGASSERT(_SEM_ERRNO(ret) == EINTR ||
_SEM_ERRNO(ret) == ECANCELED);
UNUSED(ret);
}
/* No we hold the semaphore */
g_modlock.holder = me;
g_modlock.count = 1;
}
nxrmutex_lock(&g_modlock);
}
/****************************************************************************
@ -134,25 +87,7 @@ void modlib_registry_lock(void)
void modlib_registry_unlock(void)
{
DEBUGASSERT(g_modlock.holder == getpid());
/* Is this our last count on the semaphore? */
if (g_modlock.count > 1)
{
/* No.. just decrement the count */
g_modlock.count--;
}
/* Yes.. then we can really release the semaphore */
else
{
g_modlock.holder = NO_HOLDER;
g_modlock.count = 0;
_SEM_POST(&g_modlock.lock);
}
nxrmutex_unlock(&g_modlock);
}
/****************************************************************************

47
libs/libc/netdb/lib_dnsinit.c
View file

@ -31,8 +31,7 @@
#include <arpa/inet.h>
#include <nuttx/sched.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include "netdb/lib_dns.h"
/****************************************************************************
@ -41,9 +40,7 @@
/* Protects DNS cache, nameserver list and notify list. */
static sem_t g_dns_sem = SEM_INITIALIZER(1);
static pid_t g_dns_holder = INVALID_PROCESS_ID;
static int g_dns_count;
static rmutex_t g_dns_lock = NXRMUTEX_INITIALIZER;
/****************************************************************************
* Public Data
@ -140,56 +137,24 @@ bool dns_initialize(void)
* Name: dns_semtake
*
* Description:
* Take the DNS semaphore, ignoring errors due to the receipt of signals.
* Take the DNS lock, ignoring errors due to the receipt of signals.
*
****************************************************************************/
void dns_semtake(void)
{
pid_t me = getpid();
int errcode = 0;
int ret;
/* Does this thread already hold the semaphore? */
if (g_dns_holder == me)
{
/* Yes.. just increment the reference count */
g_dns_count++;
return;
}
do
{
ret = _SEM_WAIT(&g_dns_sem);
if (ret < 0)
{
errcode = _SEM_ERRNO(ret);
DEBUGASSERT(errcode == EINTR || errcode == ECANCELED);
}
}
while (ret < 0 && errcode == EINTR);
g_dns_holder = me;
g_dns_count = 1;
nxrmutex_lock(&g_dns_lock);
}
/****************************************************************************
* Name: dns_semgive
*
* Description:
* Release the DNS semaphore
* Release the DNS lock
*
****************************************************************************/
void dns_semgive(void)
{
DEBUGASSERT(g_dns_holder == getpid() && g_dns_count > 0);
if (--g_dns_count == 0)
{
g_dns_holder = INVALID_PROCESS_ID;
DEBUGVERIFY(_SEM_POST(&g_dns_sem));
}
nxrmutex_unlock(&g_dns_lock);
}

2
libs/libc/stdio/lib_fclose.c
View file

@ -135,7 +135,7 @@ int fclose(FAR FILE *stream)
#ifndef CONFIG_STDIO_DISABLE_BUFFERING
/* Destroy the semaphore */
_SEM_DESTROY(&stream->fs_sem);
nxrmutex_destroy(&stream->fs_lock);
/* Release the buffer */

58
libs/libc/stdio/lib_libfilesem.c
View file

@ -50,10 +50,7 @@ void lib_sem_initialize(FAR struct file_struct *stream)
* to private data sets.
*/
_SEM_INIT(&stream->fs_sem, 0, 1);
stream->fs_holder = -1;
stream->fs_counts = 0;
nxrmutex_init(&stream->fs_lock);
}
/****************************************************************************
@ -62,37 +59,7 @@ void lib_sem_initialize(FAR struct file_struct *stream)
void lib_take_semaphore(FAR struct file_struct *stream)
{
pid_t my_pid = getpid();
int ret;
/* Do I already have the semaphore? */
if (stream->fs_holder == my_pid)
{
/* Yes, just increment the number of references that I have */
stream->fs_counts++;
}
else
{
/* Take the semaphore (perhaps waiting) */
while ((ret = _SEM_WAIT(&stream->fs_sem)) < 0)
{
/* The only case that an error should occr here is if the wait
* was awakened by a signal.
*/
DEBUGASSERT(_SEM_ERRNO(ret) == EINTR ||
_SEM_ERRNO(ret) == ECANCELED);
UNUSED(ret);
}
/* We have it. Claim the stak and return */
stream->fs_holder = my_pid;
stream->fs_counts = 1;
}
nxrmutex_lock(&stream->fs_lock);
}
/****************************************************************************
@ -101,26 +68,7 @@ void lib_take_semaphore(FAR struct file_struct *stream)
void lib_give_semaphore(FAR struct file_struct *stream)
{
/* I better be holding at least one reference to the semaphore */
DEBUGASSERT(stream->fs_holder == getpid());
/* Do I hold multiple references to the semphore */
if (stream->fs_counts > 1)
{
/* Yes, just release one count and return */
stream->fs_counts--;
}
else
{
/* Nope, this is the last reference I have */
stream->fs_holder = -1;
stream->fs_counts = 0;
DEBUGVERIFY(_SEM_POST(&stream->fs_sem));
}
nxrmutex_unlock(&stream->fs_lock);
}
#endif /* CONFIG_STDIO_DISABLE_BUFFERING */

8
libs/libc/stdio/lib_libstream.c
View file

@ -118,7 +118,7 @@ void lib_stream_release(FAR struct task_group_s *group)
#ifndef CONFIG_STDIO_DISABLE_BUFFERING
/* Destroy the semaphore that protects the IO buffer */
_SEM_DESTROY(&stream->fs_sem);
nxrmutex_destroy(&stream->fs_lock);
#endif
/* Release the stream */
@ -142,9 +142,9 @@ void lib_stream_release(FAR struct task_group_s *group)
/* Destroy stdin, stdout and stderr stream */
#ifndef CONFIG_STDIO_DISABLE_BUFFERING
_SEM_DESTROY(&list->sl_std[0].fs_sem);
_SEM_DESTROY(&list->sl_std[1].fs_sem);
_SEM_DESTROY(&list->sl_std[2].fs_sem);
nxrmutex_destroy(&list->sl_std[0].fs_lock);
nxrmutex_destroy(&list->sl_std[1].fs_lock);
nxrmutex_destroy(&list->sl_std[2].fs_lock);
#endif
}

146
net/route/net_fileroute.c
View file

@ -31,7 +31,7 @@
#include <assert.h>
#include <debug.h>
#include <nuttx/semaphore.h>
#include <nuttx/mutex.h>
#include <nuttx/fs/fs.h>
#include "route/fileroute.h"
@ -54,19 +54,15 @@
****************************************************************************/
#ifdef CONFIG_ROUTE_IPv4_FILEROUTE
/* Semaphore used to lock a routing table for exclusive write-only access */
/* Used to lock a routing table for exclusive write-only access */
static sem_t g_ipv4_exclsem = SEM_INITIALIZER(1);
static pid_t g_ipv4_holder = NO_HOLDER;
static int g_ipv4_count;
static rmutex_t g_ipv4_lock = RMUTEX_INITIALIZER;
#endif
#ifdef CONFIG_ROUTE_IPv6_FILEROUTE
/* Semaphore used to lock a routing table for exclusive write-only access */
/* Used to lock a routing table for exclusive write-only access */
static sem_t g_ipv6_exclsem = SEM_INITIALIZER(1);
static pid_t g_ipv6_holder = NO_HOLDER;
static int g_ipv6_count;
static rmutex_t g_ipv6_lock = RMUTEX_INITIALIZER;
#endif
/****************************************************************************
@ -597,36 +593,10 @@ int net_routesize_ipv6(void)
#ifdef CONFIG_ROUTE_IPv4_FILEROUTE
int net_lockroute_ipv4(void)
{
pid_t me = getpid();
int ret;
/* Are we already the holder of the lock? */
if (g_ipv4_holder == me)
int ret = nxrmutex_lock(&g_ipv4_lock);
if (ret < 0)
{
/* Yes.. just increment the count of locks held */
g_ipv4_count++;
ret = OK;
}
else
{
/* No.. wait to get the lock */
ret = nxsem_wait(&g_ipv4_exclsem);
if (ret < 0)
{
nerr("ERROR: nxsem_wait() failed: %d\n", ret);
}
else
{
DEBUGASSERT(g_ipv4_holder == NO_HOLDER && g_ipv4_count == 0);
/* We are now the holder with one count */
g_ipv4_holder = me;
g_ipv4_count = 1;
}
nerr("ERROR: nxrmutex_lock() failed: %d\n", ret);
}
return ret;
@ -636,36 +606,10 @@ int net_lockroute_ipv4(void)
#ifdef CONFIG_ROUTE_IPv6_FILEROUTE
int net_lockroute_ipv6(void)
{
pid_t me = getpid();
int ret;
/* Are we already the holder of the lock? */
if (g_ipv6_holder == me)
int ret = nxrmutex_lock(&g_ipv6_lock);
if (ret < 0)
{
/* Yes.. just increment the count of locks held */
g_ipv6_count++;
ret = OK;
}
else
{
/* No.. wait to get the lock */
ret = nxsem_wait(&g_ipv6_exclsem);
if (ret < 0)
{
nerr("ERROR: nxsem_wait() failed: %d\n", ret);
}
else
{
DEBUGASSERT(g_ipv6_holder == NO_HOLDER && g_ipv6_count == 0);
/* We are now the holder with one count */
g_ipv6_holder = me;
g_ipv6_count = 1;
}
nerr("ERROR: nxrmutex_lock() failed: %d\n", ret);
}
return ret;
@ -690,38 +634,10 @@ int net_lockroute_ipv6(void)
#ifdef CONFIG_ROUTE_IPv4_FILEROUTE
int net_unlockroute_ipv4(void)
{
pid_t me = getpid();
int ret;
/* If would be an error if we are called with on a thread that does not
* hold the lock.
*/
DEBUGASSERT(me == g_ipv4_holder && g_ipv4_count > 0);
/* Release the count on the lock. If this is the last count, then release
* the lock.
*/
if (g_ipv4_count > 1)
int ret = nxrmutex_unlock(&g_ipv4_lock);
if (ret < 0)
{
/* Not the last count... just decrement the count and return success */
g_ipv4_count--;
ret = OK;
}
else
{
/* This is the last count. Release the lock */
g_ipv4_holder = NO_HOLDER;
g_ipv4_count = 0;
ret = nxsem_post(&g_ipv4_exclsem);
if (ret < 0)
{
nerr("ERROR: nxsem_post() failed: %d\n", ret);
}
nerr("ERROR: nxrmutex_unlock() failed: %d\n", ret);
}
return ret;
@ -731,38 +647,10 @@ int net_unlockroute_ipv4(void)
#ifdef CONFIG_ROUTE_IPv6_FILEROUTE
int net_unlockroute_ipv6(void)
{
pid_t me = getpid();
int ret;
/* If would be an error if we are called with on a thread that does not
* hold the lock.
*/
DEBUGASSERT(me == g_ipv6_holder && g_ipv6_count > 0);
/* Release the count on the lock. If this is the last count, then release
* the lock.
*/
if (g_ipv6_count > 1)
int ret = nxrmutex_unlock(&g_ipv6_lock);
if (ret < 0)
{
/* Not the last count... just decrement the count and return success */
g_ipv6_count--;
ret = OK;
}
else
{
/* This is the last count. Release the lock */
g_ipv6_holder = NO_HOLDER;
g_ipv6_count = 0;
ret = nxsem_post(&g_ipv6_exclsem);
if (ret < 0)
{
nerr("ERROR: nxsem_post() failed: %d\n", ret);
}
nerr("ERROR: nxrmutex_unlock() failed: %d\n", ret);
}
return ret;