src/os/posix/vm/os_posix.cpp

*** 22,41 ****
--- 22,43 ----
   *
   */
  
  #include "utilities/globalDefinitions.hpp"
  #include "prims/jvm.h"
+ #include "semaphore_posix.hpp"
  #include "runtime/frame.inline.hpp"
  #include "runtime/interfaceSupport.hpp"
  #include "runtime/os.hpp"
  #include "utilities/vmError.hpp"
  
  #include <signal.h>
  #include <unistd.h>
  #include <sys/resource.h>
  #include <sys/utsname.h>
  #include <pthread.h>
+ #include <semaphore.h>
  #include <signal.h>
  
  PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
  
  // Todo: provide a os::get_max_process_id() or similar. Number of processes
*** 1013,1017 ****
--- 1015,1083 ----
      if (sig == SIGSEGV || sig == SIGBUS) {
        WatcherThread::watcher_thread()->crash_protection()->restore();
      }
    }
  }
+ 
+ #define check_with_errno(check_type, cond, msg)                                      \
+   do {                                                                               \
+     int err = errno;                                                                 \
+     check_type(cond, err_msg("%s; error='%s' (errno=%d)", msg, strerror(err), err)); \
+ } while (false)
+ 
+ #define assert_with_errno(cond, msg)    check_with_errno(assert, cond, msg)
+ #define guarantee_with_errno(cond, msg) check_with_errno(guarantee, cond, msg)
+ 
+ // POSIX unamed semaphores are not supported on OS X.
+ #ifndef __APPLE__
+ 
+ PosixSemaphore::PosixSemaphore(uint value) {
+   int ret = sem_init(&_semaphore, 0, value);
+ 
+   guarantee_with_errno(ret == 0, "Failed to initialize semaphore");
+ }
+ 
+ PosixSemaphore::~PosixSemaphore() {
+   sem_destroy(&_semaphore);
+ }
+ 
+ void PosixSemaphore::signal(uint count) {
+   for (uint i = 0; i < count; i++) {
+     int ret = sem_post(&_semaphore);
+ 
+     assert_with_errno(ret == 0, "sem_post failed");
+   }
+ }
+ 
+ void PosixSemaphore::wait() {
+   int ret;
+   while ((ret = sem_wait(&_semaphore)) == -1 && errno == EINTR) {
+     // Retry if the wait was interrupted by a signal.
+   }
+   assert_with_errno(ret == 0, "sem_wait failed");
+ }
+ 
+ bool PosixSemaphore::trywait() {
+   bool succeeded = sem_trywait(&_semaphore) == 0;
+ 
+   assert_with_errno(succeeded || errno == EAGAIN, "trywait failed");
+ 
+   return succeeded;
+ }
+ 
+ bool PosixSemaphore::timedwait(const struct timespec ts) {
+   while (true) {
+     int result = sem_timedwait(&_semaphore, &ts);
+     if (result == 0) {
+       return true;
+     } else if (errno == EINTR) {
+       continue;
+     } else if (errno == ETIMEDOUT) {
+       return false;
+     } else {
+       assert_with_errno(false, "timedwait failed");
+       return false;
+     }
+   }
+ }
+ 
+ #endif // __APPLE__