1 /*
   2  * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "utilities/globalDefinitions.hpp"
  26 #include "prims/jvm.h"
  27 #include "semaphore_posix.hpp"
  28 #include "runtime/frame.inline.hpp"
  29 #include "runtime/interfaceSupport.hpp"
  30 #include "runtime/os.hpp"
  31 #include "utilities/vmError.hpp"
  32 
  33 #include <signal.h>
  34 #include <unistd.h>
  35 #include <sys/resource.h>
  36 #include <sys/utsname.h>
  37 #include <pthread.h>
  38 #include <semaphore.h>
  39 #include <signal.h>
  40 
  41 // Todo: provide a os::get_max_process_id() or similar. Number of processes
  42 // may have been configured, can be read more accurately from proc fs etc.
  43 #ifndef MAX_PID
  44 #define MAX_PID INT_MAX
  45 #endif
  46 #define IS_VALID_PID(p) (p > 0 && p < MAX_PID)
  47 
  48 // Check core dump limit and report possible place where core can be found
  49 void os::check_dump_limit(char* buffer, size_t bufferSize) {
  50   int n;
  51   struct rlimit rlim;
  52   bool success;
  53 
  54   char core_path[PATH_MAX];
  55   n = get_core_path(core_path, PATH_MAX);
  56 
  57   if (n <= 0) {
  58     jio_snprintf(buffer, bufferSize, "core.%d (may not exist)", current_process_id());
  59     success = true;
  60 #ifdef LINUX
  61   } else if (core_path[0] == '"') { // redirect to user process
  62     jio_snprintf(buffer, bufferSize, "Core dumps may be processed with %s", core_path);
  63     success = true;
  64 #endif
  65   } else if (getrlimit(RLIMIT_CORE, &rlim) != 0) {
  66     jio_snprintf(buffer, bufferSize, "%s (may not exist)", core_path);
  67     success = true;
  68   } else {
  69     switch(rlim.rlim_cur) {
  70       case RLIM_INFINITY:
  71         jio_snprintf(buffer, bufferSize, "%s", core_path);
  72         success = true;
  73         break;
  74       case 0:
  75         jio_snprintf(buffer, bufferSize, "Core dumps have been disabled. To enable core dumping, try \"ulimit -c unlimited\" before starting Java again");
  76         success = false;
  77         break;
  78       default:
  79         jio_snprintf(buffer, bufferSize, "%s (max size %lu kB). To ensure a full core dump, try \"ulimit -c unlimited\" before starting Java again", core_path, (unsigned long)(rlim.rlim_cur >> 10));
  80         success = true;
  81         break;
  82     }
  83   }
  84 
  85   VMError::record_coredump_status(buffer, success);
  86 }
  87 
  88 int os::get_native_stack(address* stack, int frames, int toSkip) {
  89 #ifdef _NMT_NOINLINE_
  90   toSkip++;
  91 #endif
  92 
  93   int frame_idx = 0;
  94   int num_of_frames;  // number of frames captured
  95   frame fr = os::current_frame();
  96   while (fr.pc() && frame_idx < frames) {
  97     if (toSkip > 0) {
  98       toSkip --;
  99     } else {
 100       stack[frame_idx ++] = fr.pc();
 101     }
 102     if (fr.fp() == NULL || fr.cb() != NULL ||
 103         fr.sender_pc() == NULL || os::is_first_C_frame(&fr)) break;
 104 
 105     if (fr.sender_pc() && !os::is_first_C_frame(&fr)) {
 106       fr = os::get_sender_for_C_frame(&fr);
 107     } else {
 108       break;
 109     }
 110   }
 111   num_of_frames = frame_idx;
 112   for (; frame_idx < frames; frame_idx ++) {
 113     stack[frame_idx] = NULL;
 114   }
 115 
 116   return num_of_frames;
 117 }
 118 
 119 
 120 bool os::unsetenv(const char* name) {
 121   assert(name != NULL, "Null pointer");
 122   return (::unsetenv(name) == 0);
 123 }
 124 
 125 int os::get_last_error() {
 126   return errno;
 127 }
 128 
 129 bool os::is_debugger_attached() {
 130   // not implemented
 131   return false;
 132 }
 133 
 134 void os::wait_for_keypress_at_exit(void) {
 135   // don't do anything on posix platforms
 136   return;
 137 }
 138 
 139 // Multiple threads can race in this code, and can remap over each other with MAP_FIXED,
 140 // so on posix, unmap the section at the start and at the end of the chunk that we mapped
 141 // rather than unmapping and remapping the whole chunk to get requested alignment.
 142 char* os::reserve_memory_aligned(size_t size, size_t alignment) {
 143   assert((alignment & (os::vm_allocation_granularity() - 1)) == 0,
 144       "Alignment must be a multiple of allocation granularity (page size)");
 145   assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned");
 146 
 147   size_t extra_size = size + alignment;
 148   assert(extra_size >= size, "overflow, size is too large to allow alignment");
 149 
 150   char* extra_base = os::reserve_memory(extra_size, NULL, alignment);
 151 
 152   if (extra_base == NULL) {
 153     return NULL;
 154   }
 155 
 156   // Do manual alignment
 157   char* aligned_base = (char*) align_size_up((uintptr_t) extra_base, alignment);
 158 
 159   // [  |                                       |  ]
 160   // ^ extra_base
 161   //    ^ extra_base + begin_offset == aligned_base
 162   //     extra_base + begin_offset + size       ^
 163   //                       extra_base + extra_size ^
 164   // |<>| == begin_offset
 165   //                              end_offset == |<>|
 166   size_t begin_offset = aligned_base - extra_base;
 167   size_t end_offset = (extra_base + extra_size) - (aligned_base + size);
 168 
 169   if (begin_offset > 0) {
 170       os::release_memory(extra_base, begin_offset);
 171   }
 172 
 173   if (end_offset > 0) {
 174       os::release_memory(extra_base + begin_offset + size, end_offset);
 175   }
 176 
 177   return aligned_base;
 178 }
 179 
 180 int os::log_vsnprintf(char* buf, size_t len, const char* fmt, va_list args) {
 181     return vsnprintf(buf, len, fmt, args);
 182 }
 183 
 184 void os::Posix::print_load_average(outputStream* st) {
 185   st->print("load average:");
 186   double loadavg[3];
 187   os::loadavg(loadavg, 3);
 188   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
 189   st->cr();
 190 }
 191 
 192 void os::Posix::print_rlimit_info(outputStream* st) {
 193   st->print("rlimit:");
 194   struct rlimit rlim;
 195 
 196   st->print(" STACK ");
 197   getrlimit(RLIMIT_STACK, &rlim);
 198   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
 199   else st->print("%luk", rlim.rlim_cur >> 10);
 200 
 201   st->print(", CORE ");
 202   getrlimit(RLIMIT_CORE, &rlim);
 203   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
 204   else st->print("%luk", rlim.rlim_cur >> 10);
 205 
 206   // Isn't there on solaris
 207 #if !defined(TARGET_OS_FAMILY_solaris) && !defined(TARGET_OS_FAMILY_aix)
 208   st->print(", NPROC ");
 209   getrlimit(RLIMIT_NPROC, &rlim);
 210   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
 211   else st->print("%lu", rlim.rlim_cur);
 212 #endif
 213 
 214   st->print(", NOFILE ");
 215   getrlimit(RLIMIT_NOFILE, &rlim);
 216   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
 217   else st->print("%lu", rlim.rlim_cur);
 218 
 219   st->print(", AS ");
 220   getrlimit(RLIMIT_AS, &rlim);
 221   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
 222   else st->print("%luk", rlim.rlim_cur >> 10);
 223   st->cr();
 224 }
 225 
 226 void os::Posix::print_uname_info(outputStream* st) {
 227   // kernel
 228   st->print("uname:");
 229   struct utsname name;
 230   uname(&name);
 231   st->print("%s ", name.sysname);
 232 #ifdef ASSERT
 233   st->print("%s ", name.nodename);
 234 #endif
 235   st->print("%s ", name.release);
 236   st->print("%s ", name.version);
 237   st->print("%s", name.machine);
 238   st->cr();
 239 }
 240 
 241 #ifndef PRODUCT
 242 bool os::get_host_name(char* buf, size_t buflen) {
 243   struct utsname name;
 244   uname(&name);
 245   jio_snprintf(buf, buflen, "%s", name.nodename);
 246   return true;
 247 }
 248 #endif // PRODUCT
 249 
 250 bool os::has_allocatable_memory_limit(julong* limit) {
 251   struct rlimit rlim;
 252   int getrlimit_res = getrlimit(RLIMIT_AS, &rlim);
 253   // if there was an error when calling getrlimit, assume that there is no limitation
 254   // on virtual memory.
 255   bool result;
 256   if ((getrlimit_res != 0) || (rlim.rlim_cur == RLIM_INFINITY)) {
 257     result = false;
 258   } else {
 259     *limit = (julong)rlim.rlim_cur;
 260     result = true;
 261   }
 262 #ifdef _LP64
 263   return result;
 264 #else
 265   // arbitrary virtual space limit for 32 bit Unices found by testing. If
 266   // getrlimit above returned a limit, bound it with this limit. Otherwise
 267   // directly use it.
 268   const julong max_virtual_limit = (julong)3800*M;
 269   if (result) {
 270     *limit = MIN2(*limit, max_virtual_limit);
 271   } else {
 272     *limit = max_virtual_limit;
 273   }
 274 
 275   // bound by actually allocatable memory. The algorithm uses two bounds, an
 276   // upper and a lower limit. The upper limit is the current highest amount of
 277   // memory that could not be allocated, the lower limit is the current highest
 278   // amount of memory that could be allocated.
 279   // The algorithm iteratively refines the result by halving the difference
 280   // between these limits, updating either the upper limit (if that value could
 281   // not be allocated) or the lower limit (if the that value could be allocated)
 282   // until the difference between these limits is "small".
 283 
 284   // the minimum amount of memory we care about allocating.
 285   const julong min_allocation_size = M;
 286 
 287   julong upper_limit = *limit;
 288 
 289   // first check a few trivial cases
 290   if (is_allocatable(upper_limit) || (upper_limit <= min_allocation_size)) {
 291     *limit = upper_limit;
 292   } else if (!is_allocatable(min_allocation_size)) {
 293     // we found that not even min_allocation_size is allocatable. Return it
 294     // anyway. There is no point to search for a better value any more.
 295     *limit = min_allocation_size;
 296   } else {
 297     // perform the binary search.
 298     julong lower_limit = min_allocation_size;
 299     while ((upper_limit - lower_limit) > min_allocation_size) {
 300       julong temp_limit = ((upper_limit - lower_limit) / 2) + lower_limit;
 301       temp_limit = align_size_down_(temp_limit, min_allocation_size);
 302       if (is_allocatable(temp_limit)) {
 303         lower_limit = temp_limit;
 304       } else {
 305         upper_limit = temp_limit;
 306       }
 307     }
 308     *limit = lower_limit;
 309   }
 310   return true;
 311 #endif
 312 }
 313 
 314 const char* os::get_current_directory(char *buf, size_t buflen) {
 315   return getcwd(buf, buflen);
 316 }
 317 
 318 FILE* os::open(int fd, const char* mode) {
 319   return ::fdopen(fd, mode);
 320 }
 321 
 322 // Builds a platform dependent Agent_OnLoad_<lib_name> function name
 323 // which is used to find statically linked in agents.
 324 // Parameters:
 325 //            sym_name: Symbol in library we are looking for
 326 //            lib_name: Name of library to look in, NULL for shared libs.
 327 //            is_absolute_path == true if lib_name is absolute path to agent
 328 //                                     such as "/a/b/libL.so"
 329 //            == false if only the base name of the library is passed in
 330 //               such as "L"
 331 char* os::build_agent_function_name(const char *sym_name, const char *lib_name,
 332                                     bool is_absolute_path) {
 333   char *agent_entry_name;
 334   size_t len;
 335   size_t name_len;
 336   size_t prefix_len = strlen(JNI_LIB_PREFIX);
 337   size_t suffix_len = strlen(JNI_LIB_SUFFIX);
 338   const char *start;
 339 
 340   if (lib_name != NULL) {
 341     len = name_len = strlen(lib_name);
 342     if (is_absolute_path) {
 343       // Need to strip path, prefix and suffix
 344       if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
 345         lib_name = ++start;
 346       }
 347       if (len <= (prefix_len + suffix_len)) {
 348         return NULL;
 349       }
 350       lib_name += prefix_len;
 351       name_len = strlen(lib_name) - suffix_len;
 352     }
 353   }
 354   len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2;
 355   agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread);
 356   if (agent_entry_name == NULL) {
 357     return NULL;
 358   }
 359   strcpy(agent_entry_name, sym_name);
 360   if (lib_name != NULL) {
 361     strcat(agent_entry_name, "_");
 362     strncat(agent_entry_name, lib_name, name_len);
 363   }
 364   return agent_entry_name;
 365 }
 366 
 367 int os::sleep(Thread* thread, jlong millis, bool interruptible) {
 368   assert(thread == Thread::current(),  "thread consistency check");
 369 
 370   ParkEvent * const slp = thread->_SleepEvent ;
 371   slp->reset() ;
 372   OrderAccess::fence() ;
 373 
 374   if (interruptible) {
 375     jlong prevtime = javaTimeNanos();
 376 
 377     for (;;) {
 378       if (os::is_interrupted(thread, true)) {
 379         return OS_INTRPT;
 380       }
 381 
 382       jlong newtime = javaTimeNanos();
 383 
 384       if (newtime - prevtime < 0) {
 385         // time moving backwards, should only happen if no monotonic clock
 386         // not a guarantee() because JVM should not abort on kernel/glibc bugs
 387         assert(!os::supports_monotonic_clock(), "unexpected time moving backwards detected in os::sleep(interruptible)");
 388       } else {
 389         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
 390       }
 391 
 392       if (millis <= 0) {
 393         return OS_OK;
 394       }
 395 
 396       prevtime = newtime;
 397 
 398       {
 399         assert(thread->is_Java_thread(), "sanity check");
 400         JavaThread *jt = (JavaThread *) thread;
 401         ThreadBlockInVM tbivm(jt);
 402         OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
 403 
 404         jt->set_suspend_equivalent();
 405         // cleared by handle_special_suspend_equivalent_condition() or
 406         // java_suspend_self() via check_and_wait_while_suspended()
 407 
 408         slp->park(millis);
 409 
 410         // were we externally suspended while we were waiting?
 411         jt->check_and_wait_while_suspended();
 412       }
 413     }
 414   } else {
 415     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
 416     jlong prevtime = javaTimeNanos();
 417 
 418     for (;;) {
 419       // It'd be nice to avoid the back-to-back javaTimeNanos() calls on
 420       // the 1st iteration ...
 421       jlong newtime = javaTimeNanos();
 422 
 423       if (newtime - prevtime < 0) {
 424         // time moving backwards, should only happen if no monotonic clock
 425         // not a guarantee() because JVM should not abort on kernel/glibc bugs
 426         assert(!os::supports_monotonic_clock(), "unexpected time moving backwards detected on os::sleep(!interruptible)");
 427       } else {
 428         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
 429       }
 430 
 431       if (millis <= 0) break ;
 432 
 433       prevtime = newtime;
 434       slp->park(millis);
 435     }
 436     return OS_OK ;
 437   }
 438 }
 439 
 440 ////////////////////////////////////////////////////////////////////////////////
 441 // interrupt support
 442 
 443 void os::interrupt(Thread* thread) {
 444   assert(Thread::current() == thread || Threads_lock->owned_by_self(),
 445     "possibility of dangling Thread pointer");
 446 
 447   OSThread* osthread = thread->osthread();
 448 
 449   if (!osthread->interrupted()) {
 450     osthread->set_interrupted(true);
 451     // More than one thread can get here with the same value of osthread,
 452     // resulting in multiple notifications.  We do, however, want the store
 453     // to interrupted() to be visible to other threads before we execute unpark().
 454     OrderAccess::fence();
 455     ParkEvent * const slp = thread->_SleepEvent ;
 456     if (slp != NULL) slp->unpark() ;
 457   }
 458 
 459   // For JSR166. Unpark even if interrupt status already was set
 460   if (thread->is_Java_thread())
 461     ((JavaThread*)thread)->parker()->unpark();
 462 
 463   ParkEvent * ev = thread->_ParkEvent ;
 464   if (ev != NULL) ev->unpark() ;
 465 
 466 }
 467 
 468 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
 469   assert(Thread::current() == thread || Threads_lock->owned_by_self(),
 470     "possibility of dangling Thread pointer");
 471 
 472   OSThread* osthread = thread->osthread();
 473 
 474   bool interrupted = osthread->interrupted();
 475 
 476   // NOTE that since there is no "lock" around the interrupt and
 477   // is_interrupted operations, there is the possibility that the
 478   // interrupted flag (in osThread) will be "false" but that the
 479   // low-level events will be in the signaled state. This is
 480   // intentional. The effect of this is that Object.wait() and
 481   // LockSupport.park() will appear to have a spurious wakeup, which
 482   // is allowed and not harmful, and the possibility is so rare that
 483   // it is not worth the added complexity to add yet another lock.
 484   // For the sleep event an explicit reset is performed on entry
 485   // to os::sleep, so there is no early return. It has also been
 486   // recommended not to put the interrupted flag into the "event"
 487   // structure because it hides the issue.
 488   if (interrupted && clear_interrupted) {
 489     osthread->set_interrupted(false);
 490     // consider thread->_SleepEvent->reset() ... optional optimization
 491   }
 492 
 493   return interrupted;
 494 }
 495 
 496 
 497 
 498 static const struct {
 499   int sig; const char* name;
 500 }
 501  g_signal_info[] =
 502   {
 503   {  SIGABRT,     "SIGABRT" },
 504 #ifdef SIGAIO
 505   {  SIGAIO,      "SIGAIO" },
 506 #endif
 507   {  SIGALRM,     "SIGALRM" },
 508 #ifdef SIGALRM1
 509   {  SIGALRM1,    "SIGALRM1" },
 510 #endif
 511   {  SIGBUS,      "SIGBUS" },
 512 #ifdef SIGCANCEL
 513   {  SIGCANCEL,   "SIGCANCEL" },
 514 #endif
 515   {  SIGCHLD,     "SIGCHLD" },
 516 #ifdef SIGCLD
 517   {  SIGCLD,      "SIGCLD" },
 518 #endif
 519   {  SIGCONT,     "SIGCONT" },
 520 #ifdef SIGCPUFAIL
 521   {  SIGCPUFAIL,  "SIGCPUFAIL" },
 522 #endif
 523 #ifdef SIGDANGER
 524   {  SIGDANGER,   "SIGDANGER" },
 525 #endif
 526 #ifdef SIGDIL
 527   {  SIGDIL,      "SIGDIL" },
 528 #endif
 529 #ifdef SIGEMT
 530   {  SIGEMT,      "SIGEMT" },
 531 #endif
 532   {  SIGFPE,      "SIGFPE" },
 533 #ifdef SIGFREEZE
 534   {  SIGFREEZE,   "SIGFREEZE" },
 535 #endif
 536 #ifdef SIGGFAULT
 537   {  SIGGFAULT,   "SIGGFAULT" },
 538 #endif
 539 #ifdef SIGGRANT
 540   {  SIGGRANT,    "SIGGRANT" },
 541 #endif
 542   {  SIGHUP,      "SIGHUP" },
 543   {  SIGILL,      "SIGILL" },
 544   {  SIGINT,      "SIGINT" },
 545 #ifdef SIGIO
 546   {  SIGIO,       "SIGIO" },
 547 #endif
 548 #ifdef SIGIOINT
 549   {  SIGIOINT,    "SIGIOINT" },
 550 #endif
 551 #ifdef SIGIOT
 552 // SIGIOT is there for BSD compatibility, but on most Unices just a
 553 // synonym for SIGABRT. The result should be "SIGABRT", not
 554 // "SIGIOT".
 555 #if (SIGIOT != SIGABRT )
 556   {  SIGIOT,      "SIGIOT" },
 557 #endif
 558 #endif
 559 #ifdef SIGKAP
 560   {  SIGKAP,      "SIGKAP" },
 561 #endif
 562   {  SIGKILL,     "SIGKILL" },
 563 #ifdef SIGLOST
 564   {  SIGLOST,     "SIGLOST" },
 565 #endif
 566 #ifdef SIGLWP
 567   {  SIGLWP,      "SIGLWP" },
 568 #endif
 569 #ifdef SIGLWPTIMER
 570   {  SIGLWPTIMER, "SIGLWPTIMER" },
 571 #endif
 572 #ifdef SIGMIGRATE
 573   {  SIGMIGRATE,  "SIGMIGRATE" },
 574 #endif
 575 #ifdef SIGMSG
 576   {  SIGMSG,      "SIGMSG" },
 577 #endif
 578   {  SIGPIPE,     "SIGPIPE" },
 579 #ifdef SIGPOLL
 580   {  SIGPOLL,     "SIGPOLL" },
 581 #endif
 582 #ifdef SIGPRE
 583   {  SIGPRE,      "SIGPRE" },
 584 #endif
 585   {  SIGPROF,     "SIGPROF" },
 586 #ifdef SIGPTY
 587   {  SIGPTY,      "SIGPTY" },
 588 #endif
 589 #ifdef SIGPWR
 590   {  SIGPWR,      "SIGPWR" },
 591 #endif
 592   {  SIGQUIT,     "SIGQUIT" },
 593 #ifdef SIGRECONFIG
 594   {  SIGRECONFIG, "SIGRECONFIG" },
 595 #endif
 596 #ifdef SIGRECOVERY
 597   {  SIGRECOVERY, "SIGRECOVERY" },
 598 #endif
 599 #ifdef SIGRESERVE
 600   {  SIGRESERVE,  "SIGRESERVE" },
 601 #endif
 602 #ifdef SIGRETRACT
 603   {  SIGRETRACT,  "SIGRETRACT" },
 604 #endif
 605 #ifdef SIGSAK
 606   {  SIGSAK,      "SIGSAK" },
 607 #endif
 608   {  SIGSEGV,     "SIGSEGV" },
 609 #ifdef SIGSOUND
 610   {  SIGSOUND,    "SIGSOUND" },
 611 #endif
 612 #ifdef SIGSTKFLT
 613   {  SIGSTKFLT,    "SIGSTKFLT" },
 614 #endif
 615   {  SIGSTOP,     "SIGSTOP" },
 616   {  SIGSYS,      "SIGSYS" },
 617 #ifdef SIGSYSERROR
 618   {  SIGSYSERROR, "SIGSYSERROR" },
 619 #endif
 620 #ifdef SIGTALRM
 621   {  SIGTALRM,    "SIGTALRM" },
 622 #endif
 623   {  SIGTERM,     "SIGTERM" },
 624 #ifdef SIGTHAW
 625   {  SIGTHAW,     "SIGTHAW" },
 626 #endif
 627   {  SIGTRAP,     "SIGTRAP" },
 628 #ifdef SIGTSTP
 629   {  SIGTSTP,     "SIGTSTP" },
 630 #endif
 631   {  SIGTTIN,     "SIGTTIN" },
 632   {  SIGTTOU,     "SIGTTOU" },
 633 #ifdef SIGURG
 634   {  SIGURG,      "SIGURG" },
 635 #endif
 636   {  SIGUSR1,     "SIGUSR1" },
 637   {  SIGUSR2,     "SIGUSR2" },
 638 #ifdef SIGVIRT
 639   {  SIGVIRT,     "SIGVIRT" },
 640 #endif
 641   {  SIGVTALRM,   "SIGVTALRM" },
 642 #ifdef SIGWAITING
 643   {  SIGWAITING,  "SIGWAITING" },
 644 #endif
 645 #ifdef SIGWINCH
 646   {  SIGWINCH,    "SIGWINCH" },
 647 #endif
 648 #ifdef SIGWINDOW
 649   {  SIGWINDOW,   "SIGWINDOW" },
 650 #endif
 651   {  SIGXCPU,     "SIGXCPU" },
 652   {  SIGXFSZ,     "SIGXFSZ" },
 653 #ifdef SIGXRES
 654   {  SIGXRES,     "SIGXRES" },
 655 #endif
 656   { -1, NULL }
 657 };
 658 
 659 // Returned string is a constant. For unknown signals "UNKNOWN" is returned.
 660 const char* os::Posix::get_signal_name(int sig, char* out, size_t outlen) {
 661 
 662   const char* ret = NULL;
 663 
 664 #ifdef SIGRTMIN
 665   if (sig >= SIGRTMIN && sig <= SIGRTMAX) {
 666     if (sig == SIGRTMIN) {
 667       ret = "SIGRTMIN";
 668     } else if (sig == SIGRTMAX) {
 669       ret = "SIGRTMAX";
 670     } else {
 671       jio_snprintf(out, outlen, "SIGRTMIN+%d", sig - SIGRTMIN);
 672       return out;
 673     }
 674   }
 675 #endif
 676 
 677   if (sig > 0) {
 678     for (int idx = 0; g_signal_info[idx].sig != -1; idx ++) {
 679       if (g_signal_info[idx].sig == sig) {
 680         ret = g_signal_info[idx].name;
 681         break;
 682       }
 683     }
 684   }
 685 
 686   if (!ret) {
 687     if (!is_valid_signal(sig)) {
 688       ret = "INVALID";
 689     } else {
 690       ret = "UNKNOWN";
 691     }
 692   }
 693 
 694   if (out && outlen > 0) {
 695     strncpy(out, ret, outlen);
 696     out[outlen - 1] = '\0';
 697   }
 698   return out;
 699 }
 700 
 701 int os::Posix::get_signal_number(const char* signal_name) {
 702   char tmp[30];
 703   const char* s = signal_name;
 704   if (s[0] != 'S' || s[1] != 'I' || s[2] != 'G') {
 705     jio_snprintf(tmp, sizeof(tmp), "SIG%s", signal_name);
 706     s = tmp;
 707   }
 708   for (int idx = 0; g_signal_info[idx].sig != -1; idx ++) {
 709     if (strcmp(g_signal_info[idx].name, s) == 0) {
 710       return g_signal_info[idx].sig;
 711     }
 712   }
 713   return -1;
 714 }
 715 
 716 int os::get_signal_number(const char* signal_name) {
 717   return os::Posix::get_signal_number(signal_name);
 718 }
 719 
 720 // Returns true if signal number is valid.
 721 bool os::Posix::is_valid_signal(int sig) {
 722   // MacOS not really POSIX compliant: sigaddset does not return
 723   // an error for invalid signal numbers. However, MacOS does not
 724   // support real time signals and simply seems to have just 33
 725   // signals with no holes in the signal range.
 726 #ifdef __APPLE__
 727   return sig >= 1 && sig < NSIG;
 728 #else
 729   // Use sigaddset to check for signal validity.
 730   sigset_t set;
 731   if (sigaddset(&set, sig) == -1 && errno == EINVAL) {
 732     return false;
 733   }
 734   return true;
 735 #endif
 736 }
 737 
 738 // Returns:
 739 // NULL for an invalid signal number
 740 // "SIG<num>" for a valid but unknown signal number
 741 // signal name otherwise.
 742 const char* os::exception_name(int sig, char* buf, size_t size) {
 743   if (!os::Posix::is_valid_signal(sig)) {
 744     return NULL;
 745   }
 746   const char* const name = os::Posix::get_signal_name(sig, buf, size);
 747   if (strcmp(name, "UNKNOWN") == 0) {
 748     jio_snprintf(buf, size, "SIG%d", sig);
 749   }
 750   return buf;
 751 }
 752 
 753 #define NUM_IMPORTANT_SIGS 32
 754 // Returns one-line short description of a signal set in a user provided buffer.
 755 const char* os::Posix::describe_signal_set_short(const sigset_t* set, char* buffer, size_t buf_size) {
 756   assert(buf_size == (NUM_IMPORTANT_SIGS + 1), "wrong buffer size");
 757   // Note: for shortness, just print out the first 32. That should
 758   // cover most of the useful ones, apart from realtime signals.
 759   for (int sig = 1; sig <= NUM_IMPORTANT_SIGS; sig++) {
 760     const int rc = sigismember(set, sig);
 761     if (rc == -1 && errno == EINVAL) {
 762       buffer[sig-1] = '?';
 763     } else {
 764       buffer[sig-1] = rc == 0 ? '0' : '1';
 765     }
 766   }
 767   buffer[NUM_IMPORTANT_SIGS] = 0;
 768   return buffer;
 769 }
 770 
 771 // Prints one-line description of a signal set.
 772 void os::Posix::print_signal_set_short(outputStream* st, const sigset_t* set) {
 773   char buf[NUM_IMPORTANT_SIGS + 1];
 774   os::Posix::describe_signal_set_short(set, buf, sizeof(buf));
 775   st->print("%s", buf);
 776 }
 777 
 778 // Writes one-line description of a combination of sigaction.sa_flags into a user
 779 // provided buffer. Returns that buffer.
 780 const char* os::Posix::describe_sa_flags(int flags, char* buffer, size_t size) {
 781   char* p = buffer;
 782   size_t remaining = size;
 783   bool first = true;
 784   int idx = 0;
 785 
 786   assert(buffer, "invalid argument");
 787 
 788   if (size == 0) {
 789     return buffer;
 790   }
 791 
 792   strncpy(buffer, "none", size);
 793 
 794   const struct {
 795     // NB: i is an unsigned int here because SA_RESETHAND is on some
 796     // systems 0x80000000, which is implicitly unsigned.  Assignining
 797     // it to an int field would be an overflow in unsigned-to-signed
 798     // conversion.
 799     unsigned int i;
 800     const char* s;
 801   } flaginfo [] = {
 802     { SA_NOCLDSTOP, "SA_NOCLDSTOP" },
 803     { SA_ONSTACK,   "SA_ONSTACK"   },
 804     { SA_RESETHAND, "SA_RESETHAND" },
 805     { SA_RESTART,   "SA_RESTART"   },
 806     { SA_SIGINFO,   "SA_SIGINFO"   },
 807     { SA_NOCLDWAIT, "SA_NOCLDWAIT" },
 808     { SA_NODEFER,   "SA_NODEFER"   },
 809 #ifdef AIX
 810     { SA_ONSTACK,   "SA_ONSTACK"   },
 811     { SA_OLDSTYLE,  "SA_OLDSTYLE"  },
 812 #endif
 813     { 0, NULL }
 814   };
 815 
 816   for (idx = 0; flaginfo[idx].s && remaining > 1; idx++) {
 817     if (flags & flaginfo[idx].i) {
 818       if (first) {
 819         jio_snprintf(p, remaining, "%s", flaginfo[idx].s);
 820         first = false;
 821       } else {
 822         jio_snprintf(p, remaining, "|%s", flaginfo[idx].s);
 823       }
 824       const size_t len = strlen(p);
 825       p += len;
 826       remaining -= len;
 827     }
 828   }
 829 
 830   buffer[size - 1] = '\0';
 831 
 832   return buffer;
 833 }
 834 
 835 // Prints one-line description of a combination of sigaction.sa_flags.
 836 void os::Posix::print_sa_flags(outputStream* st, int flags) {
 837   char buffer[0x100];
 838   os::Posix::describe_sa_flags(flags, buffer, sizeof(buffer));
 839   st->print("%s", buffer);
 840 }
 841 
 842 // Helper function for os::Posix::print_siginfo_...():
 843 // return a textual description for signal code.
 844 struct enum_sigcode_desc_t {
 845   const char* s_name;
 846   const char* s_desc;
 847 };
 848 
 849 static bool get_signal_code_description(const siginfo_t* si, enum_sigcode_desc_t* out) {
 850 
 851   const struct {
 852     int sig; int code; const char* s_code; const char* s_desc;
 853   } t1 [] = {
 854     { SIGILL,  ILL_ILLOPC,   "ILL_ILLOPC",   "Illegal opcode." },
 855     { SIGILL,  ILL_ILLOPN,   "ILL_ILLOPN",   "Illegal operand." },
 856     { SIGILL,  ILL_ILLADR,   "ILL_ILLADR",   "Illegal addressing mode." },
 857     { SIGILL,  ILL_ILLTRP,   "ILL_ILLTRP",   "Illegal trap." },
 858     { SIGILL,  ILL_PRVOPC,   "ILL_PRVOPC",   "Privileged opcode." },
 859     { SIGILL,  ILL_PRVREG,   "ILL_PRVREG",   "Privileged register." },
 860     { SIGILL,  ILL_COPROC,   "ILL_COPROC",   "Coprocessor error." },
 861     { SIGILL,  ILL_BADSTK,   "ILL_BADSTK",   "Internal stack error." },
 862 #if defined(IA64) && defined(LINUX)
 863     { SIGILL,  ILL_BADIADDR, "ILL_BADIADDR", "Unimplemented instruction address" },
 864     { SIGILL,  ILL_BREAK,    "ILL_BREAK",    "Application Break instruction" },
 865 #endif
 866     { SIGFPE,  FPE_INTDIV,   "FPE_INTDIV",   "Integer divide by zero." },
 867     { SIGFPE,  FPE_INTOVF,   "FPE_INTOVF",   "Integer overflow." },
 868     { SIGFPE,  FPE_FLTDIV,   "FPE_FLTDIV",   "Floating-point divide by zero." },
 869     { SIGFPE,  FPE_FLTOVF,   "FPE_FLTOVF",   "Floating-point overflow." },
 870     { SIGFPE,  FPE_FLTUND,   "FPE_FLTUND",   "Floating-point underflow." },
 871     { SIGFPE,  FPE_FLTRES,   "FPE_FLTRES",   "Floating-point inexact result." },
 872     { SIGFPE,  FPE_FLTINV,   "FPE_FLTINV",   "Invalid floating-point operation." },
 873     { SIGFPE,  FPE_FLTSUB,   "FPE_FLTSUB",   "Subscript out of range." },
 874     { SIGSEGV, SEGV_MAPERR,  "SEGV_MAPERR",  "Address not mapped to object." },
 875     { SIGSEGV, SEGV_ACCERR,  "SEGV_ACCERR",  "Invalid permissions for mapped object." },
 876 #ifdef AIX
 877     // no explanation found what keyerr would be
 878     { SIGSEGV, SEGV_KEYERR,  "SEGV_KEYERR",  "key error" },
 879 #endif
 880 #if defined(IA64) && !defined(AIX)
 881     { SIGSEGV, SEGV_PSTKOVF, "SEGV_PSTKOVF", "Paragraph stack overflow" },
 882 #endif
 883 #if defined(__sparc) && defined(SOLARIS)
 884 // define Solaris Sparc M7 ADI SEGV signals
 885 #if !defined(SEGV_ACCADI)
 886 #define SEGV_ACCADI 3
 887 #endif
 888     { SIGSEGV, SEGV_ACCADI,  "SEGV_ACCADI",  "ADI not enabled for mapped object." },
 889 #if !defined(SEGV_ACCDERR)
 890 #define SEGV_ACCDERR 4
 891 #endif
 892     { SIGSEGV, SEGV_ACCDERR, "SEGV_ACCDERR", "ADI disrupting exception." },
 893 #if !defined(SEGV_ACCPERR)
 894 #define SEGV_ACCPERR 5
 895 #endif
 896     { SIGSEGV, SEGV_ACCPERR, "SEGV_ACCPERR", "ADI precise exception." },
 897 #endif // defined(__sparc) && defined(SOLARIS)
 898     { SIGBUS,  BUS_ADRALN,   "BUS_ADRALN",   "Invalid address alignment." },
 899     { SIGBUS,  BUS_ADRERR,   "BUS_ADRERR",   "Nonexistent physical address." },
 900     { SIGBUS,  BUS_OBJERR,   "BUS_OBJERR",   "Object-specific hardware error." },
 901     { SIGTRAP, TRAP_BRKPT,   "TRAP_BRKPT",   "Process breakpoint." },
 902     { SIGTRAP, TRAP_TRACE,   "TRAP_TRACE",   "Process trace trap." },
 903     { SIGCHLD, CLD_EXITED,   "CLD_EXITED",   "Child has exited." },
 904     { SIGCHLD, CLD_KILLED,   "CLD_KILLED",   "Child has terminated abnormally and did not create a core file." },
 905     { SIGCHLD, CLD_DUMPED,   "CLD_DUMPED",   "Child has terminated abnormally and created a core file." },
 906     { SIGCHLD, CLD_TRAPPED,  "CLD_TRAPPED",  "Traced child has trapped." },
 907     { SIGCHLD, CLD_STOPPED,  "CLD_STOPPED",  "Child has stopped." },
 908     { SIGCHLD, CLD_CONTINUED,"CLD_CONTINUED","Stopped child has continued." },
 909 #ifdef SIGPOLL
 910     { SIGPOLL, POLL_OUT,     "POLL_OUT",     "Output buffers available." },
 911     { SIGPOLL, POLL_MSG,     "POLL_MSG",     "Input message available." },
 912     { SIGPOLL, POLL_ERR,     "POLL_ERR",     "I/O error." },
 913     { SIGPOLL, POLL_PRI,     "POLL_PRI",     "High priority input available." },
 914     { SIGPOLL, POLL_HUP,     "POLL_HUP",     "Device disconnected. [Option End]" },
 915 #endif
 916     { -1, -1, NULL, NULL }
 917   };
 918 
 919   // Codes valid in any signal context.
 920   const struct {
 921     int code; const char* s_code; const char* s_desc;
 922   } t2 [] = {
 923     { SI_USER,      "SI_USER",     "Signal sent by kill()." },
 924     { SI_QUEUE,     "SI_QUEUE",    "Signal sent by the sigqueue()." },
 925     { SI_TIMER,     "SI_TIMER",    "Signal generated by expiration of a timer set by timer_settime()." },
 926     { SI_ASYNCIO,   "SI_ASYNCIO",  "Signal generated by completion of an asynchronous I/O request." },
 927     { SI_MESGQ,     "SI_MESGQ",    "Signal generated by arrival of a message on an empty message queue." },
 928     // Linux specific
 929 #ifdef SI_TKILL
 930     { SI_TKILL,     "SI_TKILL",    "Signal sent by tkill (pthread_kill)" },
 931 #endif
 932 #ifdef SI_DETHREAD
 933     { SI_DETHREAD,  "SI_DETHREAD", "Signal sent by execve() killing subsidiary threads" },
 934 #endif
 935 #ifdef SI_KERNEL
 936     { SI_KERNEL,    "SI_KERNEL",   "Signal sent by kernel." },
 937 #endif
 938 #ifdef SI_SIGIO
 939     { SI_SIGIO,     "SI_SIGIO",    "Signal sent by queued SIGIO" },
 940 #endif
 941 
 942 #ifdef AIX
 943     { SI_UNDEFINED, "SI_UNDEFINED","siginfo contains partial information" },
 944     { SI_EMPTY,     "SI_EMPTY",    "siginfo contains no useful information" },
 945 #endif
 946 
 947 #ifdef __sun
 948     { SI_NOINFO,    "SI_NOINFO",   "No signal information" },
 949     { SI_RCTL,      "SI_RCTL",     "kernel generated signal via rctl action" },
 950     { SI_LWP,       "SI_LWP",      "Signal sent via lwp_kill" },
 951 #endif
 952 
 953     { -1, NULL, NULL }
 954   };
 955 
 956   const char* s_code = NULL;
 957   const char* s_desc = NULL;
 958 
 959   for (int i = 0; t1[i].sig != -1; i ++) {
 960     if (t1[i].sig == si->si_signo && t1[i].code == si->si_code) {
 961       s_code = t1[i].s_code;
 962       s_desc = t1[i].s_desc;
 963       break;
 964     }
 965   }
 966 
 967   if (s_code == NULL) {
 968     for (int i = 0; t2[i].s_code != NULL; i ++) {
 969       if (t2[i].code == si->si_code) {
 970         s_code = t2[i].s_code;
 971         s_desc = t2[i].s_desc;
 972       }
 973     }
 974   }
 975 
 976   if (s_code == NULL) {
 977     out->s_name = "unknown";
 978     out->s_desc = "unknown";
 979     return false;
 980   }
 981 
 982   out->s_name = s_code;
 983   out->s_desc = s_desc;
 984 
 985   return true;
 986 }
 987 
 988 void os::print_siginfo(outputStream* os, const void* si0) {
 989 
 990   const siginfo_t* const si = (const siginfo_t*) si0;
 991 
 992   char buf[20];
 993   os->print("siginfo:");
 994 
 995   if (!si) {
 996     os->print(" <null>");
 997     return;
 998   }
 999 
1000   const int sig = si->si_signo;
1001 
1002   os->print(" si_signo: %d (%s)", sig, os::Posix::get_signal_name(sig, buf, sizeof(buf)));
1003 
1004   enum_sigcode_desc_t ed;
1005   get_signal_code_description(si, &ed);
1006   os->print(", si_code: %d (%s)", si->si_code, ed.s_name);
1007 
1008   if (si->si_errno) {
1009     os->print(", si_errno: %d", si->si_errno);
1010   }
1011 
1012   // Output additional information depending on the signal code.
1013 
1014   // Note: Many implementations lump si_addr, si_pid, si_uid etc. together as unions,
1015   // so it depends on the context which member to use. For synchronous error signals,
1016   // we print si_addr, unless the signal was sent by another process or thread, in
1017   // which case we print out pid or tid of the sender.
1018   if (si->si_code == SI_USER || si->si_code == SI_QUEUE) {
1019     const pid_t pid = si->si_pid;
1020     os->print(", si_pid: %ld", (long) pid);
1021     if (IS_VALID_PID(pid)) {
1022       const pid_t me = getpid();
1023       if (me == pid) {
1024         os->print(" (current process)");
1025       }
1026     } else {
1027       os->print(" (invalid)");
1028     }
1029     os->print(", si_uid: %ld", (long) si->si_uid);
1030     if (sig == SIGCHLD) {
1031       os->print(", si_status: %d", si->si_status);
1032     }
1033   } else if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
1034              sig == SIGTRAP || sig == SIGFPE) {
1035     os->print(", si_addr: " PTR_FORMAT, p2i(si->si_addr));
1036 #ifdef SIGPOLL
1037   } else if (sig == SIGPOLL) {
1038     os->print(", si_band: %ld", si->si_band);
1039 #endif
1040   }
1041 
1042 }
1043 
1044 int os::Posix::unblock_thread_signal_mask(const sigset_t *set) {
1045   return pthread_sigmask(SIG_UNBLOCK, set, NULL);
1046 }
1047 
1048 address os::Posix::ucontext_get_pc(const ucontext_t* ctx) {
1049 #ifdef TARGET_OS_FAMILY_linux
1050    return Linux::ucontext_get_pc(ctx);
1051 #elif defined(TARGET_OS_FAMILY_solaris)
1052    return Solaris::ucontext_get_pc(ctx);
1053 #elif defined(TARGET_OS_FAMILY_aix)
1054    return Aix::ucontext_get_pc(ctx);
1055 #elif defined(TARGET_OS_FAMILY_bsd)
1056    return Bsd::ucontext_get_pc(ctx);
1057 #else
1058    VMError::report_and_die("unimplemented ucontext_get_pc");
1059 #endif
1060 }
1061 
1062 void os::Posix::ucontext_set_pc(ucontext_t* ctx, address pc) {
1063 #ifdef TARGET_OS_FAMILY_linux
1064    Linux::ucontext_set_pc(ctx, pc);
1065 #elif defined(TARGET_OS_FAMILY_solaris)
1066    Solaris::ucontext_set_pc(ctx, pc);
1067 #elif defined(TARGET_OS_FAMILY_aix)
1068    Aix::ucontext_set_pc(ctx, pc);
1069 #elif defined(TARGET_OS_FAMILY_bsd)
1070    Bsd::ucontext_set_pc(ctx, pc);
1071 #else
1072    VMError::report_and_die("unimplemented ucontext_get_pc");
1073 #endif
1074 }
1075 
1076 
1077 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
1078   assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
1079 }
1080 
1081 /*
1082  * See the caveats for this class in os_posix.hpp
1083  * Protects the callback call so that SIGSEGV / SIGBUS jumps back into this
1084  * method and returns false. If none of the signals are raised, returns true.
1085  * The callback is supposed to provide the method that should be protected.
1086  */
1087 bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
1088   sigset_t saved_sig_mask;
1089 
1090   assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
1091   assert(!WatcherThread::watcher_thread()->has_crash_protection(),
1092       "crash_protection already set?");
1093 
1094   // we cannot rely on sigsetjmp/siglongjmp to save/restore the signal mask
1095   // since on at least some systems (OS X) siglongjmp will restore the mask
1096   // for the process, not the thread
1097   pthread_sigmask(0, NULL, &saved_sig_mask);
1098   if (sigsetjmp(_jmpbuf, 0) == 0) {
1099     // make sure we can see in the signal handler that we have crash protection
1100     // installed
1101     WatcherThread::watcher_thread()->set_crash_protection(this);
1102     cb.call();
1103     // and clear the crash protection
1104     WatcherThread::watcher_thread()->set_crash_protection(NULL);
1105     return true;
1106   }
1107   // this happens when we siglongjmp() back
1108   pthread_sigmask(SIG_SETMASK, &saved_sig_mask, NULL);
1109   WatcherThread::watcher_thread()->set_crash_protection(NULL);
1110   return false;
1111 }
1112 
1113 void os::WatcherThreadCrashProtection::restore() {
1114   assert(WatcherThread::watcher_thread()->has_crash_protection(),
1115       "must have crash protection");
1116 
1117   siglongjmp(_jmpbuf, 1);
1118 }
1119 
1120 void os::WatcherThreadCrashProtection::check_crash_protection(int sig,
1121     Thread* thread) {
1122 
1123   if (thread != NULL &&
1124       thread->is_Watcher_thread() &&
1125       WatcherThread::watcher_thread()->has_crash_protection()) {
1126 
1127     if (sig == SIGSEGV || sig == SIGBUS) {
1128       WatcherThread::watcher_thread()->crash_protection()->restore();
1129     }
1130   }
1131 }
1132 
1133 #define check_with_errno(check_type, cond, msg)                             \
1134   do {                                                                      \
1135     int err = errno;                                                        \
1136     check_type(cond, "%s; error='%s' (errno=%d)", msg, strerror(err), err); \
1137 } while (false)
1138 
1139 #define assert_with_errno(cond, msg)    check_with_errno(assert, cond, msg)
1140 #define guarantee_with_errno(cond, msg) check_with_errno(guarantee, cond, msg)
1141 
1142 // POSIX unamed semaphores are not supported on OS X.
1143 #ifndef __APPLE__
1144 
1145 PosixSemaphore::PosixSemaphore(uint value) {
1146   int ret = sem_init(&_semaphore, 0, value);
1147 
1148   guarantee_with_errno(ret == 0, "Failed to initialize semaphore");
1149 }
1150 
1151 PosixSemaphore::~PosixSemaphore() {
1152   sem_destroy(&_semaphore);
1153 }
1154 
1155 void PosixSemaphore::signal(uint count) {
1156   for (uint i = 0; i < count; i++) {
1157     int ret = sem_post(&_semaphore);
1158 
1159     assert_with_errno(ret == 0, "sem_post failed");
1160   }
1161 }
1162 
1163 void PosixSemaphore::wait() {
1164   int ret;
1165 
1166   do {
1167     ret = sem_wait(&_semaphore);
1168   } while (ret != 0 && errno == EINTR);
1169 
1170   assert_with_errno(ret == 0, "sem_wait failed");
1171 }
1172 
1173 bool PosixSemaphore::trywait() {
1174   int ret;
1175 
1176   do {
1177     ret = sem_trywait(&_semaphore);
1178   } while (ret != 0 && errno == EINTR);
1179 
1180   assert_with_errno(ret == 0 || errno == EAGAIN, "trywait failed");
1181 
1182   return ret == 0;
1183 }
1184 
1185 bool PosixSemaphore::timedwait(struct timespec ts) {
1186   while (true) {
1187     int result = sem_timedwait(&_semaphore, &ts);
1188     if (result == 0) {
1189       return true;
1190     } else if (errno == EINTR) {
1191       continue;
1192     } else if (errno == ETIMEDOUT) {
1193       return false;
1194     } else {
1195       assert_with_errno(false, "timedwait failed");
1196       return false;
1197     }
1198   }
1199 }
1200 
1201 #endif // __APPLE__