[api] Refactor mutex API to use lock/unlock verbs. (#14)

turon · web-flow · commit 4312aadc6c74 · 2026-05-19T00:34:57.000-07:00
diff --git a/include/poski/osal/os_mutex.h b/include/poski/osal/os_mutex.h
@@ -60,7 +60,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mutex);
  * @retval POS_EBUSY Returned without waiting.
  * @retval POS_TIMEOUT Waiting period timed out.
  */
-pos_error_t pos_mutex_take(struct pos_mutex * mutex, pos_time_t timeout);
+pos_error_t pos_mutex_lock(struct pos_mutex * mutex, pos_time_t timeout);
 
 /**
  * @brief Unlock a mutex.
@@ -76,7 +76,7 @@ pos_error_t pos_mutex_take(struct pos_mutex * mutex, pos_time_t timeout);
  *
  * @return N/A
  */
-pos_error_t pos_mutex_give(struct pos_mutex * mutex);
+pos_error_t pos_mutex_unlock(struct pos_mutex * mutex);
 
 #ifdef __cplusplus
 }
diff --git a/targets/freertos/os_mutex.c b/targets/freertos/os_mutex.c
@@ -37,7 +37,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mu)
     return (mu->handle == NULL) ? POS_BAD_MUTEX : POS_OK;
 }
 
-pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)
+pos_error_t pos_mutex_lock(struct pos_mutex * mu, pos_time_t timeout)
 {
     BaseType_t ret;
 
@@ -55,7 +55,7 @@ pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)
     return ret == pdPASS ? POS_OK : POS_TIMEOUT;
 }
 
-pos_error_t pos_mutex_give(struct pos_mutex * mu)
+pos_error_t pos_mutex_unlock(struct pos_mutex * mu)
 {
     assert(!pos_hw_in_isr());
 
diff --git a/targets/posix/os_mutex.c b/targets/posix/os_mutex.c
@@ -40,7 +40,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mu)
     return (ret) ? POS_BAD_MUTEX : POS_OK;
 }
 
-pos_error_t pos_mutex_give(struct pos_mutex * mu)
+pos_error_t pos_mutex_unlock(struct pos_mutex * mu)
 {
     int ret = (pthread_mutex_unlock(&mu->lock));
     SuccessOrExit(ret);
@@ -49,7 +49,7 @@ pos_error_t pos_mutex_give(struct pos_mutex * mu)
     return map_posix_to_osal_error(ret);
 }
 
-pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)
+pos_error_t pos_mutex_lock(struct pos_mutex * mu, pos_time_t timeout)
 {
     int ret;
 
diff --git a/targets/rt-thread/os_mutex.c b/targets/rt-thread/os_mutex.c
@@ -37,7 +37,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mu)
     return (mu->handle == NULL) ? POS_BAD_MUTEX : POS_OK;
 }
 
-pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)
+pos_error_t pos_mutex_lock(struct pos_mutex * mu, pos_time_t timeout)
 {
     rt_err_t ret;
 
@@ -53,7 +53,7 @@ pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)
     return ret == RT_EOK ? POS_OK : POS_BAD_MUTEX;
 }
 
-pos_error_t pos_mutex_give(struct pos_mutex * mu)
+pos_error_t pos_mutex_unlock(struct pos_mutex * mu)
 {
     assert(!pos_hw_in_isr());
 
diff --git a/targets/zephyr/os_mutex.c b/targets/zephyr/os_mutex.c
@@ -24,7 +24,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mutex)
     return POS_OK;
 }
 
-pos_error_t pos_mutex_take(struct pos_mutex * mutex, pos_time_t timeout)
+pos_error_t pos_mutex_lock(struct pos_mutex * mutex, pos_time_t timeout)
 {
     k_timeout_t tmo;
     if (timeout == POS_TIME_FOREVER) {
@@ -45,7 +45,7 @@ pos_error_t pos_mutex_take(struct pos_mutex * mutex, pos_time_t timeout)
     }
 }
 
