Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2026-05-29 04:19:37 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Revert "shced:sem: replace mutex with spinlock"

Browse Source 
Cause we can't do sem_post/wait within spinlock

This reverts commit 23d65cb97f.

Signed-off-by: ligd <liguiding1@xiaomi.com>
This commit is contained in:
ligd
2024-10-24 18:26:00 +08:00
committed by Xiang Xiao
parent d42f16939e
commit 4541132035
2 changed files with 30 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/nuttx/rwsem.h
+3 -4
View File
@@ -27,15 +27,14 @@
* Included Files * Included Files
****************************************************************************/ ****************************************************************************/
#include <nuttx/semaphore.h> #include <nuttx/mutex.h>
#include <nuttx/spinlock.h>
/**************************************************************************** /****************************************************************************
* Pre-processor Definitions * Pre-processor Definitions
****************************************************************************/ ****************************************************************************/
#define RWSEM_NO_HOLDER ((pid_t)-1) #define RWSEM_NO_HOLDER ((pid_t)-1)
#define RWSEM_INITIALIZER {SEM_INITIALIZER(0), \ #define RWSEM_INITIALIZER {NXMUTEX_INITIALIZER, SEM_INITIALIZER(0), \
RWSEM_NO_HOLDER, 0, 0, 0} RWSEM_NO_HOLDER, 0, 0, 0}
/**************************************************************************** /****************************************************************************
@@ -44,6 +43,7 @@
typedef struct typedef struct
{ {
mutex_t protected; /* Protecting Locks for Read/Write Locked Tables */
sem_t waiting; /* Reader/writer Waiting queue */ sem_t waiting; /* Reader/writer Waiting queue */
pid_t holder; /* The write lock holder, this lock still can be pid_t holder; /* The write lock holder, this lock still can be
* locked when the holder is same as the current * locked when the holder is same as the current
@@ -52,7 +52,6 @@ typedef struct
int waiter; /* Waiter Count */ int waiter; /* Waiter Count */
int writer; /* Writer Count */ int writer; /* Writer Count */
int reader; /* Reader Count */ int reader; /* Reader Count */
spinlock_t protected; /* Protecting Locks for Read/Write Locked Tables */
} rw_semaphore_t; } rw_semaphore_t;
/**************************************************************************** /****************************************************************************
sched/semaphore/sem_rw.c
+27 -20
View File
@@ -24,7 +24,6 @@
* Included Files * Included Files
****************************************************************************/ ****************************************************************************/
#include <nuttx/irq.h>
#include <nuttx/rwsem.h> #include <nuttx/rwsem.h>
#include <nuttx/sched.h> #include <nuttx/sched.h>
#include <assert.h> #include <assert.h>
@@ -66,7 +65,7 @@ static inline void up_wait(FAR rw_semaphore_t *rwsem)
int down_read_trylock(FAR rw_semaphore_t *rwsem) int down_read_trylock(FAR rw_semaphore_t *rwsem)
{ {
irqstate_t flags = spin_lock_irqsave(&rwsem->protected); nxmutex_lock(&rwsem->protected);
/* if the write lock is already held by oneself and since the write lock /* if the write lock is already held by oneself and since the write lock
* can be recursively held, so, this operation can be converted to a write * can be recursively held, so, this operation can be converted to a write
@@ -81,7 +80,7 @@ int down_read_trylock(FAR rw_semaphore_t *rwsem)
if (rwsem->writer > 0) if (rwsem->writer > 0)
{ {
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
return 0; return 0;
} }
@@ -92,7 +91,7 @@ int down_read_trylock(FAR rw_semaphore_t *rwsem)
rwsem->reader++; rwsem->reader++;
out: out:
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
return 1; return 1;
} }
@@ -114,7 +113,7 @@ void down_read(FAR rw_semaphore_t *rwsem)
* block and wait for the write-lock to be unlocked. * block and wait for the write-lock to be unlocked.
*/ */
irqstate_t flags = spin_lock_irqsave(&rwsem->protected); nxmutex_lock(&rwsem->protected);
/* if the write lock is already held by oneself and since the write lock /* if the write lock is already held by oneself and since the write lock
* can be recursively held, so, this operation can be converted to a write * can be recursively held, so, this operation can be converted to a write
@@ -130,9 +129,9 @@ void down_read(FAR rw_semaphore_t *rwsem)
while (rwsem->writer > 0) while (rwsem->writer > 0)
{ {
rwsem->waiter++; rwsem->waiter++;
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
nxsem_wait(&rwsem->waiting); nxsem_wait(&rwsem->waiting);
flags = spin_lock_irqsave(&rwsem->protected); nxmutex_lock(&rwsem->protected);
rwsem->waiter--; rwsem->waiter--;
} }
@@ -143,7 +142,7 @@ void down_read(FAR rw_semaphore_t *rwsem)
rwsem->reader++; rwsem->reader++;
out: out:
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
} }
/**************************************************************************** /****************************************************************************
@@ -159,7 +158,7 @@ out:
void up_read(FAR rw_semaphore_t *rwsem) void up_read(FAR rw_semaphore_t *rwsem)
{ {
irqstate_t flags = spin_lock_irqsave(&rwsem->protected); nxmutex_lock(&rwsem->protected);
/* when releasing a read lock and holder is oneself, the read lock is a /* when releasing a read lock and holder is oneself, the read lock is a
* write lock that has been converted, so it should be released according * write lock that has been converted, so it should be released according
@@ -186,7 +185,7 @@ void up_read(FAR rw_semaphore_t *rwsem)
} }
out: out:
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
} }
/**************************************************************************** /****************************************************************************
@@ -205,12 +204,13 @@ out:
int down_write_trylock(FAR rw_semaphore_t *rwsem) int down_write_trylock(FAR rw_semaphore_t *rwsem)
{ {
irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
pid_t tid = _SCHED_GETTID(); pid_t tid = _SCHED_GETTID();
nxmutex_lock(&rwsem->protected);
if (rwsem->reader > 0 || (rwsem->writer > 0 && tid != rwsem->holder)) if (rwsem->reader > 0 || (rwsem->writer > 0 && tid != rwsem->holder))
{ {
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
return 0; return 0;
} }
@@ -219,7 +219,7 @@ int down_write_trylock(FAR rw_semaphore_t *rwsem)
rwsem->writer++; rwsem->writer++;
rwsem->holder = tid; rwsem->holder = tid;
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
return 1; return 1;
} }
@@ -237,15 +237,16 @@ int down_write_trylock(FAR rw_semaphore_t *rwsem)
void down_write(FAR rw_semaphore_t *rwsem) void down_write(FAR rw_semaphore_t *rwsem)
{ {
irqstate_t flags = spin_lock_irqsave(&rwsem->protected);
pid_t tid = _SCHED_GETTID(); pid_t tid = _SCHED_GETTID();
nxmutex_lock(&rwsem->protected);
while (rwsem->reader > 0 || (rwsem->writer > 0 && rwsem->holder != tid)) while (rwsem->reader > 0 || (rwsem->writer > 0 && rwsem->holder != tid))
{ {
rwsem->waiter++; rwsem->waiter++;
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
nxsem_wait(&rwsem->waiting); nxsem_wait(&rwsem->waiting);
flags = spin_lock_irqsave(&rwsem->protected); nxmutex_lock(&rwsem->protected);
rwsem->waiter--; rwsem->waiter--;
} }
@@ -254,7 +255,7 @@ void down_write(FAR rw_semaphore_t *rwsem)
rwsem->writer++; rwsem->writer++;
rwsem->holder = tid; rwsem->holder = tid;
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
} }
/**************************************************************************** /****************************************************************************
@@ -270,7 +271,7 @@ void down_write(FAR rw_semaphore_t *rwsem)
void up_write(FAR rw_semaphore_t *rwsem) void up_write(FAR rw_semaphore_t *rwsem)
{ {
irqstate_t flags = spin_lock_irqsave(&rwsem->protected); nxmutex_lock(&rwsem->protected);
DEBUGASSERT(rwsem->writer > 0); DEBUGASSERT(rwsem->writer > 0);
DEBUGASSERT(rwsem->holder == _SCHED_GETTID()); DEBUGASSERT(rwsem->holder == _SCHED_GETTID());
@@ -282,7 +283,7 @@ void up_write(FAR rw_semaphore_t *rwsem)
up_wait(rwsem); up_wait(rwsem);
spin_unlock_irqrestore(&rwsem->protected, flags); nxmutex_unlock(&rwsem->protected);
} }
/**************************************************************************** /****************************************************************************
@@ -306,11 +307,16 @@ int init_rwsem(FAR rw_semaphore_t *rwsem)
/* Initialize structure information */ /* Initialize structure information */
spin_lock_init(&rwsem->protected); ret = nxmutex_init(&rwsem->protected);
if (ret < 0)
{
return ret;
}
ret = nxsem_init(&rwsem->waiting, 0, 0); ret = nxsem_init(&rwsem->waiting, 0, 0);
if (ret < 0) if (ret < 0)
{ {
nxmutex_destroy(&rwsem->protected);
return ret; return ret;
} }
@@ -341,5 +347,6 @@ void destroy_rwsem(FAR rw_semaphore_t *rwsem)
DEBUGASSERT(rwsem->waiter == 0 && rwsem->reader == 0 && DEBUGASSERT(rwsem->waiter == 0 && rwsem->reader == 0 &&
rwsem->writer == 0 && rwsem->holder == RWSEM_NO_HOLDER); rwsem->writer == 0 && rwsem->holder == RWSEM_NO_HOLDER);
nxmutex_destroy(&rwsem->protected);
nxsem_destroy(&rwsem->waiting); nxsem_destroy(&rwsem->waiting);
} }