Mirrors_Framework/nuttx
1
0
Fork 0
mirror of https://github.com/apache/nuttx.git synced 2026-06-04 14:53:47 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

sched/semaphore/spinlock.c: Remove support for re-entrant spinlocks. They seem like a good idea, but they are never used.

Browse Source
This commit is contained in:
Xiang Xiao
2019-11-03 19:38:39 -06:00
committed by Gregory Nutt
parent e805bc0660
commit e1a89d29ee
2 changed files with 1 additions and 347 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sched/semaphore/spinlock.c
-251
View File
@@ -51,50 +51,10 @@
#ifdef CONFIG_SPINLOCK
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define IMPOSSIBLE_CPU 0xff
/* REVISIT: What happens if a thread taks a spinlock while running on one
* CPU, but is suspended, then reassigned to another CPU where it runs and
* eventually calls spin_unlock(). One solution might be to lock a thread to
* a CPU if it holds a spinlock. That would assure that it never runs on
* any other CPU and avoids such complexities.
*/
#undef CONFIG_SPINLOCK_LOCKDOWN /* Feature not yet available */
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: spin_initializer
*
* Description:
* Initialize a re-entrant spinlock object to its initial, unlocked state.
*
* Input Parameters:
* lock - A reference to the spinlock object to be initialized.
*
* Returned Value:
* None.
*
****************************************************************************/
void spin_initializer(FAR struct spinlock_s *lock)
{
DEBUGASSERT(lock != NULL);
lock->sp_lock = SP_UNLOCKED;
#ifdef CONFIG_SMP
lock->sp_cpu = IMPOSSIBLE_CPU;
lock->sp_count = 0;
#endif
}
/****************************************************************************
* Name: spin_lock
*
@@ -230,217 +190,6 @@ void spin_unlock_wo_note(FAR volatile spinlock_t *lock)
SP_DSB();
}
/****************************************************************************
* Name: spin_lockr
*
* Description:
* If this CPU does not already hold the spinlock, then loop until the
* spinlock is successfully locked.
*
* This implementation is re-entrant in the sense that it can called
* numerous times from the same CPU without blocking. Of course,
* spin_unlock() must be called the same number of times. NOTE: the
* thread that originallly took the look may be executing on a different
* CPU when it unlocks the spinlock.
*
* Input Parameters:
* lock - A reference to the spinlock object to lock.
*
* Returned Value:
* None. When the function returns, the spinlock was successfully locked
* by this CPU.
*
* Assumptions:
* Not running at the interrupt level.
*
****************************************************************************/
void spin_lockr(FAR struct spinlock_s *lock)
{
#ifdef CONFIG_SMP
irqstate_t flags;
uint8_t cpu = this_cpu();
/* Disable interrupts (all CPUs) */
flags = up_irq_save();
/* Do we already hold the lock on this CPU? */
if (lock->sp_cpu == cpu)
{
/* Yes... just increment the number of references we have on the lock */
lock->sp_count++;
DEBUGASSERT(lock->sp_lock = SP_LOCKED && lock->sp_count > 0);
}
else
{
#ifdef CONFIG_SPINLOCK_LOCKDOWN
/* REVISIT: What happens if this thread is suspended, then reassigned
* to another CPU where it runs and eventually calls spin_unlock().
* One solution might be to lock a thread to a CPU if it holds a
* spinlock. That would assure that it never runs on any other CPU
* and avoids such complexities.
*/
# warning Missing logic
#endif
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
/* Notify that we are waiting for a spinlock */
sched_note_spinlock(this_task(), &lock->sp_lock);
#endif
/* Take the lock. REVISIT: We should set an indication in the TCB
* that the thread is spinning. This might be useful in determining
* some scheduling actions?
*/
while (up_testset(&lock->sp_lock) == SP_LOCKED)
{
up_irq_restore(flags);
sched_yield();
flags = up_irq_save();
SP_DSB();
}
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
/* Notify that we have the spinlock */
sched_note_spinlocked(this_task(), &lock->sp_lock);
#endif
SP_DMB();
/* Take one count on the lock */
lock->sp_cpu = cpu;
lock->sp_count = 1;
}
up_irq_restore(flags);
#else /* CONFIG_SMP */
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
/* Notify that we are waiting for a spinlock */
sched_note_spinlock(this_task(), &lock->sp_lock);
#endif
/* Take the lock. REVISIT: We should set an indication in the TCB that
* the thread is spinning. This might be useful in determining some
* scheduling actions?
*/
while (up_testset(&lock->sp_lock) == SP_LOCKED)
{
sched_yield();
SP_DSB();
}
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
/* Notify that we have the spinlock */
sched_note_spinlocked(this_task(), &lock->sp_lock);
#endif
SP_DMB();
#endif /* CONFIG_SMP */
}
/****************************************************************************
* Name: spin_unlockr
*
* Description:
* Release one count on a spinlock.
*
* Input Parameters:
* lock - A reference to the spinlock object to unlock.
*
* Returned Value:
* None.
*
* Assumptions:
* Not running at the interrupt level.
*
****************************************************************************/
void spin_unlockr(FAR struct spinlock_s *lock)
{
#ifdef CONFIG_SMP
irqstate_t flags;
#ifdef CONFIG_SPINLOCK_LOCKDOWN
uint8_t cpu = this_cpu();
#endif
/* Disable interrupts (all CPUs) */
flags = up_irq_save();
#ifdef CONFIG_SPINLOCK_LOCKDOWN
/* REVISIT: What happens if this thread took the lock on a different CPU,
* was suspended, then reassigned to this CPU where it runs and eventually
* calls spin_unlock(). One solution might be to lock a thread to a CPU if
* it holds a spinlock. That would assure that it never runs on any other
* CPU and avoids such complexities.
*/
DEBUGASSERT(lock != NULL && lock->sp_lock == SP_LOCKED &&
lock->sp_cpu == this_cpu() && lock->sp_count > 0);
/* Do we already hold the lock? */
if (lock->sp_cpu == cpu)
#else
/* The alternative is to allow the lock to be released from any CPU */
DEBUGASSERT(lock != NULL && lock->sp_lock == SP_LOCKED &&
lock->sp_count > 0);
#endif
{
/* Yes... just decrement the number of references we have on the lock */
if (lock->sp_count <= 1)
{
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
/* Notify that we are unlocking the spinlock */
sched_note_spinunlock(this_task(), &lock->sp_lock);
#endif
/* The count must decremented to zero */
lock->sp_count = 0;
lock->sp_cpu = IMPOSSIBLE_CPU;
lock->sp_lock = SP_UNLOCKED;
}
else
{
lock->sp_count--;
}
}
up_irq_restore(flags);
#else /* CONFIG_SMP */
#ifdef CONFIG_SCHED_INSTRUMENTATION_SPINLOCKS
/* Notify that we are unlocking the spinlock */
sched_note_spinunlock(this_task(), &lock->sp_lock);
#endif
/* Just mark the spinlock unlocked */
DEBUGASSERT(lock != NULL && lock->sp_lock == SP_LOCKED);
lock->sp_lock = SP_UNLOCKED;
#endif /* CONFIG_SMP */
}
/****************************************************************************
* Name: spin_setbit
*