-pos_error_t pos_mutex_give(struct pos_mutex * mutex)
+pos_error_t pos_mutex_unlock(struct pos_mutex * mutex)
 {
     int err = k_mutex_unlock(&mutex->mutex);
     return (err == 0) ? POS_OK : POS_ERROR;
diff --git a/tests/test_os_mutex.c b/tests/test_os_mutex.c
@@ -49,14 +49,14 @@ uint8_t s_buffer[TEST_ITERATIONS];
 void test_mutex_nested(uint8_t test_value, int task, bool recursive, int round)
 {
     TEST_LOG("task %d: LOCK START ROUND %d\n", task, round);
-    SuccessOrQuit(pos_mutex_take(&task1_mtx, POS_TIME_FOREVER), "pos_mutex_take: error waiting for task1_mutex.");
+    SuccessOrQuit(pos_mutex_lock(&task1_mtx, POS_TIME_FOREVER), "pos_mutex_lock: error waiting for task1_mutex.");
     for (int i = 0; i < TEST_ITERATIONS; i++)
     {
         if (recursive)
         {
             TEST_LOG("task %d: take #%d RECURSIVE\n", task, i);
-            SuccessOrQuit(pos_mutex_take(&task1_mtx, POS_TIME_FOREVER),
-                          "pos_mutex_take: error waiting for task1_mutex.");
+            SuccessOrQuit(pos_mutex_lock(&task1_mtx, POS_TIME_FOREVER),
+                          "pos_mutex_lock: error waiting for task1_mutex.");
         }
         // TEST_LOG("task %d: b[%d]=0x%02x --> 0x%02x\n", task, i, s_buffer[i], test_value);
         VerifyOrQuit(s_buffer[i] != test_value, "unexpected value: mutex did not protect resource");
@@ -70,13 +70,13 @@ void test_mutex_nested(uint8_t test_value, int task, bool recursive, int round)
         if (recursive)
         {
             TEST_LOG("task %d: give #%d RECURSIVE\n", task, i);
-            SuccessOrQuit(pos_mutex_give(&task1_mtx), "pos_mutex_give: error releasing task1_mutex.");
+            SuccessOrQuit(pos_mutex_unlock(&task1_mtx), "pos_mutex_unlock: error releasing task1_mutex.");
         }
     }
     // Clear out buffer in case this task reclaims the resource again
     memset(&s_buffer, 0, sizeof(s_buffer));
     TEST_LOG("task %d: LOCK END ROUND %d\n", task, round);
-    SuccessOrQuit(pos_mutex_give(&task1_mtx), "pos_mutex_give: error releasing task1_mutex.");
+    SuccessOrQuit(pos_mutex_unlock(&task1_mtx), "pos_mutex_unlock: error releasing task1_mutex.");
 
     pos_task_sleep(10);
 }

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mu)`
`37`	`37`	`return (mu->handle == NULL) ? POS_BAD_MUTEX : POS_OK;`
`38`	`38`	`}`
`39`	`39`
`40`		`-pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)`
	`40`	`+pos_error_t pos_mutex_lock(struct pos_mutex * mu, pos_time_t timeout)`
`41`	`41`	`{`
`42`	`42`	`BaseType_t ret;`
`43`	`43`
`@@ -55,7 +55,7 @@ pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)`
`55`	`55`	`return ret == pdPASS ? POS_OK : POS_TIMEOUT;`
`56`	`56`	`}`
`57`	`57`
`58`		`-pos_error_t pos_mutex_give(struct pos_mutex * mu)`
	`58`	`+pos_error_t pos_mutex_unlock(struct pos_mutex * mu)`
`59`	`59`	`{`
`60`	`60`	`assert(!pos_hw_in_isr());`
`61`	`61`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mu)`
`40`	`40`	`return (ret) ? POS_BAD_MUTEX : POS_OK;`
`41`	`41`	`}`
`42`	`42`
`43`		`-pos_error_t pos_mutex_give(struct pos_mutex * mu)`
	`43`	`+pos_error_t pos_mutex_unlock(struct pos_mutex * mu)`
`44`	`44`	`{`
`45`	`45`	`int ret = (pthread_mutex_unlock(&mu->lock));`
`46`	`46`	`SuccessOrExit(ret);`
`@@ -49,7 +49,7 @@ pos_error_t pos_mutex_give(struct pos_mutex * mu)`
`49`	`49`	`return map_posix_to_osal_error(ret);`
`50`	`50`	`}`
`51`	`51`
`52`		`-pos_error_t pos_mutex_take(struct pos_mutex * mu, pos_time_t timeout)`
	`52`	`+pos_error_t pos_mutex_lock(struct pos_mutex * mu, pos_time_t timeout)`
`53`	`53`	`{`
`54`	`54`	`int ret;`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ pos_error_t pos_mutex_init(struct pos_mutex * mutex)`
`24`	`24`	`return POS_OK;`
`25`	`25`	`}`
`26`	`26`
`27`		`-pos_error_t pos_mutex_take(struct pos_mutex * mutex, pos_time_t timeout)`
	`27`	`+pos_error_t pos_mutex_lock(struct pos_mutex * mutex, pos_time_t timeout)`
`28`	`28`	`{`
`29`	`29`	`k_timeout_t tmo;`
`30`	`30`	`if (timeout == POS_TIME_FOREVER) {`
`@@ -45,7 +45,7 @@ pos_error_t pos_mutex_take(struct pos_mutex * mutex, pos_time_t timeout)`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`		`-pos_error_t pos_mutex_give(struct pos_mutex * mutex)`
	`48`	`+pos_error_t pos_mutex_unlock(struct pos_mutex * mutex)`
`49`	`49`	`{`
`50`	`50`	`int err = k_mutex_unlock(&mutex->mutex);`
`51`	`51`	`return (err == 0) ? POS_OK : POS_ERROR;`
Original file line number	Diff line number	Diff line change
`@@ -49,14 +49,14 @@ uint8_t s_buffer[TEST_ITERATIONS];`
`49`	`49`	`void test_mutex_nested(uint8_t test_value, int task, bool recursive, int round)`
`50`	`50`	`{`
`51`	`51`	`TEST_LOG("task %d: LOCK START ROUND %d\n", task, round);`
`52`		`- SuccessOrQuit(pos_mutex_take(&task1_mtx, POS_TIME_FOREVER), "pos_mutex_take: error waiting for task1_mutex.");`
	`52`	`+ SuccessOrQuit(pos_mutex_lock(&task1_mtx, POS_TIME_FOREVER), "pos_mutex_lock: error waiting for task1_mutex.");`
`53`	`53`	`for (int i = 0; i < TEST_ITERATIONS; i++)`
`54`	`54`	`{`
`55`	`55`	`if (recursive)`
`56`	`56`	`{`
`57`	`57`	`TEST_LOG("task %d: take #%d RECURSIVE\n", task, i);`
`58`		`- SuccessOrQuit(pos_mutex_take(&task1_mtx, POS_TIME_FOREVER),`
`59`		`- "pos_mutex_take: error waiting for task1_mutex.");`
	`58`	`+ SuccessOrQuit(pos_mutex_lock(&task1_mtx, POS_TIME_FOREVER),`
	`59`	`+ "pos_mutex_lock: error waiting for task1_mutex.");`
`60`	`60`	`}`
`61`	`61`	`// TEST_LOG("task %d: b[%d]=0x%02x --> 0x%02x\n", task, i, s_buffer[i], test_value);`
`62`	`62`	`VerifyOrQuit(s_buffer[i] != test_value, "unexpected value: mutex did not protect resource");`
`@@ -70,13 +70,13 @@ void test_mutex_nested(uint8_t test_value, int task, bool recursive, int round)`
`70`	`70`	`if (recursive)`
`71`	`71`	`{`
`72`	`72`	`TEST_LOG("task %d: give #%d RECURSIVE\n", task, i);`
`73`		`- SuccessOrQuit(pos_mutex_give(&task1_mtx), "pos_mutex_give: error releasing task1_mutex.");`
	`73`	`+ SuccessOrQuit(pos_mutex_unlock(&task1_mtx), "pos_mutex_unlock: error releasing task1_mutex.");`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`	`// Clear out buffer in case this task reclaims the resource again`
`77`	`77`	`memset(&s_buffer, 0, sizeof(s_buffer));`
`78`	`78`	`TEST_LOG("task %d: LOCK END ROUND %d\n", task, round);`
`79`		`- SuccessOrQuit(pos_mutex_give(&task1_mtx), "pos_mutex_give: error releasing task1_mutex.");`
	`79`	`+ SuccessOrQuit(pos_mutex_unlock(&task1_mtx), "pos_mutex_unlock: error releasing task1_mutex.");`
`80`	`80`
`81`	`81`	`pos_task_sleep(10);`
`82`	`82`	`}`