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

src/shared/imc/sigpipe_test.cc

 /*
- * 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.
  */
 
 // Test that SIGPIPE is not raised when using nacl::SendDatagram or
 // nacl::SendDatagramTo when the peer has been closed for various
 // flavors of sockets.
 
 #include <stdio.h>
 #include <sys/types.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/include/nacl_string.h"
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/portability_process.h"
 #include "native_client/src/shared/imc/nacl_imc.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/shared/platform/nacl_threads.h"
 
 
 namespace {
 
 const bool kPlatformUsesBoundSockets = NACL_WINDOWS;
 
 bool gSleepBeforeReceive(false);
 std::vector<int> gTestSequence;
 
@@ skipping 95 matching lines @@
     : cli_sock(nacl::kInvalidHandle),
       srv_sock(nacl::kInvalidHandle),
       new_sock_only(nso),
       repetitions(reps),
       outer_rep(out_rep),
       test_sequence(seqp),
       errors(-1),
       cur_test(-1) {
   pair[0] = nacl::kInvalidHandle;
   pair[1] = nacl::kInvalidHandle;
-  (void) NaClMutexCtor(&mu);
-  (void) NaClCondVarCtor(&cv);
+  NaClXMutexCtor(&mu);
+  NaClXCondVarCtor(&cv);
 }
 
 int TestState::Init() {
   if (kPlatformUsesBoundSockets) {
     PickRandomSocketAddress(&cli_addr);
     cli_sock = nacl::BoundSocket(&cli_addr);
     if (nacl::kInvalidHandle == cli_sock) {
       MyPerror("BoundSocket");
       printf("ERROR: No client socket\n");
       return 1;
@@ skipping 477 matching lines @@
          tsp->test_sequence->end() != it;
          ++it) {
       int test = *it;
 
       if (test_fn[test].new_socks != tsp->new_sock_only) {
         printf("PeerThread: new_socks mismatch, skipping\n");
         continue;
       }
 
       printf("PeerThread: Locking for test %d to start\n", test);
-      NaClMutexLock(&tsp->mu);
+      NaClXMutexLock(&tsp->mu);
       while (tsp->cur_test != test) {
         printf("PeerThread: waiting for test %d to start\n", test);
         printf("tsp->cur_test %d\n", tsp->cur_test);
-        NaClCondVarWait(&tsp->cv, &tsp->mu);
+        NaClXCondVarWait(&tsp->cv, &tsp->mu);
       }
-      NaClMutexUnlock(&tsp->mu);
+      NaClXMutexUnlock(&tsp->mu);
 
       printf("PeerThread: START test %d, %s\n", test, test_fn[test].name);
       errors += test_fn[test].sender(tsp, test_fn[test].mode);
       printf("PeerThread: END test %d, %s\n", test, test_fn[test].name);
 
       printf("PeerThread: Locking for test %d to end\n", test);
-      NaClMutexLock(&tsp->mu);
+      NaClXMutexLock(&tsp->mu);
       tsp->cur_test = -1;
-      NaClCondVarSignal(&tsp->cv);
-      NaClMutexUnlock(&tsp->mu);
+      NaClXCondVarSignal(&tsp->cv);
+      NaClXMutexUnlock(&tsp->mu);
     }
   }
   if (-1 == tsp->outer_rep)
     printf("\n======== EXITING PEER THREAD ========\n");
   else
     printf("\n======== EXITING INDEPENDENT PEER THREAD"
            " ========\n");
 
   printf("%sPEER THREAD EXITING, LOCKING\n",
          (-1 == tsp->outer_rep) ? "" : "INDEPENDENT ");
-  (void) NaClMutexLock(&tsp->mu);
+  NaClXMutexLock(&tsp->mu);
   tsp->errors = errors;
   printf("%sPEER THREAD EXITING, SIGNALING\n",
          (-1 == tsp->outer_rep) ? "" : "INDEPENDENT ");
   fflush(NULL);
-  (void) NaClCondVarSignal(&tsp->cv);
-  (void) NaClMutexUnlock(&tsp->mu);
+  NaClXCondVarSignal(&tsp->cv);
+  NaClXMutexUnlock(&tsp->mu);
 }
 
 
 int TestNaClSocket(int rep_count) {
   int errors = 0;
   TestState tstate(&gTestSequence, false, rep_count, -1);
 
   errors += tstate.Init();
   if (0 != errors) return errors;
 
@@ skipping 20 matching lines @@
         fflush(NULL);
 #if NACL_WINDOWS
         Sleep(1000);
 #else
         sleep(1);
 #endif
       }
 
       if (!test_fn[test].new_socks) {
         printf("Locking to start test %d\n", test);
-        NaClMutexLock(&tstate.mu);
+        NaClXMutexLock(&tstate.mu);
         tstate.cur_test = test;
-        NaClCondVarSignal(&tstate.cv);
-        NaClMutexUnlock(&tstate.mu);
+        NaClXCondVarSignal(&tstate.cv);
+        NaClXMutexUnlock(&tstate.mu);
         printf("Signaled test %d start\n", test);
 
         errors += test_fn[test].receiver(&tstate, test_fn[test].mode);
 
         printf("Locking to wait for test %d end\n", test);
-        NaClMutexLock(&tstate.mu);
+        NaClXMutexLock(&tstate.mu);
         while (-1 != tstate.cur_test) {
           printf("Waiting for test %d to be finished\n", test);
           printf("tstate.cur_test %d\n", tstate.cur_test);
-          NaClCondVarWait(&tstate.cv, &tstate.mu);
+          NaClXCondVarWait(&tstate.cv, &tstate.mu);
         }
-        NaClMutexUnlock(&tstate.mu);
+        NaClXMutexUnlock(&tstate.mu);
       } else {
         printf("test %d requests independent socket/thread\n", test);
         std::vector<int> seq;
         seq.push_back(test);
         TestState private_sock(&seq, true, 1, rep);
         int private_errors(private_sock.Init());
         if (0 != private_errors) {
           printf("Could not create/initialize TestState.\n");
           errors += private_errors;
           continue;
         }
         struct NaClThread private_thr;
         (void) NaClThreadCtor(&private_thr, PeerThread,
                               static_cast<void *>(&private_sock), 128*1024);
 
         printf("Locking to start test %d\n", test);
-        NaClMutexLock(&private_sock.mu);
+        NaClXMutexLock(&private_sock.mu);
         private_sock.cur_test = test;
-        NaClCondVarSignal(&private_sock.cv);
-        NaClMutexUnlock(&private_sock.mu);
+        NaClXCondVarSignal(&private_sock.cv);
+        NaClXMutexUnlock(&private_sock.mu);
         printf("Signaled test %d start\n", test);
 
         errors += test_fn[test].receiver(&private_sock, test_fn[test].mode);
 
         printf("Locking to wait for test %d end\n", test);
-        NaClMutexLock(&private_sock.mu);
+        NaClXMutexLock(&private_sock.mu);
         while (-1 != private_sock.cur_test) {
           printf("Waiting for test %d to be finished\n", test);
           printf("private_sock %d\n", private_sock.cur_test);
-          NaClCondVarWait(&private_sock.cv, &private_sock.mu);
+          NaClXCondVarWait(&private_sock.cv, &private_sock.mu);
         }
-        NaClMutexUnlock(&private_sock.mu);
+        NaClXMutexUnlock(&private_sock.mu);
 
         fflush(NULL);
-        (void) NaClMutexLock(&private_sock.mu);
+        NaClXMutexLock(&private_sock.mu);
         while (-1 == private_sock.errors) {
-          (void) NaClCondVarWait(&private_sock.cv, &private_sock.mu);
+          NaClXCondVarWait(&private_sock.cv, &private_sock.mu);
         }
-        (void) NaClMutexUnlock(&private_sock.mu);
+        NaClXMutexUnlock(&private_sock.mu);
         errors += private_sock.errors;
         if (private_sock.outer_rep != rep) {
           printf("Threads out of sync!?!\n");
           abort();
         }
       }
     }
   }
 
 
   printf("MainThread: Waiting for receiver thread to exit.\n");
   fflush(NULL);
-  (void) NaClMutexLock(&tstate.mu);
+  NaClXMutexLock(&tstate.mu);
   while (-1 == tstate.errors) {
-    (void) NaClCondVarWait(&tstate.cv, &tstate.mu);
+    NaClXCondVarWait(&tstate.cv, &tstate.mu);
   }
-  (void) NaClMutexUnlock(&tstate.mu);
+  NaClXMutexUnlock(&tstate.mu);
   NaClThreadDtor(&thr);
   errors += tstate.errors;
 
   // now close server side and attempt to send again.
   printf("nacl::Close(%d)\n", tstate.srv_sock);
   (void) nacl::Close(tstate.srv_sock);
   tstate.srv_sock = nacl::kInvalidHandle;
   printf("nacl::Close(%d)\n", tstate.pair[0]);
   (void) nacl::Close(tstate.pair[0]);
   tstate.pair[0] = nacl::kInvalidHandle;
@@ skipping 97 matching lines @@
 #endif
 
   errors += TestNaClSocket(rep_count);
 
   printf("%s\n", (errors == 0) ? "PASSED" : "FAILED");
 
   NaClLogModuleFini();
 
   return errors;
 }