modified nacl_sync.h to have NACL_WUR for all functions that return a

src/trusted/service_runtime/nacl_text.c

 /*
- * Copyright 2009 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.
+ * Copyright (c) 2011 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 <string.h>
 
 #include "native_client/src/include/concurrency_ops.h"
 #include "native_client/src/include/portability.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/platform/nacl_log.h"
+#include "native_client/src/shared/platform/nacl_sync.h"
+#include "native_client/src/shared/platform/nacl_sync_checked.h"
 #include "native_client/src/trusted/desc/nacl_desc_base.h"
 #include "native_client/src/trusted/desc/nacl_desc_effector.h"
 #include "native_client/src/trusted/desc/nacl_desc_effector.h"
 #include "native_client/src/trusted/desc/nacl_desc_imc_shm.h"
 #include "native_client/src/trusted/service_runtime/arch/sel_ldr_arch.h"
 #include "native_client/src/trusted/service_runtime/include/sys/errno.h"
 #include "native_client/src/trusted/service_runtime/include/sys/mman.h"
 #include "native_client/src/trusted/service_runtime/nacl_app_thread.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 #include "native_client/src/trusted/service_runtime/nacl_text.h"
@@ skipping 354 matching lines @@
   }
 }
 
 
 void NaClSetThreadGeneration(struct NaClAppThread *natp, int generation) {
   /*
    * outer check handles fast case (no change)
    * since threads only set their own generation it is safe
    */
   if (natp->dynamic_delete_generation != generation)  {
-    NaClMutexLock(&natp->mu);
+    NaClXMutexLock(&natp->mu);
     CHECK(natp->dynamic_delete_generation <= generation);
     natp->dynamic_delete_generation = generation;
-    NaClMutexUnlock(&natp->mu);
+    NaClXMutexUnlock(&natp->mu);
   }
 }
 
 int NaClMinimumThreadGeneration(struct NaClApp *nap) {
   int i, rv = 0;
-  NaClMutexLock(&nap->threads_mu);
+  NaClXMutexLock(&nap->threads_mu);
   for (i = 0; i < nap->num_threads; ++i) {
     struct NaClAppThread *thread = NaClGetThreadMu(nap, i);
-    NaClMutexLock(&thread->mu);
+    NaClXMutexLock(&thread->mu);
     if (i == 0 || rv > thread->dynamic_delete_generation) {
       rv = thread->dynamic_delete_generation;
     }
-    NaClMutexUnlock(&thread->mu);
+    NaClXMutexUnlock(&thread->mu);
   }
-  NaClMutexUnlock(&nap->threads_mu);
+  NaClXMutexUnlock(&nap->threads_mu);
   return rv;
 }
 
 static void CopyBundleTails(uint8_t *dest,
                             uint8_t *src,
                             int32_t size,
                             int     bundle_size) {
   /*
    * The order in which these locations are written does not matter:
    * none of the locations will be reachable, because the bundle heads
@@ skipping 254 matching lines @@
    */
   if (dest + size > nap->dynamic_text_end - NACL_HALT_SLED_SIZE) {
     NaClLog(1, "NaClTextSysDyncode_Copy: Above dynamic code area\n");
     return -NACL_ABI_EFAULT;
   }
   if (0 == size) {
     /* Nothing to load.  Succeed trivially. */
     return 0;
   }
 
-  NaClMutexLock(&nap->dynamic_load_mutex);
+  NaClXMutexLock(&nap->dynamic_load_mutex);
 
   if (NaClDynamicRegionCreate(nap, dest_addr, size) == 1) {
     /* target memory region is free */
     validator_result = NaClValidateCode(nap, dest, code_copy, size);
   } else {
     /* target addr is in use */
     NaClLog(1, "NaClTextSysDyncode_Copy: Code range already allocated\n");
     retval = -NACL_ABI_EINVAL;
     goto cleanup_unlock;
   }
@@ skipping 16 matching lines @@
     retval = -NACL_ABI_ENOMEM;
     goto cleanup_unlock;
   }
 
   CopyCodeSafelyInitial(mapped_addr, code_copy, size, nap->bundle_size);
   retval = 0;
 
   NaclTextMapClearCacheIfNeeded(nap, dest, size);
 
  cleanup_unlock:
