Implement pthread_rwlock functions for NaCl newlib

src/untrusted/pthread/nc_thread.c

 /*
  * Copyright (c) 2012 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.
  */
 
 /*
  * Native Client threads library
  */
 
@@ skipping 45 matching lines @@
 #endif
 
 typedef struct nc_thread_cleanup_handler {
   struct nc_thread_cleanup_handler *previous;
   void (*handler_function)(void *arg);
   void *handler_arg;
 } nc_thread_cleanup_handler;
 
 static __thread nc_thread_cleanup_handler *__nc_cleanup_handlers = NULL;
 
-#define TDB_SIZE (sizeof(struct nc_combined_tdb))
-
 static inline char *align(uint32_t offset, uint32_t alignment) {
   return (char *) ((offset + alignment - 1) & ~(alignment - 1));
 }
 
 /* Thread management global variables. */
 const int __nc_kMaxCachedMemoryBlocks = 50;
 
 int __nc_thread_initialized;
 
 /* Mutex used to synchronize thread management code. */
 pthread_mutex_t  __nc_thread_management_lock;
 
 /*
  * Condition variable that gets signaled when all the threads
  * except the main thread have terminated.
  */
 static pthread_cond_t __nc_last_thread_cond;
 pthread_t __nc_initial_thread_id;
 
 /* Number of threads currently running in this NaCl module. */
 int __nc_running_threads_counter = 1;
 
 /* We have two queues of memory blocks - one for each type. */
 STAILQ_HEAD(tailhead, entry) __nc_thread_memory_blocks[2];
 /* We need a counter for each queue to keep track of number of blocks. */
 int __nc_memory_block_counter[2];
 
 /* Internal functions */
 
-static inline nc_thread_descriptor_t *nc_get_tdb(void) {
-  /*
-   * Fetch the thread-specific data pointer.  This is usually just
-   * a wrapper around __libnacl_irt_tls.tls_get() but we don't use
-   * that here so that the IRT build can override the definition.
-   */
-  return (void *) ((char *) __nacl_read_tp_inline()
-                   + __nacl_tp_tdb_offset(TDB_SIZE));
-}
-
 static void nc_thread_starter(void) {
-  nc_thread_descriptor_t *tdb = nc_get_tdb();
+  nc_thread_descriptor_t *tdb = __nc_get_tdb();
   __newlib_thread_init();
 #if defined(NACL_IN_IRT)
   g_is_irt_internal_thread = 1;
 #endif
   void *retval = tdb->start_func(tdb->state);
 
   /*
    * Free handler list to prevent memory leak in case function returns
    * without calling pthread_cleanup_pop(), although doing that is unspecified
    * behaviour.
@@ skipping 117 matching lines @@
     nc_free_memory_block_mu(TLS_AND_TDB_MEMORY, block);
   }
 }
 
 /* Initialize a newly allocated TDB to some default values. */
 static void nc_tdb_init(nc_thread_descriptor_t *tdb,
                         nc_basic_thread_data_t *basic_data) {
   tdb->tls_base = tdb;
   tdb->joinable = PTHREAD_CREATE_JOINABLE;
   tdb->join_waiting = 0;
+  tdb->rdlock_count = 0;
   tdb->stack_node = NULL;
   tdb->tls_node = NULL;
   tdb->start_func = NULL;
   tdb->state = NULL;
   tdb->irt_thread_data = NULL;
   tdb->basic_data = basic_data;
 
   basic_data->retval = NULL;
   basic_data->status = THREAD_RUNNING;
   if (pthread_cond_init(&basic_data->join_condvar, NULL) != 0)
@@ skipping 41 matching lines @@
 
 #else
 
 /*
  * Will be called from the library startup code,
  * which always happens on the application's main thread.
  */
 void __pthread_initialize(void) {
   __pthread_initialize_minimal(TDB_SIZE);
 
-  struct nc_combined_tdb *tdb = (struct nc_combined_tdb *) nc_get_tdb();
+  struct nc_combined_tdb *tdb = (struct nc_combined_tdb *) __nc_get_tdb();
   nc_tdb_init(&tdb->tdb, &tdb->basic_data);
   __nc_initial_thread_id = &tdb->basic_data;
 
   __nc_initialize_globals();
 }
 
 #endif
 
 
 /* pthread functions */
@@ skipping 167 matching lines @@
     nc_thread_cleanup_handler *handler = __nc_cleanup_handlers;
     __nc_cleanup_handlers = handler->previous;
     if (execute)
       handler->handler_function(handler->handler_arg);
     free(handler);
   }
 }
 
 void pthread_exit(void *retval) {
   /* Get all we need from the tdb before releasing it. */
-  nc_thread_descriptor_t    *tdb = nc_get_tdb();
+  nc_thread_descriptor_t    *tdb = __nc_get_tdb();
   nc_thread_memory_block_t  *stack_node = tdb->stack_node;
   int32_t                   *is_used = &stack_node->is_used;
   nc_basic_thread_data_t    *basic_data = tdb->basic_data;
   int                       joinable = tdb->joinable;
 
   /* Call cleanup handlers. */
   while (NULL != __nc_cleanup_handlers) {
     pthread_cleanup_pop(1);
   }
 
@@ skipping 117 matching lines @@
 }
 
 int pthread_kill(pthread_t thread_id,
                  int sig) {
   /* This function is currently unimplemented. */
   return ENOSYS;
 }
 
 pthread_t pthread_self(void) {
   /* Get the tdb pointer from gs and use it to return the thread handle. */
-  nc_thread_descriptor_t *tdb = nc_get_tdb();
+  nc_thread_descriptor_t *tdb = __nc_get_tdb();
   return tdb->basic_data;
 }
 
 int pthread_equal(pthread_t thread1, pthread_t thread2) {
   return (thread1 == thread2);
 }
 
 int pthread_setschedprio(pthread_t thread_id, int prio) {
   if (thread_id != pthread_self()) {
     /*
@@ skipping 177 matching lines @@
 
 /*
  * We include this directly in this file rather than compiling it
  * separately because there is some code (e.g. libstdc++) that uses weak
  * references to all pthread functions, but conditionalizes its calls only
  * on one symbol.  So if these functions are in another file in a library
  * archive, they might not be linked in by static linking.
  */
 /* @IGNORE_LINES_FOR_CODE_HYGIENE[1] */
 #include "native_client/src/untrusted/pthread/nc_tsd.c"