ostest: Implement mutex move test functionality

Add a new test for moving mutexes to verify behavior when a mutex is relocated.
* Introduced mutex_thread_args_t structure for thread arguments
* Created moved_mutex_thread_func to handle mutex operations in threads
* Updated mutex_test to include mutex_move_test for comprehensive testing

Signed-off-by: Huang Qi <[email protected]>

Author: no1wudi

Diff for: testing/ostest/mutex.c

@@ -53,6 +53,19 @@ static unsigned long nerrors[2] =
     0
   };
 
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+typedef struct
+{
+  pthread_mutex_t *mutex_ptr;
+  volatile int *mutex_value;
+  unsigned long *nloops;
+  unsigned long *nerrors;
+  int thread_id;
+} mutex_thread_args_t;
+
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
@@ -103,11 +116,164 @@ static void *thread_func(FAR void *parameter)
   return NULL; /* Non-reachable -- needed for some compilers */
 }
 
+static void *moved_mutex_thread_func(FAR void *parameter)
+{
+  FAR struct
+  {
+    pthread_mutex_t *mutex_ptr;
+    volatile int *mutex_value;
+    unsigned long *nloops;
+    unsigned long *nerrors;
+    int thread_id;
+  } *args = (FAR void *)parameter;
+
+  int id = args->thread_id;
+  int ndx = id - 1;
+  int i;
+  unsigned long local_loops = 0;
+
+  for (local_loops = 0; local_loops < NLOOPS; local_loops++)
+    {
+      int status = pthread_mutex_lock(args->mutex_ptr);
+      if (status != 0)
+        {
+          printf("ERROR moved mutex thread %d: pthread_mutex_lock failed, status=%d\n",
+                 id, status);
+          ASSERT(false);
+        }
+
+      if (*(args->mutex_value) == 1)
+        {
+          printf("ERROR moved mutex thread=%d: "
+                 "moved_mutex_value should be zero, instead moved_mutex_value=%d\n",
+                 id, *(args->mutex_value));
+          ASSERT(false);
+          args->nerrors[ndx]++;
+        }
+
+      *(args->mutex_value) = 1;
+      for (i = 0; i < 10; i++)
+        {
+          pthread_yield();
+        }
+
+      *(args->mutex_value) = 0;
+
+      status = pthread_mutex_unlock(args->mutex_ptr);
+      if (status != 0)
+        {
+          printf("ERROR moved mutex thread %d: pthread_mutex_unlock failed, status=%d\n",
+                 id, status);
+          ASSERT(false);
+        }
+    }
+
+  args->nloops[ndx] = local_loops;
+  pthread_exit(NULL);
+  return NULL;
+}
+
 /****************************************************************************
- * Public Functions
+ * Name: mutex_move_test
+ *
+ * Description:
+ *   Test the mutex move functionality.  This test creates a mutex, moves
+ *   it to a new location, and then starts two threads that use the moved
+ *   mutex.
+ *   POSIX specification does not define the behavior of a mutex that is
+ *   moved.  This test is intended to verify that the mutex can be moved,
+ *   it's useful for some cases, see the discussion in
+ *   https://github.com/rust-lang/rust/pull/138400
+ *
  ****************************************************************************/
 
-void mutex_test(void)
+static void mutex_move_test(void)
+{
+  pthread_t thread1;
+  pthread_t thread2;
+#ifdef SDCC
+  pthread_addr_t result1;
+  pthread_addr_t result2;
+  pthread_attr_t attr;
+#endif
+  int status;
+  pthread_mutex_t initial_mutex;
+  pthread_mutex_t moved_mutex;
+  volatile int moved_mutex_value = 0;
+  unsigned long moved_nloops[2] = {0, 0};
+  unsigned long moved_nerrors[2] = {0, 0};
+
+  printf("\nTesting moved mutex\n");
+
+  /* Allocate and initialize first mutex */
+
+  pthread_mutex_init(&initial_mutex, NULL);
+
+  /* Copy the mutex to new location */
+
+  memcpy(&moved_mutex, &initial_mutex, sizeof(pthread_mutex_t));
+
+  /* Destroy the original mutex */
+
+  pthread_mutex_destroy(&initial_mutex);
+
+  mutex_thread_args_t thread1_args, thread2_args;
+
+  thread1_args.mutex_ptr = &moved_mutex;
+  thread1_args.mutex_value = &moved_mutex_value;
+  thread1_args.nloops = moved_nloops;
+  thread1_args.nerrors = moved_nerrors;
+  thread1_args.thread_id = 1;
+
+  thread2_args.mutex_ptr = &moved_mutex;
+  thread2_args.mutex_value = &moved_mutex_value;
+  thread2_args.nloops = moved_nloops;
+  thread2_args.nerrors = moved_nerrors;
+  thread2_args.thread_id = 2;
+
+  /* Start two threads using the moved mutex */
+
+  printf("Starting moved mutex thread 1\n");
+#ifdef SDCC
+  pthread_attr_init(&attr);
+  status = pthread_create(&thread1, &attr, moved_mutex_thread_func, &thread1_args);
+#else
+  status = pthread_create(&thread1, NULL, moved_mutex_thread_func, &thread1_args);
+#endif
+  if (status != 0)
+    {
+      printf("ERROR in moved mutex thread#1 creation\n");
+      ASSERT(false);
+    }
+
+  printf("Starting moved mutex thread 2\n");
+#ifdef SDCC
+  status = pthread_create(&thread2, &attr, moved_mutex_thread_func, &thread2_args);
+#else
+  status = pthread_create(&thread2, NULL, moved_mutex_thread_func, &thread2_args);
+#endif
+  if (status != 0)
+    {
+      printf("ERROR in moved mutex thread#2 creation\n");
+      ASSERT(false);
+    }
+
+#ifdef SDCC
+  pthread_join(thread1, &result1);
+  pthread_join(thread2, &result2);
+#else
+  pthread_join(thread1, NULL);
+  pthread_join(thread2, NULL);
+#endif
+
+  pthread_mutex_destroy(&moved_mutex);
+
+  printf("\t\tThread1\tThread2\n");
+  printf("\tMoved Loops\t%lu\t%lu\n", moved_nloops[0], moved_nloops[1]);
+  printf("\tMoved Errors\t%lu\t%lu\n", moved_nerrors[0], moved_nerrors[1]);
+}
+
+void mutex_simple_test(void)
 {
   pthread_t thread1;
   pthread_t thread2;
@@ -164,3 +330,13 @@ void mutex_test(void)
   printf("\tLoops\t%lu\t%lu\n", nloops[0], nloops[1]);
   printf("\tErrors\t%lu\t%lu\n", nerrors[0], nerrors[1]);
 }
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+void mutex_test(void)
+{
+  mutex_simple_test();
+  mutex_move_test();
+}