-  NaClMutexUnlock(&nap->dynamic_load_mutex);
+  NaClXMutexUnlock(&nap->dynamic_load_mutex);
 
   return retval;
 }
 
 int32_t NaClTextSysDyncode_Create(struct NaClAppThread *natp,
                                   uint32_t             dest,
                                   uint32_t             src,
                                   uint32_t             size) {
   struct NaClApp              *nap = natp->nap;
   uintptr_t                   src_addr;
@@ skipping 49 matching lines @@
     return 0;
   }
 
   dest_addr = NaClUserToSysAddrRange(nap, dest, size);
   src_addr = NaClUserToSysAddrRange(nap, src, size);
   if (kNaClBadAddress == src_addr || kNaClBadAddress == dest_addr) {
     NaClLog(1, "NaClTextSysDyncode_Modify: Address out of range\n");
     return -NACL_ABI_EFAULT;
   }
 
-  NaClMutexLock(&nap->dynamic_load_mutex);
+  NaClXMutexLock(&nap->dynamic_load_mutex);
 
   region = NaClDynamicRegionFind(nap, dest_addr, size);
   if (NULL == region || region->start > dest_addr
         || region->start + region->size < dest_addr + size) {
     /* target not a subregion of region or region is null */
     NaClLog(1, "NaClTextSysDyncode_Modify: Can't find region to modify\n");
     retval = -NACL_ABI_EFAULT;
     goto cleanup_unlock;
   }
 
@@ skipping 59 matching lines @@
     NaClLog(1, "NaClTextSysDyncode_Modify "
                "Copying of replacement code failed\n");
     retval = -NACL_ABI_EINVAL;
     goto cleanup_unlock;
   }
   retval = 0;
 
   NaclTextMapClearCacheIfNeeded(nap, dest, size);
 
  cleanup_unlock:
-  NaClMutexUnlock(&nap->dynamic_load_mutex);
+  NaClXMutexUnlock(&nap->dynamic_load_mutex);
 
   if (code_copy != code_copy_buf) {
     free(code_copy);
   }
 
   return retval;
 }
 
 int32_t NaClTextSysDyncode_Delete(struct NaClAppThread *natp,
                                   uint32_t             dest,
@@ skipping 12 matching lines @@
   dest_addr = NaClUserToSysAddrRange(nap, dest, size);
   if (kNaClBadAddress == dest_addr) {
     NaClLog(1, "NaClTextSysDyncode_Delete: Address out of range\n");
     return -NACL_ABI_EFAULT;
   }
 
   if (0 == size) {
     /* Nothing to delete.  Just update our generation. */
     int gen;
     /* fetch current generation */
-    NaClMutexLock(&nap->dynamic_load_mutex);
+    NaClXMutexLock(&nap->dynamic_load_mutex);
     gen = nap->dynamic_delete_generation;
-    NaClMutexUnlock(&nap->dynamic_load_mutex);
+    NaClXMutexUnlock(&nap->dynamic_load_mutex);
     /* set our generation */
     NaClSetThreadGeneration(natp, gen);
     return 0;
   }
 
-  NaClMutexLock(&nap->dynamic_load_mutex);
+  NaClXMutexLock(&nap->dynamic_load_mutex);
 
   /*
    * this check ensures the to-be-deleted region is identical to a
    * previously inserted region, so no need to check for alignment/bounds/etc
    */
   region = NaClDynamicRegionFind(nap, dest_addr, size);
   if (NULL == region || region->start != dest_addr || region->size != size) {
     NaClLog(1, "NaClTextSysDyncode_Delete: Can't find region to delete\n");
     retval = -NACL_ABI_EFAULT;
     goto cleanup_unlock;
@@ skipping 38 matching lines @@
     NaClDynamicRegionDelete(nap, region);
     retval = 0;
   } else {
     /*
      * Still waiting for some threads to report in...
      */
     retval = -NACL_ABI_EAGAIN;
   }
 
  cleanup_unlock:
-  NaClMutexUnlock(&nap->dynamic_load_mutex);
+  NaClXMutexUnlock(&nap->dynamic_load_mutex);
   return retval;
 }