Implement pthread_rwlock functions for NaCl newlib

tests/threads/rwlock_test.c

 /*
  * Copyright 2015 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <errno.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <time.h>
@@ skipping 173 matching lines @@
   ASSERT_EQ(rc, 0);
 
   rc = pthread_rwlock_rdlock(&g_rwlock);
   ASSERT_EQ(rc, 0);
   rc = pthread_rwlock_unlock(&g_rwlock);
   ASSERT_EQ(rc, 0);
 
   tell_thread_to_release_lock();
 }
 
+void *read_lock_thread(void *unused) {
+  fprintf(stderr, "%lx: waiting for read lock\n", (long)pthread_self());
+  int rc = pthread_rwlock_rdlock(&g_rwlock);
+  fprintf(stderr, "%lx: read lock acquired\n", (long)pthread_self());
+  ASSERT_EQ(rc, 0);
+  rc = pthread_rwlock_unlock(&g_rwlock);
+  ASSERT_EQ(rc, 0);
+  fprintf(stderr, "%lx: thread done\n", (long)pthread_self());
+  return NULL;
+}
+
+/*
+ * Test that multiple readers are woken up when the write lock
+ * is released.
+ */
+void test_multiple_reader_wakeup(void) {
+  /*
+   * First, aquire the write lock so that all readers

[Roland McGrath, 2015/03/23 20:34:07]

typo: "acquire"

[Sam Clegg, 2015/03/23 20:55:21]

Done.

+   * will be blocked.
+   */
+  fprintf(stderr, "test_multiple_reader_wakeup\n");
+  int rc;
+  rc = pthread_rwlock_wrlock(&g_rwlock);
+  ASSERT_EQ(rc, 0);
+
+  /*
+   * Now start two new threads that which will both

[Roland McGrath, 2015/03/23 20:34:07]

s/that which/that/

[Sam Clegg, 2015/03/23 20:55:21]

Done.

+   * wait on a read lock.
+   */
+  pthread_t thread1;
+  rc = pthread_create(&thread1, NULL, read_lock_thread, NULL);
+  ASSERT_EQ(rc, 0);
+
+  pthread_t thread2;
+  rc = pthread_create(&thread2, NULL, read_lock_thread, NULL);
+  ASSERT_EQ(rc, 0);
+
+  /*
+   * Sleep for 20ms to allow both readers to become blocked on rdlock()

[Roland McGrath, 2015/03/23 20:34:07]

Put this duration in a macro so it's clear it can be tuned.  Then add a comment
explaining why the antipattern of an arbitrary delay in lieu of real
synchronization is the only way available to test this case.

[Sam Clegg, 2015/03/23 20:55:21]

Done.

+   */
+  rc = usleep(20 * 1000);
+  ASSERT_EQ(rc, 0);
+
+  /*
+   * Releasing the write lock should unblock both the readers and they
+   * should then both be joinable.
+   */
+  rc = pthread_rwlock_unlock(&g_rwlock);
+
+  pthread_join(thread1, NULL);
+  pthread_join(thread2, NULL);
+}
+
 void test_reader_plus_writer(void) {
   fprintf(stderr, "test_reader_plus_writer\n");
   tell_thread_to_acquire_lock(READ_LOCK);
 
   /*
    * Now attempt to acquire the write lock on the main thread.
    * This should fail.
    */
   int rc = pthread_rwlock_trywrlock(&g_rwlock);
   ASSERT_EQ(rc, EBUSY);
@@ skipping 60 matching lines @@
   fprintf(stderr, "Thread started.\n");
 
   test_unlocked_with_zero_timestamp();
   test_multiple_readers();
   test_multiple_writers();
   test_reader_plus_writer();
   test_writer_plus_reader();
   test_reader_timedwait();
   test_writer_timedwait();
   test_recursive_reader();
+  test_multiple_reader_wakeup();
 
   rc = pthread_rwlock_destroy(&g_rwlock);
   ASSERT_EQ(rc, 0);
   fprintf(stderr, "Done.\n");
   return 0;
 }