Add implementation of pthread_rwlock based on NaCl futexs

tests/threads/rwlock_test.c

Index: tests/threads/rwlock_test.c
diff --git a/tests/threads/rwlock_test.c b/tests/threads/rwlock_test.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5c45d1a26a1d96dc30ee341de3ad4b7ba525dc4
--- /dev/null
+++ b/tests/threads/rwlock_test.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2014 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>
+
+#include "native_client/src/include/nacl_assert.h"
+
+static pthread_rwlock_t rwlock;
+volatile int thread_has_lock = 0;
+volatile int thread_should_acquire_lock = 0;
+volatile int thread_should_release_lock = 0;
+
+void *locking_thread(void *unused) {
+  for (;;) {
+    while (!thread_should_acquire_lock) { /* Spin. */ }
+
+    ASSERT_EQ(thread_has_lock, 0);
+    int rc = pthread_rwlock_rdlock(&rwlock);
+    ASSERT_EQ(rc, 0);
+    __sync_fetch_and_add(&thread_has_lock, 1);
+
+    while (!thread_should_release_lock) { /* Spin. */ }
+
+    ASSERT_EQ(thread_has_lock, 1);
+    rc = pthread_rwlock_unlock(&rwlock);
+    ASSERT_EQ(rc, 0);
+    __sync_fetch_and_sub(&thread_has_lock, 1);
+  }
+
+  return NULL;
+}
+
+void test_unlocked_with_zero_timestamp(void) {
+  int rc;
+  struct timespec abstime = { 0, 0 };
+  ASSERT_EQ(thread_has_lock, 0);
+  fprintf(stderr, "Trying to lock the unlocked rwlock with a valid "
+          "zero absolute timestamp. "
+          "Expected to succeed instantly since the lock is free.\n");
+  rc = pthread_rwlock_timedrdlock(&rwlock, &abstime);
+  ASSERT_EQ(rc, 0);
+  rc = pthread_rwlock_unlock(&rwlock);
+  ASSERT_EQ(rc, 0);
+}
+
+int main(int argc, char **argv) {
+  int rc;
+  fprintf(stderr, "Running...\n");
+
+  pthread_rwlockattr_t attrs;
+  rc = pthread_rwlockattr_init(&attrs);
+  ASSERT_EQ(rc, 0);
+  rc = pthread_rwlock_init(&rwlock, &attrs);
+  ASSERT_EQ(rc, 0);
+  rc = pthread_rwlockattr_destroy(&attrs);
+  ASSERT_EQ(rc, 0);
+
+  pthread_t thread;
+  rc = pthread_create(&thread, NULL, locking_thread, NULL);

[Mark Seaborn, 2014/10/02 19:58:51]

AFAICT you don't synchronise with this thread, so effectively it's not testing
for anything reliably.

+  ASSERT_EQ(rc, 0);
+  fprintf(stderr, "Thread started.\n");
+
+  test_unlocked_with_zero_timestamp();
+
+  fprintf(stderr, "Done.\n");
+  return 0;
+}