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

src/trusted/service_runtime/fs/obj_proxy.c

 /*
- * Copyright 2008 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.
  */
 
 /*
  * NaCl Service Runtime Object Proxy.  Used for the NaCl file system
  * and as a generic object proxy mechanism.
  */
 
 #include "native_client/src/include/portability.h"
 
 #include <string.h>
@@ skipping 221 matching lines @@
   NaClMutexDtor(&self->mu);
 }
 
 
 uint8_t const *NaClObjProxyFindNameByObj(struct NaClObjProxy *self,
                                          void                *obj) {
   struct NaClObjProxyEntry        *found = NULL;
   struct NaClContainerHashTblIter iter;
   uint8_t const                   *rv = NULL;
 
-  NaClMutexLock(&self->mu);
+  NaClXMutexLock(&self->mu);
   self->key->obj = obj;
   (*self->obj_to_name->vtbl->Find)(self->obj_to_name,
                                    self->key,
                                    (struct NaClContainerIter *) &iter);
   if (!(*iter.base.vtbl->AtEnd)((struct NaClContainerIter *) &iter)) {
     found = ((struct NaClObjProxyEntry *)
              (*iter.base.vtbl->Star)((struct NaClContainerIter *) &iter));
     rv = found->name;
   }
-  NaClMutexUnlock(&self->mu);
+  NaClXMutexUnlock(&self->mu);
 
   return rv;
 }
 
 
 int NaClObjProxyFindObjByName(struct NaClObjProxy *self,
                               uint8_t const       *name,
                               void                **out) {
   struct NaClObjProxyEntry        *found = NULL;
   struct NaClContainerHashTblIter iter;
   int                             rv = 0;
 
-  NaClMutexLock(&self->mu);
+  NaClXMutexLock(&self->mu);
   memcpy(self->key->name, name, self->name_bytes);
   (*self->name_to_obj->vtbl->Find)(self->name_to_obj,
                                    self->key,
                                    (struct NaClContainerIter *) &iter);
   if (!(*iter.base.vtbl->AtEnd)((struct NaClContainerIter *) &iter)) {
     found = ((struct NaClObjProxyEntry *)
              (*iter.base.vtbl->Star)((struct NaClContainerIter *) &iter));
     *out = found->obj;
 #if DEBUG
     printf("ObjByName %d: %02x%02x%02x...\n", (int) found->obj,
            self->key->name[0], self->key->name[1], self->key->name[2]);
 #endif
     rv = 1;
   }
-  NaClMutexUnlock(&self->mu);
+  NaClXMutexUnlock(&self->mu);
   return rv;
 }
 
 
 uint8_t const *NaClObjProxyInsert(struct NaClObjProxy *self, void *obj) {
   struct NaClObjProxyEntry  *entry = NULL;
   struct NaClObjProxyEntry  *entry2 = NULL;
   uint8_t const             *rv = NULL;
 #if PARANOID
   void                      *out;
@@ skipping 22 matching lines @@
   } while (NaClObjProxyFindObjByName(self, entry->name, &out));
 #endif
   memcpy(entry2, entry, (sizeof *entry) + self->name_bytes);
 #if DEBUG
     printf("entry: %d: %02x%02x%02x...\n", (int) entry->obj,
            entry->name[0], entry->name[1], entry->name[2]);
     printf("entry2: %d: %02x%02x%02x...\n", (int) entry2->obj,
            entry2->name[0], entry2->name[1], entry2->name[2]);
 #endif
 
-  NaClMutexLock(&self->mu);
+  NaClXMutexLock(&self->mu);
   (*self->obj_to_name->vtbl->Insert)(self->obj_to_name, entry);
   (*self->name_to_obj->vtbl->Insert)(self->name_to_obj, entry2);
-  NaClMutexUnlock(&self->mu);
+  NaClXMutexUnlock(&self->mu);
 
   rv = entry->name;
 cleanup:
   return rv;
 }
 
 
 int NaClObjProxyRemove(struct NaClObjProxy *self, void *obj) {
   /*
    * must first find the entry so we know its randomly assigned name,
@@ skipping 20 matching lines @@
     NaClLog(LOG_FATAL, "object %08"NACL_PRIxPTR
             " found in o2n tbl, but not in n2o\n",
             (uintptr_t) obj);
     return 0;  /* internal error! */
   }
   (*o2niter.base.vtbl->Erase)((struct NaClContainerIter *) &o2niter);
   (*n2oiter.base.vtbl->Erase)((struct NaClContainerIter *) &n2oiter);
 
   return 1;
 }