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

src/trusted/service_runtime/nacl_sync_cond_test.c

 /*
  * 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 <stdio.h>
 
 #include "native_client/src/include/nacl_assert.h"
 #include "native_client/src/include/nacl_macros.h"
@@ skipping 72 matching lines @@
   uint64_t          sleep_usec;
   uint64_t          cond_timeout_usec;
   int               abort_on_wake;
   struct NaClMutex  mu;
   struct NaClThread thr;
 };
 
 void AlarmerStateCtor(struct AlarmerState *sp,
                       uint64_t            sleep_usec,
                       uint64_t            cond_timeout_usec) {
-  NaClMutexCtor(&sp->mu);
+  NaClXMutexCtor(&sp->mu);
   sp->abort_on_wake = 1;
   sp->sleep_usec = sleep_usec;
   sp->cond_timeout_usec = cond_timeout_usec;
 }
 
 void AlarmerStateDtor(struct AlarmerState *sp) {
   NaClMutexDtor(&sp->mu);
 }
 
 void AlarmerDisable(struct AlarmerState *sp) {
-  NaClMutexLock(&sp->mu);
+  NaClXMutexLock(&sp->mu);
   sp->abort_on_wake = 0;
-  NaClMutexUnlock(&sp->mu);
+  NaClXMutexUnlock(&sp->mu);
 }
 
 static void PrintFailureSuggestions() {
     printf("If this test is running on a very busy machine,\n"
            " try using the -F flag to increase the timeout\n"
            " (this is a multiplier of actual requested timeout time)\n"
            " or -C to increase the minium value for maximum elapsed\n"
            " time permitted\n"
            "Current fuzz factor %g\n",
            gSchedulerMaxFuzzFactor);
@@ skipping 16 matching lines @@
     fflush(NULL);
   }
 #if NACL_WINDOWS
   Sleep(millisec);
 #else
   usleep((useconds_t) sp->sleep_usec);
 #endif
   if (gVerbosity) {
     printf("Alarmer %p: woke up\n", (void *) sp);
   }
-  NaClMutexLock(&sp->mu);
+  NaClXMutexLock(&sp->mu);
   should_abort = sp->abort_on_wake;
   cond_timeout_usec = sp->cond_timeout_usec;
-  NaClMutexUnlock(&sp->mu);
+  NaClXMutexUnlock(&sp->mu);
   if (should_abort) {
     printf("Alarmer %p: woke up after %"NACL_PRId64".%06"NACL_PRId64" seconds"
            " without condition\n",
            (void *) sp,
            sp->sleep_usec / kMicroXinX,
            sp->sleep_usec % kMicroXinX);
     printf("condvar timeout was %"NACL_PRId64".%06"NACL_PRId64" sec\n",
            cond_timeout_usec / kMicroXinX,
            cond_timeout_usec % kMicroXinX);
     printf("Alarmer %p:  variable timing out.\n", (void *) sp);
@@ skipping 91 matching lines @@
   if (NULL != asp) {
     AlarmerDisable(asp);
   }
   TimerCheckElapsed(&t, cond_timeout_usec, min_elapsed_usec, max_elapsed_usec);
 }
 
 struct NaClMutex        gMu;
 struct NaClCondVar      gCv;
 
 void TestInit() {
-  (void) NaClMutexCtor(&gMu);
-  (void) NaClCondVarCtor(&gCv);
+  NaClXMutexCtor(&gMu);
+  NaClXCondVarCtor(&gCv);
 }
 
 void TestFini() {
   NaClMutexDtor(&gMu);
   NaClCondVarDtor(&gCv);
 }
 
 struct TestFunctorArg {
   uint64_t  sleep_usec;
 };
 
 void TestRelWait(void *arg) {
   uint64_t                  sleep_usec;
   struct nacl_abi_timespec  t;
 
   sleep_usec = ((struct TestFunctorArg *) arg)->sleep_usec;
   t.tv_sec = (nacl_abi_time_t) (sleep_usec / kMicroXinX);
   t.tv_nsec = (long int) (kNanoXinMicroX * (sleep_usec % kMicroXinX));
   if (gVerbosity > 1) {
     printf("TestRelWait: locking\n");
   }
   NaClXMutexLock(&gMu);
   if (gVerbosity > 1) {
     printf("TestRelWait: waiting\n");
   }
-  NaClCondVarTimedWaitRelative(&gCv, &gMu, &t);
+  NaClXCondVarTimedWaitRelative(&gCv, &gMu, &t);
   if (gVerbosity > 1) {
     printf("TestRelWait: unlocking\n");
   }
   NaClXMutexUnlock(&gMu);
 }
 
 void TestAbsWait(void *arg) {
   uint64_t                  sleep_usec;
   struct nacl_abi_timeval   now;
   struct nacl_abi_timespec  t;
 
   sleep_usec = ((struct TestFunctorArg *) arg)->sleep_usec;
   (void) NaClGetTimeOfDay(&now);
   t.tv_sec = (nacl_abi_time_t) (now.nacl_abi_tv_sec + sleep_usec / kMicroXinX);
   t.tv_nsec = (long int) (kNanoXinMicroX * (now.nacl_abi_tv_usec
                                             + (sleep_usec % kMicroXinX)));
   while (t.tv_nsec > kNanoXinX) {
     t.tv_nsec -= kNanoXinX;
     ++t.tv_sec;
   }
   if (gVerbosity > 1) {
     printf("TestAbsWait: locking\n");
   }
   NaClXMutexLock(&gMu);
   if (gVerbosity > 1) {
     printf("TestAbsWait: waiting\n");
   }
-  NaClCondVarTimedWaitAbsolute(&gCv, &gMu, &t);
+  NaClXCondVarTimedWaitAbsolute(&gCv, &gMu, &t);
   if (gVerbosity > 1) {
     printf("TestAbsWait: unlocking\n");
   }
   NaClXMutexUnlock(&gMu);
 }
 
 
 int main(int argc,
          char **argv) {
   int                     opt;
@@ skipping 113 matching lines @@
       FunctorDelays(test_tbl[ix], &arg, sleep_usec, min_sleep, max_sleep,
                     alarmer);
     }
   }
   TestFini();
 
   NaClAllModulesFini();
   printf("PASS\n");
   return 0;
 }