1 /*
   2  * Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright 2012, 2014 SAP AG. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 // According to the AIX OS doc #pragma alloca must be used
  27 // with C++ compiler before referencing the function alloca()
  28 #pragma alloca
  29 
  30 // no precompiled headers
  31 #include "classfile/classLoader.hpp"
  32 #include "classfile/systemDictionary.hpp"
  33 #include "classfile/vmSymbols.hpp"
  34 #include "code/icBuffer.hpp"
  35 #include "code/vtableStubs.hpp"
  36 #include "compiler/compileBroker.hpp"
  37 #include "interpreter/interpreter.hpp"
  38 #include "jvm_aix.h"
  39 #include "libperfstat_aix.hpp"
  40 #include "loadlib_aix.hpp"
  41 #include "memory/allocation.inline.hpp"
  42 #include "memory/filemap.hpp"
  43 #include "mutex_aix.inline.hpp"
  44 #include "oops/oop.inline.hpp"
  45 #include "os_share_aix.hpp"
  46 #include "porting_aix.hpp"
  47 #include "prims/jniFastGetField.hpp"
  48 #include "prims/jvm.h"
  49 #include "prims/jvm_misc.hpp"
  50 #include "runtime/arguments.hpp"
  51 #include "runtime/extendedPC.hpp"
  52 #include "runtime/globals.hpp"
  53 #include "runtime/interfaceSupport.hpp"
  54 #include "runtime/java.hpp"
  55 #include "runtime/javaCalls.hpp"
  56 #include "runtime/mutexLocker.hpp"
  57 #include "runtime/objectMonitor.hpp"
  58 #include "runtime/orderAccess.inline.hpp"
  59 #include "runtime/osThread.hpp"
  60 #include "runtime/perfMemory.hpp"
  61 #include "runtime/sharedRuntime.hpp"
  62 #include "runtime/statSampler.hpp"
  63 #include "runtime/stubRoutines.hpp"
  64 #include "runtime/thread.inline.hpp"
  65 #include "runtime/threadCritical.hpp"
  66 #include "runtime/timer.hpp"
  67 #include "services/attachListener.hpp"
  68 #include "services/runtimeService.hpp"
  69 #include "utilities/decoder.hpp"
  70 #include "utilities/defaultStream.hpp"
  71 #include "utilities/events.hpp"
  72 #include "utilities/growableArray.hpp"
  73 #include "utilities/vmError.hpp"
  74 
  75 // put OS-includes here (sorted alphabetically)
  76 #include <errno.h>
  77 #include <fcntl.h>
  78 #include <inttypes.h>
  79 #include <poll.h>
  80 #include <procinfo.h>
  81 #include <pthread.h>
  82 #include <pwd.h>
  83 #include <semaphore.h>
  84 #include <signal.h>
  85 #include <stdint.h>
  86 #include <stdio.h>
  87 #include <string.h>
  88 #include <unistd.h>
  89 #include <sys/ioctl.h>
  90 #include <sys/ipc.h>
  91 #include <sys/mman.h>
  92 #include <sys/resource.h>
  93 #include <sys/select.h>
  94 #include <sys/shm.h>
  95 #include <sys/socket.h>
  96 #include <sys/stat.h>
  97 #include <sys/sysinfo.h>
  98 #include <sys/systemcfg.h>
  99 #include <sys/time.h>
 100 #include <sys/times.h>
 101 #include <sys/types.h>
 102 #include <sys/utsname.h>
 103 #include <sys/vminfo.h>
 104 #include <sys/wait.h>
 105 
 106 // Add missing declarations (should be in procinfo.h but isn't until AIX 6.1).
 107 #if !defined(_AIXVERSION_610)
 108 extern "C" {
 109   int getthrds64(pid_t ProcessIdentifier,
 110                  struct thrdentry64* ThreadBuffer,
 111                  int ThreadSize,
 112                  tid64_t* IndexPointer,
 113                  int Count);
 114 }
 115 #endif
 116 
 117 #define MAX_PATH (2 * K)
 118 
 119 // for timer info max values which include all bits
 120 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
 121 // for multipage initialization error analysis (in 'g_multipage_error')
 122 #define ERROR_MP_OS_TOO_OLD                          100
 123 #define ERROR_MP_EXTSHM_ACTIVE                       101
 124 #define ERROR_MP_VMGETINFO_FAILED                    102
 125 #define ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K 103
 126 
 127 // The semantics in this file are thus that codeptr_t is a *real code ptr*.
 128 // This means that any function taking codeptr_t as arguments will assume
 129 // a real codeptr and won't handle function descriptors (eg getFuncName),
 130 // whereas functions taking address as args will deal with function
 131 // descriptors (eg os::dll_address_to_library_name).
 132 typedef unsigned int* codeptr_t;
 133 
 134 // Typedefs for stackslots, stack pointers, pointers to op codes.
 135 typedef unsigned long stackslot_t;
 136 typedef stackslot_t* stackptr_t;
 137 
 138 // Excerpts from systemcfg.h definitions newer than AIX 5.3.
 139 #ifndef PV_7
 140 #define PV_7 0x200000          /* Power PC 7 */
 141 #define PV_7_Compat 0x208000   /* Power PC 7 */
 142 #endif
 143 #ifndef PV_8
 144 #define PV_8 0x300000          /* Power PC 8 */
 145 #define PV_8_Compat 0x308000   /* Power PC 8 */
 146 #endif
 147 
 148 #define trcVerbose(fmt, ...) { /* PPC port */  \
 149   if (Verbose) { \
 150     fprintf(stderr, fmt, ##__VA_ARGS__); \
 151     fputc('\n', stderr); fflush(stderr); \
 152   } \
 153 }
 154 #define trc(fmt, ...)        /* PPC port */
 155 
 156 #define ERRBYE(s) { \
 157     trcVerbose(s); \
 158     return -1; \
 159 }
 160 
 161 // query dimensions of the stack of the calling thread
 162 static void query_stack_dimensions(address* p_stack_base, size_t* p_stack_size);
 163 
 164 // function to check a given stack pointer against given stack limits
 165 inline bool is_valid_stackpointer(stackptr_t sp, stackptr_t stack_base, size_t stack_size) {
 166   if (((uintptr_t)sp) & 0x7) {
 167     return false;
 168   }
 169   if (sp > stack_base) {
 170     return false;
 171   }
 172   if (sp < (stackptr_t) ((address)stack_base - stack_size)) {
 173     return false;
 174   }
 175   return true;
 176 }
 177 
 178 // returns true if function is a valid codepointer
 179 inline bool is_valid_codepointer(codeptr_t p) {
 180   if (!p) {
 181     return false;
 182   }
 183   if (((uintptr_t)p) & 0x3) {
 184     return false;
 185   }
 186   if (LoadedLibraries::find_for_text_address((address)p) == NULL) {
 187     return false;
 188   }
 189   return true;
 190 }
 191 
 192 // Macro to check a given stack pointer against given stack limits and to die if test fails.
 193 #define CHECK_STACK_PTR(sp, stack_base, stack_size) { \
 194     guarantee(is_valid_stackpointer((stackptr_t)(sp), (stackptr_t)(stack_base), stack_size), "Stack Pointer Invalid"); \
 195 }
 196 
 197 // Macro to check the current stack pointer against given stacklimits.
 198 #define CHECK_CURRENT_STACK_PTR(stack_base, stack_size) { \
 199   address sp; \
 200   sp = os::current_stack_pointer(); \
 201   CHECK_STACK_PTR(sp, stack_base, stack_size); \
 202 }
 203 
 204 ////////////////////////////////////////////////////////////////////////////////
 205 // global variables (for a description see os_aix.hpp)
 206 
 207 julong    os::Aix::_physical_memory = 0;
 208 pthread_t os::Aix::_main_thread = ((pthread_t)0);
 209 int       os::Aix::_page_size = -1;
 210 int       os::Aix::_on_pase = -1;
 211 int       os::Aix::_os_version = -1;
 212 int       os::Aix::_stack_page_size = -1;
 213 size_t    os::Aix::_shm_default_page_size = -1;
 214 int       os::Aix::_can_use_64K_pages = -1;
 215 int       os::Aix::_can_use_16M_pages = -1;
 216 int       os::Aix::_xpg_sus_mode = -1;
 217 int       os::Aix::_extshm = -1;
 218 int       os::Aix::_logical_cpus = -1;
 219 
 220 ////////////////////////////////////////////////////////////////////////////////
 221 // local variables
 222 
 223 static int      g_multipage_error  = -1;   // error analysis for multipage initialization
 224 static jlong    initial_time_count = 0;
 225 static int      clock_tics_per_sec = 100;
 226 static sigset_t check_signal_done;         // For diagnostics to print a message once (see run_periodic_checks)
 227 static bool     check_signals      = true;
 228 static pid_t    _initial_pid       = 0;
 229 static int      SR_signum          = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769)
 230 static sigset_t SR_sigset;
 231 static pthread_mutex_t dl_mutex;              // Used to protect dlsym() calls.
 232 
 233 julong os::available_memory() {
 234   return Aix::available_memory();
 235 }
 236 
 237 julong os::Aix::available_memory() {
 238   os::Aix::meminfo_t mi;
 239   if (os::Aix::get_meminfo(&mi)) {
 240     return mi.real_free;
 241   } else {
 242     return 0xFFFFFFFFFFFFFFFFLL;
 243   }
 244 }
 245 
 246 julong os::physical_memory() {
 247   return Aix::physical_memory();
 248 }
 249 
 250 ////////////////////////////////////////////////////////////////////////////////
 251 // environment support
 252 
 253 bool os::getenv(const char* name, char* buf, int len) {
 254   const char* val = ::getenv(name);
 255   if (val != NULL && strlen(val) < (size_t)len) {
 256     strcpy(buf, val);
 257     return true;
 258   }
 259   if (len > 0) buf[0] = 0;  // return a null string
 260   return false;
 261 }
 262 
 263 // Return true if user is running as root.
 264 
 265 bool os::have_special_privileges() {
 266   static bool init = false;
 267   static bool privileges = false;
 268   if (!init) {
 269     privileges = (getuid() != geteuid()) || (getgid() != getegid());
 270     init = true;
 271   }
 272   return privileges;
 273 }
 274 
 275 // Helper function, emulates disclaim64 using multiple 32bit disclaims
 276 // because we cannot use disclaim64() on AS/400 and old AIX releases.
 277 static bool my_disclaim64(char* addr, size_t size) {
 278 
 279   if (size == 0) {
 280     return true;
 281   }
 282 
 283   // Maximum size 32bit disclaim() accepts. (Theoretically 4GB, but I just do not trust that.)
 284   const unsigned int maxDisclaimSize = 0x80000000;
 285 
 286   const unsigned int numFullDisclaimsNeeded = (size / maxDisclaimSize);
 287   const unsigned int lastDisclaimSize = (size % maxDisclaimSize);
 288 
 289   char* p = addr;
 290 
 291   for (int i = 0; i < numFullDisclaimsNeeded; i ++) {
 292     if (::disclaim(p, maxDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
 293       trc("Cannot disclaim %p - %p (errno %d)\n", p, p + maxDisclaimSize, errno);
 294       return false;
 295     }
 296     p += maxDisclaimSize;
 297   }
 298 
 299   if (lastDisclaimSize > 0) {
 300     if (::disclaim(p, lastDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
 301       trc("Cannot disclaim %p - %p (errno %d)\n", p, p + lastDisclaimSize, errno);
 302       return false;
 303     }
 304   }
 305 
 306   return true;
 307 }
 308 
 309 // Cpu architecture string
 310 #if defined(PPC32)
 311 static char cpu_arch[] = "ppc";
 312 #elif defined(PPC64)
 313 static char cpu_arch[] = "ppc64";
 314 #else
 315 #error Add appropriate cpu_arch setting
 316 #endif
 317 
 318 
 319 // Given an address, returns the size of the page backing that address.
 320 size_t os::Aix::query_pagesize(void* addr) {
 321 
 322   vm_page_info pi;
 323   pi.addr = (uint64_t)addr;
 324   if (::vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) {
 325     return pi.pagesize;
 326   } else {
 327     fprintf(stderr, "vmgetinfo failed to retrieve page size for address %p (errno %d).\n", addr, errno);
 328     assert(false, "vmgetinfo failed to retrieve page size");
 329     return SIZE_4K;
 330   }
 331 
 332 }
 333 
 334 // Returns the kernel thread id of the currently running thread.
 335 pid_t os::Aix::gettid() {
 336   return (pid_t) thread_self();
 337 }
 338 
 339 void os::Aix::initialize_system_info() {
 340 
 341   // Get the number of online(logical) cpus instead of configured.
 342   os::_processor_count = sysconf(_SC_NPROCESSORS_ONLN);
 343   assert(_processor_count > 0, "_processor_count must be > 0");
 344 
 345   // Retrieve total physical storage.
 346   os::Aix::meminfo_t mi;
 347   if (!os::Aix::get_meminfo(&mi)) {
 348     fprintf(stderr, "os::Aix::get_meminfo failed.\n"); fflush(stderr);
 349     assert(false, "os::Aix::get_meminfo failed.");
 350   }
 351   _physical_memory = (julong) mi.real_total;
 352 }
 353 
 354 // Helper function for tracing page sizes.
 355 static const char* describe_pagesize(size_t pagesize) {
 356   switch (pagesize) {
 357     case SIZE_4K : return "4K";
 358     case SIZE_64K: return "64K";
 359     case SIZE_16M: return "16M";
 360     case SIZE_16G: return "16G";
 361     default:
 362       assert(false, "surprise");
 363       return "??";
 364   }
 365 }
 366 
 367 // Retrieve information about multipage size support. Will initialize
 368 // Aix::_page_size, Aix::_stack_page_size, Aix::_can_use_64K_pages,
 369 // Aix::_can_use_16M_pages.
 370 // Must be called before calling os::large_page_init().
 371 void os::Aix::query_multipage_support() {
 372 
 373   guarantee(_page_size == -1 &&
 374             _stack_page_size == -1 &&
 375             _can_use_64K_pages == -1 &&
 376             _can_use_16M_pages == -1 &&
 377             g_multipage_error == -1,
 378             "do not call twice");
 379 
 380   _page_size = ::sysconf(_SC_PAGESIZE);
 381 
 382   // This really would surprise me.
 383   assert(_page_size == SIZE_4K, "surprise!");
 384 
 385 
 386   // Query default data page size (default page size for C-Heap, pthread stacks and .bss).
 387   // Default data page size is influenced either by linker options (-bdatapsize)
 388   // or by environment variable LDR_CNTRL (suboption DATAPSIZE). If none is given,
 389   // default should be 4K.
 390   size_t data_page_size = SIZE_4K;
 391   {
 392     void* p = ::malloc(SIZE_16M);
 393     guarantee(p != NULL, "malloc failed");
 394     data_page_size = os::Aix::query_pagesize(p);
 395     ::free(p);
 396   }
 397 
 398   // query default shm page size (LDR_CNTRL SHMPSIZE)
 399   {
 400     const int shmid = ::shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR | S_IWUSR);
 401     guarantee(shmid != -1, "shmget failed");
 402     void* p = ::shmat(shmid, NULL, 0);
 403     ::shmctl(shmid, IPC_RMID, NULL);
 404     guarantee(p != (void*) -1, "shmat failed");
 405     _shm_default_page_size = os::Aix::query_pagesize(p);
 406     ::shmdt(p);
 407   }
 408 
 409   // before querying the stack page size, make sure we are not running as primordial
 410   // thread (because primordial thread's stack may have different page size than
 411   // pthread thread stacks). Running a VM on the primordial thread won't work for a
 412   // number of reasons so we may just as well guarantee it here
 413   guarantee(!os::is_primordial_thread(), "Must not be called for primordial thread");
 414 
 415   // query stack page size
 416   {
 417     int dummy = 0;
 418     _stack_page_size = os::Aix::query_pagesize(&dummy);
 419     // everything else would surprise me and should be looked into
 420     guarantee(_stack_page_size == SIZE_4K || _stack_page_size == SIZE_64K, "Wrong page size");
 421     // also, just for completeness: pthread stacks are allocated from C heap, so
 422     // stack page size should be the same as data page size
 423     guarantee(_stack_page_size == data_page_size, "stack page size should be the same as data page size");
 424   }
 425 
 426   // EXTSHM is bad: among other things, it prevents setting pagesize dynamically
 427   // for system V shm.
 428   if (Aix::extshm()) {
 429     if (Verbose) {
 430       fprintf(stderr, "EXTSHM is active - will disable large page support.\n"
 431                       "Please make sure EXTSHM is OFF for large page support.\n");
 432     }
 433     g_multipage_error = ERROR_MP_EXTSHM_ACTIVE;
 434     _can_use_64K_pages = _can_use_16M_pages = 0;
 435     goto query_multipage_support_end;
 436   }
 437 
 438   // now check which page sizes the OS claims it supports, and of those, which actually can be used.
 439   {
 440     const int MAX_PAGE_SIZES = 4;
 441     psize_t sizes[MAX_PAGE_SIZES];
 442     const int num_psizes = ::vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES);
 443     if (num_psizes == -1) {
 444       if (Verbose) {
 445         fprintf(stderr, "vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)\n", errno);
 446         fprintf(stderr, "disabling multipage support.\n");
 447       }
 448       g_multipage_error = ERROR_MP_VMGETINFO_FAILED;
 449       _can_use_64K_pages = _can_use_16M_pages = 0;
 450       goto query_multipage_support_end;
 451     }
 452     guarantee(num_psizes > 0, "vmgetinfo(.., VMINFO_GETPSIZES, ...) failed.");
 453     assert(num_psizes <= MAX_PAGE_SIZES, "Surprise! more than 4 page sizes?");
 454     if (Verbose) {
 455       fprintf(stderr, "vmgetinfo(.., VMINFO_GETPSIZES, ...) returns %d supported page sizes: ", num_psizes);
 456       for (int i = 0; i < num_psizes; i ++) {
 457         fprintf(stderr, " %s ", describe_pagesize(sizes[i]));
 458       }
 459       fprintf(stderr, " .\n");
 460     }
 461 
 462     // Can we use 64K, 16M pages?
 463     _can_use_64K_pages = 0;
 464     _can_use_16M_pages = 0;
 465     for (int i = 0; i < num_psizes; i ++) {
 466       if (sizes[i] == SIZE_64K) {
 467         _can_use_64K_pages = 1;
 468       } else if (sizes[i] == SIZE_16M) {
 469         _can_use_16M_pages = 1;
 470       }
 471     }
 472 
 473     if (!_can_use_64K_pages) {
 474       g_multipage_error = ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K;
 475     }
 476 
 477     // Double-check for 16M pages: Even if AIX claims to be able to use 16M pages,
 478     // there must be an actual 16M page pool, and we must run with enough rights.
 479     if (_can_use_16M_pages) {
 480       const int shmid = ::shmget(IPC_PRIVATE, SIZE_16M, IPC_CREAT | S_IRUSR | S_IWUSR);
 481       guarantee(shmid != -1, "shmget failed");
 482       struct shmid_ds shm_buf = { 0 };
 483       shm_buf.shm_pagesize = SIZE_16M;
 484       const bool can_set_pagesize = ::shmctl(shmid, SHM_PAGESIZE, &shm_buf) == 0 ? true : false;
 485       const int en = errno;
 486       ::shmctl(shmid, IPC_RMID, NULL);
 487       if (!can_set_pagesize) {
 488         if (Verbose) {
 489           fprintf(stderr, "Failed to allocate even one misely 16M page. shmctl failed with %d (%s).\n"
 490                           "Will deactivate 16M support.\n", en, strerror(en));
 491         }
 492         _can_use_16M_pages = 0;
 493       }
 494     }
 495 
 496   } // end: check which pages can be used for shared memory
 497 
 498 query_multipage_support_end:
 499 
 500   guarantee(_page_size != -1 &&
 501             _stack_page_size != -1 &&
 502             _can_use_64K_pages != -1 &&
 503             _can_use_16M_pages != -1, "Page sizes not properly initialized");
 504 
 505   if (_can_use_64K_pages) {
 506     g_multipage_error = 0;
 507   }
 508 
 509   if (Verbose) {
 510     fprintf(stderr, "Data page size (C-Heap, bss, etc): %s\n", describe_pagesize(data_page_size));
 511     fprintf(stderr, "Thread stack page size (pthread): %s\n", describe_pagesize(_stack_page_size));
 512     fprintf(stderr, "Default shared memory page size: %s\n", describe_pagesize(_shm_default_page_size));
 513     fprintf(stderr, "Can use 64K pages dynamically with shared meory: %s\n", (_can_use_64K_pages ? "yes" :"no"));
 514     fprintf(stderr, "Can use 16M pages dynamically with shared memory: %s\n", (_can_use_16M_pages ? "yes" :"no"));
 515     fprintf(stderr, "Multipage error details: %d\n", g_multipage_error);
 516   }
 517 
 518 } // end os::Aix::query_multipage_support()
 519 
 520 void os::init_system_properties_values() {
 521 
 522 #define DEFAULT_LIBPATH "/usr/lib:/lib"
 523 #define EXTENSIONS_DIR  "/lib/ext"
 524 #define ENDORSED_DIR    "/lib/endorsed"
 525 
 526   // Buffer that fits several sprintfs.
 527   // Note that the space for the trailing null is provided
 528   // by the nulls included by the sizeof operator.
 529   const size_t bufsize =
 530     MAX3((size_t)MAXPATHLEN,  // For dll_dir & friends.
 531          (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR), // extensions dir
 532          (size_t)MAXPATHLEN + sizeof(ENDORSED_DIR)); // endorsed dir
 533   char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
 534 
 535   // sysclasspath, java_home, dll_dir
 536   {
 537     char *pslash;
 538     os::jvm_path(buf, bufsize);
 539 
 540     // Found the full path to libjvm.so.
 541     // Now cut the path to <java_home>/jre if we can.
 542     *(strrchr(buf, '/')) = '\0'; // Get rid of /libjvm.so.
 543     pslash = strrchr(buf, '/');
 544     if (pslash != NULL) {
 545       *pslash = '\0';            // Get rid of /{client|server|hotspot}.
 546     }
 547     Arguments::set_dll_dir(buf);
 548 
 549     if (pslash != NULL) {
 550       pslash = strrchr(buf, '/');
 551       if (pslash != NULL) {
 552         *pslash = '\0';          // Get rid of /<arch>.
 553         pslash = strrchr(buf, '/');
 554         if (pslash != NULL) {
 555           *pslash = '\0';        // Get rid of /lib.
 556         }
 557       }
 558     }
 559     Arguments::set_java_home(buf);
 560     set_boot_path('/', ':');
 561   }
 562 
 563   // Where to look for native libraries.
 564 
 565   // On Aix we get the user setting of LIBPATH.
 566   // Eventually, all the library path setting will be done here.
 567   // Get the user setting of LIBPATH.
 568   const char *v = ::getenv("LIBPATH");
 569   const char *v_colon = ":";
 570   if (v == NULL) { v = ""; v_colon = ""; }
 571 
 572   // Concatenate user and invariant part of ld_library_path.
 573   // That's +1 for the colon and +1 for the trailing '\0'.
 574   char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal);
 575   sprintf(ld_library_path, "%s%s" DEFAULT_LIBPATH, v, v_colon);
 576   Arguments::set_library_path(ld_library_path);
 577   FREE_C_HEAP_ARRAY(char, ld_library_path, mtInternal);
 578 
 579   // Extensions directories.
 580   sprintf(buf, "%s" EXTENSIONS_DIR, Arguments::get_java_home());
 581   Arguments::set_ext_dirs(buf);
 582 
 583   // Endorsed standards default directory.
 584   sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home());
 585   Arguments::set_endorsed_dirs(buf);
 586 
 587   FREE_C_HEAP_ARRAY(char, buf, mtInternal);
 588 
 589 #undef DEFAULT_LIBPATH
 590 #undef EXTENSIONS_DIR
 591 #undef ENDORSED_DIR
 592 }
 593 
 594 ////////////////////////////////////////////////////////////////////////////////
 595 // breakpoint support
 596 
 597 void os::breakpoint() {
 598   BREAKPOINT;
 599 }
 600 
 601 extern "C" void breakpoint() {
 602   // use debugger to set breakpoint here
 603 }
 604 
 605 ////////////////////////////////////////////////////////////////////////////////
 606 // signal support
 607 
 608 debug_only(static bool signal_sets_initialized = false);
 609 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
 610 
 611 bool os::Aix::is_sig_ignored(int sig) {
 612   struct sigaction oact;
 613   sigaction(sig, (struct sigaction*)NULL, &oact);
 614   void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
 615     : CAST_FROM_FN_PTR(void*, oact.sa_handler);
 616   if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
 617     return true;
 618   } else {
 619     return false;
 620   }
 621 }
 622 
 623 void os::Aix::signal_sets_init() {
 624   // Should also have an assertion stating we are still single-threaded.
 625   assert(!signal_sets_initialized, "Already initialized");
 626   // Fill in signals that are necessarily unblocked for all threads in
 627   // the VM. Currently, we unblock the following signals:
 628   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
 629   //                         by -Xrs (=ReduceSignalUsage));
 630   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
 631   // other threads. The "ReduceSignalUsage" boolean tells us not to alter
 632   // the dispositions or masks wrt these signals.
 633   // Programs embedding the VM that want to use the above signals for their
 634   // own purposes must, at this time, use the "-Xrs" option to prevent
 635   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
 636   // (See bug 4345157, and other related bugs).
 637   // In reality, though, unblocking these signals is really a nop, since
 638   // these signals are not blocked by default.
 639   sigemptyset(&unblocked_sigs);
 640   sigemptyset(&allowdebug_blocked_sigs);
 641   sigaddset(&unblocked_sigs, SIGILL);
 642   sigaddset(&unblocked_sigs, SIGSEGV);
 643   sigaddset(&unblocked_sigs, SIGBUS);
 644   sigaddset(&unblocked_sigs, SIGFPE);
 645   sigaddset(&unblocked_sigs, SIGTRAP);
 646   sigaddset(&unblocked_sigs, SIGDANGER);
 647   sigaddset(&unblocked_sigs, SR_signum);
 648 
 649   if (!ReduceSignalUsage) {
 650    if (!os::Aix::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
 651      sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
 652      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
 653    }
 654    if (!os::Aix::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
 655      sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
 656      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
 657    }
 658    if (!os::Aix::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
 659      sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
 660      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
 661    }
 662   }
 663   // Fill in signals that are blocked by all but the VM thread.
 664   sigemptyset(&vm_sigs);
 665   if (!ReduceSignalUsage)
 666     sigaddset(&vm_sigs, BREAK_SIGNAL);
 667   debug_only(signal_sets_initialized = true);
 668 }
 669 
 670 // These are signals that are unblocked while a thread is running Java.
 671 // (For some reason, they get blocked by default.)
 672 sigset_t* os::Aix::unblocked_signals() {
 673   assert(signal_sets_initialized, "Not initialized");
 674   return &unblocked_sigs;
 675 }
 676 
 677 // These are the signals that are blocked while a (non-VM) thread is
 678 // running Java. Only the VM thread handles these signals.
 679 sigset_t* os::Aix::vm_signals() {
 680   assert(signal_sets_initialized, "Not initialized");
 681   return &vm_sigs;
 682 }
 683 
 684 // These are signals that are blocked during cond_wait to allow debugger in
 685 sigset_t* os::Aix::allowdebug_blocked_signals() {
 686   assert(signal_sets_initialized, "Not initialized");
 687   return &allowdebug_blocked_sigs;
 688 }
 689 
 690 void os::Aix::hotspot_sigmask(Thread* thread) {
 691 
 692   //Save caller's signal mask before setting VM signal mask
 693   sigset_t caller_sigmask;
 694   pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);
 695 
 696   OSThread* osthread = thread->osthread();
 697   osthread->set_caller_sigmask(caller_sigmask);
 698 
 699   pthread_sigmask(SIG_UNBLOCK, os::Aix::unblocked_signals(), NULL);
 700 
 701   if (!ReduceSignalUsage) {
 702     if (thread->is_VM_thread()) {
 703       // Only the VM thread handles BREAK_SIGNAL ...
 704       pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);
 705     } else {
 706       // ... all other threads block BREAK_SIGNAL
 707       pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);
 708     }
 709   }
 710 }
 711 
 712 // retrieve memory information.
 713 // Returns false if something went wrong;
 714 // content of pmi undefined in this case.
 715 bool os::Aix::get_meminfo(meminfo_t* pmi) {
 716 
 717   assert(pmi, "get_meminfo: invalid parameter");
 718 
 719   memset(pmi, 0, sizeof(meminfo_t));
 720 
 721   if (os::Aix::on_pase()) {
 722 
 723     Unimplemented();
 724     return false;
 725 
 726   } else {
 727 
 728     // On AIX, I use the (dynamically loaded) perfstat library to retrieve memory statistics
 729     // See:
 730     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 731     //        ?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_memtot.htm
 732     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 733     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
 734 
 735     perfstat_memory_total_t psmt;
 736     memset (&psmt, '\0', sizeof(psmt));
 737     const int rc = libperfstat::perfstat_memory_total(NULL, &psmt, sizeof(psmt), 1);
 738     if (rc == -1) {
 739       fprintf(stderr, "perfstat_memory_total() failed (errno=%d)\n", errno);
 740       assert(0, "perfstat_memory_total() failed");
 741       return false;
 742     }
 743 
 744     assert(rc == 1, "perfstat_memory_total() - weird return code");
 745 
 746     // excerpt from
 747     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 748     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
 749     // The fields of perfstat_memory_total_t:
 750     // u_longlong_t virt_total         Total virtual memory (in 4 KB pages).
 751     // u_longlong_t real_total         Total real memory (in 4 KB pages).
 752     // u_longlong_t real_free          Free real memory (in 4 KB pages).
 753     // u_longlong_t pgsp_total         Total paging space (in 4 KB pages).
 754     // u_longlong_t pgsp_free          Free paging space (in 4 KB pages).
 755 
 756     pmi->virt_total = psmt.virt_total * 4096;
 757     pmi->real_total = psmt.real_total * 4096;
 758     pmi->real_free = psmt.real_free * 4096;
 759     pmi->pgsp_total = psmt.pgsp_total * 4096;
 760     pmi->pgsp_free = psmt.pgsp_free * 4096;
 761 
 762     return true;
 763 
 764   }
 765 } // end os::Aix::get_meminfo
 766 
 767 // Retrieve global cpu information.
 768 // Returns false if something went wrong;
 769 // the content of pci is undefined in this case.
 770 bool os::Aix::get_cpuinfo(cpuinfo_t* pci) {
 771   assert(pci, "get_cpuinfo: invalid parameter");
 772   memset(pci, 0, sizeof(cpuinfo_t));
 773 
 774   perfstat_cpu_total_t psct;
 775   memset (&psct, '\0', sizeof(psct));
 776 
 777   if (-1 == libperfstat::perfstat_cpu_total(NULL, &psct, sizeof(perfstat_cpu_total_t), 1)) {
 778     fprintf(stderr, "perfstat_cpu_total() failed (errno=%d)\n", errno);
 779     assert(0, "perfstat_cpu_total() failed");
 780     return false;
 781   }
 782 
 783   // global cpu information
 784   strcpy (pci->description, psct.description);
 785   pci->processorHZ = psct.processorHZ;
 786   pci->ncpus = psct.ncpus;
 787   os::Aix::_logical_cpus = psct.ncpus;
 788   for (int i = 0; i < 3; i++) {
 789     pci->loadavg[i] = (double) psct.loadavg[i] / (1 << SBITS);
 790   }
 791 
 792   // get the processor version from _system_configuration
 793   switch (_system_configuration.version) {
 794   case PV_8:
 795     strcpy(pci->version, "Power PC 8");
 796     break;
 797   case PV_7:
 798     strcpy(pci->version, "Power PC 7");
 799     break;
 800   case PV_6_1:
 801     strcpy(pci->version, "Power PC 6 DD1.x");
 802     break;
 803   case PV_6:
 804     strcpy(pci->version, "Power PC 6");
 805     break;
 806   case PV_5:
 807     strcpy(pci->version, "Power PC 5");
 808     break;
 809   case PV_5_2:
 810     strcpy(pci->version, "Power PC 5_2");
 811     break;
 812   case PV_5_3:
 813     strcpy(pci->version, "Power PC 5_3");
 814     break;
 815   case PV_5_Compat:
 816     strcpy(pci->version, "PV_5_Compat");
 817     break;
 818   case PV_6_Compat:
 819     strcpy(pci->version, "PV_6_Compat");
 820     break;
 821   case PV_7_Compat:
 822     strcpy(pci->version, "PV_7_Compat");
 823     break;
 824   case PV_8_Compat:
 825     strcpy(pci->version, "PV_8_Compat");
 826     break;
 827   default:
 828     strcpy(pci->version, "unknown");
 829   }
 830 
 831   return true;
 832 
 833 } //end os::Aix::get_cpuinfo
 834 
 835 //////////////////////////////////////////////////////////////////////////////
 836 // detecting pthread library
 837 
 838 void os::Aix::libpthread_init() {
 839   return;
 840 }
 841 
 842 //////////////////////////////////////////////////////////////////////////////
 843 // create new thread
 844 
 845 // Thread start routine for all newly created threads
 846 static void *java_start(Thread *thread) {
 847 
 848   // find out my own stack dimensions
 849   {
 850     // actually, this should do exactly the same as thread->record_stack_base_and_size...
 851     address base = 0;
 852     size_t size = 0;
 853     query_stack_dimensions(&base, &size);
 854     thread->set_stack_base(base);
 855     thread->set_stack_size(size);
 856   }
 857 
 858   // Do some sanity checks.
 859   CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());
 860 
 861   // Try to randomize the cache line index of hot stack frames.
 862   // This helps when threads of the same stack traces evict each other's
 863   // cache lines. The threads can be either from the same JVM instance, or
 864   // from different JVM instances. The benefit is especially true for
 865   // processors with hyperthreading technology.
 866 
 867   static int counter = 0;
 868   int pid = os::current_process_id();
 869   alloca(((pid ^ counter++) & 7) * 128);
 870 
 871   ThreadLocalStorage::set_thread(thread);
 872 
 873   OSThread* osthread = thread->osthread();
 874 
 875   // thread_id is kernel thread id (similar to Solaris LWP id)
 876   osthread->set_thread_id(os::Aix::gettid());
 877 
 878   // initialize signal mask for this thread
 879   os::Aix::hotspot_sigmask(thread);
 880 
 881   // initialize floating point control register
 882   os::Aix::init_thread_fpu_state();
 883 
 884   assert(osthread->get_state() == RUNNABLE, "invalid os thread state");
 885 
 886   // call one more level start routine
 887   thread->run();
 888 
 889   return 0;
 890 }
 891 
 892 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
 893 
 894   // We want the whole function to be synchronized.
 895   ThreadCritical cs;
 896 
 897   assert(thread->osthread() == NULL, "caller responsible");
 898 
 899   // Allocate the OSThread object
 900   OSThread* osthread = new OSThread(NULL, NULL);
 901   if (osthread == NULL) {
 902     return false;
 903   }
 904 
 905   // set the correct thread state
 906   osthread->set_thread_type(thr_type);
 907 
 908   // Initial state is ALLOCATED but not INITIALIZED
 909   osthread->set_state(ALLOCATED);
 910 
 911   thread->set_osthread(osthread);
 912 
 913   // init thread attributes
 914   pthread_attr_t attr;
 915   pthread_attr_init(&attr);
 916   guarantee(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0, "???");
 917 
 918   // Make sure we run in 1:1 kernel-user-thread mode.
 919   if (os::Aix::on_aix()) {
 920     guarantee(pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0, "???");
 921     guarantee(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0, "???");
 922   } // end: aix
 923 
 924   // Start in suspended state, and in os::thread_start, wake the thread up.
 925   guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???");
 926 
 927   // calculate stack size if it's not specified by caller
 928   if (os::Aix::supports_variable_stack_size()) {
 929     if (stack_size == 0) {
 930       stack_size = os::Aix::default_stack_size(thr_type);
 931 
 932       switch (thr_type) {
 933       case os::java_thread:
 934         // Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.
 935         assert(JavaThread::stack_size_at_create() > 0, "this should be set");
 936         stack_size = JavaThread::stack_size_at_create();
 937         break;
 938       case os::compiler_thread:
 939         if (CompilerThreadStackSize > 0) {
 940           stack_size = (size_t)(CompilerThreadStackSize * K);
 941           break;
 942         } // else fall through:
 943           // use VMThreadStackSize if CompilerThreadStackSize is not defined
 944       case os::vm_thread:
 945       case os::pgc_thread:
 946       case os::cgc_thread:
 947       case os::watcher_thread:
 948         if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
 949         break;
 950       }
 951     }
 952 
 953     stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);
 954     pthread_attr_setstacksize(&attr, stack_size);
 955   } //else let thread_create() pick the default value (96 K on AIX)
 956 
 957   pthread_t tid;
 958   int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
 959 
 960   pthread_attr_destroy(&attr);
 961 
 962   if (ret == 0) {
 963     // PPC port traceOsMisc(("Created New Thread : pthread-id %u", tid));
 964   } else {
 965     if (PrintMiscellaneous && (Verbose || WizardMode)) {
 966       perror("pthread_create()");
 967     }
 968     // Need to clean up stuff we've allocated so far
 969     thread->set_osthread(NULL);
 970     delete osthread;
 971     return false;
 972   }
 973 
 974   // Store pthread info into the OSThread
 975   osthread->set_pthread_id(tid);
 976 
 977   return true;
 978 }
 979 
 980 /////////////////////////////////////////////////////////////////////////////
 981 // attach existing thread
 982 
 983 // bootstrap the main thread
 984 bool os::create_main_thread(JavaThread* thread) {
 985   assert(os::Aix::_main_thread == pthread_self(), "should be called inside main thread");
 986   return create_attached_thread(thread);
 987 }
 988 
 989 bool os::create_attached_thread(JavaThread* thread) {
 990 #ifdef ASSERT
 991     thread->verify_not_published();
 992 #endif
 993 
 994   // Allocate the OSThread object
 995   OSThread* osthread = new OSThread(NULL, NULL);
 996 
 997   if (osthread == NULL) {
 998     return false;
 999   }
1000 
1001   // Store pthread info into the OSThread
1002   osthread->set_thread_id(os::Aix::gettid());
1003   osthread->set_pthread_id(::pthread_self());
1004 
1005   // initialize floating point control register
1006   os::Aix::init_thread_fpu_state();
1007 
1008   // some sanity checks
1009   CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());
1010 
1011   // Initial thread state is RUNNABLE
1012   osthread->set_state(RUNNABLE);
1013 
1014   thread->set_osthread(osthread);
1015 
1016   if (UseNUMA) {
1017     int lgrp_id = os::numa_get_group_id();
1018     if (lgrp_id != -1) {
1019       thread->set_lgrp_id(lgrp_id);
1020     }
1021   }
1022 
1023   // initialize signal mask for this thread
1024   // and save the caller's signal mask
1025   os::Aix::hotspot_sigmask(thread);
1026 
1027   return true;
1028 }
1029 
1030 void os::pd_start_thread(Thread* thread) {
1031   int status = pthread_continue_np(thread->osthread()->pthread_id());
1032   assert(status == 0, "thr_continue failed");
1033 }
1034 
1035 // Free OS resources related to the OSThread
1036 void os::free_thread(OSThread* osthread) {
1037   assert(osthread != NULL, "osthread not set");
1038 
1039   if (Thread::current()->osthread() == osthread) {
1040     // Restore caller's signal mask
1041     sigset_t sigmask = osthread->caller_sigmask();
1042     pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
1043    }
1044 
1045   delete osthread;
1046 }
1047 
1048 //////////////////////////////////////////////////////////////////////////////
1049 // thread local storage
1050 
1051 int os::allocate_thread_local_storage() {
1052   pthread_key_t key;
1053   int rslt = pthread_key_create(&key, NULL);
1054   assert(rslt == 0, "cannot allocate thread local storage");
1055   return (int)key;
1056 }
1057 
1058 // Note: This is currently not used by VM, as we don't destroy TLS key
1059 // on VM exit.
1060 void os::free_thread_local_storage(int index) {
1061   int rslt = pthread_key_delete((pthread_key_t)index);
1062   assert(rslt == 0, "invalid index");
1063 }
1064 
1065 void os::thread_local_storage_at_put(int index, void* value) {
1066   int rslt = pthread_setspecific((pthread_key_t)index, value);
1067   assert(rslt == 0, "pthread_setspecific failed");
1068 }
1069 
1070 extern "C" Thread* get_thread() {
1071   return ThreadLocalStorage::thread();
1072 }
1073 
1074 ////////////////////////////////////////////////////////////////////////////////
1075 // time support
1076 
1077 // Time since start-up in seconds to a fine granularity.
1078 // Used by VMSelfDestructTimer and the MemProfiler.
1079 double os::elapsedTime() {
1080   return (double)(os::elapsed_counter()) * 0.000001;
1081 }
1082 
1083 jlong os::elapsed_counter() {
1084   timeval time;
1085   int status = gettimeofday(&time, NULL);
1086   return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;
1087 }
1088 
1089 jlong os::elapsed_frequency() {
1090   return (1000 * 1000);
1091 }
1092 
1093 // For now, we say that linux does not support vtime. I have no idea
1094 // whether it can actually be made to (DLD, 9/13/05).
1095 
1096 bool os::supports_vtime() { return false; }
1097 bool os::enable_vtime()   { return false; }
1098 bool os::vtime_enabled()  { return false; }
1099 double os::elapsedVTime() {
1100   // better than nothing, but not much
1101   return elapsedTime();
1102 }
1103 
1104 jlong os::javaTimeMillis() {
1105   timeval time;
1106   int status = gettimeofday(&time, NULL);
1107   assert(status != -1, "aix error at gettimeofday()");
1108   return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000);
1109 }
1110 
1111 // We need to manually declare mread_real_time,
1112 // because IBM didn't provide a prototype in time.h.
1113 // (they probably only ever tested in C, not C++)
1114 extern "C"
1115 int mread_real_time(timebasestruct_t *t, size_t size_of_timebasestruct_t);
1116 
1117 jlong os::javaTimeNanos() {
1118   if (os::Aix::on_pase()) {
1119     Unimplemented();
1120     return 0;
1121   } else {
1122     // On AIX use the precision of processors real time clock
1123     // or time base registers.
1124     timebasestruct_t time;
1125     int rc;
1126 
1127     // If the CPU has a time register, it will be used and
1128     // we have to convert to real time first. After convertion we have following data:
1129     // time.tb_high [seconds since 00:00:00 UTC on 1.1.1970]
1130     // time.tb_low  [nanoseconds after the last full second above]
1131     // We better use mread_real_time here instead of read_real_time
1132     // to ensure that we will get a monotonic increasing time.
1133     if (mread_real_time(&time, TIMEBASE_SZ) != RTC_POWER) {
1134       rc = time_base_to_time(&time, TIMEBASE_SZ);
1135       assert(rc != -1, "aix error at time_base_to_time()");
1136     }
1137     return jlong(time.tb_high) * (1000 * 1000 * 1000) + jlong(time.tb_low);
1138   }
1139 }
1140 
1141 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1142   {
1143     // gettimeofday - based on time in seconds since the Epoch thus does not wrap
1144     info_ptr->max_value = ALL_64_BITS;
1145 
1146     // gettimeofday is a real time clock so it skips
1147     info_ptr->may_skip_backward = true;
1148     info_ptr->may_skip_forward = true;
1149   }
1150 
1151   info_ptr->kind = JVMTI_TIMER_ELAPSED;    // elapsed not CPU time
1152 }
1153 
1154 // Return the real, user, and system times in seconds from an
1155 // arbitrary fixed point in the past.
1156 bool os::getTimesSecs(double* process_real_time,
1157                       double* process_user_time,
1158                       double* process_system_time) {
1159   struct tms ticks;
1160   clock_t real_ticks = times(&ticks);
1161 
1162   if (real_ticks == (clock_t) (-1)) {
1163     return false;
1164   } else {
1165     double ticks_per_second = (double) clock_tics_per_sec;
1166     *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1167     *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1168     *process_real_time = ((double) real_ticks) / ticks_per_second;
1169 
1170     return true;
1171   }
1172 }
1173 
1174 char * os::local_time_string(char *buf, size_t buflen) {
1175   struct tm t;
1176   time_t long_time;
1177   time(&long_time);
1178   localtime_r(&long_time, &t);
1179   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1180                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1181                t.tm_hour, t.tm_min, t.tm_sec);
1182   return buf;
1183 }
1184 
1185 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
1186   return localtime_r(clock, res);
1187 }
1188 
1189 ////////////////////////////////////////////////////////////////////////////////
1190 // runtime exit support
1191 
1192 // Note: os::shutdown() might be called very early during initialization, or
1193 // called from signal handler. Before adding something to os::shutdown(), make
1194 // sure it is async-safe and can handle partially initialized VM.
1195 void os::shutdown() {
1196 
1197   // allow PerfMemory to attempt cleanup of any persistent resources
1198   perfMemory_exit();
1199 
1200   // needs to remove object in file system
1201   AttachListener::abort();
1202 
1203   // flush buffered output, finish log files
1204   ostream_abort();
1205 
1206   // Check for abort hook
1207   abort_hook_t abort_hook = Arguments::abort_hook();
1208   if (abort_hook != NULL) {
1209     abort_hook();
1210   }
1211 }
1212 
1213 // Note: os::abort() might be called very early during initialization, or
1214 // called from signal handler. Before adding something to os::abort(), make
1215 // sure it is async-safe and can handle partially initialized VM.
1216 void os::abort(bool dump_core) {
1217   os::shutdown();
1218   if (dump_core) {
1219 #ifndef PRODUCT
1220     fdStream out(defaultStream::output_fd());
1221     out.print_raw("Current thread is ");
1222     char buf[16];
1223     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1224     out.print_raw_cr(buf);
1225     out.print_raw_cr("Dumping core ...");
1226 #endif
1227     ::abort(); // dump core
1228   }
1229 
1230   ::exit(1);
1231 }
1232 
1233 // Die immediately, no exit hook, no abort hook, no cleanup.
1234 void os::die() {
1235   ::abort();
1236 }
1237 
1238 // This method is a copy of JDK's sysGetLastErrorString
1239 // from src/solaris/hpi/src/system_md.c
1240 
1241 size_t os::lasterror(char *buf, size_t len) {
1242   if (errno == 0) return 0;
1243 
1244   const char *s = ::strerror(errno);
1245   size_t n = ::strlen(s);
1246   if (n >= len) {
1247     n = len - 1;
1248   }
1249   ::strncpy(buf, s, n);
1250   buf[n] = '\0';
1251   return n;
1252 }
1253 
1254 intx os::current_thread_id() { return (intx)pthread_self(); }
1255 
1256 int os::current_process_id() {
1257 
1258   // This implementation returns a unique pid, the pid of the
1259   // launcher thread that starts the vm 'process'.
1260 
1261   // Under POSIX, getpid() returns the same pid as the
1262   // launcher thread rather than a unique pid per thread.
1263   // Use gettid() if you want the old pre NPTL behaviour.
1264 
1265   // if you are looking for the result of a call to getpid() that
1266   // returns a unique pid for the calling thread, then look at the
1267   // OSThread::thread_id() method in osThread_linux.hpp file
1268 
1269   return (int)(_initial_pid ? _initial_pid : getpid());
1270 }
1271 
1272 // DLL functions
1273 
1274 const char* os::dll_file_extension() { return ".so"; }
1275 
1276 // This must be hard coded because it's the system's temporary
1277 // directory not the java application's temp directory, ala java.io.tmpdir.
1278 const char* os::get_temp_directory() { return "/tmp"; }
1279 
1280 static bool file_exists(const char* filename) {
1281   struct stat statbuf;
1282   if (filename == NULL || strlen(filename) == 0) {
1283     return false;
1284   }
1285   return os::stat(filename, &statbuf) == 0;
1286 }
1287 
1288 bool os::dll_build_name(char* buffer, size_t buflen,
1289                         const char* pname, const char* fname) {
1290   bool retval = false;
1291   // Copied from libhpi
1292   const size_t pnamelen = pname ? strlen(pname) : 0;
1293 
1294   // Return error on buffer overflow.
1295   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1296     *buffer = '\0';
1297     return retval;
1298   }
1299 
1300   if (pnamelen == 0) {
1301     snprintf(buffer, buflen, "lib%s.so", fname);
1302     retval = true;
1303   } else if (strchr(pname, *os::path_separator()) != NULL) {
1304     int n;
1305     char** pelements = split_path(pname, &n);
1306     for (int i = 0; i < n; i++) {
1307       // Really shouldn't be NULL, but check can't hurt
1308       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1309         continue; // skip the empty path values
1310       }
1311       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1312       if (file_exists(buffer)) {
1313         retval = true;
1314         break;
1315       }
1316     }
1317     // release the storage
1318     for (int i = 0; i < n; i++) {
1319       if (pelements[i] != NULL) {
1320         FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
1321       }
1322     }
1323     if (pelements != NULL) {
1324       FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
1325     }
1326   } else {
1327     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1328     retval = true;
1329   }
1330   return retval;
1331 }
1332 
1333 // Check if addr is inside libjvm.so.
1334 bool os::address_is_in_vm(address addr) {
1335 
1336   // Input could be a real pc or a function pointer literal. The latter
1337   // would be a function descriptor residing in the data segment of a module.
1338 
1339   const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(addr);
1340   if (lib) {
1341     if (strcmp(lib->get_shortname(), "libjvm.so") == 0) {
1342       return true;
1343     } else {
1344       return false;
1345     }
1346   } else {
1347     lib = LoadedLibraries::find_for_data_address(addr);
1348     if (lib) {
1349       if (strcmp(lib->get_shortname(), "libjvm.so") == 0) {
1350         return true;
1351       } else {
1352         return false;
1353       }
1354     } else {
1355       return false;
1356     }
1357   }
1358 }
1359 
1360 // Resolve an AIX function descriptor literal to a code pointer.
1361 // If the input is a valid code pointer to a text segment of a loaded module,
1362 //   it is returned unchanged.
1363 // If the input is a valid AIX function descriptor, it is resolved to the
1364 //   code entry point.
1365 // If the input is neither a valid function descriptor nor a valid code pointer,
1366 //   NULL is returned.
1367 static address resolve_function_descriptor_to_code_pointer(address p) {
1368 
1369   const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(p);
1370   if (lib) {
1371     // its a real code pointer
1372     return p;
1373   } else {
1374     lib = LoadedLibraries::find_for_data_address(p);
1375     if (lib) {
1376       // pointer to data segment, potential function descriptor
1377       address code_entry = (address)(((FunctionDescriptor*)p)->entry());
1378       if (LoadedLibraries::find_for_text_address(code_entry)) {
1379         // Its a function descriptor
1380         return code_entry;
1381       }
1382     }
1383   }
1384   return NULL;
1385 }
1386 
1387 bool os::dll_address_to_function_name(address addr, char *buf,
1388                                       int buflen, int *offset) {
1389   if (offset) {
1390     *offset = -1;
1391   }
1392   // Buf is not optional, but offset is optional.
1393   assert(buf != NULL, "sanity check");
1394   buf[0] = '\0';
1395 
1396   // Resolve function ptr literals first.
1397   addr = resolve_function_descriptor_to_code_pointer(addr);
1398   if (!addr) {
1399     return false;
1400   }
1401 
1402   // Go through Decoder::decode to call getFuncName which reads the name from the traceback table.
1403   return Decoder::decode(addr, buf, buflen, offset);
1404 }
1405 
1406 static int getModuleName(codeptr_t pc,                    // [in] program counter
1407                          char* p_name, size_t namelen,    // [out] optional: function name
1408                          char* p_errmsg, size_t errmsglen // [out] optional: user provided buffer for error messages
1409                          ) {
1410 
1411   // initialize output parameters
1412   if (p_name && namelen > 0) {
1413     *p_name = '\0';
1414   }
1415   if (p_errmsg && errmsglen > 0) {
1416     *p_errmsg = '\0';
1417   }
1418 
1419   const LoadedLibraryModule* const lib = LoadedLibraries::find_for_text_address((address)pc);
1420   if (lib) {
1421     if (p_name && namelen > 0) {
1422       sprintf(p_name, "%.*s", namelen, lib->get_shortname());
1423     }
1424     return 0;
1425   }
1426 
1427   trcVerbose("pc outside any module");
1428 
1429   return -1;
1430 }
1431 
1432 bool os::dll_address_to_library_name(address addr, char* buf,
1433                                      int buflen, int* offset) {
1434   if (offset) {
1435     *offset = -1;
1436   }
1437   // Buf is not optional, but offset is optional.
1438   assert(buf != NULL, "sanity check");
1439   buf[0] = '\0';
1440 
1441   // Resolve function ptr literals first.
1442   addr = resolve_function_descriptor_to_code_pointer(addr);
1443   if (!addr) {
1444     return false;
1445   }
1446 
1447   if (::getModuleName((codeptr_t) addr, buf, buflen, 0, 0) == 0) {
1448     return true;
1449   }
1450   return false;
1451 }
1452 
1453 // Loads .dll/.so and in case of error it checks if .dll/.so was built
1454 // for the same architecture as Hotspot is running on.
1455 void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {
1456 
1457   if (ebuf && ebuflen > 0) {
1458     ebuf[0] = '\0';
1459     ebuf[ebuflen - 1] = '\0';
1460   }
1461 
1462   if (!filename || strlen(filename) == 0) {
1463     ::strncpy(ebuf, "dll_load: empty filename specified", ebuflen - 1);
1464     return NULL;
1465   }
1466 
1467   // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants.
1468   void * result= ::dlopen(filename, RTLD_LAZY);
1469   if (result != NULL) {
1470     // Reload dll cache. Don't do this in signal handling.
1471     LoadedLibraries::reload();
1472     return result;
1473   } else {
1474     // error analysis when dlopen fails
1475     const char* const error_report = ::dlerror();
1476     if (error_report && ebuf && ebuflen > 0) {
1477       snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s",
1478                filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report);
1479     }
1480   }
1481   return NULL;
1482 }
1483 
1484 // Glibc-2.0 libdl is not MT safe. If you are building with any glibc,
1485 // chances are you might want to run the generated bits against glibc-2.0
1486 // libdl.so, so always use locking for any version of glibc.
1487 void* os::dll_lookup(void* handle, const char* name) {
1488   pthread_mutex_lock(&dl_mutex);
1489   void* res = dlsym(handle, name);
1490   pthread_mutex_unlock(&dl_mutex);
1491   return res;
1492 }
1493 
1494 void* os::get_default_process_handle() {
1495   return (void*)::dlopen(NULL, RTLD_LAZY);
1496 }
1497 
1498 void os::print_dll_info(outputStream *st) {
1499   st->print_cr("Dynamic libraries:");
1500   LoadedLibraries::print(st);
1501 }
1502 
1503 void os::print_os_info(outputStream* st) {
1504   st->print("OS:");
1505 
1506   st->print("uname:");
1507   struct utsname name;
1508   uname(&name);
1509   st->print(name.sysname); st->print(" ");
1510   st->print(name.nodename); st->print(" ");
1511   st->print(name.release); st->print(" ");
1512   st->print(name.version); st->print(" ");
1513   st->print(name.machine);
1514   st->cr();
1515 
1516   // rlimit
1517   st->print("rlimit:");
1518   struct rlimit rlim;
1519 
1520   st->print(" STACK ");
1521   getrlimit(RLIMIT_STACK, &rlim);
1522   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1523   else st->print("%uk", rlim.rlim_cur >> 10);
1524 
1525   st->print(", CORE ");
1526   getrlimit(RLIMIT_CORE, &rlim);
1527   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1528   else st->print("%uk", rlim.rlim_cur >> 10);
1529 
1530   st->print(", NPROC ");
1531   st->print("%d", sysconf(_SC_CHILD_MAX));
1532 
1533   st->print(", NOFILE ");
1534   getrlimit(RLIMIT_NOFILE, &rlim);
1535   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1536   else st->print("%d", rlim.rlim_cur);
1537 
1538   st->print(", AS ");
1539   getrlimit(RLIMIT_AS, &rlim);
1540   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1541   else st->print("%uk", rlim.rlim_cur >> 10);
1542 
1543   // Print limits on DATA, because it limits the C-heap.
1544   st->print(", DATA ");
1545   getrlimit(RLIMIT_DATA, &rlim);
1546   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1547   else st->print("%uk", rlim.rlim_cur >> 10);
1548   st->cr();
1549 
1550   // load average
1551   st->print("load average:");
1552   double loadavg[3] = {-1.L, -1.L, -1.L};
1553   os::loadavg(loadavg, 3);
1554   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
1555   st->cr();
1556 }
1557 





