From b88a8cf39ff1019ad787c4316b22ce29c7daa2dc Mon Sep 17 00:00:00 2001 From: anjiahao Date: Sun, 29 May 2022 23:59:14 +0800 Subject: [PATCH] use rmutex inside of all repeated implementation Signed-off-by: anjiahao --- drivers/1wire/1wire.c | 108 +-------------------- drivers/1wire/1wire_internal.h | 14 +-- drivers/1wire/1wire_read.c | 4 +- drivers/1wire/1wire_write.c | 4 +- drivers/1wire/1wire_writeread.c | 4 +- drivers/1wire/ds28e17.c | 16 +-- drivers/clk/clk.c | 2 +- drivers/clk/clk_rpmsg.c | 2 +- drivers/power/pm.h | 2 +- drivers/power/regulator_rpmsg.c | 2 +- drivers/rptun/rptun.c | 61 +----------- drivers/syslog/syslog_device.c | 79 ++------------- drivers/usbhost/usbhost_max3421e.c | 80 +++------------ fs/aio/aio_initialize.c | 53 +--------- fs/inode/fs_inode.c | 74 +------------- fs/spiffs/src/spiffs.h | 17 +--- fs/spiffs/src/spiffs_vfs.c | 77 +-------------- fs/tmpfs/fs_tmpfs.c | 151 +++++------------------------ fs/tmpfs/fs_tmpfs.h | 23 +---- include/nuttx/fs/fs.h | 5 +- include/nuttx/mutex.h | 70 ++++++++++--- libs/libc/modlib/modlib_registry.c | 73 +------------- libs/libc/netdb/lib_dnsinit.c | 47 ++------- libs/libc/stdio/lib_fclose.c | 2 +- libs/libc/stdio/lib_libfilesem.c | 58 +---------- libs/libc/stdio/lib_libstream.c | 8 +- net/route/net_fileroute.c | 146 ++++------------------------ 27 files changed, 189 insertions(+), 993 deletions(-) diff --git a/drivers/1wire/1wire.c b/drivers/1wire/1wire.c index 43aee5c15b..f1fbfed9ff 100644 --- a/drivers/1wire/1wire.c +++ b/drivers/1wire/1wire.c @@ -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; } diff --git a/drivers/1wire/1wire_internal.h b/drivers/1wire/1wire_internal.h index 2465948121..0e7aad9e90 100644 --- a/drivers/1wire/1wire_internal.h +++ b/drivers/1wire/1wire_internal.h @@ -28,7 +28,7 @@ #include #include -#include +#include #include /**************************************************************************** @@ -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, diff --git a/drivers/1wire/1wire_read.c b/drivers/1wire/1wire_read.c index d6903aadf4..b4f27c2d78 100644 --- a/drivers/1wire/1wire_read.c +++ b/drivers/1wire/1wire_read.c @@ -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; } diff --git a/drivers/1wire/1wire_write.c b/drivers/1wire/1wire_write.c index 5e24a5cb1a..6b9edc0060 100644 --- a/drivers/1wire/1wire_write.c +++ b/drivers/1wire/1wire_write.c @@ -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; } diff --git a/drivers/1wire/1wire_writeread.c b/drivers/1wire/1wire_writeread.c index d31914a918..9560b97d44 100644 --- a/drivers/1wire/1wire_writeread.c +++ b/drivers/1wire/1wire_writeread.c @@ -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; } diff --git a/drivers/1wire/ds28e17.c b/drivers/1wire/ds28e17.c index ad7dc57757..a93a29f104 100644 --- a/drivers/1wire/ds28e17.c +++ b/drivers/1wire/ds28e17.c @@ -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; } diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c index 512a09d20c..6d5ce529d3 100644 --- a/drivers/clk/clk.c +++ b/drivers/clk/clk.c @@ -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); diff --git a/drivers/clk/clk_rpmsg.c b/drivers/clk/clk_rpmsg.c index f96387ddb7..2d7ff00812 100644 --- a/drivers/clk/clk_rpmsg.c +++ b/drivers/clk/clk_rpmsg.c @@ -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); diff --git a/drivers/power/pm.h b/drivers/power/pm.h index c3cdb67595..1814f70ec7 100644 --- a/drivers/power/pm.h +++ b/drivers/power/pm.h @@ -29,7 +29,7 @@ #include -#include +#include #include #include #include diff --git a/drivers/power/regulator_rpmsg.c b/drivers/power/regulator_rpmsg.c index 77e86f40b0..689e999201 100644 --- a/drivers/power/regulator_rpmsg.c +++ b/drivers/power/regulator_rpmsg.c @@ -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); diff --git a/drivers/rptun/rptun.c b/drivers/rptun/rptun.c index 3a6aae7773..11d277cf02 100644 --- a/drivers/rptun/rptun.c +++ b/drivers/rptun/rptun.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -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) diff --git a/drivers/syslog/syslog_device.c b/drivers/syslog/syslog_device.c index 51d441c923..ea744232f5 100644 --- a/drivers/syslog/syslog_device.c +++ b/drivers/syslog/syslog_device.c @@ -38,7 +38,7 @@ #include #include #include -#include +#include #include #include @@ -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. */ diff --git a/drivers/usbhost/usbhost_max3421e.c b/drivers/usbhost/usbhost_max3421e.c index cf72d6078f..b3ef780b9c 100644 --- a/drivers/usbhost/usbhost_max3421e.c +++ b/drivers/usbhost/usbhost_max3421e.c @@ -45,6 +45,7 @@ #include #include #include +#include #include #include #include @@ -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. diff --git a/fs/aio/aio_initialize.c b/fs/aio/aio_initialize.c index 968065a513..ae7b7935ad 100644 --- a/fs/aio/aio_initialize.c +++ b/fs/aio/aio_initialize.c @@ -29,7 +29,7 @@ #include #include -#include +#include #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); } /**************************************************************************** diff --git a/fs/inode/fs_inode.c b/fs/inode/fs_inode.c index a5aa0dbbad..8ed88badd1 100644 --- a/fs/inode/fs_inode.c +++ b/fs/inode/fs_inode.c @@ -29,7 +29,7 @@ #include #include -#include +#include #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)); } diff --git a/fs/spiffs/src/spiffs.h b/fs/spiffs/src/spiffs.h index bf4b832c70..f011511868 100644 --- a/fs/spiffs/src/spiffs.h +++ b/fs/spiffs/src/spiffs.h @@ -57,7 +57,7 @@ extern "C" #include #include -#include +#include #include /**************************************************************************** @@ -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 */ diff --git a/fs/spiffs/src/spiffs_vfs.c b/fs/spiffs/src/spiffs_vfs.c index 1945ef2f90..9bc47dd536 100644 --- a/fs/spiffs/src/spiffs_vfs.c +++ b/fs/spiffs/src/spiffs_vfs.c @@ -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; diff --git a/fs/tmpfs/fs_tmpfs.c b/fs/tmpfs/fs_tmpfs.c index d15dab86fd..8165a19833 100644 --- a/fs/tmpfs/fs_tmpfs.c +++ b/fs/tmpfs/fs_tmpfs.c @@ -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); diff --git a/fs/tmpfs/fs_tmpfs.h b/fs/tmpfs/fs_tmpfs.h index 27c1eb78ad..0a14e6f58c 100644 --- a/fs/tmpfs/fs_tmpfs.h +++ b/fs/tmpfs/fs_tmpfs.h @@ -30,16 +30,12 @@ #include #include -#include +#include /**************************************************************************** * 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 diff --git a/include/nuttx/fs/fs.h b/include/nuttx/fs/fs.h index 8c7b5d2ff7..c411cc60c7 100644 --- a/include/nuttx/fs/fs.h +++ b/include/nuttx/fs/fs.h @@ -34,6 +34,7 @@ #include #include +#include #include /**************************************************************************** @@ -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 */ diff --git a/include/nuttx/mutex.h b/include/nuttx/mutex.h index 267e1f89d6..d2367639a1 100644 --- a/include/nuttx/mutex.h +++ b/include/nuttx/mutex.h @@ -29,15 +29,15 @@ #include #include #include -#include #include /**************************************************************************** * 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 diff --git a/libs/libc/modlib/modlib_registry.c b/libs/libc/modlib/modlib_registry.c index 53e4e22138..6194de11c5 100644 --- a/libs/libc/modlib/modlib_registry.c +++ b/libs/libc/modlib/modlib_registry.c @@ -29,36 +29,22 @@ #include #include -#include +#include #include /**************************************************************************** * 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); } /**************************************************************************** diff --git a/libs/libc/netdb/lib_dnsinit.c b/libs/libc/netdb/lib_dnsinit.c index ae45b82142..51795168a7 100644 --- a/libs/libc/netdb/lib_dnsinit.c +++ b/libs/libc/netdb/lib_dnsinit.c @@ -31,8 +31,7 @@ #include #include -#include - +#include #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); } diff --git a/libs/libc/stdio/lib_fclose.c b/libs/libc/stdio/lib_fclose.c index ac9c1d790e..d414f5abee 100644 --- a/libs/libc/stdio/lib_fclose.c +++ b/libs/libc/stdio/lib_fclose.c @@ -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 */ diff --git a/libs/libc/stdio/lib_libfilesem.c b/libs/libc/stdio/lib_libfilesem.c index a67a89dbfb..6f778a62f0 100644 --- a/libs/libc/stdio/lib_libfilesem.c +++ b/libs/libc/stdio/lib_libfilesem.c @@ -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 */ diff --git a/libs/libc/stdio/lib_libstream.c b/libs/libc/stdio/lib_libstream.c index b59bf3dca5..3a25734287 100644 --- a/libs/libc/stdio/lib_libstream.c +++ b/libs/libc/stdio/lib_libstream.c @@ -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 } diff --git a/net/route/net_fileroute.c b/net/route/net_fileroute.c index 5349979b53..1b35179ff6 100644 --- a/net/route/net_fileroute.c +++ b/net/route/net_fileroute.c @@ -31,7 +31,7 @@ #include #include -#include +#include #include #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;