OS/FreeRTOS: Correct recursive spinlock for weak memory models in FreeRTOS SMP

The previous implementation of `vPortRecursiveLock` was unsafe on systems with weak memory ordering (like RISC-V), leading to potential race conditions. This commit corrects the implementation by introducing necessary memory barriers and optimizes the spin-wait loop.

**Correctness Fixes:**

*   **Acquire Barrier**: An acquire memory barrier (`__RWMB()`) is added immediately after a successful atomic swap (`__AMOSWAP_W`). This is critical to prevent the compiler or CPU from reordering memory operations from within the critical section to before the lock is actually acquired. Without this, the lock provides no protection.

*   **Release Barrier**: A release memory barrier (`__RWMB()`) is added before the lock variable is cleared. This ensures that all memory writes within the critical section are globally visible *before* the lock is released. This prevents other cores from acquiring the lock and seeing stale data.

**Performance and Logic Improvements:**

*   **Test-and-Test-and-Set (TTS)**: The lock acquisition logic has been restructured into a more efficient TTS pattern. The code now spins on a cheap, non-atomic read (`while (*pxSpinLock == 0)`) and only attempts the expensive atomic swap when the lock appears to be free. This significantly reduces bus contention and improves system performance when multiple cores are contending for a lock.

*   **NOP in Spin Loop**: A `__NOP()` has been added to the spin-wait loop. This can help reduce power consumption and pipeline pressure on some CPU architectures during tight spins.

*   **Improved Readability**: Added comments to clarify the logic for recursive locking, lock acquisition, and the purpose of the memory barriers.

Signed-off-by: Huaqi Fang <578567190@qq.com>

Author: fanghuaqi

OS/FreeRTOS/Source/portable/port.c

@@ -176,42 +176,53 @@ spin_lock_t hw_sync_locks[portRTOS_SPINLOCK_COUNT] = {0, 0};
 * uxAcquire, and the compiler should do the right thing! */
 void vPortRecursiveLock(unsigned long ulLockNum, spin_lock_t *pxSpinLock, BaseType_t uxAcquire)
 {
+    /* Track, per-core, which locks this core currently owns.          */
     static uint8_t ucOwnedByCore[portMAX_CORE_COUNT];
+    /* Track, per-lock, how many times it has been recursively taken.  */
     static uint8_t ucRecursionCountByLock[portRTOS_SPINLOCK_COUNT];
 
     configASSERT(ulLockNum < portRTOS_SPINLOCK_COUNT);
-    unsigned long ulCoreNum = __get_hart_index();
-    unsigned long ulLockBit = 1u << ulLockNum;
+    unsigned long ulCoreNum = __get_hart_index();   /* ID of current hart  */
+    unsigned long ulLockBit = 1u << ulLockNum;      /* Bit mask for lock   */
     configASSERT(ulLockBit < 256u);
 
-    if (uxAcquire) {
+    if (uxAcquire) {    /* ACQUIRE PATH */
+        /* Case 1: lock already held by THIS core -> pure recursion.  */
         if ((!*pxSpinLock == 0)) {
             if (ucOwnedByCore[ulCoreNum] & ulLockBit) {
                 configASSERT(ucRecursionCountByLock[ulLockNum] != 255u);
                 ucRecursionCountByLock[ulLockNum]++;
                 return;
             }
-
-            while ((!*pxSpinLock == 0)) {
-            }
         }
 
+        /* Case 2: lock not held (or held by another core).           */
         do {
-            if (__AMOSWAP_W(pxSpinLock, 1) == 0) {
-                break;
+            /* Spin-wait until the lock appears free.                 */
+            while ((!*pxSpinLock == 0)) {
+                __NOP();
+            }
+            /* Atomically attempt to take the lock.                   */
+            if (__AMOSWAP_W(pxSpinLock, 1) == 0) {  /* success        */
+                __RWMB();                           /* mem-barrier    */
+                break;                              /* lock taken     */
             }
         } while (1);
 
+        /* First successful take on THIS core -> init recursion state.*/
         configASSERT(ucRecursionCountByLock[ulLockNum] == 0);
         ucRecursionCountByLock[ulLockNum] = 1;
-        ucOwnedByCore[ulCoreNum] |= ulLockBit;
-    } else {
+        ucOwnedByCore[ulCoreNum] |= ulLockBit;      /* mark ownership */
+    } else {    /* RELEASE PATH */
         configASSERT((ucOwnedByCore[ulCoreNum] & ulLockBit) != 0);
         configASSERT(ucRecursionCountByLock[ulLockNum] != 0);
 
+        /* Decrease recursion counter.                                */
         if (!--ucRecursionCountByLock[ulLockNum]) {
+            /* Last release -> clear ownership and unlock.            */
             ucOwnedByCore[ulCoreNum] &= ~ulLockBit;
-            *pxSpinLock = 0;
+            __RWMB();                  /* ensure prior stores visible */
+            *pxSpinLock = 0;           /* hand the lock back          */
         }
     }
 }