1558 void os::print_memory_info(outputStream* st) {
1559 
1560   st->print_cr("Memory:");
1561 
1562   st->print_cr("  default page size: %s", describe_pagesize(os::vm_page_size()));
1563   st->print_cr("  default stack page size: %s", describe_pagesize(os::vm_page_size()));
1564   st->print_cr("  default shm page size: %s", describe_pagesize(os::Aix::shm_default_page_size()));
1565   st->print_cr("  can use 64K pages dynamically: %s", (os::Aix::can_use_64K_pages() ? "yes" :"no"));
1566   st->print_cr("  can use 16M pages dynamically: %s", (os::Aix::can_use_16M_pages() ? "yes" :"no"));
1567   if (g_multipage_error != 0) {
1568     st->print_cr("  multipage error: %d", g_multipage_error);
1569   }
1570 
1571   // print out LDR_CNTRL because it affects the default page sizes
1572   const char* const ldr_cntrl = ::getenv("LDR_CNTRL");
1573   st->print_cr("  LDR_CNTRL=%s.", ldr_cntrl ? ldr_cntrl : "<unset>");
1574 
1575   const char* const extshm = ::getenv("EXTSHM");
1576   st->print_cr("  EXTSHM=%s.", extshm ? extshm : "<unset>");
1577 
1578   // Call os::Aix::get_meminfo() to retrieve memory statistics.
1579   os::Aix::meminfo_t mi;
1580   if (os::Aix::get_meminfo(&mi)) {
1581     char buffer[256];
1582     if (os::Aix::on_aix()) {
1583       jio_snprintf(buffer, sizeof(buffer),
1584                    "  physical total : %llu\n"
1585                    "  physical free  : %llu\n"
1586                    "  swap total     : %llu\n"
1587                    "  swap free      : %llu\n",
1588                    mi.real_total,
1589                    mi.real_free,
1590                    mi.pgsp_total,
1591                    mi.pgsp_free);
1592     } else {
1593       Unimplemented();
1594     }
1595     st->print_raw(buffer);
1596   } else {
1597     st->print_cr("  (no more information available)");
1598   }
1599 }
1600 
1601 void os::pd_print_cpu_info(outputStream* st) {
1602   // cpu
1603   st->print("CPU:");
1604   st->print("total %d", os::processor_count());
1605   // It's not safe to query number of active processors after crash
1606   // st->print("(active %d)", os::active_processor_count());
1607   st->print(" %s", VM_Version::cpu_features());
1608   st->cr();
1609 }
1610 
1611 void os::print_siginfo(outputStream* st, void* siginfo) {
1612   // Use common posix version.
1613   os::Posix::print_siginfo_brief(st, (const siginfo_t*) siginfo);
1614   st->cr();
1615 }
1616 
1617 static void print_signal_handler(outputStream* st, int sig,
1618                                  char* buf, size_t buflen);
1619 
1620 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1621   st->print_cr("Signal Handlers:");
1622   print_signal_handler(st, SIGSEGV, buf, buflen);
1623   print_signal_handler(st, SIGBUS , buf, buflen);
1624   print_signal_handler(st, SIGFPE , buf, buflen);
1625   print_signal_handler(st, SIGPIPE, buf, buflen);
1626   print_signal_handler(st, SIGXFSZ, buf, buflen);
1627   print_signal_handler(st, SIGILL , buf, buflen);
1628   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
1629   print_signal_handler(st, SR_signum, buf, buflen);
1630   print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
1631   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
1632   print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
1633   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
1634   print_signal_handler(st, SIGTRAP, buf, buflen);
1635   print_signal_handler(st, SIGDANGER, buf, buflen);
1636 }
1637 
1638 static char saved_jvm_path[MAXPATHLEN] = {0};
1639 
1640 // Find the full path to the current module, libjvm.so.
1641 void os::jvm_path(char *buf, jint buflen) {
1642   // Error checking.
1643   if (buflen < MAXPATHLEN) {
1644     assert(false, "must use a large-enough buffer");
1645     buf[0] = '\0';
1646     return;
1647   }
1648   // Lazy resolve the path to current module.
1649   if (saved_jvm_path[0] != 0) {
1650     strcpy(buf, saved_jvm_path);
1651     return;
1652   }
1653 
1654   Dl_info dlinfo;
1655   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
1656   assert(ret != 0, "cannot locate libjvm");
1657   char* rp = realpath((char *)dlinfo.dli_fname, buf);
1658   assert(rp != NULL, "error in realpath(): maybe the 'path' argument is too long?");
1659 
1660   strcpy(saved_jvm_path, buf);
1661 }
1662 
1663 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1664   // no prefix required, not even "_"
1665 }
1666 
1667 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1668   // no suffix required
1669 }
1670 
1671 ////////////////////////////////////////////////////////////////////////////////
1672 // sun.misc.Signal support
1673 
1674 static volatile jint sigint_count = 0;
1675 
1676 static void
1677 UserHandler(int sig, void *siginfo, void *context) {
1678   // 4511530 - sem_post is serialized and handled by the manager thread. When
1679   // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
1680   // don't want to flood the manager thread with sem_post requests.
1681   if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
1682     return;
1683 
1684   // Ctrl-C is pressed during error reporting, likely because the error
1685   // handler fails to abort. Let VM die immediately.
1686   if (sig == SIGINT && is_error_reported()) {
1687     os::die();
1688   }
1689 
1690   os::signal_notify(sig);
1691 }
1692 
1693 void* os::user_handler() {
1694   return CAST_FROM_FN_PTR(void*, UserHandler);
1695 }
1696 
1697 extern "C" {
1698   typedef void (*sa_handler_t)(int);
1699   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
1700 }
1701 
1702 void* os::signal(int signal_number, void* handler) {
1703   struct sigaction sigAct, oldSigAct;
1704 
1705   sigfillset(&(sigAct.sa_mask));
1706 
1707   // Do not block out synchronous signals in the signal handler.
1708   // Blocking synchronous signals only makes sense if you can really
1709   // be sure that those signals won't happen during signal handling,
1710   // when the blocking applies. Normal signal handlers are lean and
1711   // do not cause signals. But our signal handlers tend to be "risky"
1712   // - secondary SIGSEGV, SIGILL, SIGBUS' may and do happen.
1713   // On AIX, PASE there was a case where a SIGSEGV happened, followed
1714   // by a SIGILL, which was blocked due to the signal mask. The process
1715   // just hung forever. Better to crash from a secondary signal than to hang.
1716   sigdelset(&(sigAct.sa_mask), SIGSEGV);
1717   sigdelset(&(sigAct.sa_mask), SIGBUS);
1718   sigdelset(&(sigAct.sa_mask), SIGILL);
1719   sigdelset(&(sigAct.sa_mask), SIGFPE);
1720   sigdelset(&(sigAct.sa_mask), SIGTRAP);
1721 
1722   sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;
1723 
1724   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
1725 
1726   if (sigaction(signal_number, &sigAct, &oldSigAct)) {
1727     // -1 means registration failed
1728     return (void *)-1;
1729   }
1730 
1731   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
1732 }
1733 
1734 void os::signal_raise(int signal_number) {
1735   ::raise(signal_number);
1736 }
1737 
1738 //
1739 // The following code is moved from os.cpp for making this
1740 // code platform specific, which it is by its very nature.
1741 //
1742 
1743 // Will be modified when max signal is changed to be dynamic
1744 int os::sigexitnum_pd() {
1745   return NSIG;
1746 }
1747 
1748 // a counter for each possible signal value
1749 static volatile jint pending_signals[NSIG+1] = { 0 };
1750 
1751 // Linux(POSIX) specific hand shaking semaphore.
1752 static sem_t sig_sem;
1753 
1754 void os::signal_init_pd() {
1755   // Initialize signal structures
1756   ::memset((void*)pending_signals, 0, sizeof(pending_signals));
1757 
1758   // Initialize signal semaphore
1759   int rc = ::sem_init(&sig_sem, 0, 0);
1760   guarantee(rc != -1, "sem_init failed");
1761 }
1762 
1763 void os::signal_notify(int sig) {
1764   Atomic::inc(&pending_signals[sig]);
1765   ::sem_post(&sig_sem);
1766 }
1767 
1768 static int check_pending_signals(bool wait) {
1769   Atomic::store(0, &sigint_count);
1770   for (;;) {
1771     for (int i = 0; i < NSIG + 1; i++) {
1772       jint n = pending_signals[i];
1773       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1774         return i;
1775       }
1776     }
1777     if (!wait) {
1778       return -1;
1779     }
1780     JavaThread *thread = JavaThread::current();
1781     ThreadBlockInVM tbivm(thread);
1782 
1783     bool threadIsSuspended;
1784     do {
1785       thread->set_suspend_equivalent();
1786       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1787 
1788       ::sem_wait(&sig_sem);
1789 
1790       // were we externally suspended while we were waiting?
1791       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1792       if (threadIsSuspended) {
1793         //
1794         // The semaphore has been incremented, but while we were waiting
1795         // another thread suspended us. We don't want to continue running
1796         // while suspended because that would surprise the thread that
1797         // suspended us.
1798         //
1799         ::sem_post(&sig_sem);
1800 
1801         thread->java_suspend_self();
1802       }
1803     } while (threadIsSuspended);
1804   }
1805 }
1806 
1807 int os::signal_lookup() {
1808   return check_pending_signals(false);
1809 }
1810 
1811 int os::signal_wait() {
1812   return check_pending_signals(true);
1813 }
1814 
1815 ////////////////////////////////////////////////////////////////////////////////
1816 // Virtual Memory
1817 
1818 // AddrRange describes an immutable address range
1819 //
1820 // This is a helper class for the 'shared memory bookkeeping' below.
1821 class AddrRange {
1822   friend class ShmBkBlock;
1823 
1824   char* _start;
1825   size_t _size;
1826 
1827 public:
1828 
1829   AddrRange(char* start, size_t size)
1830     : _start(start), _size(size)
1831   {}
1832 
1833   AddrRange(const AddrRange& r)
1834     : _start(r.start()), _size(r.size())
1835   {}
1836 
1837   char* start() const { return _start; }
1838   size_t size() const { return _size; }
1839   char* end() const { return _start + _size; }
1840   bool is_empty() const { return _size == 0 ? true : false; }
1841 
1842   static AddrRange empty_range() { return AddrRange(NULL, 0); }
1843 
1844   bool contains(const char* p) const {
1845     return start() <= p && end() > p;
1846   }
1847 
1848   bool contains(const AddrRange& range) const {
1849     return start() <= range.start() && end() >= range.end();
1850   }
1851 
1852   bool intersects(const AddrRange& range) const {
1853     return (range.start() <= start() && range.end() > start()) ||
1854            (range.start() < end() && range.end() >= end()) ||
1855            contains(range);
1856   }
1857 
1858   bool is_same_range(const AddrRange& range) const {
1859     return start() == range.start() && size() == range.size();
1860   }
1861 
1862   // return the closest inside range consisting of whole pages
1863   AddrRange find_closest_aligned_range(size_t pagesize) const {
1864     if (pagesize == 0 || is_empty()) {
1865       return empty_range();
1866     }
1867     char* const from = (char*)align_size_up((intptr_t)_start, pagesize);
1868     char* const to = (char*)align_size_down((intptr_t)end(), pagesize);
1869     if (from > to) {
1870       return empty_range();
1871     }
1872     return AddrRange(from, to - from);
1873   }
1874 };
1875 
1876 ////////////////////////////////////////////////////////////////////////////
1877 // shared memory bookkeeping
1878 //
1879 // the os::reserve_memory() API and friends hand out different kind of memory, depending
1880 // on need and circumstances. Memory may be allocated with mmap() or with shmget/shmat.
1881 //
1882 // But these memory types have to be treated differently. For example, to uncommit
1883 // mmap-based memory, msync(MS_INVALIDATE) is needed, to uncommit shmat-based memory,
1884 // disclaim64() is needed.
1885 //
1886 // Therefore we need to keep track of the allocated memory segments and their
1887 // properties.
1888 
1889 // ShmBkBlock: base class for all blocks in the shared memory bookkeeping
1890 class ShmBkBlock {
1891 
1892   ShmBkBlock* _next;
1893 
1894 protected:
1895 
1896   AddrRange _range;
1897   const size_t _pagesize;
1898   const bool _pinned;
1899 
1900 public:
1901 
1902   ShmBkBlock(AddrRange range, size_t pagesize, bool pinned)
1903     : _range(range), _pagesize(pagesize), _pinned(pinned) , _next(NULL) {
1904 
1905     assert(_pagesize == SIZE_4K || _pagesize == SIZE_64K || _pagesize == SIZE_16M, "invalid page size");
1906     assert(!_range.is_empty(), "invalid range");
1907   }
1908 
1909   virtual void print(outputStream* st) const {
1910     st->print("0x%p ... 0x%p (%llu) - %d %s pages - %s",
1911               _range.start(), _range.end(), _range.size(),
1912               _range.size() / _pagesize, describe_pagesize(_pagesize),
1913               _pinned ? "pinned" : "");
1914   }
1915 
1916   enum Type { MMAP, SHMAT };
1917   virtual Type getType() = 0;
1918 
1919   char* base() const { return _range.start(); }
1920   size_t size() const { return _range.size(); }
1921 
1922   void setAddrRange(AddrRange range) {
1923     _range = range;
1924   }
1925 
1926   bool containsAddress(const char* p) const {
1927     return _range.contains(p);
1928   }
1929 
1930   bool containsRange(const char* p, size_t size) const {
1931     return _range.contains(AddrRange((char*)p, size));
1932   }
1933 
1934   bool isSameRange(const char* p, size_t size) const {
1935     return _range.is_same_range(AddrRange((char*)p, size));
1936   }
1937 
1938   virtual bool disclaim(char* p, size_t size) = 0;
1939   virtual bool release() = 0;
1940 
1941   // blocks live in a list.
1942   ShmBkBlock* next() const { return _next; }
1943   void set_next(ShmBkBlock* blk) { _next = blk; }
1944 
1945 }; // end: ShmBkBlock
1946 
1947 
1948 // ShmBkMappedBlock: describes an block allocated with mmap()
1949 class ShmBkMappedBlock : public ShmBkBlock {
1950 public:
1951 
1952   ShmBkMappedBlock(AddrRange range)
1953     : ShmBkBlock(range, SIZE_4K, false) {} // mmap: always 4K, never pinned
1954 
1955   void print(outputStream* st) const {
1956     ShmBkBlock::print(st);
1957     st->print_cr(" - mmap'ed");
1958   }
1959 
1960   Type getType() {
1961     return MMAP;
1962   }
1963 
1964   bool disclaim(char* p, size_t size) {
1965 
1966     AddrRange r(p, size);
1967 
1968     guarantee(_range.contains(r), "invalid disclaim");
1969 
1970     // only disclaim whole ranges.
1971     const AddrRange r2 = r.find_closest_aligned_range(_pagesize);
1972     if (r2.is_empty()) {
1973       return true;
1974     }
1975 
1976     const int rc = ::msync(r2.start(), r2.size(), MS_INVALIDATE);
1977 
1978     if (rc != 0) {
1979       warning("msync(0x%p, %llu, MS_INVALIDATE) failed (%d)\n", r2.start(), r2.size(), errno);
1980     }
1981 
1982     return rc == 0 ? true : false;
1983   }
1984 
1985   bool release() {
1986     // mmap'ed blocks are released using munmap
1987     if (::munmap(_range.start(), _range.size()) != 0) {
1988       warning("munmap(0x%p, %llu) failed (%d)\n", _range.start(), _range.size(), errno);
1989       return false;
1990     }
1991     return true;
1992   }
1993 }; // end: ShmBkMappedBlock
1994 
1995 // ShmBkShmatedBlock: describes an block allocated with shmget/shmat()
1996 class ShmBkShmatedBlock : public ShmBkBlock {
1997 public:
1998 
1999   ShmBkShmatedBlock(AddrRange range, size_t pagesize, bool pinned)
2000     : ShmBkBlock(range, pagesize, pinned) {}
2001 
2002   void print(outputStream* st) const {
2003     ShmBkBlock::print(st);
2004     st->print_cr(" - shmat'ed");
2005   }
2006 
2007   Type getType() {
2008     return SHMAT;
2009   }
2010 
2011   bool disclaim(char* p, size_t size) {
2012 
2013     AddrRange r(p, size);
2014 
2015     if (_pinned) {
2016       return true;
2017     }
2018 
2019     // shmat'ed blocks are disclaimed using disclaim64
2020     guarantee(_range.contains(r), "invalid disclaim");
2021 
2022     // only disclaim whole ranges.
2023     const AddrRange r2 = r.find_closest_aligned_range(_pagesize);
2024     if (r2.is_empty()) {
2025       return true;
2026     }
2027 
2028     const bool rc = my_disclaim64(r2.start(), r2.size());
2029 
2030     if (Verbose && !rc) {
2031       warning("failed to disclaim shm %p-%p\n", r2.start(), r2.end());
2032     }
2033 
2034     return rc;
2035   }
2036 
2037   bool release() {
2038     bool rc = false;
2039     if (::shmdt(_range.start()) != 0) {
2040       warning("shmdt(0x%p) failed (%d)\n", _range.start(), errno);
2041     } else {
2042       rc = true;
2043     }
2044     return rc;
2045   }
2046 
2047 }; // end: ShmBkShmatedBlock
2048 
2049 static ShmBkBlock* g_shmbk_list = NULL;
2050 static volatile jint g_shmbk_table_lock = 0;
2051 
2052 // keep some usage statistics
2053 static struct {
2054   int nodes;    // number of nodes in list
2055   size_t bytes; // reserved - not committed - bytes.
2056   int reserves; // how often reserve was called
2057   int lookups;  // how often a lookup was made
2058 } g_shmbk_stats = { 0, 0, 0, 0 };
2059 
2060 // add information about a shared memory segment to the bookkeeping
2061 static void shmbk_register(ShmBkBlock* p_block) {
2062   guarantee(p_block, "logic error");
2063   p_block->set_next(g_shmbk_list);
2064   g_shmbk_list = p_block;
2065   g_shmbk_stats.reserves ++;
2066   g_shmbk_stats.bytes += p_block->size();
2067   g_shmbk_stats.nodes ++;
2068 }
2069 
2070 // remove information about a shared memory segment by its starting address
2071 static void shmbk_unregister(ShmBkBlock* p_block) {
2072   ShmBkBlock* p = g_shmbk_list;
2073   ShmBkBlock* prev = NULL;
2074   while (p) {
2075     if (p == p_block) {
2076       if (prev) {
2077         prev->set_next(p->next());
2078       } else {
2079         g_shmbk_list = p->next();
2080       }
2081       g_shmbk_stats.nodes --;
2082       g_shmbk_stats.bytes -= p->size();
2083       return;
2084     }
2085     prev = p;
2086     p = p->next();
2087   }
2088   assert(false, "should not happen");
2089 }
2090 
2091 // given a pointer, return shared memory bookkeeping record for the segment it points into
2092 // using the returned block info must happen under lock protection
2093 static ShmBkBlock* shmbk_find_by_containing_address(const char* addr) {
2094   g_shmbk_stats.lookups ++;
2095   ShmBkBlock* p = g_shmbk_list;
2096   while (p) {
2097     if (p->containsAddress(addr)) {
2098       return p;
2099     }
2100     p = p->next();
2101   }
2102   return NULL;
2103 }
2104 
2105 // dump all information about all memory segments allocated with os::reserve_memory()
2106 void shmbk_dump_info() {
2107   tty->print_cr("-- shared mem bookkeeping (alive: %d segments, %llu bytes, "
2108     "total reserves: %d total lookups: %d)",
2109     g_shmbk_stats.nodes, g_shmbk_stats.bytes, g_shmbk_stats.reserves, g_shmbk_stats.lookups);
2110   const ShmBkBlock* p = g_shmbk_list;
2111   int i = 0;
2112   while (p) {
2113     p->print(tty);
2114     p = p->next();
2115     i ++;
2116   }
2117 }
2118 
2119 #define LOCK_SHMBK     { ThreadCritical _LOCK_SHMBK;
2120 #define UNLOCK_SHMBK   }
2121 
2122 // End: shared memory bookkeeping
2123 ////////////////////////////////////////////////////////////////////////////////////////////////////
2124 
2125 int os::vm_page_size() {
2126   // Seems redundant as all get out
2127   assert(os::Aix::page_size() != -1, "must call os::init");
2128   return os::Aix::page_size();
2129 }
2130 
2131 // Aix allocates memory by pages.
2132 int os::vm_allocation_granularity() {
2133   assert(os::Aix::page_size() != -1, "must call os::init");
2134   return os::Aix::page_size();
2135 }
2136 
2137 int os::Aix::commit_memory_impl(char* addr, size_t size, bool exec) {
2138 
2139   // Commit is a noop. There is no explicit commit
2140   // needed on AIX. Memory is committed when touched.
2141   //
2142   // Debug : check address range for validity
2143 #ifdef ASSERT
2144   LOCK_SHMBK
2145     ShmBkBlock* const block = shmbk_find_by_containing_address(addr);
2146     if (!block) {
2147       fprintf(stderr, "invalid pointer: " INTPTR_FORMAT "\n", addr);
2148       shmbk_dump_info();
2149       assert(false, "invalid pointer");
2150       return false;
2151     } else if (!block->containsRange(addr, size)) {
2152       fprintf(stderr, "invalid range: " INTPTR_FORMAT " .. " INTPTR_FORMAT "\n", addr, addr + size);
2153       shmbk_dump_info();
2154       assert(false, "invalid range");
2155       return false;
2156     }
2157   UNLOCK_SHMBK
2158 #endif // ASSERT
2159 
2160   return 0;
2161 }
2162 
2163 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
2164   return os::Aix::commit_memory_impl(addr, size, exec) == 0;
2165 }
2166 
2167 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
2168                                   const char* mesg) {
2169   assert(mesg != NULL, "mesg must be specified");
2170   os::Aix::commit_memory_impl(addr, size, exec);
2171 }
2172 
2173 int os::Aix::commit_memory_impl(char* addr, size_t size,
2174                                 size_t alignment_hint, bool exec) {
2175   return os::Aix::commit_memory_impl(addr, size, exec);
2176 }
2177 
2178 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
2179                           bool exec) {
2180   return os::Aix::commit_memory_impl(addr, size, alignment_hint, exec) == 0;
2181 }
2182 
2183 void os::pd_commit_memory_or_exit(char* addr, size_t size,
2184                                   size_t alignment_hint, bool exec,
2185                                   const char* mesg) {
2186   os::Aix::commit_memory_impl(addr, size, alignment_hint, exec);
2187 }
2188 
2189 bool os::pd_uncommit_memory(char* addr, size_t size) {
2190 
2191   // Delegate to ShmBkBlock class which knows how to uncommit its memory.
2192 
2193   bool rc = false;
2194   LOCK_SHMBK
2195     ShmBkBlock* const block = shmbk_find_by_containing_address(addr);
2196     if (!block) {
2197       fprintf(stderr, "invalid pointer: 0x%p.\n", addr);
2198       shmbk_dump_info();
2199       assert(false, "invalid pointer");
2200       return false;
2201     } else if (!block->containsRange(addr, size)) {
2202       fprintf(stderr, "invalid range: 0x%p .. 0x%p.\n", addr, addr + size);
2203       shmbk_dump_info();
2204       assert(false, "invalid range");
2205       return false;
2206     }
2207     rc = block->disclaim(addr, size);
2208   UNLOCK_SHMBK
2209 
2210   if (Verbose && !rc) {
2211     warning("failed to disclaim 0x%p .. 0x%p (0x%llX bytes).", addr, addr + size, size);
2212   }
2213   return rc;
2214 }
2215 
2216 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
2217   return os::guard_memory(addr, size);
2218 }
2219 
2220 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2221   return os::unguard_memory(addr, size);
2222 }
2223 
2224 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2225 }
2226 
2227 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
2228 }
2229 
2230 void os::numa_make_global(char *addr, size_t bytes) {
2231 }
2232 
2233 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2234 }
2235 
2236 bool os::numa_topology_changed() {
2237   return false;
2238 }
2239 
2240 size_t os::numa_get_groups_num() {
2241   return 1;
2242 }
2243 
2244 int os::numa_get_group_id() {
2245   return 0;
2246 }
2247 
2248 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2249   if (size > 0) {
2250     ids[0] = 0;
2251     return 1;
2252   }
2253   return 0;
2254 }
2255 
2256 bool os::get_page_info(char *start, page_info* info) {
2257   return false;
2258 }
2259 
2260 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2261   return end;
2262 }
2263 
2264 // Flags for reserve_shmatted_memory:
2265 #define RESSHM_WISHADDR_OR_FAIL                     1
2266 #define RESSHM_TRY_16M_PAGES                        2
2267 #define RESSHM_16M_PAGES_OR_FAIL                    4
2268 
2269 // Result of reserve_shmatted_memory:
2270 struct shmatted_memory_info_t {
2271   char* addr;
2272   size_t pagesize;
2273   bool pinned;
2274 };
2275 
2276 // Reserve a section of shmatted memory.
2277 // params:
2278 // bytes [in]: size of memory, in bytes
2279 // requested_addr [in]: wish address.
2280 //                      NULL = no wish.
2281 //                      If RESSHM_WISHADDR_OR_FAIL is set in flags and wish address cannot
2282 //                      be obtained, function will fail. Otherwise wish address is treated as hint and
2283 //                      another pointer is returned.
2284 // flags [in]:          some flags. Valid flags are:
2285 //                      RESSHM_WISHADDR_OR_FAIL - fail if wish address is given and cannot be obtained.
2286 //                      RESSHM_TRY_16M_PAGES - try to allocate from 16M page pool
2287 //                          (requires UseLargePages and Use16MPages)
2288 //                      RESSHM_16M_PAGES_OR_FAIL - if you cannot allocate from 16M page pool, fail.
2289 //                          Otherwise any other page size will do.
2290 // p_info [out] :       holds information about the created shared memory segment.
2291 static bool reserve_shmatted_memory(size_t bytes, char* requested_addr, int flags, shmatted_memory_info_t* p_info) {
2292 
2293   assert(p_info, "parameter error");
2294 
2295   // init output struct.
2296   p_info->addr = NULL;
2297 
2298   // neither should we be here for EXTSHM=ON.
2299   if (os::Aix::extshm()) {
2300     ShouldNotReachHere();
2301   }
2302 
2303   // extract flags. sanity checks.
2304   const bool wishaddr_or_fail =
2305     flags & RESSHM_WISHADDR_OR_FAIL;
2306   const bool try_16M_pages =
2307     flags & RESSHM_TRY_16M_PAGES;
2308   const bool f16M_pages_or_fail =
2309     flags & RESSHM_16M_PAGES_OR_FAIL;
2310 
2311   // first check: if a wish address is given and it is mandatory, but not aligned to segment boundary,
2312   // shmat will fail anyway, so save some cycles by failing right away
2313   if (requested_addr && ((uintptr_t)requested_addr % SIZE_256M == 0)) {
2314     if (wishaddr_or_fail) {
2315       return false;
2316     } else {
2317       requested_addr = NULL;
2318     }
2319   }
2320 
2321   char* addr = NULL;
2322 
2323   // Align size of shm up to the largest possible page size, to avoid errors later on when we try to change
2324   // pagesize dynamically.
2325   const size_t size = align_size_up(bytes, SIZE_16M);
2326 
2327   // reserve the shared segment
2328   int shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | S_IRUSR | S_IWUSR);
2329   if (shmid == -1) {
2330     warning("shmget(.., %lld, ..) failed (errno: %d).", size, errno);
2331     return false;
2332   }
2333 
2334   // Important note:
2335   // It is very important that we, upon leaving this function, do not leave a shm segment alive.
2336   // We must right after attaching it remove it from the system. System V shm segments are global and
2337   // survive the process.
2338   // So, from here on: Do not assert. Do not return. Always do a "goto cleanup_shm".
2339 
2340   // try forcing the page size
2341   size_t pagesize = -1; // unknown so far
2342 
2343   if (UseLargePages) {
2344 
2345     struct shmid_ds shmbuf;
2346     memset(&shmbuf, 0, sizeof(shmbuf));
2347 
2348     // First, try to take from 16M page pool if...
2349     if (os::Aix::can_use_16M_pages()  // we can ...
2350         && Use16MPages                // we are not explicitly forbidden to do so (-XX:-Use16MPages)..
2351         && try_16M_pages) {           // caller wants us to.
2352       shmbuf.shm_pagesize = SIZE_16M;
2353       if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) == 0) {
2354         pagesize = SIZE_16M;
2355       } else {
2356         warning("Failed to allocate %d 16M pages. 16M page pool might be exhausted. (shmctl failed with %d)",
2357                 size / SIZE_16M, errno);
2358         if (f16M_pages_or_fail) {
2359           goto cleanup_shm;
2360         }
2361       }
2362     }
2363 
2364     // Nothing yet? Try setting 64K pages. Note that I never saw this fail, but in theory it might,
2365     // because the 64K page pool may also be exhausted.
2366     if (pagesize == -1) {
2367       shmbuf.shm_pagesize = SIZE_64K;
2368       if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) == 0) {
2369         pagesize = SIZE_64K;
2370       } else {
2371         warning("Failed to allocate %d 64K pages. (shmctl failed with %d)",
2372                 size / SIZE_64K, errno);
2373         // here I give up. leave page_size -1 - later, after attaching, we will query the
2374         // real page size of the attached memory. (in theory, it may be something different
2375         // from 4K if LDR_CNTRL SHM_PSIZE is set)
2376       }
2377     }
2378   }
2379 
2380   // sanity point
2381   assert(pagesize == -1 || pagesize == SIZE_16M || pagesize == SIZE_64K, "wrong page size");
2382 
2383   // Now attach the shared segment.
2384   addr = (char*) shmat(shmid, requested_addr, 0);
2385   if (addr == (char*)-1) {
2386     // How to handle attach failure:
2387     // If it failed for a specific wish address, tolerate this: in that case, if wish address was
2388     // mandatory, fail, if not, retry anywhere.
2389     // If it failed for any other reason, treat that as fatal error.
2390     addr = NULL;
2391     if (requested_addr) {
2392       if (wishaddr_or_fail) {
2393         goto cleanup_shm;
2394       } else {
2395         addr = (char*) shmat(shmid, NULL, 0);
2396         if (addr == (char*)-1) { // fatal
2397           addr = NULL;
2398           warning("shmat failed (errno: %d)", errno);
2399           goto cleanup_shm;
2400         }
2401       }
2402     } else { // fatal
2403       addr = NULL;
2404       warning("shmat failed (errno: %d)", errno);
2405       goto cleanup_shm;
2406     }
2407   }
2408 
2409   // sanity point
2410   assert(addr && addr != (char*) -1, "wrong address");
2411 
2412   // after successful Attach remove the segment - right away.
2413   if (::shmctl(shmid, IPC_RMID, NULL) == -1) {
2414     warning("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);
2415     guarantee(false, "failed to remove shared memory segment!");
2416   }
2417   shmid = -1;
2418 
2419   // query the real page size. In case setting the page size did not work (see above), the system
2420   // may have given us something other then 4K (LDR_CNTRL)
2421   {
2422     const size_t real_pagesize = os::Aix::query_pagesize(addr);
2423     if (pagesize != -1) {
2424       assert(pagesize == real_pagesize, "unexpected pagesize after shmat");
2425     } else {
2426       pagesize = real_pagesize;
2427     }
2428   }
2429 
2430   // Now register the reserved block with internal book keeping.
2431   LOCK_SHMBK
2432     const bool pinned = pagesize >= SIZE_16M ? true : false;
2433     ShmBkShmatedBlock* const p_block = new ShmBkShmatedBlock(AddrRange(addr, size), pagesize, pinned);
2434     assert(p_block, "");
2435     shmbk_register(p_block);
2436   UNLOCK_SHMBK
2437 
2438 cleanup_shm:
2439 
2440   // if we have not done so yet, remove the shared memory segment. This is very important.
2441   if (shmid != -1) {
2442     if (::shmctl(shmid, IPC_RMID, NULL) == -1) {
2443       warning("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);
2444       guarantee(false, "failed to remove shared memory segment!");
2445     }
2446     shmid = -1;
2447   }
2448 
2449   // trace
2450   if (Verbose && !addr) {
2451     if (requested_addr != NULL) {
2452       warning("failed to shm-allocate 0x%llX bytes at wish address 0x%p.", size, requested_addr);
2453     } else {
2454       warning("failed to shm-allocate 0x%llX bytes at any address.", size);
2455     }
2456   }
2457 
2458   // hand info to caller
2459   if (addr) {
2460     p_info->addr = addr;
2461     p_info->pagesize = pagesize;
2462     p_info->pinned = pagesize == SIZE_16M ? true : false;
2463   }
2464 
2465   // sanity test:
2466   if (requested_addr && addr && wishaddr_or_fail) {
2467     guarantee(addr == requested_addr, "shmat error");
2468   }
2469 
2470   // just one more test to really make sure we have no dangling shm segments.
2471   guarantee(shmid == -1, "dangling shm segments");
2472 
2473   return addr ? true : false;
2474 
2475 } // end: reserve_shmatted_memory
2476 
2477 // Reserve memory using mmap. Behaves the same as reserve_shmatted_memory():
2478 // will return NULL in case of an error.
2479 static char* reserve_mmaped_memory(size_t bytes, char* requested_addr) {
2480 
2481   // if a wish address is given, but not aligned to 4K page boundary, mmap will fail.
2482   if (requested_addr && ((uintptr_t)requested_addr % os::vm_page_size() != 0)) {
2483     warning("Wish address 0x%p not aligned to page boundary.", requested_addr);
2484     return NULL;
2485   }
2486 
2487   const size_t size = align_size_up(bytes, SIZE_4K);
2488 
2489   // Note: MAP_SHARED (instead of MAP_PRIVATE) needed to be able to
2490   // msync(MS_INVALIDATE) (see os::uncommit_memory)
2491   int flags = MAP_ANONYMOUS | MAP_SHARED;
2492 
2493   // MAP_FIXED is needed to enforce requested_addr - manpage is vague about what
2494   // it means if wishaddress is given but MAP_FIXED is not set.
2495   //
2496   // Note however that this changes semantics in SPEC1170 mode insofar as MAP_FIXED
2497   // clobbers the address range, which is probably not what the caller wants. That's
2498   // why I assert here (again) that the SPEC1170 compat mode is off.
2499   // If we want to be able to run under SPEC1170, we have to do some porting and
2500   // testing.
2501   if (requested_addr != NULL) {
2502     assert(!os::Aix::xpg_sus_mode(), "SPEC1170 mode not allowed.");
2503     flags |= MAP_FIXED;
2504   }
2505 
2506   char* addr = (char*)::mmap(requested_addr, size, PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0);
2507 
2508   if (addr == MAP_FAILED) {
2509     // attach failed: tolerate for specific wish addresses. Not being able to attach
2510     // anywhere is a fatal error.
2511     if (requested_addr == NULL) {
2512       // It's ok to fail here if the machine has not enough memory.
2513       warning("mmap(NULL, 0x%llX, ..) failed (%d)", size, errno);
2514     }
2515     addr = NULL;
2516     goto cleanup_mmap;
2517   }
2518 
2519   // If we did request a specific address and that address was not available, fail.
2520   if (addr && requested_addr) {
2521     guarantee(addr == requested_addr, "unexpected");
2522   }
2523 
2524   // register this mmap'ed segment with book keeping
2525   LOCK_SHMBK
2526     ShmBkMappedBlock* const p_block = new ShmBkMappedBlock(AddrRange(addr, size));
2527     assert(p_block, "");
2528     shmbk_register(p_block);
2529   UNLOCK_SHMBK
2530 
2531 cleanup_mmap:
2532 
2533   // trace
2534   if (Verbose) {
2535     if (addr) {
2536       fprintf(stderr, "mmap-allocated 0x%p .. 0x%p (0x%llX bytes)\n", addr, addr + bytes, bytes);
2537     }
2538     else {
2539       if (requested_addr != NULL) {
2540         warning("failed to mmap-allocate 0x%llX bytes at wish address 0x%p.", bytes, requested_addr);
2541       } else {
2542         warning("failed to mmap-allocate 0x%llX bytes at any address.", bytes);
2543       }
2544     }
2545   }
2546 
2547   return addr;
2548 
2549 } // end: reserve_mmaped_memory
2550 
2551 // Reserves and attaches a shared memory segment.
2552 // Will assert if a wish address is given and could not be obtained.
2553 char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2554   return os::attempt_reserve_memory_at(bytes, requested_addr);
2555 }
2556 
2557 bool os::pd_release_memory(char* addr, size_t size) {
2558 
2559   // delegate to ShmBkBlock class which knows how to uncommit its memory.
2560 
2561   bool rc = false;
2562   LOCK_SHMBK
2563     ShmBkBlock* const block = shmbk_find_by_containing_address(addr);
2564     if (!block) {
2565       fprintf(stderr, "invalid pointer: 0x%p.\n", addr);
2566       shmbk_dump_info();
2567       assert(false, "invalid pointer");
2568       return false;
2569     }
2570     else if (!block->isSameRange(addr, size)) {
2571       if (block->getType() == ShmBkBlock::MMAP) {
2572         // Release only the same range or a the beginning or the end of a range.
2573         if (block->base() == addr && size < block->size()) {
2574           ShmBkMappedBlock* const b = new ShmBkMappedBlock(AddrRange(block->base() + size, block->size() - size));
2575           assert(b, "");
2576           shmbk_register(b);
2577           block->setAddrRange(AddrRange(addr, size));
2578         }
2579         else if (addr > block->base() && addr + size == block->base() + block->size()) {
2580           ShmBkMappedBlock* const b = new ShmBkMappedBlock(AddrRange(block->base(), block->size() - size));
2581           assert(b, "");
2582           shmbk_register(b);
2583           block->setAddrRange(AddrRange(addr, size));
2584         }
2585         else {
2586           fprintf(stderr, "invalid mmap range: 0x%p .. 0x%p.\n", addr, addr + size);
2587           shmbk_dump_info();
2588           assert(false, "invalid mmap range");
2589           return false;
2590         }
2591       }
2592       else {
2593         // Release only the same range. No partial release allowed.
2594         // Soften the requirement a bit, because the user may think he owns a smaller size
2595         // than the block is due to alignment etc.
2596         if (block->base() != addr || block->size() < size) {
2597           fprintf(stderr, "invalid shmget range: 0x%p .. 0x%p.\n", addr, addr + size);
2598           shmbk_dump_info();
2599           assert(false, "invalid shmget range");
2600           return false;
2601         }
2602       }
2603     }
2604     rc = block->release();
2605     assert(rc, "release failed");
2606     // remove block from bookkeeping
2607     shmbk_unregister(block);
2608     delete block;
2609   UNLOCK_SHMBK
2610 
2611   if (!rc) {
2612     warning("failed to released %lu bytes at 0x%p", size, addr);
2613   }
2614 
2615   return rc;
2616 }
2617 
2618 static bool checked_mprotect(char* addr, size_t size, int prot) {
2619 
2620   // Little problem here: if SPEC1170 behaviour is off, mprotect() on AIX will
2621   // not tell me if protection failed when trying to protect an un-protectable range.
2622   //
2623   // This means if the memory was allocated using shmget/shmat, protection wont work
2624   // but mprotect will still return 0:
2625   //
2626   // See http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/mprotect.htm
2627 
2628   bool rc = ::mprotect(addr, size, prot) == 0 ? true : false;
2629 
2630   if (!rc) {
2631     const char* const s_errno = strerror(errno);
2632     warning("mprotect(" PTR_FORMAT "-" PTR_FORMAT ", 0x%X) failed (%s).", addr, addr + size, prot, s_errno);
2633     return false;
2634   }
2635 
2636   // mprotect success check
2637   //
2638   // Mprotect said it changed the protection but can I believe it?
2639   //
2640   // To be sure I need to check the protection afterwards. Try to
2641   // read from protected memory and check whether that causes a segfault.
2642   //
2643   if (!os::Aix::xpg_sus_mode()) {
2644 
2645     if (StubRoutines::SafeFetch32_stub()) {
2646 
2647       const bool read_protected =
2648         (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&
2649          SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;
2650 
2651       if (prot & PROT_READ) {
2652         rc = !read_protected;
2653       } else {
2654         rc = read_protected;
2655       }
2656     }
2657   }
2658   if (!rc) {
2659     assert(false, "mprotect failed.");
2660   }
2661   return rc;
2662 }
2663 
2664 // Set protections specified
2665 bool os::protect_memory(char* addr, size_t size, ProtType prot, bool is_committed) {
2666   unsigned int p = 0;
2667   switch (prot) {
2668   case MEM_PROT_NONE: p = PROT_NONE; break;
2669   case MEM_PROT_READ: p = PROT_READ; break;
2670   case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;
2671   case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
2672   default:
2673     ShouldNotReachHere();
2674   }
2675   // is_committed is unused.
2676   return checked_mprotect(addr, size, p);
2677 }
2678 
2679 bool os::guard_memory(char* addr, size_t size) {
2680   return checked_mprotect(addr, size, PROT_NONE);
2681 }
2682 
2683 bool os::unguard_memory(char* addr, size_t size) {
2684   return checked_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC);
2685 }
2686 
2687 // Large page support
2688 
2689 static size_t _large_page_size = 0;
2690 
2691 // Enable large page support if OS allows that.
2692 void os::large_page_init() {
2693 
2694   // Note: os::Aix::query_multipage_support must run first.
2695 
2696   if (!UseLargePages) {
2697     return;
2698   }
2699 
2700   if (!Aix::can_use_64K_pages()) {
2701     assert(!Aix::can_use_16M_pages(), "64K is a precondition for 16M.");
2702     UseLargePages = false;
2703     return;
2704   }
2705 
2706   if (!Aix::can_use_16M_pages() && Use16MPages) {
2707     fprintf(stderr, "Cannot use 16M pages. Please ensure that there is a 16M page pool "
2708             " and that the VM runs with CAP_BYPASS_RAC_VMM and CAP_PROPAGATE capabilities.\n");
2709   }
2710 
2711   // Do not report 16M page alignment as part of os::_page_sizes if we are
2712   // explicitly forbidden from using 16M pages. Doing so would increase the
2713   // alignment the garbage collector calculates with, slightly increasing
2714   // heap usage. We should only pay for 16M alignment if we really want to
2715   // use 16M pages.
2716   if (Use16MPages && Aix::can_use_16M_pages()) {
2717     _large_page_size = SIZE_16M;
2718     _page_sizes[0] = SIZE_16M;
2719     _page_sizes[1] = SIZE_64K;
2720     _page_sizes[2] = SIZE_4K;
2721     _page_sizes[3] = 0;
2722   } else if (Aix::can_use_64K_pages()) {
2723     _large_page_size = SIZE_64K;
2724     _page_sizes[0] = SIZE_64K;
2725     _page_sizes[1] = SIZE_4K;
2726     _page_sizes[2] = 0;
2727   }
2728 
2729   if (Verbose) {
2730     ("Default large page size is 0x%llX.", _large_page_size);
2731   }
2732 } // end: os::large_page_init()
2733 
2734 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
2735   // "exec" is passed in but not used. Creating the shared image for
2736   // the code cache doesn't have an SHM_X executable permission to check.
2737   Unimplemented();
2738   return 0;
2739 }
2740 
2741 bool os::release_memory_special(char* base, size_t bytes) {
2742   // detaching the SHM segment will also delete it, see reserve_memory_special()
2743   Unimplemented();
2744   return false;
2745 }
2746 
2747 size_t os::large_page_size() {
2748   return _large_page_size;
2749 }
2750 
2751 bool os::can_commit_large_page_memory() {
2752   // Well, sadly we cannot commit anything at all (see comment in
2753   // os::commit_memory) but we claim to so we can make use of large pages
2754   return true;
2755 }
2756 
2757 bool os::can_execute_large_page_memory() {
2758   // We can do that
2759   return true;
2760 }
2761 
2762 // Reserve memory at an arbitrary address, only if that area is
2763 // available (and not reserved for something else).
2764 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2765 
2766   bool use_mmap = false;
2767 
2768   // mmap: smaller graining, no large page support
2769   // shm: large graining (256M), large page support, limited number of shm segments
2770   //
2771   // Prefer mmap wherever we either do not need large page support or have OS limits
2772 
2773   if (!UseLargePages || bytes < SIZE_16M) {
2774     use_mmap = true;
2775   }
2776 
2777   char* addr = NULL;
2778   if (use_mmap) {
2779     addr = reserve_mmaped_memory(bytes, requested_addr);
2780   } else {
2781     // shmat: wish address is mandatory, and do not try 16M pages here.
2782     shmatted_memory_info_t info;
2783     const int flags = RESSHM_WISHADDR_OR_FAIL;
2784     if (reserve_shmatted_memory(bytes, requested_addr, flags, &info)) {
2785       addr = info.addr;
2786     }
2787   }
2788 
2789   return addr;
2790 }
2791 
2792 size_t os::read(int fd, void *buf, unsigned int nBytes) {
2793   return ::read(fd, buf, nBytes);




2794 }
2795 
2796 #define NANOSECS_PER_MILLISEC 1000000
2797 
2798 int os::sleep(Thread* thread, jlong millis, bool interruptible) {
2799   assert(thread == Thread::current(), "thread consistency check");
2800 
2801   // Prevent nasty overflow in deadline calculation
2802   // by handling long sleeps similar to solaris or windows.
2803   const jlong limit = INT_MAX;
2804   int result;
2805   while (millis > limit) {
2806     if ((result = os::sleep(thread, limit, interruptible)) != OS_OK) {
2807       return result;
2808     }
2809     millis -= limit;
2810   }
2811 
2812   ParkEvent * const slp = thread->_SleepEvent;
2813   slp->reset();
2814   OrderAccess::fence();
2815 
2816   if (interruptible) {
2817     jlong prevtime = javaTimeNanos();
2818 
2819     // Prevent precision loss and too long sleeps
2820     jlong deadline = prevtime + millis * NANOSECS_PER_MILLISEC;
2821 
2822     for (;;) {
2823       if (os::is_interrupted(thread, true)) {
2824         return OS_INTRPT;
2825       }
2826 
2827       jlong newtime = javaTimeNanos();
2828 
2829       assert(newtime >= prevtime, "time moving backwards");
2830       // Doing prevtime and newtime in microseconds doesn't help precision,
2831       // and trying to round up to avoid lost milliseconds can result in a
2832       // too-short delay.
2833       millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
2834 
2835       if (millis <= 0) {
2836         return OS_OK;
2837       }
2838 
2839       // Stop sleeping if we passed the deadline
2840       if (newtime >= deadline) {
2841         return OS_OK;
2842       }
2843 
2844       prevtime = newtime;
2845 
2846       {
2847         assert(thread->is_Java_thread(), "sanity check");
2848         JavaThread *jt = (JavaThread *) thread;
2849         ThreadBlockInVM tbivm(jt);
2850         OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
2851 
2852         jt->set_suspend_equivalent();
2853 
2854         slp->park(millis);
2855 
2856         // were we externally suspended while we were waiting?
2857         jt->check_and_wait_while_suspended();
2858       }
2859     }
2860   } else {
2861     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
2862     jlong prevtime = javaTimeNanos();
2863 
2864     // Prevent precision loss and too long sleeps
2865     jlong deadline = prevtime + millis * NANOSECS_PER_MILLISEC;
2866 
2867     for (;;) {
2868       // It'd be nice to avoid the back-to-back javaTimeNanos() calls on
2869       // the 1st iteration ...
2870       jlong newtime = javaTimeNanos();
2871 
2872       if (newtime - prevtime < 0) {
2873         // time moving backwards, should only happen if no monotonic clock
2874         // not a guarantee() because JVM should not abort on kernel/glibc bugs
2875         // - HS14 Commented out as not implemented.
2876         // - TODO Maybe we should implement it?
2877         //assert(!Aix::supports_monotonic_clock(), "time moving backwards");
2878       } else {
2879         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
2880       }
2881 
2882       if (millis <= 0) break;
2883 
2884       if (newtime >= deadline) {
2885         break;
2886       }
2887 
2888       prevtime = newtime;
2889       slp->park(millis);
2890     }
2891     return OS_OK;
2892   }
2893 }
2894 
2895 void os::naked_short_sleep(jlong ms) {
2896   struct timespec req;
2897 
2898   assert(ms < 1000, "Un-interruptable sleep, short time use only");
2899   req.tv_sec = 0;
2900   if (ms > 0) {
2901     req.tv_nsec = (ms % 1000) * 1000000;
2902   }
2903   else {
2904     req.tv_nsec = 1;
2905   }
2906 
2907   nanosleep(&req, NULL);
2908 
2909   return;
2910 }
2911 
2912 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
2913 void os::infinite_sleep() {
2914   while (true) {    // sleep forever ...
2915     ::sleep(100);   // ... 100 seconds at a time
2916   }
2917 }
2918 
2919 // Used to convert frequent JVM_Yield() to nops
2920 bool os::dont_yield() {
2921   return DontYieldALot;
2922 }
2923 
2924 void os::yield() {
2925   sched_yield();
2926 }
2927 
2928 os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN; }
2929 
2930 void os::yield_all(int attempts) {
2931   // Yields to all threads, including threads with lower priorities
2932   // Threads on Linux are all with same priority. The Solaris style
2933   // os::yield_all() with nanosleep(1ms) is not necessary.
2934   sched_yield();
2935 }
2936 
2937 // Called from the tight loops to possibly influence time-sharing heuristics
2938 void os::loop_breaker(int attempts) {
2939   os::yield_all(attempts);
2940 }
2941 
2942 ////////////////////////////////////////////////////////////////////////////////
2943 // thread priority support
2944 
2945 // From AIX manpage to pthread_setschedparam
2946 // (see: http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?
2947 //    topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_setschedparam.htm):
2948 //
2949 // "If schedpolicy is SCHED_OTHER, then sched_priority must be in the
2950 // range from 40 to 80, where 40 is the least favored priority and 80
2951 // is the most favored."
2952 //
2953 // (Actually, I doubt this even has an impact on AIX, as we do kernel
2954 // scheduling there; however, this still leaves iSeries.)
2955 //
2956 // We use the same values for AIX and PASE.
2957 int os::java_to_os_priority[CriticalPriority + 1] = {
2958   54,             // 0 Entry should never be used
2959 
2960   55,             // 1 MinPriority
2961   55,             // 2
2962   56,             // 3
2963 
2964   56,             // 4
2965   57,             // 5 NormPriority
2966   57,             // 6
2967 
2968   58,             // 7
2969   58,             // 8
2970   59,             // 9 NearMaxPriority
2971 
2972   60,             // 10 MaxPriority
2973 
2974   60              // 11 CriticalPriority
2975 };
2976 
2977 OSReturn os::set_native_priority(Thread* thread, int newpri) {
2978   if (!UseThreadPriorities) return OS_OK;
2979   pthread_t thr = thread->osthread()->pthread_id();
2980   int policy = SCHED_OTHER;
2981   struct sched_param param;
2982   param.sched_priority = newpri;
2983   int ret = pthread_setschedparam(thr, policy, &param);
2984 
2985   if (ret != 0) {
2986     trcVerbose("Could not change priority for thread %d to %d (error %d, %s)",
2987         (int)thr, newpri, ret, strerror(ret));
2988   }
2989   return (ret == 0) ? OS_OK : OS_ERR;
2990 }
2991 
2992 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
2993   if (!UseThreadPriorities) {
2994     *priority_ptr = java_to_os_priority[NormPriority];
2995     return OS_OK;
2996   }
2997   pthread_t thr = thread->osthread()->pthread_id();
2998   int policy = SCHED_OTHER;
2999   struct sched_param param;
3000   int ret = pthread_getschedparam(thr, &policy, &param);
3001   *priority_ptr = param.sched_priority;
3002 
3003   return (ret == 0) ? OS_OK : OS_ERR;
3004 }
3005 
3006 // Hint to the underlying OS that a task switch would not be good.
3007 // Void return because it's a hint and can fail.
3008 void os::hint_no_preempt() {}
3009 
3010 ////////////////////////////////////////////////////////////////////////////////
3011 // suspend/resume support
3012 
3013 //  the low-level signal-based suspend/resume support is a remnant from the
3014 //  old VM-suspension that used to be for java-suspension, safepoints etc,
3015 //  within hotspot. Now there is a single use-case for this:
3016 //    - calling get_thread_pc() on the VMThread by the flat-profiler task
3017 //      that runs in the watcher thread.
3018 //  The remaining code is greatly simplified from the more general suspension
3019 //  code that used to be used.
3020 //
3021 //  The protocol is quite simple:
3022 //  - suspend:
3023 //      - sends a signal to the target thread
3024 //      - polls the suspend state of the osthread using a yield loop
3025 //      - target thread signal handler (SR_handler) sets suspend state
3026 //        and blocks in sigsuspend until continued
3027 //  - resume:
3028 //      - sets target osthread state to continue
3029 //      - sends signal to end the sigsuspend loop in the SR_handler
3030 //
3031 //  Note that the SR_lock plays no role in this suspend/resume protocol.
3032 //
3033 
3034 static void resume_clear_context(OSThread *osthread) {
3035   osthread->set_ucontext(NULL);
3036   osthread->set_siginfo(NULL);
3037 }
3038 
3039 static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
3040   osthread->set_ucontext(context);
3041   osthread->set_siginfo(siginfo);
3042 }
3043 
3044 //
3045 // Handler function invoked when a thread's execution is suspended or
3046 // resumed. We have to be careful that only async-safe functions are
3047 // called here (Note: most pthread functions are not async safe and
3048 // should be avoided.)
3049 //
3050 // Note: sigwait() is a more natural fit than sigsuspend() from an
3051 // interface point of view, but sigwait() prevents the signal hander
3052 // from being run. libpthread would get very confused by not having
3053 // its signal handlers run and prevents sigwait()'s use with the
3054 // mutex granting granting signal.
3055 //
3056 // Currently only ever called on the VMThread and JavaThreads (PC sampling).
3057 //
3058 static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) {
3059   // Save and restore errno to avoid confusing native code with EINTR
3060   // after sigsuspend.
3061   int old_errno = errno;
3062 
3063   Thread* thread = Thread::current();
3064   OSThread* osthread = thread->osthread();
3065   assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread");
3066 
3067   os::SuspendResume::State current = osthread->sr.state();
3068   if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
3069     suspend_save_context(osthread, siginfo, context);
3070 
3071     // attempt to switch the state, we assume we had a SUSPEND_REQUEST
3072     os::SuspendResume::State state = osthread->sr.suspended();
3073     if (state == os::SuspendResume::SR_SUSPENDED) {
3074       sigset_t suspend_set;  // signals for sigsuspend()
3075 
3076       // get current set of blocked signals and unblock resume signal
3077       pthread_sigmask(SIG_BLOCK, NULL, &suspend_set);
3078       sigdelset(&suspend_set, SR_signum);
3079 
3080       // wait here until we are resumed
3081       while (1) {
3082         sigsuspend(&suspend_set);
3083 
3084         os::SuspendResume::State result = osthread->sr.running();
3085         if (result == os::SuspendResume::SR_RUNNING) {
3086           break;
3087         }
3088       }
3089 
3090     } else if (state == os::SuspendResume::SR_RUNNING) {
3091       // request was cancelled, continue
3092     } else {
3093       ShouldNotReachHere();
3094     }
3095 
3096     resume_clear_context(osthread);
3097   } else if (current == os::SuspendResume::SR_RUNNING) {
3098     // request was cancelled, continue
3099   } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
3100     // ignore
3101   } else {
3102     ShouldNotReachHere();
3103   }
3104 
3105   errno = old_errno;
3106 }
3107 
3108 static int SR_initialize() {
3109   struct sigaction act;
3110   char *s;
3111   // Get signal number to use for suspend/resume
3112   if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
3113     int sig = ::strtol(s, 0, 10);
3114     if (sig > 0 || sig < NSIG) {
3115       SR_signum = sig;
3116     }
3117   }
3118 
3119   assert(SR_signum > SIGSEGV && SR_signum > SIGBUS,
3120         "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
3121 
3122   sigemptyset(&SR_sigset);
3123   sigaddset(&SR_sigset, SR_signum);
3124 
3125   // Set up signal handler for suspend/resume.
3126   act.sa_flags = SA_RESTART|SA_SIGINFO;
3127   act.sa_handler = (void (*)(int)) SR_handler;
3128 
3129   // SR_signum is blocked by default.
3130   // 4528190 - We also need to block pthread restart signal (32 on all
3131   // supported Linux platforms). Note that LinuxThreads need to block
3132   // this signal for all threads to work properly. So we don't have
3133   // to use hard-coded signal number when setting up the mask.
3134   pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask);
3135 
3136   if (sigaction(SR_signum, &act, 0) == -1) {
3137     return -1;
3138   }
3139 
3140   // Save signal flag
3141   os::Aix::set_our_sigflags(SR_signum, act.sa_flags);
3142   return 0;
3143 }
3144 
3145 static int SR_finalize() {
3146   return 0;
3147 }
3148 
3149 static int sr_notify(OSThread* osthread) {
3150   int status = pthread_kill(osthread->pthread_id(), SR_signum);
3151   assert_status(status == 0, status, "pthread_kill");
3152   return status;
3153 }
3154 
3155 // "Randomly" selected value for how long we want to spin
3156 // before bailing out on suspending a thread, also how often
3157 // we send a signal to a thread we want to resume
3158 static const int RANDOMLY_LARGE_INTEGER = 1000000;
3159 static const int RANDOMLY_LARGE_INTEGER2 = 100;
3160 
3161 // returns true on success and false on error - really an error is fatal
3162 // but this seems the normal response to library errors
3163 static bool do_suspend(OSThread* osthread) {
3164   assert(osthread->sr.is_running(), "thread should be running");
3165   // mark as suspended and send signal
3166 
3167   if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
3168     // failed to switch, state wasn't running?
3169     ShouldNotReachHere();
3170     return false;
3171   }
3172 
3173   if (sr_notify(osthread) != 0) {
3174     // try to cancel, switch to running
3175 
3176     os::SuspendResume::State result = osthread->sr.cancel_suspend();
3177     if (result == os::SuspendResume::SR_RUNNING) {
3178       // cancelled
3179       return false;
3180     } else if (result == os::SuspendResume::SR_SUSPENDED) {
3181       // somehow managed to suspend
3182       return true;
3183     } else {
3184       ShouldNotReachHere();
3185       return false;
3186     }
3187   }
3188 
3189   // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED
3190 
3191   for (int n = 0; !osthread->sr.is_suspended(); n++) {
3192     for (int i = 0; i < RANDOMLY_LARGE_INTEGER2 && !osthread->sr.is_suspended(); i++) {
3193       os::yield_all(i);
3194     }
3195 
3196     // timeout, try to cancel the request
3197     if (n >= RANDOMLY_LARGE_INTEGER) {
3198       os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
3199       if (cancelled == os::SuspendResume::SR_RUNNING) {
3200         return false;
3201       } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
3202         return true;
3203       } else {
3204         ShouldNotReachHere();
3205         return false;
3206       }
3207     }
3208   }
3209 
3210   guarantee(osthread->sr.is_suspended(), "Must be suspended");
3211   return true;
3212 }
3213 
3214 static void do_resume(OSThread* osthread) {
3215   //assert(osthread->sr.is_suspended(), "thread should be suspended");
3216 
3217   if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
3218     // failed to switch to WAKEUP_REQUEST
3219     ShouldNotReachHere();
3220     return;
3221   }
3222 
3223   while (!osthread->sr.is_running()) {
3224     if (sr_notify(osthread) == 0) {
3225       for (int n = 0; n < RANDOMLY_LARGE_INTEGER && !osthread->sr.is_running(); n++) {
3226         for (int i = 0; i < 100 && !osthread->sr.is_running(); i++) {
3227           os::yield_all(i);
3228         }
3229       }
3230     } else {
3231       ShouldNotReachHere();
3232     }
3233   }
3234 
3235   guarantee(osthread->sr.is_running(), "Must be running!");
3236 }
3237 
3238 ////////////////////////////////////////////////////////////////////////////////
3239 // interrupt support
3240 
3241 void os::interrupt(Thread* thread) {
3242   assert(Thread::current() == thread || Threads_lock->owned_by_self(),
3243     "possibility of dangling Thread pointer");
3244 
3245   OSThread* osthread = thread->osthread();
3246 
3247   if (!osthread->interrupted()) {
3248     osthread->set_interrupted(true);
3249     // More than one thread can get here with the same value of osthread,
3250     // resulting in multiple notifications.  We do, however, want the store
3251     // to interrupted() to be visible to other threads before we execute unpark().
3252     OrderAccess::fence();
3253     ParkEvent * const slp = thread->_SleepEvent;
3254     if (slp != NULL) slp->unpark();
3255   }
3256 
3257   // For JSR166. Unpark even if interrupt status already was set
3258   if (thread->is_Java_thread())
3259     ((JavaThread*)thread)->parker()->unpark();
3260 
3261   ParkEvent * ev = thread->_ParkEvent;
3262   if (ev != NULL) ev->unpark();
3263 
3264 }
3265 
3266 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3267   assert(Thread::current() == thread || Threads_lock->owned_by_self(),
3268     "possibility of dangling Thread pointer");
3269 
3270   OSThread* osthread = thread->osthread();
3271 
3272   bool interrupted = osthread->interrupted();
3273 
3274   if (interrupted && clear_interrupted) {
3275     osthread->set_interrupted(false);
3276     // consider thread->_SleepEvent->reset() ... optional optimization
3277   }
3278 
3279   return interrupted;
3280 }
3281 
3282 ///////////////////////////////////////////////////////////////////////////////////
3283 // signal handling (except suspend/resume)
3284 
3285 // This routine may be used by user applications as a "hook" to catch signals.
3286 // The user-defined signal handler must pass unrecognized signals to this
3287 // routine, and if it returns true (non-zero), then the signal handler must
3288 // return immediately. If the flag "abort_if_unrecognized" is true, then this
3289 // routine will never retun false (zero), but instead will execute a VM panic
3290 // routine kill the process.
3291 //
3292 // If this routine returns false, it is OK to call it again. This allows
3293 // the user-defined signal handler to perform checks either before or after
3294 // the VM performs its own checks. Naturally, the user code would be making
3295 // a serious error if it tried to handle an exception (such as a null check
3296 // or breakpoint) that the VM was generating for its own correct operation.
3297 //
3298 // This routine may recognize any of the following kinds of signals:
3299 //   SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1.
3300 // It should be consulted by handlers for any of those signals.
3301 //
3302 // The caller of this routine must pass in the three arguments supplied
3303 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
3304 // field of the structure passed to sigaction(). This routine assumes that
3305 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
3306 //
3307 // Note that the VM will print warnings if it detects conflicting signal
3308 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
3309 //
3310 extern "C" JNIEXPORT int
3311 JVM_handle_aix_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized);
3312 
3313 // Set thread signal mask (for some reason on AIX sigthreadmask() seems
3314 // to be the thing to call; documentation is not terribly clear about whether
3315 // pthread_sigmask also works, and if it does, whether it does the same.
3316 bool set_thread_signal_mask(int how, const sigset_t* set, sigset_t* oset) {
3317   const int rc = ::pthread_sigmask(how, set, oset);
3318   // return value semantics differ slightly for error case:
3319   // pthread_sigmask returns error number, sigthreadmask -1 and sets global errno
3320   // (so, pthread_sigmask is more theadsafe for error handling)
3321   // But success is always 0.
3322   return rc == 0 ? true : false;
3323 }
3324 
3325 // Function to unblock all signals which are, according
3326 // to POSIX, typical program error signals. If they happen while being blocked,
3327 // they typically will bring down the process immediately.
3328 bool unblock_program_error_signals() {
3329   sigset_t set;
3330   ::sigemptyset(&set);
3331   ::sigaddset(&set, SIGILL);
3332   ::sigaddset(&set, SIGBUS);
3333   ::sigaddset(&set, SIGFPE);
3334   ::sigaddset(&set, SIGSEGV);
3335   return set_thread_signal_mask(SIG_UNBLOCK, &set, NULL);
3336 }
3337 
3338 // Renamed from 'signalHandler' to avoid collision with other shared libs.
3339 void javaSignalHandler(int sig, siginfo_t* info, void* uc) {
3340   assert(info != NULL && uc != NULL, "it must be old kernel");
3341 
3342   // Never leave program error signals blocked;
3343   // on all our platforms they would bring down the process immediately when
3344   // getting raised while being blocked.
3345   unblock_program_error_signals();
3346 
3347   JVM_handle_aix_signal(sig, info, uc, true);
3348 }
3349 
3350 // This boolean allows users to forward their own non-matching signals
3351 // to JVM_handle_aix_signal, harmlessly.
3352 bool os::Aix::signal_handlers_are_installed = false;
3353 
3354 // For signal-chaining
3355 struct sigaction os::Aix::sigact[MAXSIGNUM];
3356 unsigned int os::Aix::sigs = 0;
3357 bool os::Aix::libjsig_is_loaded = false;
3358 typedef struct sigaction *(*get_signal_t)(int);
3359 get_signal_t os::Aix::get_signal_action = NULL;
3360 
3361 struct sigaction* os::Aix::get_chained_signal_action(int sig) {
3362   struct sigaction *actp = NULL;
3363 
3364   if (libjsig_is_loaded) {
3365     // Retrieve the old signal handler from libjsig
3366     actp = (*get_signal_action)(sig);
3367   }
3368   if (actp == NULL) {
3369     // Retrieve the preinstalled signal handler from jvm
3370     actp = get_preinstalled_handler(sig);
3371   }
3372 
3373   return actp;
3374 }
3375 
3376 static bool call_chained_handler(struct sigaction *actp, int sig,
3377                                  siginfo_t *siginfo, void *context) {
3378   // Call the old signal handler
3379   if (actp->sa_handler == SIG_DFL) {
3380     // It's more reasonable to let jvm treat it as an unexpected exception
3381     // instead of taking the default action.
3382     return false;
3383   } else if (actp->sa_handler != SIG_IGN) {
3384     if ((actp->sa_flags & SA_NODEFER) == 0) {
3385       // automaticlly block the signal
3386       sigaddset(&(actp->sa_mask), sig);
3387     }
3388 
3389     sa_handler_t hand = NULL;
3390     sa_sigaction_t sa = NULL;
3391     bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
3392     // retrieve the chained handler
3393     if (siginfo_flag_set) {
3394       sa = actp->sa_sigaction;
3395     } else {
3396       hand = actp->sa_handler;
3397     }
3398 
3399     if ((actp->sa_flags & SA_RESETHAND) != 0) {
3400       actp->sa_handler = SIG_DFL;
3401     }
3402 
3403     // try to honor the signal mask
3404     sigset_t oset;
3405     pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset);
3406 
3407     // call into the chained handler
3408     if (siginfo_flag_set) {
3409       (*sa)(sig, siginfo, context);
3410     } else {
3411       (*hand)(sig);
3412     }
3413 
3414     // restore the signal mask
3415     pthread_sigmask(SIG_SETMASK, &oset, 0);
3416   }
3417   // Tell jvm's signal handler the signal is taken care of.
3418   return true;
3419 }
3420 
3421 bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) {
3422   bool chained = false;
3423   // signal-chaining
3424   if (UseSignalChaining) {
3425     struct sigaction *actp = get_chained_signal_action(sig);
3426     if (actp != NULL) {
3427       chained = call_chained_handler(actp, sig, siginfo, context);
3428     }
3429   }
3430   return chained;
3431 }
3432 
3433 struct sigaction* os::Aix::get_preinstalled_handler(int sig) {
3434   if ((((unsigned int)1 << sig) & sigs) != 0) {
3435     return &sigact[sig];
3436   }
3437   return NULL;
3438 }
3439 
3440 void os::Aix::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
3441   assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3442   sigact[sig] = oldAct;
3443   sigs |= (unsigned int)1 << sig;
3444 }
3445 
3446 // for diagnostic
3447 int os::Aix::sigflags[MAXSIGNUM];
3448 
3449 int os::Aix::get_our_sigflags(int sig) {
3450   assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3451   return sigflags[sig];
3452 }
3453 
3454 void os::Aix::set_our_sigflags(int sig, int flags) {
3455   assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3456   sigflags[sig] = flags;
3457 }
3458 
3459 void os::Aix::set_signal_handler(int sig, bool set_installed) {
3460   // Check for overwrite.
3461   struct sigaction oldAct;
3462   sigaction(sig, (struct sigaction*)NULL, &oldAct);
3463 
3464   void* oldhand = oldAct.sa_sigaction
3465     ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3466     : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3467   // Renamed 'signalHandler' to avoid collision with other shared libs.
3468   if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
3469       oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
3470       oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) {
3471     if (AllowUserSignalHandlers || !set_installed) {
3472       // Do not overwrite; user takes responsibility to forward to us.
3473       return;
3474     } else if (UseSignalChaining) {
3475       // save the old handler in jvm
3476       save_preinstalled_handler(sig, oldAct);
3477       // libjsig also interposes the sigaction() call below and saves the
3478       // old sigaction on it own.
3479     } else {
3480       fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
3481                     "%#lx for signal %d.", (long)oldhand, sig));
3482     }
3483   }
3484 
3485   struct sigaction sigAct;
3486   sigfillset(&(sigAct.sa_mask));
3487   if (!set_installed) {
3488     sigAct.sa_handler = SIG_DFL;
3489     sigAct.sa_flags = SA_RESTART;
3490   } else {
3491     // Renamed 'signalHandler' to avoid collision with other shared libs.
3492     sigAct.sa_sigaction = javaSignalHandler;
3493     sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
3494   }
3495   // Save flags, which are set by ours
3496   assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3497   sigflags[sig] = sigAct.sa_flags;
3498 
3499   int ret = sigaction(sig, &sigAct, &oldAct);
3500   assert(ret == 0, "check");
3501 
3502   void* oldhand2 = oldAct.sa_sigaction
3503                  ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3504                  : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3505   assert(oldhand2 == oldhand, "no concurrent signal handler installation");
3506 }
3507 
3508 // install signal handlers for signals that HotSpot needs to
3509 // handle in order to support Java-level exception handling.
3510 void os::Aix::install_signal_handlers() {
3511   if (!signal_handlers_are_installed) {
3512     signal_handlers_are_installed = true;
3513 
3514     // signal-chaining
3515     typedef void (*signal_setting_t)();
3516     signal_setting_t begin_signal_setting = NULL;
3517     signal_setting_t end_signal_setting = NULL;
3518     begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3519                              dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
3520     if (begin_signal_setting != NULL) {
3521       end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3522                              dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
3523       get_signal_action = CAST_TO_FN_PTR(get_signal_t,
3524                             dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
3525       libjsig_is_loaded = true;
3526       assert(UseSignalChaining, "should enable signal-chaining");
3527     }
3528     if (libjsig_is_loaded) {
3529       // Tell libjsig jvm is setting signal handlers
3530       (*begin_signal_setting)();
3531     }
3532 
3533     set_signal_handler(SIGSEGV, true);
3534     set_signal_handler(SIGPIPE, true);
3535     set_signal_handler(SIGBUS, true);
3536     set_signal_handler(SIGILL, true);
3537     set_signal_handler(SIGFPE, true);
3538     set_signal_handler(SIGTRAP, true);
3539     set_signal_handler(SIGXFSZ, true);
3540     set_signal_handler(SIGDANGER, true);
3541 
3542     if (libjsig_is_loaded) {
3543       // Tell libjsig jvm finishes setting signal handlers.
3544       (*end_signal_setting)();
3545     }
3546 
3547     // We don't activate signal checker if libjsig is in place, we trust ourselves
3548     // and if UserSignalHandler is installed all bets are off.
3549     // Log that signal checking is off only if -verbose:jni is specified.
3550     if (CheckJNICalls) {
3551       if (libjsig_is_loaded) {
3552         tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
3553         check_signals = false;
3554       }
3555       if (AllowUserSignalHandlers) {
3556         tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
3557         check_signals = false;
3558       }
3559       // Need to initialize check_signal_done.
3560       ::sigemptyset(&check_signal_done);
3561     }
3562   }
3563 }
3564 
3565 static const char* get_signal_handler_name(address handler,
3566                                            char* buf, int buflen) {
3567   int offset;
3568   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
3569   if (found) {
3570     // skip directory names
3571     const char *p1, *p2;
3572     p1 = buf;
3573     size_t len = strlen(os::file_separator());
3574     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
3575     // The way os::dll_address_to_library_name is implemented on Aix
3576     // right now, it always returns -1 for the offset which is not
3577     // terribly informative.
3578     // Will fix that. For now, omit the offset.
3579     jio_snprintf(buf, buflen, "%s", p1);
3580   } else {
3581     jio_snprintf(buf, buflen, PTR_FORMAT, handler);
3582   }
3583   return buf;
3584 }
3585 
3586 static void print_signal_handler(outputStream* st, int sig,
3587                                  char* buf, size_t buflen) {
3588   struct sigaction sa;
3589   sigaction(sig, NULL, &sa);
3590 
3591   st->print("%s: ", os::exception_name(sig, buf, buflen));
3592 
3593   address handler = (sa.sa_flags & SA_SIGINFO)
3594     ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
3595     : CAST_FROM_FN_PTR(address, sa.sa_handler);
3596 
3597   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
3598     st->print("SIG_DFL");
3599   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
3600     st->print("SIG_IGN");
3601   } else {
3602     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
3603   }
3604 
3605   // Print readable mask.
3606   st->print(", sa_mask[0]=");
3607   os::Posix::print_signal_set_short(st, &sa.sa_mask);
3608 
3609   address rh = VMError::get_resetted_sighandler(sig);
3610   // May be, handler was resetted by VMError?
3611   if (rh != NULL) {
3612     handler = rh;
3613     sa.sa_flags = VMError::get_resetted_sigflags(sig);
3614   }
3615 
3616   // Print textual representation of sa_flags.
3617   st->print(", sa_flags=");
3618   os::Posix::print_sa_flags(st, sa.sa_flags);
3619 
3620   // Check: is it our handler?
3621   if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler) ||
3622       handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
3623     // It is our signal handler.
3624     // Check for flags, reset system-used one!
3625     if ((int)sa.sa_flags != os::Aix::get_our_sigflags(sig)) {
3626       st->print(", flags was changed from " PTR32_FORMAT ", consider using jsig library",
3627                 os::Aix::get_our_sigflags(sig));
3628     }
3629   }
3630   st->cr();
3631 }
3632 
3633 #define DO_SIGNAL_CHECK(sig) \
3634   if (!sigismember(&check_signal_done, sig)) \
3635     os::Aix::check_signal_handler(sig)
3636 
3637 // This method is a periodic task to check for misbehaving JNI applications
3638 // under CheckJNI, we can add any periodic checks here
3639 
3640 void os::run_periodic_checks() {
3641 
3642   if (check_signals == false) return;
3643 
3644   // SEGV and BUS if overridden could potentially prevent
3645   // generation of hs*.log in the event of a crash, debugging
3646   // such a case can be very challenging, so we absolutely
3647   // check the following for a good measure:
3648   DO_SIGNAL_CHECK(SIGSEGV);
3649   DO_SIGNAL_CHECK(SIGILL);
3650   DO_SIGNAL_CHECK(SIGFPE);
3651   DO_SIGNAL_CHECK(SIGBUS);
3652   DO_SIGNAL_CHECK(SIGPIPE);
3653   DO_SIGNAL_CHECK(SIGXFSZ);
3654   if (UseSIGTRAP) {
3655     DO_SIGNAL_CHECK(SIGTRAP);
3656   }
3657   DO_SIGNAL_CHECK(SIGDANGER);
3658 
3659   // ReduceSignalUsage allows the user to override these handlers
3660   // see comments at the very top and jvm_solaris.h
3661   if (!ReduceSignalUsage) {
3662     DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
3663     DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
3664     DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
3665     DO_SIGNAL_CHECK(BREAK_SIGNAL);
3666   }
3667 
3668   DO_SIGNAL_CHECK(SR_signum);
3669   DO_SIGNAL_CHECK(INTERRUPT_SIGNAL);
3670 }
3671 
3672 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
3673 
3674 static os_sigaction_t os_sigaction = NULL;
3675 
3676 void os::Aix::check_signal_handler(int sig) {
3677   char buf[O_BUFLEN];
3678   address jvmHandler = NULL;
3679 
3680   struct sigaction act;
3681   if (os_sigaction == NULL) {
3682     // only trust the default sigaction, in case it has been interposed
3683     os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
3684     if (os_sigaction == NULL) return;
3685   }
3686 
3687   os_sigaction(sig, (struct sigaction*)NULL, &act);
3688 
3689   address thisHandler = (act.sa_flags & SA_SIGINFO)
3690     ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
3691     : CAST_FROM_FN_PTR(address, act.sa_handler);
3692 
3693   switch(sig) {
3694   case SIGSEGV:
3695   case SIGBUS:
3696   case SIGFPE:
3697   case SIGPIPE:
3698   case SIGILL:
3699   case SIGXFSZ:
3700     // Renamed 'signalHandler' to avoid collision with other shared libs.
3701     jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler);
3702     break;
3703 
3704   case SHUTDOWN1_SIGNAL:
3705   case SHUTDOWN2_SIGNAL:
3706   case SHUTDOWN3_SIGNAL:
3707   case BREAK_SIGNAL:
3708     jvmHandler = (address)user_handler();
3709     break;
3710 
3711   case INTERRUPT_SIGNAL:
3712     jvmHandler = CAST_FROM_FN_PTR(address, SIG_DFL);
3713     break;
3714 
3715   default:
3716     if (sig == SR_signum) {
3717       jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler);
3718     } else {
3719       return;
3720     }
3721     break;
3722   }
3723 
3724   if (thisHandler != jvmHandler) {
3725     tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
3726     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
3727     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
3728     // No need to check this sig any longer
3729     sigaddset(&check_signal_done, sig);
3730     // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN
3731     if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) {
3732       tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell",
3733                     exception_name(sig, buf, O_BUFLEN));
3734     }
3735   } else if (os::Aix::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Aix::get_our_sigflags(sig)) {
3736     tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
3737     tty->print("expected:" PTR32_FORMAT, os::Aix::get_our_sigflags(sig));
3738     tty->print_cr("  found:" PTR32_FORMAT, act.sa_flags);
3739     // No need to check this sig any longer
3740     sigaddset(&check_signal_done, sig);
3741   }
3742 
3743   // Dump all the signal
3744   if (sigismember(&check_signal_done, sig)) {
3745     print_signal_handlers(tty, buf, O_BUFLEN);
3746   }
3747 }
3748 
3749 extern bool signal_name(int signo, char* buf, size_t len);
3750 
3751 const char* os::exception_name(int exception_code, char* buf, size_t size) {
3752   if (0 < exception_code && exception_code <= SIGRTMAX) {
3753     // signal
3754     if (!signal_name(exception_code, buf, size)) {
3755       jio_snprintf(buf, size, "SIG%d", exception_code);
3756     }
3757     return buf;
3758   } else {
3759     return NULL;
3760   }
3761 }
3762 
3763 // To install functions for atexit system call
3764 extern "C" {
3765   static void perfMemory_exit_helper() {
3766     perfMemory_exit();
3767   }
3768 }
3769 
3770 // This is called _before_ the most of global arguments have been parsed.
3771 void os::init(void) {
3772   // This is basic, we want to know if that ever changes.
3773   // (shared memory boundary is supposed to be a 256M aligned)
3774   assert(SHMLBA == ((uint64_t)0x10000000ULL)/*256M*/, "unexpected");
3775 
3776   // First off, we need to know whether we run on AIX or PASE, and
3777   // the OS level we run on.
3778   os::Aix::initialize_os_info();
3779 
3780   // Scan environment (SPEC1170 behaviour, etc)
3781   os::Aix::scan_environment();
3782 
3783   // Check which pages are supported by AIX.
3784   os::Aix::query_multipage_support();
3785 
3786   // Next, we need to initialize libo4 and libperfstat libraries.
3787   if (os::Aix::on_pase()) {
3788     os::Aix::initialize_libo4();
3789   } else {
3790     os::Aix::initialize_libperfstat();
3791   }
3792 
3793   // Reset the perfstat information provided by ODM.
3794   if (os::Aix::on_aix()) {
3795     libperfstat::perfstat_reset();
3796   }
3797 
3798   // Now initialze basic system properties. Note that for some of the values we
3799   // need libperfstat etc.
3800   os::Aix::initialize_system_info();
3801 
3802   // Initialize large page support.
3803   if (UseLargePages) {
3804     os::large_page_init();
3805     if (!UseLargePages) {
3806       // initialize os::_page_sizes
3807       _page_sizes[0] = Aix::page_size();
3808       _page_sizes[1] = 0;
3809       if (Verbose) {
3810         fprintf(stderr, "Large Page initialization failed: setting UseLargePages=0.\n");
3811       }
3812     }
3813   } else {
3814     // initialize os::_page_sizes
3815     _page_sizes[0] = Aix::page_size();
3816     _page_sizes[1] = 0;
3817   }
3818 
3819   // debug trace
3820   if (Verbose) {
3821     fprintf(stderr, "os::vm_page_size 0x%llX\n", os::vm_page_size());
3822     fprintf(stderr, "os::large_page_size 0x%llX\n", os::large_page_size());
3823     fprintf(stderr, "os::_page_sizes = ( ");
3824     for (int i = 0; _page_sizes[i]; i ++) {
3825       fprintf(stderr, " %s ", describe_pagesize(_page_sizes[i]));
3826     }
3827     fprintf(stderr, ")\n");
3828   }
3829 
3830   _initial_pid = getpid();
3831 
3832   clock_tics_per_sec = sysconf(_SC_CLK_TCK);
3833 
3834   init_random(1234567);
3835 
3836   ThreadCritical::initialize();
3837 
3838   // _main_thread points to the thread that created/loaded the JVM.
3839   Aix::_main_thread = pthread_self();
3840 
3841   initial_time_count = os::elapsed_counter();
3842   pthread_mutex_init(&dl_mutex, NULL);
3843 }
3844 
3845 // This is called _after_ the global arguments have been parsed.
3846 jint os::init_2(void) {
3847 
3848   trcVerbose("processor count: %d", os::_processor_count);
3849   trcVerbose("physical memory: %lu", Aix::_physical_memory);
3850 
3851   // Initially build up the loaded dll map.
3852   LoadedLibraries::reload();
3853 
3854   const int page_size = Aix::page_size();
3855   const int map_size = page_size;
3856 
3857   address map_address = (address) MAP_FAILED;
3858   const int prot  = PROT_READ;
3859   const int flags = MAP_PRIVATE|MAP_ANONYMOUS;
3860 
3861   // use optimized addresses for the polling page,
3862   // e.g. map it to a special 32-bit address.
3863   if (OptimizePollingPageLocation) {
3864     // architecture-specific list of address wishes:
3865     address address_wishes[] = {
3866       // AIX: addresses lower than 0x30000000 don't seem to work on AIX.
3867       // PPC64: all address wishes are non-negative 32 bit values where
3868       // the lower 16 bits are all zero. we can load these addresses
3869       // with a single ppc_lis instruction.
3870       (address) 0x30000000, (address) 0x31000000,
3871       (address) 0x32000000, (address) 0x33000000,
3872       (address) 0x40000000, (address) 0x41000000,
3873       (address) 0x42000000, (address) 0x43000000,
3874       (address) 0x50000000, (address) 0x51000000,
3875       (address) 0x52000000, (address) 0x53000000,
3876       (address) 0x60000000, (address) 0x61000000,
3877       (address) 0x62000000, (address) 0x63000000
3878     };
3879     int address_wishes_length = sizeof(address_wishes)/sizeof(address);
3880 
3881     // iterate over the list of address wishes:
3882     for (int i=0; i<address_wishes_length; i++) {
3883       // try to map with current address wish.
3884       // AIX: AIX needs MAP_FIXED if we provide an address and mmap will
3885       // fail if the address is already mapped.
3886       map_address = (address) ::mmap(address_wishes[i] - (ssize_t)page_size,
3887                                      map_size, prot,
3888                                      flags | MAP_FIXED,
3889                                      -1, 0);
3890       if (Verbose) {
3891         fprintf(stderr, "SafePoint Polling Page address: %p (wish) => %p\n",
3892                 address_wishes[i], map_address + (ssize_t)page_size);
3893       }
3894 
3895       if (map_address + (ssize_t)page_size == address_wishes[i]) {
3896         // map succeeded and map_address is at wished address, exit loop.
3897         break;
3898       }
3899 
3900       if (map_address != (address) MAP_FAILED) {
3901         // Map succeeded, but polling_page is not at wished address, unmap and continue.
3902         ::munmap(map_address, map_size);
3903         map_address = (address) MAP_FAILED;
3904       }
3905       // map failed, continue loop.
3906     }
3907   } // end OptimizePollingPageLocation
3908 
3909   if (map_address == (address) MAP_FAILED) {
3910     map_address = (address) ::mmap(NULL, map_size, prot, flags, -1, 0);
3911   }
3912   guarantee(map_address != MAP_FAILED, "os::init_2: failed to allocate polling page");
3913   os::set_polling_page(map_address);
3914 
3915   if (!UseMembar) {
3916     address mem_serialize_page = (address) ::mmap(NULL, Aix::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
3917     guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
3918     os::set_memory_serialize_page(mem_serialize_page);
3919 
3920 #ifndef PRODUCT
3921     if (Verbose && PrintMiscellaneous)
3922       tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3923 #endif
3924   }
3925 
3926   // initialize suspend/resume support - must do this before signal_sets_init()
3927   if (SR_initialize() != 0) {
3928     perror("SR_initialize failed");
3929     return JNI_ERR;
3930   }
3931 
3932   Aix::signal_sets_init();
3933   Aix::install_signal_handlers();
3934 
3935   // Check minimum allowable stack size for thread creation and to initialize
3936   // the java system classes, including StackOverflowError - depends on page
3937   // size. Add a page for compiler2 recursion in main thread.
3938   // Add in 2*BytesPerWord times page size to account for VM stack during
3939   // class initialization depending on 32 or 64 bit VM.
3940   os::Aix::min_stack_allowed = MAX2(os::Aix::min_stack_allowed,
3941             (size_t)(StackYellowPages+StackRedPages+StackShadowPages +
3942                      2*BytesPerWord COMPILER2_PRESENT(+1)) * Aix::page_size());
3943 
3944   size_t threadStackSizeInBytes = ThreadStackSize * K;
3945   if (threadStackSizeInBytes != 0 &&
3946       threadStackSizeInBytes < os::Aix::min_stack_allowed) {
3947         tty->print_cr("\nThe stack size specified is too small, "
3948                       "Specify at least %dk",
3949                       os::Aix::min_stack_allowed / K);
3950         return JNI_ERR;
3951   }
3952 
3953   // Make the stack size a multiple of the page size so that
3954   // the yellow/red zones can be guarded.
3955   // Note that this can be 0, if no default stacksize was set.
3956   JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, vm_page_size()));
3957 
3958   Aix::libpthread_init();
3959 
3960   if (MaxFDLimit) {
3961     // set the number of file descriptors to max. print out error
3962     // if getrlimit/setrlimit fails but continue regardless.
3963     struct rlimit nbr_files;
3964     int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
3965     if (status != 0) {
3966       if (PrintMiscellaneous && (Verbose || WizardMode))
3967         perror("os::init_2 getrlimit failed");
3968     } else {
3969       nbr_files.rlim_cur = nbr_files.rlim_max;
3970       status = setrlimit(RLIMIT_NOFILE, &nbr_files);
3971       if (status != 0) {
3972         if (PrintMiscellaneous && (Verbose || WizardMode))
3973           perror("os::init_2 setrlimit failed");
3974       }
3975     }
3976   }
3977 
3978   if (PerfAllowAtExitRegistration) {
3979     // only register atexit functions if PerfAllowAtExitRegistration is set.
3980     // atexit functions can be delayed until process exit time, which
3981     // can be problematic for embedded VM situations. Embedded VMs should
3982     // call DestroyJavaVM() to assure that VM resources are released.
3983 
3984     // note: perfMemory_exit_helper atexit function may be removed in
3985     // the future if the appropriate cleanup code can be added to the
3986     // VM_Exit VMOperation's doit method.
3987     if (atexit(perfMemory_exit_helper) != 0) {
3988       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3989     }
3990   }
3991 
3992   return JNI_OK;
3993 }
3994 
3995 // Mark the polling page as unreadable
3996 void os::make_polling_page_unreadable(void) {
3997   if (!guard_memory((char*)_polling_page, Aix::page_size())) {
3998     fatal("Could not disable polling page");
3999   }
4000 };
4001 
4002 // Mark the polling page as readable
4003 void os::make_polling_page_readable(void) {
4004   // Changed according to os_linux.cpp.
4005   if (!checked_mprotect((char *)_polling_page, Aix::page_size(), PROT_READ)) {
4006     fatal(err_msg("Could not enable polling page at " PTR_FORMAT, _polling_page));
4007   }
4008 };
4009 
4010 int os::active_processor_count() {
4011   // User has overridden the number of active processors
4012   if (ActiveProcessorCount > 0) {
4013     if (PrintActiveCpus) {
4014       tty->print_cr("active_processor_count: "
4015                     "active processor count set by user : %d",
4016                      ActiveProcessorCount);
4017     }
4018     return ActiveProcessorCount;
4019   }
4020 
4021   int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
4022   assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
4023   return online_cpus;
4024 }
4025 
4026 void os::set_native_thread_name(const char *name) {
4027   // Not yet implemented.
4028   return;
4029 }
4030 
4031 bool os::distribute_processes(uint length, uint* distribution) {
4032   // Not yet implemented.
4033   return false;
4034 }
4035 
4036 bool os::bind_to_processor(uint processor_id) {
4037   // Not yet implemented.
4038   return false;
4039 }
4040 
4041 void os::SuspendedThreadTask::internal_do_task() {
4042   if (do_suspend(_thread->osthread())) {
4043     SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext());
4044     do_task(context);
4045     do_resume(_thread->osthread());
4046   }
4047 }
4048 
4049 class PcFetcher : public os::SuspendedThreadTask {
4050 public:
4051   PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
4052   ExtendedPC result();
4053 protected:
4054   void do_task(const os::SuspendedThreadTaskContext& context);
4055 private:
4056   ExtendedPC _epc;
4057 };
4058 
4059 ExtendedPC PcFetcher::result() {
4060   guarantee(is_done(), "task is not done yet.");
4061   return _epc;
4062 }
4063 
4064 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
4065   Thread* thread = context.thread();
4066   OSThread* osthread = thread->osthread();
4067   if (osthread->ucontext() != NULL) {
4068     _epc = os::Aix::ucontext_get_pc((ucontext_t *) context.ucontext());
4069   } else {
4070     // NULL context is unexpected, double-check this is the VMThread.
4071     guarantee(thread->is_VM_thread(), "can only be called for VMThread");
4072   }
4073 }
4074 
4075 // Suspends the target using the signal mechanism and then grabs the PC before
4076 // resuming the target. Used by the flat-profiler only
4077 ExtendedPC os::get_thread_pc(Thread* thread) {
4078   // Make sure that it is called by the watcher for the VMThread.
4079   assert(Thread::current()->is_Watcher_thread(), "Must be watcher");
4080   assert(thread->is_VM_thread(), "Can only be called for VMThread");
4081 
4082   PcFetcher fetcher(thread);
4083   fetcher.run();
4084   return fetcher.result();
4085 }
4086 
4087 // Not neede on Aix.
4088 // int os::Aix::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime) {
4089 // }
4090 
4091 ////////////////////////////////////////////////////////////////////////////////
4092 // debug support
4093 
4094 static address same_page(address x, address y) {
4095   intptr_t page_bits = -os::vm_page_size();
4096   if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
4097     return x;
4098   else if (x > y)
4099     return (address)(intptr_t(y) | ~page_bits) + 1;
4100   else
4101     return (address)(intptr_t(y) & page_bits);
4102 }
4103 
4104 bool os::find(address addr, outputStream* st) {
4105 
4106   st->print(PTR_FORMAT ": ", addr);
4107 
4108   const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(addr);
4109   if (lib) {
4110     lib->print(st);
4111     return true;
4112   } else {
4113     lib = LoadedLibraries::find_for_data_address(addr);
4114     if (lib) {
4115       lib->print(st);
4116       return true;
4117     } else {
4118       st->print_cr("(outside any module)");
4119     }
4120   }
4121 
4122   return false;
4123 }
4124 
4125 ////////////////////////////////////////////////////////////////////////////////
4126 // misc
4127 
4128 // This does not do anything on Aix. This is basically a hook for being
4129 // able to use structured exception handling (thread-local exception filters)
4130 // on, e.g., Win32.
4131 void
4132 os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method,
4133                          JavaCallArguments* args, Thread* thread) {
4134   f(value, method, args, thread);
4135 }
4136 
4137 void os::print_statistics() {
4138 }
4139 
4140 int os::message_box(const char* title, const char* message) {
4141   int i;
4142   fdStream err(defaultStream::error_fd());
4143   for (i = 0; i < 78; i++) err.print_raw("=");
4144   err.cr();
4145   err.print_raw_cr(title);
4146   for (i = 0; i < 78; i++) err.print_raw("-");
4147   err.cr();
4148   err.print_raw_cr(message);
4149   for (i = 0; i < 78; i++) err.print_raw("=");
4150   err.cr();
4151 
4152   char buf[16];
4153   // Prevent process from exiting upon "read error" without consuming all CPU
4154   while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
4155 
4156   return buf[0] == 'y' || buf[0] == 'Y';
4157 }
4158 
4159 int os::stat(const char *path, struct stat *sbuf) {
4160   char pathbuf[MAX_PATH];
4161   if (strlen(path) > MAX_PATH - 1) {
4162     errno = ENAMETOOLONG;
4163     return -1;
4164   }
4165   os::native_path(strcpy(pathbuf, path));
4166   return ::stat(pathbuf, sbuf);
4167 }
4168 
4169 bool os::check_heap(bool force) {
4170   return true;
4171 }
4172 
4173 // int local_vsnprintf(char* buf, size_t count, const char* format, va_list args) {
4174 //   return ::vsnprintf(buf, count, format, args);
4175 // }
4176 
4177 // Is a (classpath) directory empty?
4178 bool os::dir_is_empty(const char* path) {
4179   DIR *dir = NULL;
4180   struct dirent *ptr;
4181 
4182   dir = opendir(path);
4183   if (dir == NULL) return true;
4184 
4185   /* Scan the directory */
4186   bool result = true;
4187   while (result && (ptr = readdir(dir)) != NULL) {
4188     if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
4189       result = false;
4190     }
4191   }
4192   closedir(dir);
4193   return result;
4194 }
4195 
4196 // This code originates from JDK's sysOpen and open64_w
4197 // from src/solaris/hpi/src/system_md.c
4198 
4199 #ifndef O_DELETE
4200 #define O_DELETE 0x10000
4201 #endif
4202 
4203 // Open a file. Unlink the file immediately after open returns
4204 // if the specified oflag has the O_DELETE flag set.
4205 // O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
4206 
4207 int os::open(const char *path, int oflag, int mode) {
4208 
4209   if (strlen(path) > MAX_PATH - 1) {
4210     errno = ENAMETOOLONG;
4211     return -1;
4212   }
4213   int fd;
4214   int o_delete = (oflag & O_DELETE);
4215   oflag = oflag & ~O_DELETE;
4216 
4217   fd = ::open64(path, oflag, mode);
4218   if (fd == -1) return -1;
4219 
4220   // If the open succeeded, the file might still be a directory.
4221   {
4222     struct stat64 buf64;
4223     int ret = ::fstat64(fd, &buf64);
4224     int st_mode = buf64.st_mode;
4225 
4226     if (ret != -1) {
4227       if ((st_mode & S_IFMT) == S_IFDIR) {
4228         errno = EISDIR;
4229         ::close(fd);
4230         return -1;
4231       }
4232     } else {
4233       ::close(fd);
4234       return -1;
4235     }
4236   }
4237 
4238   // All file descriptors that are opened in the JVM and not
4239   // specifically destined for a subprocess should have the
4240   // close-on-exec flag set. If we don't set it, then careless 3rd
4241   // party native code might fork and exec without closing all
4242   // appropriate file descriptors (e.g. as we do in closeDescriptors in
4243   // UNIXProcess.c), and this in turn might:
4244   //
4245   // - cause end-of-file to fail to be detected on some file
4246   //   descriptors, resulting in mysterious hangs, or
4247   //
4248   // - might cause an fopen in the subprocess to fail on a system
4249   //   suffering from bug 1085341.
4250   //
4251   // (Yes, the default setting of the close-on-exec flag is a Unix
4252   // design flaw.)
4253   //
4254   // See:
4255   // 1085341: 32-bit stdio routines should support file descriptors >255
4256   // 4843136: (process) pipe file descriptor from Runtime.exec not being closed
4257   // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
4258 #ifdef FD_CLOEXEC
4259   {
4260     int flags = ::fcntl(fd, F_GETFD);
4261     if (flags != -1)
4262       ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
4263   }
4264 #endif
4265 
4266   if (o_delete != 0) {
4267     ::unlink(path);
4268   }
4269   return fd;
4270 }
4271 
4272 // create binary file, rewriting existing file if required
4273 int os::create_binary_file(const char* path, bool rewrite_existing) {
4274   int oflags = O_WRONLY | O_CREAT;
4275   if (!rewrite_existing) {
4276     oflags |= O_EXCL;
4277   }
4278   return ::open64(path, oflags, S_IREAD | S_IWRITE);
4279 }
4280 
4281 // return current position of file pointer
4282 jlong os::current_file_offset(int fd) {
4283   return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
4284 }
4285 
4286 // move file pointer to the specified offset
4287 jlong os::seek_to_file_offset(int fd, jlong offset) {
4288   return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
4289 }
4290 
4291 // This code originates from JDK's sysAvailable
4292 // from src/solaris/hpi/src/native_threads/src/sys_api_td.c
4293 
4294 int os::available(int fd, jlong *bytes) {
4295   jlong cur, end;
4296   int mode;
4297   struct stat64 buf64;
4298 
4299   if (::fstat64(fd, &buf64) >= 0) {
4300     mode = buf64.st_mode;
4301     if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
4302       // XXX: is the following call interruptible? If so, this might
4303       // need to go through the INTERRUPT_IO() wrapper as for other
4304       // blocking, interruptible calls in this file.
4305       int n;
4306       if (::ioctl(fd, FIONREAD, &n) >= 0) {
4307         *bytes = n;
4308         return 1;
4309       }
4310     }
4311   }
4312   if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
4313     return 0;
4314   } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
4315     return 0;
4316   } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
4317     return 0;
4318   }
4319   *bytes = end - cur;
4320   return 1;
4321 }
4322 
4323 int os::socket_available(int fd, jint *pbytes) {
4324   // Linux doc says EINTR not returned, unlike Solaris
4325   int ret = ::ioctl(fd, FIONREAD, pbytes);
4326 
4327   //%% note ioctl can return 0 when successful, JVM_SocketAvailable
4328   // is expected to return 0 on failure and 1 on success to the jdk.
4329   return (ret < 0) ? 0 : 1;
4330 }
4331 
4332 // Map a block of memory.
4333 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4334                         char *addr, size_t bytes, bool read_only,
4335                         bool allow_exec) {
4336   Unimplemented();
4337   return NULL;
4338 }
4339 
4340 // Remap a block of memory.
4341 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4342                           char *addr, size_t bytes, bool read_only,
4343                           bool allow_exec) {
4344   // same as map_memory() on this OS
4345   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4346                         allow_exec);
4347 }
4348 
4349 // Unmap a block of memory.
4350 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4351   return munmap(addr, bytes) == 0;
4352 }
4353 
4354 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4355 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4356 // of a thread.
4357 //
4358 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4359 // the fast estimate available on the platform.
4360 
4361 jlong os::current_thread_cpu_time() {
4362   // return user + sys since the cost is the same
4363   const jlong n = os::thread_cpu_time(Thread::current(), true /* user + sys */);
4364   assert(n >= 0, "negative CPU time");
4365   return n;
4366 }
4367 
4368 jlong os::thread_cpu_time(Thread* thread) {
4369   // consistent with what current_thread_cpu_time() returns
4370   const jlong n = os::thread_cpu_time(thread, true /* user + sys */);
4371   assert(n >= 0, "negative CPU time");
4372   return n;
4373 }
4374 
4375 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4376   const jlong n = os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4377   assert(n >= 0, "negative CPU time");
4378   return n;
4379 }
4380 
4381 static bool thread_cpu_time_unchecked(Thread* thread, jlong* p_sys_time, jlong* p_user_time) {
4382   bool error = false;
4383 
4384   jlong sys_time = 0;
4385   jlong user_time = 0;
4386 
4387   // Reimplemented using getthrds64().
4388   //
4389   // Works like this:
4390   // For the thread in question, get the kernel thread id. Then get the
4391   // kernel thread statistics using that id.
4392   //
4393   // This only works of course when no pthread scheduling is used,
4394   // i.e. there is a 1:1 relationship to kernel threads.
4395   // On AIX, see AIXTHREAD_SCOPE variable.
4396 
4397   pthread_t pthtid = thread->osthread()->pthread_id();
4398 
4399   // retrieve kernel thread id for the pthread:
4400   tid64_t tid = 0;
4401   struct __pthrdsinfo pinfo;
4402   // I just love those otherworldly IBM APIs which force me to hand down
4403   // dummy buffers for stuff I dont care for...
4404   char dummy[1];
4405   int dummy_size = sizeof(dummy);
4406   if (pthread_getthrds_np(&pthtid, PTHRDSINFO_QUERY_TID, &pinfo, sizeof(pinfo),
4407                           dummy, &dummy_size) == 0) {
4408     tid = pinfo.__pi_tid;
4409   } else {
4410     tty->print_cr("pthread_getthrds_np failed.");
4411     error = true;
4412   }
4413 
4414   // retrieve kernel timing info for that kernel thread
4415   if (!error) {
4416     struct thrdentry64 thrdentry;
4417     if (getthrds64(getpid(), &thrdentry, sizeof(thrdentry), &tid, 1) == 1) {
4418       sys_time = thrdentry.ti_ru.ru_stime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_stime.tv_usec * 1000LL;
4419       user_time = thrdentry.ti_ru.ru_utime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_utime.tv_usec * 1000LL;
4420     } else {
4421       tty->print_cr("pthread_getthrds_np failed.");
4422       error = true;
4423     }
4424   }
4425 
4426   if (p_sys_time) {
4427     *p_sys_time = sys_time;
4428   }
4429 
4430   if (p_user_time) {
4431     *p_user_time = user_time;
4432   }
4433 
4434   if (error) {
4435     return false;
4436   }
4437 
4438   return true;
4439 }
4440 
4441 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
4442   jlong sys_time;
4443   jlong user_time;
4444 
4445   if (!thread_cpu_time_unchecked(thread, &sys_time, &user_time)) {
4446     return -1;
4447   }
4448 
4449   return user_sys_cpu_time ? sys_time + user_time : user_time;
4450 }
4451 
4452 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4453   info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4454   info_ptr->may_skip_backward = false;     // elapsed time not wall time
4455   info_ptr->may_skip_forward = false;      // elapsed time not wall time
4456   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4457 }
4458 
4459 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4460   info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4461   info_ptr->may_skip_backward = false;     // elapsed time not wall time
4462   info_ptr->may_skip_forward = false;      // elapsed time not wall time
4463   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4464 }
4465 
4466 bool os::is_thread_cpu_time_supported() {
4467   return true;
4468 }
4469 
4470 // System loadavg support. Returns -1 if load average cannot be obtained.
4471 // For now just return the system wide load average (no processor sets).
4472 int os::loadavg(double values[], int nelem) {
4473 
4474   // Implemented using libperfstat on AIX.
4475 
4476   guarantee(nelem >= 0 && nelem <= 3, "argument error");
4477   guarantee(values, "argument error");
4478 
4479   if (os::Aix::on_pase()) {
4480     Unimplemented();
4481     return -1;
4482   } else {
4483     // AIX: use libperfstat
4484     //
4485     // See also:
4486     // http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_cputot.htm
4487     // /usr/include/libperfstat.h:
4488 
4489     // Use the already AIX version independent get_cpuinfo.
4490     os::Aix::cpuinfo_t ci;
4491     if (os::Aix::get_cpuinfo(&ci)) {
4492       for (int i = 0; i < nelem; i++) {
4493         values[i] = ci.loadavg[i];
4494       }
4495     } else {
4496       return -1;
4497     }
4498     return nelem;
4499   }
4500 }
4501 
4502 void os::pause() {
4503   char filename[MAX_PATH];
4504   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4505     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4506   } else {
4507     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4508   }
4509 
4510   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4511   if (fd != -1) {
4512     struct stat buf;
4513     ::close(fd);
4514     while (::stat(filename, &buf) == 0) {
4515       (void)::poll(NULL, 0, 100);
4516     }
4517   } else {
4518     jio_fprintf(stderr,
4519       "Could not open pause file '%s', continuing immediately.\n", filename);
4520   }
4521 }
4522 
4523 bool os::is_primordial_thread(void) {
4524   if (pthread_self() == (pthread_t)1) {
4525     return true;
4526   } else {
4527     return false;
4528   }
4529 }
4530 
4531 // OS recognitions (PASE/AIX, OS level) call this before calling any
4532 // one of Aix::on_pase(), Aix::os_version() static
4533 void os::Aix::initialize_os_info() {
4534 
4535   assert(_on_pase == -1 && _os_version == -1, "already called.");
4536 
4537   struct utsname uts;
4538   memset(&uts, 0, sizeof(uts));
4539   strcpy(uts.sysname, "?");
4540   if (::uname(&uts) == -1) {
4541     trc("uname failed (%d)", errno);
4542     guarantee(0, "Could not determine whether we run on AIX or PASE");
4543   } else {
4544     trcVerbose("uname says: sysname \"%s\" version \"%s\" release \"%s\" "
4545                "node \"%s\" machine \"%s\"\n",
4546                uts.sysname, uts.version, uts.release, uts.nodename, uts.machine);
4547     const int major = atoi(uts.version);
4548     assert(major > 0, "invalid OS version");
4549     const int minor = atoi(uts.release);
4550     assert(minor > 0, "invalid OS release");
4551     _os_version = (major << 8) | minor;
4552     if (strcmp(uts.sysname, "OS400") == 0) {
4553       Unimplemented();
4554     } else if (strcmp(uts.sysname, "AIX") == 0) {
4555       // We run on AIX. We do not support versions older than AIX 5.3.
4556       _on_pase = 0;
4557       if (_os_version < 0x0503) {
4558         trc("AIX release older than AIX 5.3 not supported.");
4559         assert(false, "AIX release too old.");
4560       } else {
4561         trcVerbose("We run on AIX %d.%d\n", major, minor);
4562       }
4563     } else {
4564       assert(false, "unknown OS");
4565     }
4566   }
4567 
4568   guarantee(_on_pase != -1 && _os_version, "Could not determine AIX/OS400 release");
4569 } // end: os::Aix::initialize_os_info()
4570 
4571 // Scan environment for important settings which might effect the VM.
4572 // Trace out settings. Warn about invalid settings and/or correct them.
4573 //
4574 // Must run after os::Aix::initialue_os_info().
4575 void os::Aix::scan_environment() {
4576 
4577   char* p;
4578   int rc;
4579 
4580   // Warn explicity if EXTSHM=ON is used. That switch changes how
4581   // System V shared memory behaves. One effect is that page size of
4582   // shared memory cannot be change dynamically, effectivly preventing
4583   // large pages from working.
4584   // This switch was needed on AIX 32bit, but on AIX 64bit the general
4585   // recommendation is (in OSS notes) to switch it off.
4586   p = ::getenv("EXTSHM");
4587   if (Verbose) {
4588     fprintf(stderr, "EXTSHM=%s.\n", p ? p : "<unset>");
4589   }
4590   if (p && strcmp(p, "ON") == 0) {
4591     fprintf(stderr, "Unsupported setting: EXTSHM=ON. Large Page support will be disabled.\n");
4592     _extshm = 1;
4593   } else {
4594     _extshm = 0;
4595   }
4596 
4597   // SPEC1170 behaviour: will change the behaviour of a number of POSIX APIs.
4598   // Not tested, not supported.
4599   //
4600   // Note that it might be worth the trouble to test and to require it, if only to
4601   // get useful return codes for mprotect.
4602   //
4603   // Note: Setting XPG_SUS_ENV in the process is too late. Must be set earlier (before
4604   // exec() ? before loading the libjvm ? ....)
4605   p = ::getenv("XPG_SUS_ENV");
4606   trcVerbose("XPG_SUS_ENV=%s.", p ? p : "<unset>");
4607   if (p && strcmp(p, "ON") == 0) {
4608     _xpg_sus_mode = 1;
4609     trc("Unsupported setting: XPG_SUS_ENV=ON");
4610     // This is not supported. Worst of all, it changes behaviour of mmap MAP_FIXED to
4611     // clobber address ranges. If we ever want to support that, we have to do some
4612     // testing first.
4613     guarantee(false, "XPG_SUS_ENV=ON not supported");
4614   } else {
4615     _xpg_sus_mode = 0;
4616   }
4617 
4618   // Switch off AIX internal (pthread) guard pages. This has
4619   // immediate effect for any pthread_create calls which follow.
4620   p = ::getenv("AIXTHREAD_GUARDPAGES");
4621   trcVerbose("AIXTHREAD_GUARDPAGES=%s.", p ? p : "<unset>");
4622   rc = ::putenv("AIXTHREAD_GUARDPAGES=0");
4623   guarantee(rc == 0, "");
4624 
4625 } // end: os::Aix::scan_environment()
4626 
4627 // PASE: initialize the libo4 library (AS400 PASE porting library).
4628 void os::Aix::initialize_libo4() {
4629   Unimplemented();
4630 }
4631 
4632 // AIX: initialize the libperfstat library (we load this dynamically
4633 // because it is only available on AIX.
4634 void os::Aix::initialize_libperfstat() {
4635 
4636   assert(os::Aix::on_aix(), "AIX only");
4637 
4638   if (!libperfstat::init()) {
4639     trc("libperfstat initialization failed.");
4640     assert(false, "libperfstat initialization failed");
4641   } else {
4642     if (Verbose) {
4643       fprintf(stderr, "libperfstat initialized.\n");
4644     }
4645   }
4646 } // end: os::Aix::initialize_libperfstat
4647 
4648 /////////////////////////////////////////////////////////////////////////////
4649 // thread stack
4650 
4651 // function to query the current stack size using pthread_getthrds_np
4652 //
4653 // ! do not change anything here unless you know what you are doing !
4654 static void query_stack_dimensions(address* p_stack_base, size_t* p_stack_size) {
4655 
4656   // This only works when invoked on a pthread. As we agreed not to use
4657   // primordial threads anyway, I assert here
4658   guarantee(!os::is_primordial_thread(), "not allowed on the primordial thread");
4659 
4660   // information about this api can be found (a) in the pthread.h header and
4661   // (b) in http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_getthrds_np.htm
4662   //
4663   // The use of this API to find out the current stack is kind of undefined.
4664   // But after a lot of tries and asking IBM about it, I concluded that it is safe
4665   // enough for cases where I let the pthread library create its stacks. For cases
4666   // where I create an own stack and pass this to pthread_create, it seems not to
4667   // work (the returned stack size in that case is 0).
4668 
4669   pthread_t tid = pthread_self();
4670   struct __pthrdsinfo pinfo;
4671   char dummy[1]; // we only need this to satisfy the api and to not get E
4672   int dummy_size = sizeof(dummy);
4673 
4674   memset(&pinfo, 0, sizeof(pinfo));
4675 
4676   const int rc = pthread_getthrds_np (&tid, PTHRDSINFO_QUERY_ALL, &pinfo,
4677                                       sizeof(pinfo), dummy, &dummy_size);
4678 
4679   if (rc != 0) {
4680     fprintf(stderr, "pthread_getthrds_np failed (%d)\n", rc);
4681     guarantee(0, "pthread_getthrds_np failed");
4682   }
4683 
4684   guarantee(pinfo.__pi_stackend, "returned stack base invalid");
4685 
4686   // the following can happen when invoking pthread_getthrds_np on a pthread running on a user provided stack
4687   // (when handing down a stack to pthread create, see pthread_attr_setstackaddr).
4688   // Not sure what to do here - I feel inclined to forbid this use case completely.
4689   guarantee(pinfo.__pi_stacksize, "returned stack size invalid");
4690 
4691   // On AIX, stacks are not necessarily page aligned so round the base and size accordingly
4692   if (p_stack_base) {
4693     (*p_stack_base) = (address) align_size_up((intptr_t)pinfo.__pi_stackend, os::Aix::stack_page_size());
4694   }
4695 
4696   if (p_stack_size) {
4697     (*p_stack_size) = pinfo.__pi_stacksize - os::Aix::stack_page_size();
4698   }
4699 
4700 #ifndef PRODUCT
4701   if (Verbose) {
4702     fprintf(stderr,
4703             "query_stack_dimensions() -> real stack_base=" INTPTR_FORMAT ", real stack_addr=" INTPTR_FORMAT
4704             ", real stack_size=" INTPTR_FORMAT
4705             ", stack_base=" INTPTR_FORMAT ", stack_size=" INTPTR_FORMAT "\n",
4706             (intptr_t)pinfo.__pi_stackend, (intptr_t)pinfo.__pi_stackaddr, pinfo.__pi_stacksize,
4707             (intptr_t)align_size_up((intptr_t)pinfo.__pi_stackend, os::Aix::stack_page_size()),
4708             pinfo.__pi_stacksize - os::Aix::stack_page_size());
4709   }
4710 #endif
4711 
4712 } // end query_stack_dimensions
4713 
4714 // get the current stack base from the OS (actually, the pthread library)
4715 address os::current_stack_base() {
4716   address p;
4717   query_stack_dimensions(&p, 0);
4718   return p;
4719 }
4720 
4721 // get the current stack size from the OS (actually, the pthread library)
4722 size_t os::current_stack_size() {
4723   size_t s;
4724   query_stack_dimensions(0, &s);
4725   return s;
4726 }
4727 
4728 // Refer to the comments in os_solaris.cpp park-unpark.
4729 //
4730 // Beware -- Some versions of NPTL embody a flaw where pthread_cond_timedwait() can
4731 // hang indefinitely. For instance NPTL 0.60 on 2.4.21-4ELsmp is vulnerable.
4732 // For specifics regarding the bug see GLIBC BUGID 261237 :
4733 //    http://www.mail-archive.com/debian-glibc@lists.debian.org/msg10837.html.
4734 // Briefly, pthread_cond_timedwait() calls with an expiry time that's not in the future
4735 // will either hang or corrupt the condvar, resulting in subsequent hangs if the condvar
4736 // is used. (The simple C test-case provided in the GLIBC bug report manifests the
4737 // hang). The JVM is vulernable via sleep(), Object.wait(timo), LockSupport.parkNanos()
4738 // and monitorenter when we're using 1-0 locking. All those operations may result in
4739 // calls to pthread_cond_timedwait(). Using LD_ASSUME_KERNEL to use an older version
4740 // of libpthread avoids the problem, but isn't practical.
4741 //
4742 // Possible remedies:
4743 //
4744 // 1.   Establish a minimum relative wait time. 50 to 100 msecs seems to work.
4745 //      This is palliative and probabilistic, however. If the thread is preempted
4746 //      between the call to compute_abstime() and pthread_cond_timedwait(), more
4747 //      than the minimum period may have passed, and the abstime may be stale (in the
4748 //      past) resultin in a hang. Using this technique reduces the odds of a hang
4749 //      but the JVM is still vulnerable, particularly on heavily loaded systems.
4750 //
4751 // 2.   Modify park-unpark to use per-thread (per ParkEvent) pipe-pairs instead
4752 //      of the usual flag-condvar-mutex idiom. The write side of the pipe is set
4753 //      NDELAY. unpark() reduces to write(), park() reduces to read() and park(timo)
4754 //      reduces to poll()+read(). This works well, but consumes 2 FDs per extant
4755 //      thread.
4756 //
4757 // 3.   Embargo pthread_cond_timedwait() and implement a native "chron" thread
4758 //      that manages timeouts. We'd emulate pthread_cond_timedwait() by enqueuing
4759 //      a timeout request to the chron thread and then blocking via pthread_cond_wait().
4760 //      This also works well. In fact it avoids kernel-level scalability impediments
4761 //      on certain platforms that don't handle lots of active pthread_cond_timedwait()
4762 //      timers in a graceful fashion.
4763 //
4764 // 4.   When the abstime value is in the past it appears that control returns
4765 //      correctly from pthread_cond_timedwait(), but the condvar is left corrupt.
4766 //      Subsequent timedwait/wait calls may hang indefinitely. Given that, we
4767 //      can avoid the problem by reinitializing the condvar -- by cond_destroy()
4768 //      followed by cond_init() -- after all calls to pthread_cond_timedwait().
4769 //      It may be possible to avoid reinitialization by checking the return
4770 //      value from pthread_cond_timedwait(). In addition to reinitializing the
4771 //      condvar we must establish the invariant that cond_signal() is only called
4772 //      within critical sections protected by the adjunct mutex. This prevents
4773 //      cond_signal() from "seeing" a condvar that's in the midst of being
4774 //      reinitialized or that is corrupt. Sadly, this invariant obviates the
4775 //      desirable signal-after-unlock optimization that avoids futile context switching.
4776 //
4777 //      I'm also concerned that some versions of NTPL might allocate an auxilliary
4778 //      structure when a condvar is used or initialized. cond_destroy() would
4779 //      release the helper structure. Our reinitialize-after-timedwait fix
4780 //      put excessive stress on malloc/free and locks protecting the c-heap.
4781 //
4782 // We currently use (4). See the WorkAroundNTPLTimedWaitHang flag.
4783 // It may be possible to refine (4) by checking the kernel and NTPL verisons
4784 // and only enabling the work-around for vulnerable environments.
4785 
4786 // utility to compute the abstime argument to timedwait:
4787 // millis is the relative timeout time
4788 // abstime will be the absolute timeout time
4789 // TODO: replace compute_abstime() with unpackTime()
4790 
4791 static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
4792   if (millis < 0) millis = 0;
4793   struct timeval now;
4794   int status = gettimeofday(&now, NULL);
4795   assert(status == 0, "gettimeofday");
4796   jlong seconds = millis / 1000;
4797   millis %= 1000;
4798   if (seconds > 50000000) { // see man cond_timedwait(3T)
4799     seconds = 50000000;
4800   }
4801   abstime->tv_sec = now.tv_sec  + seconds;
4802   long       usec = now.tv_usec + millis * 1000;
4803   if (usec >= 1000000) {
4804     abstime->tv_sec += 1;
4805     usec -= 1000000;
4806   }
4807   abstime->tv_nsec = usec * 1000;
4808   return abstime;
4809 }
4810 
4811 // Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
4812 // Conceptually TryPark() should be equivalent to park(0).
4813 
4814 int os::PlatformEvent::TryPark() {
4815   for (;;) {
4816     const int v = _Event;
4817     guarantee ((v == 0) || (v == 1), "invariant");
4818     if (Atomic::cmpxchg (0, &_Event, v) == v) return v;
4819   }
4820 }
4821 
4822 void os::PlatformEvent::park() {       // AKA "down()"
4823   // Invariant: Only the thread associated with the Event/PlatformEvent
4824   // may call park().
4825   // TODO: assert that _Assoc != NULL or _Assoc == Self
4826   int v;
4827   for (;;) {
4828     v = _Event;
4829     if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4830   }
4831   guarantee (v >= 0, "invariant");
4832   if (v == 0) {
4833     // Do this the hard way by blocking ...
4834     int status = pthread_mutex_lock(_mutex);
4835     assert_status(status == 0, status, "mutex_lock");
4836     guarantee (_nParked == 0, "invariant");
4837     ++ _nParked;
4838     while (_Event < 0) {
4839       status = pthread_cond_wait(_cond, _mutex);
4840       assert_status(status == 0 || status == ETIMEDOUT, status, "cond_timedwait");
4841     }
4842     -- _nParked;
4843 
4844     // In theory we could move the ST of 0 into _Event past the unlock(),
4845     // but then we'd need a MEMBAR after the ST.
4846     _Event = 0;
4847     status = pthread_mutex_unlock(_mutex);
4848     assert_status(status == 0, status, "mutex_unlock");
4849   }
4850   guarantee (_Event >= 0, "invariant");
4851 }
4852 
4853 int os::PlatformEvent::park(jlong millis) {
4854   guarantee (_nParked == 0, "invariant");
4855 
4856   int v;
4857   for (;;) {
4858     v = _Event;
4859     if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4860   }
4861   guarantee (v >= 0, "invariant");
4862   if (v != 0) return OS_OK;
4863 
4864   // We do this the hard way, by blocking the thread.
4865   // Consider enforcing a minimum timeout value.
4866   struct timespec abst;
4867   compute_abstime(&abst, millis);
4868 
4869   int ret = OS_TIMEOUT;
4870   int status = pthread_mutex_lock(_mutex);
4871   assert_status(status == 0, status, "mutex_lock");
4872   guarantee (_nParked == 0, "invariant");
4873   ++_nParked;
4874 
4875   // Object.wait(timo) will return because of
4876   // (a) notification
4877   // (b) timeout
4878   // (c) thread.interrupt
4879   //
4880   // Thread.interrupt and object.notify{All} both call Event::set.
4881   // That is, we treat thread.interrupt as a special case of notification.
4882   // The underlying Solaris implementation, cond_timedwait, admits
4883   // spurious/premature wakeups, but the JLS/JVM spec prevents the
4884   // JVM from making those visible to Java code. As such, we must
4885   // filter out spurious wakeups. We assume all ETIME returns are valid.
4886   //
4887   // TODO: properly differentiate simultaneous notify+interrupt.
4888   // In that case, we should propagate the notify to another waiter.
4889 
4890   while (_Event < 0) {
4891     status = pthread_cond_timedwait(_cond, _mutex, &abst);
4892     assert_status(status == 0 || status == ETIMEDOUT,
4893                   status, "cond_timedwait");
4894     if (!FilterSpuriousWakeups) break;         // previous semantics
4895     if (status == ETIMEDOUT) break;
4896     // We consume and ignore EINTR and spurious wakeups.
4897   }
4898   --_nParked;
4899   if (_Event >= 0) {
4900      ret = OS_OK;
4901   }
4902   _Event = 0;
4903   status = pthread_mutex_unlock(_mutex);
4904   assert_status(status == 0, status, "mutex_unlock");
4905   assert (_nParked == 0, "invariant");
4906   return ret;
4907 }
4908 
4909 void os::PlatformEvent::unpark() {
4910   int v, AnyWaiters;
4911   for (;;) {
4912     v = _Event;
4913     if (v > 0) {
4914       // The LD of _Event could have reordered or be satisfied
4915       // by a read-aside from this processor's write buffer.
4916       // To avoid problems execute a barrier and then
4917       // ratify the value.
4918       OrderAccess::fence();
4919       if (_Event == v) return;
4920       continue;
4921     }
4922     if (Atomic::cmpxchg (v+1, &_Event, v) == v) break;
4923   }
4924   if (v < 0) {
4925     // Wait for the thread associated with the event to vacate
4926     int status = pthread_mutex_lock(_mutex);
4927     assert_status(status == 0, status, "mutex_lock");
4928     AnyWaiters = _nParked;
4929 
4930     if (AnyWaiters != 0) {
4931       // We intentional signal *after* dropping the lock
4932       // to avoid a common class of futile wakeups.
4933       status = pthread_cond_signal(_cond);
4934       assert_status(status == 0, status, "cond_signal");
4935     }
4936     // Mutex should be locked for pthread_cond_signal(_cond).
4937     status = pthread_mutex_unlock(_mutex);
4938     assert_status(status == 0, status, "mutex_unlock");
4939   }
4940 
4941   // Note that we signal() _after dropping the lock for "immortal" Events.
4942   // This is safe and avoids a common class of futile wakeups. In rare
4943   // circumstances this can cause a thread to return prematurely from
4944   // cond_{timed}wait() but the spurious wakeup is benign and the victim will
4945   // simply re-test the condition and re-park itself.
4946 }
4947 
4948 
4949 // JSR166
4950 // -------------------------------------------------------
4951 
4952 //
4953 // The solaris and linux implementations of park/unpark are fairly
4954 // conservative for now, but can be improved. They currently use a
4955 // mutex/condvar pair, plus a a count.
4956 // Park decrements count if > 0, else does a condvar wait. Unpark
4957 // sets count to 1 and signals condvar. Only one thread ever waits
4958 // on the condvar. Contention seen when trying to park implies that someone
4959 // is unparking you, so don't wait. And spurious returns are fine, so there
4960 // is no need to track notifications.
4961 //
4962 
4963 #define MAX_SECS 100000000
4964 //
4965 // This code is common to linux and solaris and will be moved to a
4966 // common place in dolphin.
4967 //
4968 // The passed in time value is either a relative time in nanoseconds
4969 // or an absolute time in milliseconds. Either way it has to be unpacked
4970 // into suitable seconds and nanoseconds components and stored in the
4971 // given timespec structure.
4972 // Given time is a 64-bit value and the time_t used in the timespec is only
4973 // a signed-32-bit value (except on 64-bit Linux) we have to watch for
4974 // overflow if times way in the future are given. Further on Solaris versions
4975 // prior to 10 there is a restriction (see cond_timedwait) that the specified
4976 // number of seconds, in abstime, is less than current_time + 100,000,000.
4977 // As it will be 28 years before "now + 100000000" will overflow we can
4978 // ignore overflow and just impose a hard-limit on seconds using the value
4979 // of "now + 100,000,000". This places a limit on the timeout of about 3.17
4980 // years from "now".
4981 //
4982 
4983 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
4984   assert (time > 0, "convertTime");
4985 
4986   struct timeval now;
4987   int status = gettimeofday(&now, NULL);
4988   assert(status == 0, "gettimeofday");
4989 
4990   time_t max_secs = now.tv_sec + MAX_SECS;
4991 
4992   if (isAbsolute) {
4993     jlong secs = time / 1000;
4994     if (secs > max_secs) {
4995       absTime->tv_sec = max_secs;
4996     }
4997     else {
4998       absTime->tv_sec = secs;
4999     }
5000     absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
5001   }
5002   else {
5003     jlong secs = time / NANOSECS_PER_SEC;
5004     if (secs >= MAX_SECS) {
5005       absTime->tv_sec = max_secs;
5006       absTime->tv_nsec = 0;
5007     }
5008     else {
5009       absTime->tv_sec = now.tv_sec + secs;
5010       absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
5011       if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
5012         absTime->tv_nsec -= NANOSECS_PER_SEC;
5013         ++absTime->tv_sec; // note: this must be <= max_secs
5014       }
5015     }
5016   }
5017   assert(absTime->tv_sec >= 0, "tv_sec < 0");
5018   assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
5019   assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
5020   assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
5021 }
5022 
5023 void Parker::park(bool isAbsolute, jlong time) {
5024   // Optional fast-path check:
5025   // Return immediately if a permit is available.
5026   if (_counter > 0) {
5027     _counter = 0;
5028     OrderAccess::fence();
5029     return;
5030   }
5031 
5032   Thread* thread = Thread::current();
5033   assert(thread->is_Java_thread(), "Must be JavaThread");
5034   JavaThread *jt = (JavaThread *)thread;
5035 
5036   // Optional optimization -- avoid state transitions if there's an interrupt pending.
5037   // Check interrupt before trying to wait
5038   if (Thread::is_interrupted(thread, false)) {
5039     return;
5040   }
5041 
5042   // Next, demultiplex/decode time arguments
5043   timespec absTime;
5044   if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
5045     return;
5046   }
5047   if (time > 0) {
5048     unpackTime(&absTime, isAbsolute, time);
5049   }
5050 
5051   // Enter safepoint region
5052   // Beware of deadlocks such as 6317397.
5053   // The per-thread Parker:: mutex is a classic leaf-lock.
5054   // In particular a thread must never block on the Threads_lock while
5055   // holding the Parker:: mutex. If safepoints are pending both the
5056   // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
5057   ThreadBlockInVM tbivm(jt);
5058 
5059   // Don't wait if cannot get lock since interference arises from
5060   // unblocking. Also. check interrupt before trying wait
5061   if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
5062     return;
5063   }
5064 
5065   int status;
5066   if (_counter > 0) { // no wait needed
5067     _counter = 0;
5068     status = pthread_mutex_unlock(_mutex);
5069     assert (status == 0, "invariant");
5070     OrderAccess::fence();
5071     return;
5072   }
5073 
5074 #ifdef ASSERT
5075   // Don't catch signals while blocked; let the running threads have the signals.
5076   // (This allows a debugger to break into the running thread.)
5077   sigset_t oldsigs;
5078   sigset_t* allowdebug_blocked = os::Aix::allowdebug_blocked_signals();
5079   pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
5080 #endif
5081 
5082   OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5083   jt->set_suspend_equivalent();
5084   // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
5085 
5086   if (time == 0) {
5087     status = pthread_cond_wait (_cond, _mutex);
5088   } else {
5089     status = pthread_cond_timedwait (_cond, _mutex, &absTime);
5090     if (status != 0 && WorkAroundNPTLTimedWaitHang) {
5091       pthread_cond_destroy (_cond);
5092       pthread_cond_init    (_cond, NULL);
5093     }
5094   }
5095   assert_status(status == 0 || status == EINTR ||
5096                 status == ETIME || status == ETIMEDOUT,
5097                 status, "cond_timedwait");
5098 
5099 #ifdef ASSERT
5100   pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
5101 #endif
5102 
5103   _counter = 0;
5104   status = pthread_mutex_unlock(_mutex);
5105   assert_status(status == 0, status, "invariant");
5106   // If externally suspended while waiting, re-suspend
5107   if (jt->handle_special_suspend_equivalent_condition()) {
5108     jt->java_suspend_self();
5109   }
5110 
5111   OrderAccess::fence();
5112 }
5113 
5114 void Parker::unpark() {
5115   int s, status;
5116   status = pthread_mutex_lock(_mutex);
5117   assert (status == 0, "invariant");
5118   s = _counter;
5119   _counter = 1;
5120   if (s < 1) {
5121     if (WorkAroundNPTLTimedWaitHang) {
5122       status = pthread_cond_signal (_cond);
5123       assert (status == 0, "invariant");
5124       status = pthread_mutex_unlock(_mutex);
5125       assert (status == 0, "invariant");
5126     } else {
5127       status = pthread_mutex_unlock(_mutex);
5128       assert (status == 0, "invariant");
5129       status = pthread_cond_signal (_cond);
5130       assert (status == 0, "invariant");
5131     }
5132   } else {
5133     pthread_mutex_unlock(_mutex);
5134     assert (status == 0, "invariant");
5135   }
5136 }
5137 
5138 extern char** environ;
5139 
5140 // Run the specified command in a separate process. Return its exit value,
5141 // or -1 on failure (e.g. can't fork a new process).
5142 // Unlike system(), this function can be called from signal handler. It
5143 // doesn't block SIGINT et al.
5144 int os::fork_and_exec(char* cmd, bool use_vfork_if_available) {
5145   char * argv[4] = {"sh", "-c", cmd, NULL};
5146 
5147   pid_t pid = fork();
5148 
5149   if (pid < 0) {
5150     // fork failed
5151     return -1;
5152 
5153   } else if (pid == 0) {
5154     // child process
5155 
5156     // Try to be consistent with system(), which uses "/usr/bin/sh" on AIX.
5157     execve("/usr/bin/sh", argv, environ);
5158 
5159     // execve failed
5160     _exit(-1);
5161 
5162   } else {
5163     // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
5164     // care about the actual exit code, for now.
5165 
5166     int status;
5167 
5168     // Wait for the child process to exit. This returns immediately if
5169     // the child has already exited. */
5170     while (waitpid(pid, &status, 0) < 0) {
5171       switch (errno) {
5172         case ECHILD: return 0;
5173         case EINTR: break;
5174         default: return -1;
5175       }
5176     }
5177 
5178     if (WIFEXITED(status)) {
5179       // The child exited normally; get its exit code.
5180       return WEXITSTATUS(status);
5181     } else if (WIFSIGNALED(status)) {
5182       // The child exited because of a signal.
5183       // The best value to return is 0x80 + signal number,
5184       // because that is what all Unix shells do, and because
5185       // it allows callers to distinguish between process exit and
5186       // process death by signal.
5187       return 0x80 + WTERMSIG(status);
5188     } else {
5189       // Unknown exit code; pass it through.
5190       return status;
5191     }
5192   }
5193   return -1;
5194 }
5195 
5196 // is_headless_jre()
5197 //
5198 // Test for the existence of xawt/libmawt.so or libawt_xawt.so
5199 // in order to report if we are running in a headless jre.
5200 //
5201 // Since JDK8 xawt/libmawt.so is moved into the same directory
5202 // as libawt.so, and renamed libawt_xawt.so
5203 bool os::is_headless_jre() {
5204   struct stat statbuf;
5205   char buf[MAXPATHLEN];
5206   char libmawtpath[MAXPATHLEN];
5207   const char *xawtstr = "/xawt/libmawt.so";
5208   const char *new_xawtstr = "/libawt_xawt.so";
5209 
5210   char *p;
5211 
5212   // Get path to libjvm.so
5213   os::jvm_path(buf, sizeof(buf));
5214 
5215   // Get rid of libjvm.so
5216   p = strrchr(buf, '/');
5217   if (p == NULL) return false;
5218   else *p = '\0';
5219 
5220   // Get rid of client or server
5221   p = strrchr(buf, '/');
5222   if (p == NULL) return false;
5223   else *p = '\0';
5224 
5225   // check xawt/libmawt.so
5226   strcpy(libmawtpath, buf);
5227   strcat(libmawtpath, xawtstr);
5228   if (::stat(libmawtpath, &statbuf) == 0) return false;
5229 
5230   // check libawt_xawt.so
5231   strcpy(libmawtpath, buf);
5232   strcat(libmawtpath, new_xawtstr);
5233   if (::stat(libmawtpath, &statbuf) == 0) return false;
5234 
5235   return true;
5236 }
5237 
5238 // Get the default path to the core file
5239 // Returns the length of the string
5240 int os::get_core_path(char* buffer, size_t bufferSize) {
5241   const char* p = get_current_directory(buffer, bufferSize);
5242 
5243   if (p == NULL) {
5244     assert(p != NULL, "failed to get current directory");
5245     return 0;
5246   }
5247 
5248   return strlen(buffer);
5249 }
5250 
5251 #ifndef PRODUCT
5252 void TestReserveMemorySpecial_test() {
5253   // No tests available for this platform
5254 }
5255 #endif
--- EOF ---