rev 9449 : 8143125-Further Developments for AIX

   1 /*
   2  * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright 2012, 2015 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 "libo4.hpp"
  40 #include "libperfstat_aix.hpp"
  41 #include "loadlib_aix.hpp"
  42 #include "memory/allocation.inline.hpp"
  43 #include "memory/filemap.hpp"
  44 #include "misc_aix.hpp"
  45 #include "mutex_aix.inline.hpp"
  46 #include "oops/oop.inline.hpp"
  47 #include "os_aix.inline.hpp"
  48 #include "os_share_aix.hpp"
  49 #include "porting_aix.hpp"
  50 #include "prims/jniFastGetField.hpp"
  51 #include "prims/jvm.h"
  52 #include "prims/jvm_misc.hpp"
  53 #include "runtime/arguments.hpp"
  54 #include "runtime/atomic.inline.hpp"
  55 #include "runtime/extendedPC.hpp"
  56 #include "runtime/globals.hpp"
  57 #include "runtime/interfaceSupport.hpp"
  58 #include "runtime/java.hpp"
  59 #include "runtime/javaCalls.hpp"
  60 #include "runtime/mutexLocker.hpp"
  61 #include "runtime/objectMonitor.hpp"
  62 #include "runtime/orderAccess.inline.hpp"
  63 #include "runtime/os.hpp"
  64 #include "runtime/osThread.hpp"
  65 #include "runtime/perfMemory.hpp"
  66 #include "runtime/sharedRuntime.hpp"
  67 #include "runtime/statSampler.hpp"
  68 #include "runtime/stubRoutines.hpp"
  69 #include "runtime/thread.inline.hpp"
  70 #include "runtime/threadCritical.hpp"
  71 #include "runtime/timer.hpp"
  72 #include "runtime/vm_version.hpp"
  73 #include "services/attachListener.hpp"
  74 #include "services/runtimeService.hpp"
  75 #include "utilities/decoder.hpp"
  76 #include "utilities/defaultStream.hpp"
  77 #define PV_8_Compat 0x308000   /* Power PC 8 */
  78 #include "utilities/events.hpp"
  79 #include "utilities/growableArray.hpp"
  80 #include "utilities/vmError.hpp"
  81 
  82 // put OS-includes here (sorted alphabetically)
  83 #include <errno.h>
  84 #include <fcntl.h>
  85 #include <inttypes.h>
  86 #include <poll.h>
  87 #include <procinfo.h>
  88 #include <pthread.h>
  89 #include <pwd.h>
  90 #include <semaphore.h>
  91 #include <signal.h>
  92 #include <stdint.h>
  93 #include <stdio.h>
  94 #include <string.h>
  95 #include <unistd.h>
  96 #include <sys/ioctl.h>
  97 #include <sys/ipc.h>
  98 #include <sys/mman.h>
  99 #include <sys/resource.h>
 100 #include <sys/select.h>
 101 #include <sys/shm.h>
 102 #include <sys/socket.h>
 103 #include <sys/stat.h>
 104 #include <sys/sysinfo.h>
 105 #include <sys/systemcfg.h>
 106 #include <sys/time.h>
 107 #include <sys/times.h>
 108 #include <sys/types.h>
 109 #include <sys/utsname.h>
 110 #include <sys/vminfo.h>
 111 #include <sys/wait.h>
 112 
 113 // Missing prototypes for various system APIs.
 114 extern "C"
 115 int mread_real_time(timebasestruct_t *t, size_t size_of_timebasestruct_t);






 116 

 117 #if !defined(_AIXVERSION_610)
 118 extern "C" int getthrds64(pid_t, struct thrdentry64*, int, tid64_t*, int);
 119 extern "C" int getprocs64(procentry64*, int, fdsinfo*, int, pid_t*, int);
 120 extern "C" int getargs   (procsinfo*, int, char*, int);




 121 #endif
 122 
 123 #define MAX_PATH (2 * K)
 124 
 125 // for timer info max values which include all bits
 126 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
 127 // for multipage initialization error analysis (in 'g_multipage_error')
 128 #define ERROR_MP_OS_TOO_OLD                          100
 129 #define ERROR_MP_EXTSHM_ACTIVE                       101
 130 #define ERROR_MP_VMGETINFO_FAILED                    102
 131 #define ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K 103
 132 
 133 // The semantics in this file are thus that codeptr_t is a *real code ptr*.
 134 // This means that any function taking codeptr_t as arguments will assume
 135 // a real codeptr and won't handle function descriptors (eg getFuncName),
 136 // whereas functions taking address as args will deal with function
 137 // descriptors (eg os::dll_address_to_library_name).
 138 typedef unsigned int* codeptr_t;
 139 
 140 // Typedefs for stackslots, stack pointers, pointers to op codes.
 141 typedef unsigned long stackslot_t;
 142 typedef stackslot_t* stackptr_t;
 143 










 144 // Query dimensions of the stack of the calling thread.
 145 static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size);
 146 static address resolve_function_descriptor_to_code_pointer(address p);
 147 
 148 // Function to check a given stack pointer against given stack limits.
 149 inline bool is_valid_stackpointer(stackptr_t sp, stackptr_t stack_base, size_t stack_size) {
 150   if (((uintptr_t)sp) & 0x7) {
 151     return false;
 152   }
 153   if (sp > stack_base) {
 154     return false;
 155   }
 156   if (sp < (stackptr_t) ((address)stack_base - stack_size)) {
 157     return false;
 158   }
 159   return true;
 160 }
 161 
 162 // Returns true if function is a valid codepointer.
 163 inline bool is_valid_codepointer(codeptr_t p) {
 164   if (!p) {
 165     return false;
 166   }
 167   if (((uintptr_t)p) & 0x3) {
 168     return false;
 169   }
 170   if (LoadedLibraries::find_for_text_address(p, NULL) == NULL) {
 171     return false;
 172   }
 173   return true;
 174 }
 175 
 176 // Macro to check a given stack pointer against given stack limits and to die if test fails.
 177 #define CHECK_STACK_PTR(sp, stack_base, stack_size) { \
 178     guarantee(is_valid_stackpointer((stackptr_t)(sp), (stackptr_t)(stack_base), stack_size), "Stack Pointer Invalid"); \
 179 }
 180 
 181 // Macro to check the current stack pointer against given stacklimits.
 182 #define CHECK_CURRENT_STACK_PTR(stack_base, stack_size) { \
 183   address sp; \
 184   sp = os::current_stack_pointer(); \
 185   CHECK_STACK_PTR(sp, stack_base, stack_size); \
 186 }
 187 
 188 static void vmembk_print_on(outputStream* os);
 189 
 190 ////////////////////////////////////////////////////////////////////////////////
 191 // global variables (for a description see os_aix.hpp)
 192 
 193 julong    os::Aix::_physical_memory = 0;
 194 
 195 pthread_t os::Aix::_main_thread = ((pthread_t)0);
 196 int       os::Aix::_page_size = -1;
 197 
 198 // -1 = uninitialized, 0 if AIX, 1 if OS/400 pase
 199 int       os::Aix::_on_pase = -1;
 200 
 201 // -1 = uninitialized, otherwise os version in the form 0xMMmm - MM:major, mm:minor
 202 //  E.g. 0x0601 for  AIX 6.1 or 0x0504 for OS/400 V5R4
 203 int       os::Aix::_os_version = -1;
 204 
 205 int       os::Aix::_stack_page_size = -1;
 206 
 207 // -1 = uninitialized, 0 - no, 1 - yes
 208 int       os::Aix::_xpg_sus_mode = -1;
 209 
 210 // -1 = uninitialized, 0 - no, 1 - yes
 211 int       os::Aix::_extshm = -1;

 212 
 213 ////////////////////////////////////////////////////////////////////////////////
 214 // local variables
 215 

 216 static jlong    initial_time_count = 0;
 217 static int      clock_tics_per_sec = 100;
 218 static sigset_t check_signal_done;         // For diagnostics to print a message once (see run_periodic_checks)
 219 static bool     check_signals      = true;

 220 static int      SR_signum          = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769)
 221 static sigset_t SR_sigset;
 222 
 223 // Process break recorded at startup.
 224 static address g_brk_at_startup = NULL;
 225 
 226 // This describes the state of multipage support of the underlying
 227 // OS. Note that this is of no interest to the outsize world and
 228 // therefore should not be defined in AIX class.
 229 //
 230 // AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The
 231 // latter two (16M "large" resp. 16G "huge" pages) require special
 232 // setup and are normally not available.
 233 //
 234 // AIX supports multiple page sizes per process, for:
 235 //  - Stack (of the primordial thread, so not relevant for us)
 236 //  - Data - data, bss, heap, for us also pthread stacks
 237 //  - Text - text code
 238 //  - shared memory
 239 //
 240 // Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...)
 241 // and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...).
 242 //
 243 // For shared memory, page size can be set dynamically via
 244 // shmctl(). Different shared memory regions can have different page
 245 // sizes.
 246 //
 247 // More information can be found at AIBM info center:
 248 //   http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm
 249 //
 250 static struct {
 251   size_t pagesize;            // sysconf _SC_PAGESIZE (4K)
 252   size_t datapsize;           // default data page size (LDR_CNTRL DATAPSIZE)
 253   size_t shmpsize;            // default shared memory page size (LDR_CNTRL SHMPSIZE)
 254   size_t pthr_stack_pagesize; // stack page size of pthread threads
 255   size_t textpsize;           // default text page size (LDR_CNTRL STACKPSIZE)
 256   bool can_use_64K_pages;     // True if we can alloc 64K pages dynamically with Sys V shm.
 257   bool can_use_16M_pages;     // True if we can alloc 16M pages dynamically with Sys V shm.
 258   int error;                  // Error describing if something went wrong at multipage init.
 259 } g_multipage_support = {
 260   (size_t) -1,
 261   (size_t) -1,
 262   (size_t) -1,
 263   (size_t) -1,
 264   (size_t) -1,
 265   false, false,
 266   0
 267 };
 268 
 269 // We must not accidentally allocate memory close to the BRK - even if
 270 // that would work - because then we prevent the BRK segment from
 271 // growing which may result in a malloc OOM even though there is
 272 // enough memory. The problem only arises if we shmat() or mmap() at
 273 // a specific wish address, e.g. to place the heap in a
 274 // compressed-oops-friendly way.
 275 static bool is_close_to_brk(address a) {
 276   assert0(g_brk_at_startup != NULL);
 277   if (a >= g_brk_at_startup &&
 278       a < (g_brk_at_startup + MaxExpectedDataSegmentSize)) {
 279     return true;
 280   }
 281   return false;
 282 }
 283 
 284 julong os::available_memory() {
 285   return Aix::available_memory();
 286 }
 287 
 288 julong os::Aix::available_memory() {
 289   // Avoid expensive API call here, as returned value will always be null.
 290   if (os::Aix::on_pase()) {
 291     return 0x0LL;
 292   }
 293   os::Aix::meminfo_t mi;
 294   if (os::Aix::get_meminfo(&mi)) {
 295     return mi.real_free;
 296   } else {
 297     return ULONG_MAX;
 298   }
 299 }
 300 
 301 julong os::physical_memory() {
 302   return Aix::physical_memory();
 303 }
 304 
 305 // Return true if user is running as root.
 306 
 307 bool os::have_special_privileges() {
 308   static bool init = false;
 309   static bool privileges = false;
 310   if (!init) {
 311     privileges = (getuid() != geteuid()) || (getgid() != getegid());
 312     init = true;
 313   }
 314   return privileges;
 315 }
 316 
 317 // Helper function, emulates disclaim64 using multiple 32bit disclaims
 318 // because we cannot use disclaim64() on AS/400 and old AIX releases.
 319 static bool my_disclaim64(char* addr, size_t size) {
 320 
 321   if (size == 0) {
 322     return true;
 323   }
 324 
 325   // Maximum size 32bit disclaim() accepts. (Theoretically 4GB, but I just do not trust that.)
 326   const unsigned int maxDisclaimSize = 0x40000000;
 327 
 328   const unsigned int numFullDisclaimsNeeded = (size / maxDisclaimSize);
 329   const unsigned int lastDisclaimSize = (size % maxDisclaimSize);
 330 
 331   char* p = addr;
 332 
 333   for (int i = 0; i < numFullDisclaimsNeeded; i ++) {
 334     if (::disclaim(p, maxDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
 335       trcVerbose("Cannot disclaim %p - %p (errno %d)\n", p, p + maxDisclaimSize, errno);
 336       return false;
 337     }
 338     p += maxDisclaimSize;
 339   }
 340 
 341   if (lastDisclaimSize > 0) {
 342     if (::disclaim(p, lastDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
 343       trcVerbose("Cannot disclaim %p - %p (errno %d)\n", p, p + lastDisclaimSize, errno);
 344       return false;
 345     }
 346   }
 347 
 348   return true;
 349 }
 350 
 351 // Cpu architecture string
 352 #if defined(PPC32)
 353 static char cpu_arch[] = "ppc";
 354 #elif defined(PPC64)
 355 static char cpu_arch[] = "ppc64";
 356 #else
 357 #error Add appropriate cpu_arch setting
 358 #endif
 359 
 360 // Wrap the function "vmgetinfo" which is not available on older OS releases.
 361 static int checked_vmgetinfo(void *out, int command, int arg) {
 362   if (os::Aix::on_pase() && os::Aix::os_version() < 0x0601) {
 363     guarantee(false, "cannot call vmgetinfo on AS/400 older than V6R1");
 364   }
 365   return ::vmgetinfo(out, command, arg);
 366 }
 367 
 368 // Given an address, returns the size of the page backing that address.
 369 size_t os::Aix::query_pagesize(void* addr) {
 370 
 371   if (os::Aix::on_pase() && os::Aix::os_version() < 0x0601) {
 372     // AS/400 older than V6R1: no vmgetinfo here, default to 4K
 373     return SIZE_4K;
 374   }
 375 
 376   vm_page_info pi;
 377   pi.addr = (uint64_t)addr;
 378   if (checked_vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) {
 379     return pi.pagesize;
 380   } else {

 381     assert(false, "vmgetinfo failed to retrieve page size");
 382     return SIZE_4K;
 383   }






 384 }
 385 
 386 void os::Aix::initialize_system_info() {
 387 
 388   // Get the number of online(logical) cpus instead of configured.
 389   os::_processor_count = sysconf(_SC_NPROCESSORS_ONLN);
 390   assert(_processor_count > 0, "_processor_count must be > 0");
 391 
 392   // Retrieve total physical storage.
 393   os::Aix::meminfo_t mi;
 394   if (!os::Aix::get_meminfo(&mi)) {

 395     assert(false, "os::Aix::get_meminfo failed.");
 396   }
 397   _physical_memory = (julong) mi.real_total;
 398 }
 399 
 400 // Helper function for tracing page sizes.
 401 static const char* describe_pagesize(size_t pagesize) {
 402   switch (pagesize) {
 403     case SIZE_4K : return "4K";
 404     case SIZE_64K: return "64K";
 405     case SIZE_16M: return "16M";
 406     case SIZE_16G: return "16G";

 407     default:
 408       assert(false, "surprise");
 409       return "??";
 410   }
 411 }
 412 
 413 // Probe OS for multipage support.
 414 // Will fill the global g_multipage_support structure.
 415 // Must be called before calling os::large_page_init().
 416 static void query_multipage_support() {
 417 
 418   guarantee(g_multipage_support.pagesize == -1,
 419             "do not call twice");
 420 
 421   g_multipage_support.pagesize = ::sysconf(_SC_PAGESIZE);
 422 
 423   // This really would surprise me.
 424   assert(g_multipage_support.pagesize == SIZE_4K, "surprise!");
 425 
 426   // Query default data page size (default page size for C-Heap, pthread stacks and .bss).
 427   // Default data page size is defined either by linker options (-bdatapsize)
 428   // or by environment variable LDR_CNTRL (suboption DATAPSIZE). If none is given,
 429   // default should be 4K.
 430   {
 431     void* p = ::malloc(SIZE_16M);
 432     g_multipage_support.datapsize = os::Aix::query_pagesize(p);
 433     ::free(p);
 434   }
 435 
 436   // Query default shm page size (LDR_CNTRL SHMPSIZE).
 437   // Note that this is pure curiosity. We do not rely on default page size but set
 438   // our own page size after allocated.
 439   {
 440     const int shmid = ::shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR | S_IWUSR);
 441     guarantee(shmid != -1, "shmget failed");
 442     void* p = ::shmat(shmid, NULL, 0);
 443     ::shmctl(shmid, IPC_RMID, NULL);
 444     guarantee(p != (void*) -1, "shmat failed");
 445     g_multipage_support.shmpsize = os::Aix::query_pagesize(p);
 446     ::shmdt(p);
 447   }
 448 
 449   // Before querying the stack page size, make sure we are not running as primordial
 450   // thread (because primordial thread's stack may have different page size than
 451   // pthread thread stacks). Running a VM on the primordial thread won't work for a
 452   // number of reasons so we may just as well guarantee it here.
 453   guarantee0(!os::Aix::is_primordial_thread());
 454 
 455   // Query pthread stack page size. Should be the same as data page size because
 456   // pthread stacks are allocated from C-Heap.
 457   {
 458     int dummy = 0;
 459     g_multipage_support.pthr_stack_pagesize = os::Aix::query_pagesize(&dummy);
 460   }
 461 
 462   // Query default text page size (LDR_CNTRL TEXTPSIZE).

 463   {
 464     address any_function =
 465       resolve_function_descriptor_to_code_pointer((address)describe_pagesize);
 466     g_multipage_support.textpsize = os::Aix::query_pagesize(any_function);
 467   }

 468 
 469   // Now probe for support of 64K pages and 16M pages.
 470 
 471   // Before OS/400 V6R1, there is no support for pages other than 4K.
 472   if (os::Aix::on_pase_V5R4_or_older()) {
 473     trcVerbose("OS/400 < V6R1 - no large page support.");
 474     g_multipage_support.error = ERROR_MP_OS_TOO_OLD;
 475     goto query_multipage_support_end;
 476   }
 477 
 478   // Now check which page sizes the OS claims it supports, and of those, which actually can be used.
 479   {
 480     const int MAX_PAGE_SIZES = 4;
 481     psize_t sizes[MAX_PAGE_SIZES];
 482     const int num_psizes = checked_vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES);
 483     if (num_psizes == -1) {
 484       trcVerbose("vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)", errno);
 485       trcVerbose("disabling multipage support.");
 486       g_multipage_support.error = ERROR_MP_VMGETINFO_FAILED;
 487       goto query_multipage_support_end;
 488     }
 489     guarantee(num_psizes > 0, "vmgetinfo(.., VMINFO_GETPSIZES, ...) failed.");
 490     assert(num_psizes <= MAX_PAGE_SIZES, "Surprise! more than 4 page sizes?");
 491     trcVerbose("vmgetinfo(.., VMINFO_GETPSIZES, ...) returns %d supported page sizes: ", num_psizes);
 492     for (int i = 0; i < num_psizes; i ++) {
 493       trcVerbose(" %s ", describe_pagesize(sizes[i]));
 494     }
 495 
 496     // Can we use 64K, 16M pages?
 497     for (int i = 0; i < num_psizes; i ++) {
 498       const size_t pagesize = sizes[i];
 499       if (pagesize != SIZE_64K && pagesize != SIZE_16M) {
 500         continue;
 501       }
 502       bool can_use = false;
 503       trcVerbose("Probing support for %s pages...", describe_pagesize(pagesize));
 504       const int shmid = ::shmget(IPC_PRIVATE, pagesize,
 505         IPC_CREAT | S_IRUSR | S_IWUSR);
 506       guarantee0(shmid != -1); // Should always work.
 507       // Try to set pagesize.
 508       struct shmid_ds shm_buf = { 0 };
 509       shm_buf.shm_pagesize = pagesize;
 510       if (::shmctl(shmid, SHM_PAGESIZE, &shm_buf) != 0) {
 511         const int en = errno;
 512         ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
 513         trcVerbose("shmctl(SHM_PAGESIZE) failed with %s",
 514           MiscUtils::describe_errno(en));
 515       } else {
 516         // Attach and double check pageisze.
 517         void* p = ::shmat(shmid, NULL, 0);
 518         ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
 519         guarantee0(p != (void*) -1); // Should always work.
 520         const size_t real_pagesize = os::Aix::query_pagesize(p);
 521         if (real_pagesize != pagesize) {
 522           trcVerbose("real page size (0x%llX) differs.", real_pagesize);
 523         } else {
 524           can_use = true;
 525         }
 526         ::shmdt(p);
 527       }
 528       trcVerbose("Can use: %s", (can_use ? "yes" : "no"));
 529       if (pagesize == SIZE_64K) {
 530         g_multipage_support.can_use_64K_pages = can_use;
 531       } else if (pagesize == SIZE_16M) {
 532         g_multipage_support.can_use_16M_pages = can_use;
 533       }
 534     }
 535 
 536   } // end: check which pages can be used for shared memory
 537 
 538 query_multipage_support_end:
 539 
 540   trcVerbose("base page size (sysconf _SC_PAGESIZE): %s",
 541       describe_pagesize(g_multipage_support.pagesize));
 542   trcVerbose("Data page size (C-Heap, bss, etc): %s",
 543       describe_pagesize(g_multipage_support.datapsize));
 544   trcVerbose("Text page size: %s",
 545       describe_pagesize(g_multipage_support.textpsize));
 546   trcVerbose("Thread stack page size (pthread): %s",
 547       describe_pagesize(g_multipage_support.pthr_stack_pagesize));
 548   trcVerbose("Default shared memory page size: %s",
 549       describe_pagesize(g_multipage_support.shmpsize));
 550   trcVerbose("Can use 64K pages dynamically with shared meory: %s",
 551       (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
 552   trcVerbose("Can use 16M pages dynamically with shared memory: %s",
 553       (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
 554   trcVerbose("Multipage error details: %d",
 555       g_multipage_support.error);
 556 
 557   // sanity checks
 558   assert0(g_multipage_support.pagesize == SIZE_4K);
 559   assert0(g_multipage_support.datapsize == SIZE_4K || g_multipage_support.datapsize == SIZE_64K);
 560   assert0(g_multipage_support.textpsize == SIZE_4K || g_multipage_support.textpsize == SIZE_64K);
 561   assert0(g_multipage_support.pthr_stack_pagesize == g_multipage_support.datapsize);
 562   assert0(g_multipage_support.shmpsize == SIZE_4K || g_multipage_support.shmpsize == SIZE_64K);
 563 
 564 }
 565 
 566 void os::init_system_properties_values() {
 567 
 568 #define DEFAULT_LIBPATH "/lib:/usr/lib"
 569 #define EXTENSIONS_DIR  "/lib/ext"
 570 
 571   // Buffer that fits several sprintfs.
 572   // Note that the space for the trailing null is provided
 573   // by the nulls included by the sizeof operator.
 574   const size_t bufsize =
 575     MAX2((size_t)MAXPATHLEN,  // For dll_dir & friends.
 576          (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR)); // extensions dir
 577   char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
 578 
 579   // sysclasspath, java_home, dll_dir
 580   {
 581     char *pslash;
 582     os::jvm_path(buf, bufsize);
 583 
 584     // Found the full path to libjvm.so.
 585     // Now cut the path to <java_home>/jre if we can.
 586     pslash = strrchr(buf, '/');
 587     if (pslash != NULL) {
 588       *pslash = '\0';            // Get rid of /libjvm.so.
 589     }
 590     pslash = strrchr(buf, '/');
 591     if (pslash != NULL) {
 592       *pslash = '\0';            // Get rid of /{client|server|hotspot}.
 593     }
 594     Arguments::set_dll_dir(buf);
 595 
 596     if (pslash != NULL) {
 597       pslash = strrchr(buf, '/');
 598       if (pslash != NULL) {
 599         *pslash = '\0';          // Get rid of /<arch>.
 600         pslash = strrchr(buf, '/');
 601         if (pslash != NULL) {
 602           *pslash = '\0';        // Get rid of /lib.
 603         }
 604       }
 605     }
 606     Arguments::set_java_home(buf);
 607     set_boot_path('/', ':');
 608   }
 609 
 610   // Where to look for native libraries.
 611 
 612   // On Aix we get the user setting of LIBPATH.
 613   // Eventually, all the library path setting will be done here.
 614   // Get the user setting of LIBPATH.
 615   const char *v = ::getenv("LIBPATH");
 616   const char *v_colon = ":";
 617   if (v == NULL) { v = ""; v_colon = ""; }
 618 
 619   // Concatenate user and invariant part of ld_library_path.
 620   // That's +1 for the colon and +1 for the trailing '\0'.
 621   char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal);
 622   sprintf(ld_library_path, "%s%s" DEFAULT_LIBPATH, v, v_colon);
 623   Arguments::set_library_path(ld_library_path);
 624   FREE_C_HEAP_ARRAY(char, ld_library_path);
 625 
 626   // Extensions directories.
 627   sprintf(buf, "%s" EXTENSIONS_DIR, Arguments::get_java_home());
 628   Arguments::set_ext_dirs(buf);
 629 
 630   FREE_C_HEAP_ARRAY(char, buf);
 631 
 632 #undef DEFAULT_LIBPATH
 633 #undef EXTENSIONS_DIR
 634 }
 635 
 636 ////////////////////////////////////////////////////////////////////////////////
 637 // breakpoint support
 638 
 639 void os::breakpoint() {
 640   BREAKPOINT;
 641 }
 642 
 643 extern "C" void breakpoint() {
 644   // use debugger to set breakpoint here
 645 }
 646 
 647 ////////////////////////////////////////////////////////////////////////////////
 648 // signal support
 649 
 650 debug_only(static bool signal_sets_initialized = false);
 651 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
 652 
 653 bool os::Aix::is_sig_ignored(int sig) {
 654   struct sigaction oact;
 655   sigaction(sig, (struct sigaction*)NULL, &oact);
 656   void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
 657     : CAST_FROM_FN_PTR(void*, oact.sa_handler);
 658   if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
 659     return true;
 660   } else {
 661     return false;
 662   }
 663 }
 664 
 665 void os::Aix::signal_sets_init() {
 666   // Should also have an assertion stating we are still single-threaded.
 667   assert(!signal_sets_initialized, "Already initialized");
 668   // Fill in signals that are necessarily unblocked for all threads in
 669   // the VM. Currently, we unblock the following signals:
 670   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
 671   //                         by -Xrs (=ReduceSignalUsage));
 672   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
 673   // other threads. The "ReduceSignalUsage" boolean tells us not to alter
 674   // the dispositions or masks wrt these signals.
 675   // Programs embedding the VM that want to use the above signals for their
 676   // own purposes must, at this time, use the "-Xrs" option to prevent
 677   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
 678   // (See bug 4345157, and other related bugs).
 679   // In reality, though, unblocking these signals is really a nop, since
 680   // these signals are not blocked by default.
 681   sigemptyset(&unblocked_sigs);
 682   sigemptyset(&allowdebug_blocked_sigs);
 683   sigaddset(&unblocked_sigs, SIGILL);
 684   sigaddset(&unblocked_sigs, SIGSEGV);
 685   sigaddset(&unblocked_sigs, SIGBUS);
 686   sigaddset(&unblocked_sigs, SIGFPE);
 687   sigaddset(&unblocked_sigs, SIGTRAP);
 688   sigaddset(&unblocked_sigs, SIGDANGER);
 689   sigaddset(&unblocked_sigs, SR_signum);
 690 
 691   if (!ReduceSignalUsage) {
 692    if (!os::Aix::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
 693      sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
 694      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
 695    }
 696    if (!os::Aix::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
 697      sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
 698      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
 699    }
 700    if (!os::Aix::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
 701      sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
 702      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
 703    }
 704   }
 705   // Fill in signals that are blocked by all but the VM thread.
 706   sigemptyset(&vm_sigs);
 707   if (!ReduceSignalUsage)
 708     sigaddset(&vm_sigs, BREAK_SIGNAL);
 709   debug_only(signal_sets_initialized = true);
 710 }
 711 
 712 // These are signals that are unblocked while a thread is running Java.
 713 // (For some reason, they get blocked by default.)
 714 sigset_t* os::Aix::unblocked_signals() {
 715   assert(signal_sets_initialized, "Not initialized");
 716   return &unblocked_sigs;
 717 }
 718 
 719 // These are the signals that are blocked while a (non-VM) thread is
 720 // running Java. Only the VM thread handles these signals.
 721 sigset_t* os::Aix::vm_signals() {
 722   assert(signal_sets_initialized, "Not initialized");
 723   return &vm_sigs;
 724 }
 725 
 726 // These are signals that are blocked during cond_wait to allow debugger in
 727 sigset_t* os::Aix::allowdebug_blocked_signals() {
 728   assert(signal_sets_initialized, "Not initialized");
 729   return &allowdebug_blocked_sigs;
 730 }
 731 
 732 void os::Aix::hotspot_sigmask(Thread* thread) {
 733 
 734   //Save caller's signal mask before setting VM signal mask
 735   sigset_t caller_sigmask;
 736   pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);
 737 
 738   OSThread* osthread = thread->osthread();
 739   osthread->set_caller_sigmask(caller_sigmask);
 740 
 741   pthread_sigmask(SIG_UNBLOCK, os::Aix::unblocked_signals(), NULL);
 742 
 743   if (!ReduceSignalUsage) {
 744     if (thread->is_VM_thread()) {
 745       // Only the VM thread handles BREAK_SIGNAL ...
 746       pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);
 747     } else {
 748       // ... all other threads block BREAK_SIGNAL
 749       pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);
 750     }
 751   }
 752 }
 753 
 754 // retrieve memory information.
 755 // Returns false if something went wrong;
 756 // content of pmi undefined in this case.
 757 bool os::Aix::get_meminfo(meminfo_t* pmi) {
 758 
 759   assert(pmi, "get_meminfo: invalid parameter");
 760 
 761   memset(pmi, 0, sizeof(meminfo_t));
 762 
 763   if (os::Aix::on_pase()) {
 764     // On PASE, use the libo4 porting library.
 765 
 766     unsigned long long virt_total = 0;
 767     unsigned long long real_total = 0;
 768     unsigned long long real_free = 0;
 769     unsigned long long pgsp_total = 0;
 770     unsigned long long pgsp_free = 0;
 771     if (libo4::get_memory_info(&virt_total, &real_total, &real_free, &pgsp_total, &pgsp_free)) {
 772       pmi->virt_total = virt_total;
 773       pmi->real_total = real_total;
 774       pmi->real_free = real_free;
 775       pmi->pgsp_total = pgsp_total;
 776       pmi->pgsp_free = pgsp_free;
 777       return true;
 778     }
 779     return false;
 780 
 781   } else {
 782 
 783     // On AIX, I use the (dynamically loaded) perfstat library to retrieve memory statistics
 784     // See:
 785     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 786     //        ?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_memtot.htm
 787     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 788     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
 789 
 790     perfstat_memory_total_t psmt;
 791     memset (&psmt, '\0', sizeof(psmt));
 792     const int rc = libperfstat::perfstat_memory_total(NULL, &psmt, sizeof(psmt), 1);
 793     if (rc == -1) {
 794       fprintf(stderr, "perfstat_memory_total() failed (errno=%d)\n", errno);
 795       assert(0, "perfstat_memory_total() failed");
 796       return false;
 797     }
 798 
 799     assert(rc == 1, "perfstat_memory_total() - weird return code");
 800 
 801     // excerpt from
 802     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 803     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
 804     // The fields of perfstat_memory_total_t:
 805     // u_longlong_t virt_total         Total virtual memory (in 4 KB pages).
 806     // u_longlong_t real_total         Total real memory (in 4 KB pages).
 807     // u_longlong_t real_free          Free real memory (in 4 KB pages).
 808     // u_longlong_t pgsp_total         Total paging space (in 4 KB pages).
 809     // u_longlong_t pgsp_free          Free paging space (in 4 KB pages).
 810 
 811     pmi->virt_total = psmt.virt_total * 4096;
 812     pmi->real_total = psmt.real_total * 4096;
 813     pmi->real_free = psmt.real_free * 4096;
 814     pmi->pgsp_total = psmt.pgsp_total * 4096;
 815     pmi->pgsp_free = psmt.pgsp_free * 4096;
 816 
 817     return true;
 818 
 819   }
 820 } // end os::Aix::get_meminfo
 821 











































































 822 //////////////////////////////////////////////////////////////////////////////
 823 // create new thread
 824 
 825 // Thread start routine for all newly created threads
 826 static void *java_start(Thread *thread) {
 827 
 828   // find out my own stack dimensions
 829   {
 830     // actually, this should do exactly the same as thread->record_stack_base_and_size...
 831     address base = 0;
 832     size_t size = 0;
 833     query_stack_dimensions(&base, &size);
 834     thread->set_stack_base(base);
 835     thread->set_stack_size(size);
 836   }
 837 
 838   const pthread_t pthread_id = ::pthread_self();
 839   const tid_t kernel_thread_id = ::thread_self();
 840 
 841   trcVerbose("newborn Thread : pthread-id %u, ktid " UINT64_FORMAT
 842     ", stack %p ... %p, stacksize 0x%IX (%IB)",
 843     pthread_id, kernel_thread_id,
 844     thread->stack_base() - thread->stack_size(),
 845     thread->stack_base(),
 846     thread->stack_size(),
 847     thread->stack_size());
 848 
 849   // Normally, pthread stacks on AIX live in the data segment (are allocated with malloc()
 850   // by the pthread library). In rare cases, this may not be the case, e.g. when third-party
 851   // tools hook pthread_create(). In this case, we may run into problems establishing
 852   // guard pages on those stacks, because the stacks may reside in memory which is not
 853   // protectable (shmated).
 854   if (thread->stack_base() > ::sbrk(0)) {
 855     fprintf(stderr, "Thread " UINT64_FORMAT ": stack not in data segment.", (uint64_t) pthread_id);
 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 pthread id.
 876   osthread->set_thread_id(pthread_id);
 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   trcVerbose("Thread finished : pthread-id %u, ktid " UINT64_FORMAT ".",
 890     pthread_id, kernel_thread_id);
 891 
 892   return 0;
 893 }
 894 
 895 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
 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 (stack_size == 0) {
 929     stack_size = os::Aix::default_stack_size(thr_type);
 930 
 931     switch (thr_type) {
 932     case os::java_thread:
 933       // Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.
 934       assert(JavaThread::stack_size_at_create() > 0, "this should be set");
 935       stack_size = JavaThread::stack_size_at_create();
 936       break;
 937     case os::compiler_thread:
 938       if (CompilerThreadStackSize > 0) {
 939         stack_size = (size_t)(CompilerThreadStackSize * K);
 940         break;
 941       } // else fall through:
 942         // use VMThreadStackSize if CompilerThreadStackSize is not defined
 943     case os::vm_thread:
 944     case os::pgc_thread:
 945     case os::cgc_thread:
 946     case os::watcher_thread:
 947       if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
 948       break;
 949     }
 950   }
 951 
 952   stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);
 953   pthread_attr_setstacksize(&attr, stack_size);
 954 
 955   pthread_t tid;
 956   int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
 957 
 958   pthread_attr_destroy(&attr);
 959 
 960   if (ret == 0) {
 961     trcVerbose("Created New Thread : pthread-id %u", tid);
 962   } else {
 963     if (os::Aix::on_pase()) {
 964       // QIBM_MULTI_THREADED=Y is needed when the launcher is started on iSeries
 965       // using QSH. Otherwise pthread_create fails with errno=11.
 966       trcVerbose("(Please make sure you set the environment variable "
 967               "QIBM_MULTI_THREADED=Y before running this program.)");
 968     }
 969     if (PrintMiscellaneous && (Verbose || WizardMode)) {
 970       perror("pthread_create()");
 971     }
 972     // Need to clean up stuff we've allocated so far
 973     thread->set_osthread(NULL);
 974     delete osthread;
 975     return false;
 976   }
 977 
 978   // OSThread::thread_id is the pthread id.
 979   osthread->set_thread_id(tid);
 980 
 981   return true;
 982 }
 983 
 984 /////////////////////////////////////////////////////////////////////////////
 985 // attach existing thread
 986 
 987 // bootstrap the main thread
 988 bool os::create_main_thread(JavaThread* thread) {
 989   assert(os::Aix::_main_thread == pthread_self(), "should be called inside main thread");
 990   return create_attached_thread(thread);
 991 }
 992 
 993 bool os::create_attached_thread(JavaThread* thread) {
 994 #ifdef ASSERT
 995     thread->verify_not_published();
 996 #endif
 997 
 998   // Allocate the OSThread object
 999   OSThread* osthread = new OSThread(NULL, NULL);
1000 
1001   if (osthread == NULL) {
1002     return false;
1003   }
1004 
1005   const pthread_t pthread_id = ::pthread_self();
1006   const tid_t kernel_thread_id = ::thread_self();
1007 
1008   trcVerbose("attaching Thread : pthread-id %u, ktid " UINT64_FORMAT ", stack %p ... %p, stacksize 0x%IX (%IB)",
1009     pthread_id, kernel_thread_id,
1010     thread->stack_base() - thread->stack_size(),
1011     thread->stack_base(),
1012     thread->stack_size(),
1013     thread->stack_size());
1014 
1015   // OSThread::thread_id is the pthread id.
1016   osthread->set_thread_id(pthread_id);
1017 
1018   // initialize floating point control register
1019   os::Aix::init_thread_fpu_state();
1020 
1021   // some sanity checks
1022   CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());
1023 
1024   // Initial thread state is RUNNABLE
1025   osthread->set_state(RUNNABLE);
1026 
1027   thread->set_osthread(osthread);
1028 
1029   if (UseNUMA) {
1030     int lgrp_id = os::numa_get_group_id();
1031     if (lgrp_id != -1) {
1032       thread->set_lgrp_id(lgrp_id);
1033     }
1034   }
1035 
1036   // initialize signal mask for this thread
1037   // and save the caller's signal mask
1038   os::Aix::hotspot_sigmask(thread);
1039 
1040   return true;
1041 }
1042 
1043 void os::pd_start_thread(Thread* thread) {
1044   int status = pthread_continue_np(thread->osthread()->pthread_id());
1045   assert(status == 0, "thr_continue failed");
1046 }
1047 
1048 // Free OS resources related to the OSThread
1049 void os::free_thread(OSThread* osthread) {
1050   assert(osthread != NULL, "osthread not set");
1051 
1052   if (Thread::current()->osthread() == osthread) {
1053     // Restore caller's signal mask
1054     sigset_t sigmask = osthread->caller_sigmask();
1055     pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
1056    }
1057 
1058   delete osthread;
1059 }
1060 
1061 //////////////////////////////////////////////////////////////////////////////
1062 // thread local storage
1063 
1064 int os::allocate_thread_local_storage() {
1065   pthread_key_t key;
1066   int rslt = pthread_key_create(&key, NULL);
1067   assert(rslt == 0, "cannot allocate thread local storage");
1068   return (int)key;
1069 }
1070 
1071 // Note: This is currently not used by VM, as we don't destroy TLS key
1072 // on VM exit.
1073 void os::free_thread_local_storage(int index) {
1074   int rslt = pthread_key_delete((pthread_key_t)index);
1075   assert(rslt == 0, "invalid index");
1076 }
1077 
1078 void os::thread_local_storage_at_put(int index, void* value) {
1079   int rslt = pthread_setspecific((pthread_key_t)index, value);
1080   assert(rslt == 0, "pthread_setspecific failed");
1081 }
1082 
1083 extern "C" Thread* get_thread() {
1084   return ThreadLocalStorage::thread();
1085 }
1086 
1087 ////////////////////////////////////////////////////////////////////////////////
1088 // time support
1089 
1090 // Time since start-up in seconds to a fine granularity.
1091 // Used by VMSelfDestructTimer and the MemProfiler.
1092 double os::elapsedTime() {
1093   return (double)(os::elapsed_counter()) * 0.000001;
1094 }
1095 
1096 jlong os::elapsed_counter() {
1097   timeval time;
1098   int status = gettimeofday(&time, NULL);
1099   return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;
1100 }
1101 
1102 jlong os::elapsed_frequency() {
1103   return (1000 * 1000);
1104 }
1105 
1106 bool os::supports_vtime() { return true; }
1107 bool os::enable_vtime()   { return false; }
1108 bool os::vtime_enabled()  { return false; }
1109 
1110 double os::elapsedVTime() {
1111   struct rusage usage;
1112   int retval = getrusage(RUSAGE_THREAD, &usage);
1113   if (retval == 0) {
1114     return usage.ru_utime.tv_sec + usage.ru_stime.tv_sec + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec) / (1000.0 * 1000);
1115   } else {
1116     // better than nothing, but not much
1117     return elapsedTime();
1118   }
1119 }
1120 
1121 jlong os::javaTimeMillis() {
1122   timeval time;
1123   int status = gettimeofday(&time, NULL);
1124   assert(status != -1, "aix error at gettimeofday()");
1125   return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000);
1126 }
1127 
1128 void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) {
1129   timeval time;
1130   int status = gettimeofday(&time, NULL);
1131   assert(status != -1, "aix error at gettimeofday()");
1132   seconds = jlong(time.tv_sec);
1133   nanos = jlong(time.tv_usec) * 1000;
1134 }
1135 







1136 jlong os::javaTimeNanos() {
1137   if (os::Aix::on_pase()) {
1138 
1139     timeval time;
1140     int status = gettimeofday(&time, NULL);
1141     assert(status != -1, "PASE error at gettimeofday()");
1142     jlong usecs = jlong((unsigned long long) time.tv_sec * (1000 * 1000) + time.tv_usec);
1143     return 1000 * usecs;
1144 
1145   } else {
1146     // On AIX use the precision of processors real time clock
1147     // or time base registers.
1148     timebasestruct_t time;
1149     int rc;
1150 
1151     // If the CPU has a time register, it will be used and
1152     // we have to convert to real time first. After convertion we have following data:
1153     // time.tb_high [seconds since 00:00:00 UTC on 1.1.1970]
1154     // time.tb_low  [nanoseconds after the last full second above]
1155     // We better use mread_real_time here instead of read_real_time
1156     // to ensure that we will get a monotonic increasing time.
1157     if (mread_real_time(&time, TIMEBASE_SZ) != RTC_POWER) {
1158       rc = time_base_to_time(&time, TIMEBASE_SZ);
1159       assert(rc != -1, "aix error at time_base_to_time()");
1160     }
1161     return jlong(time.tb_high) * (1000 * 1000 * 1000) + jlong(time.tb_low);
1162   }
1163 }
1164 
1165 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1166   info_ptr->max_value = ALL_64_BITS;
1167   // mread_real_time() is monotonic (see 'os::javaTimeNanos()')
1168   info_ptr->may_skip_backward = false;
1169   info_ptr->may_skip_forward = false;
1170   info_ptr->kind = JVMTI_TIMER_ELAPSED;    // elapsed not CPU time
1171 }
1172 
1173 // Return the real, user, and system times in seconds from an
1174 // arbitrary fixed point in the past.
1175 bool os::getTimesSecs(double* process_real_time,
1176                       double* process_user_time,
1177                       double* process_system_time) {
1178   struct tms ticks;
1179   clock_t real_ticks = times(&ticks);
1180 
1181   if (real_ticks == (clock_t) (-1)) {
1182     return false;
1183   } else {
1184     double ticks_per_second = (double) clock_tics_per_sec;
1185     *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1186     *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1187     *process_real_time = ((double) real_ticks) / ticks_per_second;
1188 
1189     return true;
1190   }
1191 }
1192 
1193 char * os::local_time_string(char *buf, size_t buflen) {
1194   struct tm t;
1195   time_t long_time;
1196   time(&long_time);
1197   localtime_r(&long_time, &t);
1198   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1199                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1200                t.tm_hour, t.tm_min, t.tm_sec);
1201   return buf;
1202 }
1203 
1204 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
1205   return localtime_r(clock, res);
1206 }
1207 
1208 ////////////////////////////////////////////////////////////////////////////////
1209 // runtime exit support
1210 
1211 // Note: os::shutdown() might be called very early during initialization, or
1212 // called from signal handler. Before adding something to os::shutdown(), make
1213 // sure it is async-safe and can handle partially initialized VM.
1214 void os::shutdown() {
1215 
1216   // allow PerfMemory to attempt cleanup of any persistent resources
1217   perfMemory_exit();
1218 
1219   // needs to remove object in file system
1220   AttachListener::abort();
1221 
1222   // flush buffered output, finish log files
1223   ostream_abort();
1224 
1225   // Check for abort hook
1226   abort_hook_t abort_hook = Arguments::abort_hook();
1227   if (abort_hook != NULL) {
1228     abort_hook();
1229   }
1230 }
1231 
1232 // Note: os::abort() might be called very early during initialization, or
1233 // called from signal handler. Before adding something to os::abort(), make
1234 // sure it is async-safe and can handle partially initialized VM.
1235 void os::abort(bool dump_core, void* siginfo, void* context) {
1236   os::shutdown();
1237   if (dump_core) {
1238 #ifndef PRODUCT
1239     fdStream out(defaultStream::output_fd());
1240     out.print_raw("Current thread is ");
1241     char buf[16];
1242     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1243     out.print_raw_cr(buf);
1244     out.print_raw_cr("Dumping core ...");
1245 #endif
1246     ::abort(); // dump core
1247   }
1248 
1249   ::exit(1);
1250 }
1251 
1252 // Die immediately, no exit hook, no abort hook, no cleanup.
1253 void os::die() {
1254   ::abort();
1255 }
1256 
1257 // This method is a copy of JDK's sysGetLastErrorString
1258 // from src/solaris/hpi/src/system_md.c
1259 
1260 size_t os::lasterror(char *buf, size_t len) {
1261   if (errno == 0) return 0;
1262 
1263   const char *s = ::strerror(errno);
1264   size_t n = ::strlen(s);
1265   if (n >= len) {
1266     n = len - 1;
1267   }
1268   ::strncpy(buf, s, n);
1269   buf[n] = '\0';
1270   return n;
1271 }
1272 
1273 intx os::current_thread_id() {
1274   return (intx)pthread_self();
1275 }
1276 
1277 int os::current_process_id() {
1278   return getpid();












1279 }
1280 
1281 // DLL functions
1282 
1283 const char* os::dll_file_extension() { return ".so"; }
1284 
1285 // This must be hard coded because it's the system's temporary
1286 // directory not the java application's temp directory, ala java.io.tmpdir.
1287 const char* os::get_temp_directory() { return "/tmp"; }
1288 
1289 static bool file_exists(const char* filename) {
1290   struct stat statbuf;
1291   if (filename == NULL || strlen(filename) == 0) {
1292     return false;
1293   }
1294   return os::stat(filename, &statbuf) == 0;
1295 }
1296 
1297 bool os::dll_build_name(char* buffer, size_t buflen,
1298                         const char* pname, const char* fname) {
1299   bool retval = false;
1300   // Copied from libhpi
1301   const size_t pnamelen = pname ? strlen(pname) : 0;
1302 
1303   // Return error on buffer overflow.
1304   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1305     *buffer = '\0';
1306     return retval;
1307   }
1308 
1309   if (pnamelen == 0) {
1310     snprintf(buffer, buflen, "lib%s.so", fname);
1311     retval = true;
1312   } else if (strchr(pname, *os::path_separator()) != NULL) {
1313     int n;
1314     char** pelements = split_path(pname, &n);
1315     if (pelements == NULL) {
1316       return false;
1317     }
1318     for (int i = 0; i < n; i++) {
1319       // Really shouldn't be NULL, but check can't hurt
1320       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1321         continue; // skip the empty path values
1322       }
1323       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1324       if (file_exists(buffer)) {
1325         retval = true;
1326         break;
1327       }
1328     }
1329     // release the storage
1330     for (int i = 0; i < n; i++) {
1331       if (pelements[i] != NULL) {
1332         FREE_C_HEAP_ARRAY(char, pelements[i]);
1333       }
1334     }
1335     if (pelements != NULL) {
1336       FREE_C_HEAP_ARRAY(char*, pelements);
1337     }
1338   } else {
1339     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1340     retval = true;
1341   }
1342   return retval;
1343 }
1344 
1345 // Check if addr is inside libjvm.so.
1346 bool os::address_is_in_vm(address addr) {
1347 
1348   // Input could be a real pc or a function pointer literal. The latter
1349   // would be a function descriptor residing in the data segment of a module.
1350   loaded_module_t lm;
1351   if (LoadedLibraries::find_for_text_address(addr, &lm) != NULL) {
1352     return lm.is_in_vm;
1353   } else if (LoadedLibraries::find_for_data_address(addr, &lm) != NULL) {
1354     return lm.is_in_vm;
1355   } else {
1356     return false;
1357   }
1358 
1359 }
1360 
1361 // Resolve an AIX function descriptor literal to a code pointer.
1362 // If the input is a valid code pointer to a text segment of a loaded module,
1363 //   it is returned unchanged.
1364 // If the input is a valid AIX function descriptor, it is resolved to the
1365 //   code entry point.
1366 // If the input is neither a valid function descriptor nor a valid code pointer,
1367 //   NULL is returned.
1368 static address resolve_function_descriptor_to_code_pointer(address p) {
1369 
1370   if (LoadedLibraries::find_for_text_address(p, NULL) != NULL) {
1371     // It is a real code pointer.
1372     return p;
1373   } else if (LoadedLibraries::find_for_data_address(p, NULL) != NULL) {
1374     // Pointer to data segment, potential function descriptor.
1375     address code_entry = (address)(((FunctionDescriptor*)p)->entry());
1376     if (LoadedLibraries::find_for_text_address(code_entry, NULL) != NULL) {
1377       // It is a function descriptor.
1378       return code_entry;
1379     }
1380   }
1381 
1382   return NULL;
1383 }
1384 
1385 bool os::dll_address_to_function_name(address addr, char *buf,
1386                                       int buflen, int *offset,
1387                                       bool demangle) {
1388   if (offset) {
1389     *offset = -1;
1390   }
1391   // Buf is not optional, but offset is optional.
1392   assert(buf != NULL, "sanity check");
1393   buf[0] = '\0';
1394 
1395   // Resolve function ptr literals first.
1396   addr = resolve_function_descriptor_to_code_pointer(addr);
1397   if (!addr) {
1398     return false;
1399   }
1400 
1401   // Go through Decoder::decode to call getFuncName which reads the name from the traceback table.
1402   return Decoder::decode(addr, buf, buflen, offset, demangle);
1403 }
1404 
1405 static int getModuleName(codeptr_t pc,                    // [in] program counter
1406                          char* p_name, size_t namelen,    // [out] optional: function name
1407                          char* p_errmsg, size_t errmsglen // [out] optional: user provided buffer for error messages
1408                          ) {
1409 
1410   if (p_name && namelen > 0) {
1411     *p_name = '\0';
1412   }
1413   if (p_errmsg && errmsglen > 0) {
1414     *p_errmsg = '\0';
1415   }
1416 
1417   if (p_name && namelen > 0) {
1418     loaded_module_t lm;
1419     if (LoadedLibraries::find_for_text_address(pc, &lm) != NULL) {
1420       strncpy(p_name, lm.shortname, namelen);
1421       p_name[namelen - 1] = '\0';
1422     }
1423     return 0;
1424   }
1425 
1426   return -1;
1427 }
1428 
1429 bool os::dll_address_to_library_name(address addr, char* buf,
1430                                      int buflen, int* offset) {
1431   if (offset) {
1432     *offset = -1;
1433   }
1434   // Buf is not optional, but offset is optional.
1435   assert(buf != NULL, "sanity check");
1436   buf[0] = '\0';
1437 
1438   // Resolve function ptr literals first.
1439   addr = resolve_function_descriptor_to_code_pointer(addr);
1440   if (!addr) {
1441     return false;
1442   }
1443 
1444   if (::getModuleName((codeptr_t) addr, buf, buflen, 0, 0) == 0) {
1445     return true;
1446   }
1447   return false;
1448 }
1449 
1450 // Loads .dll/.so and in case of error it checks if .dll/.so was built
1451 // for the same architecture as Hotspot is running on.
1452 void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {
1453 
1454   if (ebuf && ebuflen > 0) {
1455     ebuf[0] = '\0';
1456     ebuf[ebuflen - 1] = '\0';
1457   }
1458 
1459   if (!filename || strlen(filename) == 0) {
1460     ::strncpy(ebuf, "dll_load: empty filename specified", ebuflen - 1);
1461     return NULL;
1462   }
1463 
1464   // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants.
1465   void * result= ::dlopen(filename, RTLD_LAZY);
1466   if (result != NULL) {
1467     // Reload dll cache. Don't do this in signal handling.
1468     LoadedLibraries::reload();
1469     return result;
1470   } else {
1471     // error analysis when dlopen fails
1472     const char* const error_report = ::dlerror();
1473     if (error_report && ebuf && ebuflen > 0) {
1474       snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s",
1475                filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report);
1476     }
1477   }
1478   return NULL;
1479 }
1480 
1481 void* os::dll_lookup(void* handle, const char* name) {
1482   void* res = dlsym(handle, name);
1483   return res;
1484 }
1485 
1486 void* os::get_default_process_handle() {
1487   return (void*)::dlopen(NULL, RTLD_LAZY);
1488 }
1489 
1490 void os::print_dll_info(outputStream *st) {
1491   st->print_cr("Dynamic libraries:");
1492   LoadedLibraries::print(st);
1493 }
1494 
1495 void os::get_summary_os_info(char* buf, size_t buflen) {
1496   // There might be something more readable than uname results for AIX.
1497   struct utsname name;
1498   uname(&name);
1499   snprintf(buf, buflen, "%s %s", name.release, name.version);
1500 }
1501 
1502 void os::print_os_info(outputStream* st) {
1503   st->print("OS:");
1504 
1505   st->print("uname:");
1506   struct utsname name;
1507   uname(&name);
1508   st->print(name.sysname); st->print(" ");
1509   st->print(name.nodename); st->print(" ");
1510   st->print(name.release); st->print(" ");
1511   st->print(name.version); st->print(" ");
1512   st->print(name.machine);
1513   st->cr();
1514 
1515   // rlimit
1516   st->print("rlimit:");
1517   struct rlimit rlim;
1518 
1519   st->print(" STACK ");
1520   getrlimit(RLIMIT_STACK, &rlim);
1521   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1522   else st->print("%uk", rlim.rlim_cur >> 10);
1523 
1524   st->print(", CORE ");
1525   getrlimit(RLIMIT_CORE, &rlim);
1526   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1527   else st->print("%uk", rlim.rlim_cur >> 10);
1528 
1529   st->print(", NPROC ");
1530   st->print("%d", sysconf(_SC_CHILD_MAX));
1531 
1532   st->print(", NOFILE ");
1533   getrlimit(RLIMIT_NOFILE, &rlim);
1534   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1535   else st->print("%d", rlim.rlim_cur);
1536 
1537   st->print(", AS ");
1538   getrlimit(RLIMIT_AS, &rlim);
1539   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1540   else st->print("%uk", rlim.rlim_cur >> 10);
1541 
1542   // Print limits on DATA, because it limits the C-heap.
1543   st->print(", DATA ");
1544   getrlimit(RLIMIT_DATA, &rlim);
1545   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1546   else st->print("%uk", rlim.rlim_cur >> 10);
1547   st->cr();
1548 
1549   // load average
1550   st->print("load average:");
1551   double loadavg[3] = {-1.L, -1.L, -1.L};
1552   os::loadavg(loadavg, 3);
1553   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
1554   st->cr();
1555 
1556   // print wpar info
1557   libperfstat::wparinfo_t wi;
1558   if (libperfstat::get_wparinfo(&wi)) {
1559     st->print_cr("wpar info");
1560     st->print_cr("name: %s", wi.name);
1561     st->print_cr("id:   %d", wi.wpar_id);
1562     st->print_cr("type: %s", (wi.app_wpar ? "application" : "system"));
1563   }
1564 
1565   // print partition info
1566   libperfstat::partitioninfo_t pi;
1567   if (libperfstat::get_partitioninfo(&pi)) {
1568     st->print_cr("partition info");
1569     st->print_cr(" name: %s", pi.name);
1570   }
1571 
1572 }
1573 
1574 void os::print_memory_info(outputStream* st) {
1575 
1576   st->print_cr("Memory:");
1577 
1578   st->print_cr("  Base page size (sysconf _SC_PAGESIZE):  %s",
1579     describe_pagesize(g_multipage_support.pagesize));
1580   st->print_cr("  Data page size (C-Heap, bss, etc):      %s",
1581     describe_pagesize(g_multipage_support.datapsize));
1582   st->print_cr("  Text page size:                         %s",
1583     describe_pagesize(g_multipage_support.textpsize));
1584   st->print_cr("  Thread stack page size (pthread):       %s",
1585     describe_pagesize(g_multipage_support.pthr_stack_pagesize));
1586   st->print_cr("  Default shared memory page size:        %s",
1587     describe_pagesize(g_multipage_support.shmpsize));
1588   st->print_cr("  Can use 64K pages dynamically with shared meory:  %s",
1589     (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
1590   st->print_cr("  Can use 16M pages dynamically with shared memory: %s",
1591     (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
1592   st->print_cr("  Multipage error: %d",
1593     g_multipage_support.error);
1594   st->cr();
1595   st->print_cr("  os::vm_page_size:       %s", describe_pagesize(os::vm_page_size()));
1596   // not used in OpenJDK st->print_cr("  os::stack_page_size:    %s", describe_pagesize(os::stack_page_size()));
1597 
1598   // print out LDR_CNTRL because it affects the default page sizes
1599   const char* const ldr_cntrl = ::getenv("LDR_CNTRL");
1600   st->print_cr("  LDR_CNTRL=%s.", ldr_cntrl ? ldr_cntrl : "<unset>");
1601 
1602   // Print out EXTSHM because it is an unsupported setting.
1603   const char* const extshm = ::getenv("EXTSHM");
1604   st->print_cr("  EXTSHM=%s.", extshm ? extshm : "<unset>");
1605   if ( (strcmp(extshm, "on") == 0) || (strcmp(extshm, "ON") == 0) ) {
1606     st->print_cr("  *** Unsupported! Please remove EXTSHM from your environment! ***");
1607   }
1608 
1609   // Print out AIXTHREAD_GUARDPAGES because it affects the size of pthread stacks.
1610   const char* const aixthread_guardpages = ::getenv("AIXTHREAD_GUARDPAGES");
1611   st->print_cr("  AIXTHREAD_GUARDPAGES=%s.",
1612       aixthread_guardpages ? aixthread_guardpages : "<unset>");
1613 
1614   os::Aix::meminfo_t mi;
1615   if (os::Aix::get_meminfo(&mi)) {
1616     char buffer[256];
1617     if (os::Aix::on_aix()) {
1618       st->print_cr("physical total : " SIZE_FORMAT, mi.real_total);
1619       st->print_cr("physical free  : " SIZE_FORMAT, mi.real_free);
1620       st->print_cr("swap total     : " SIZE_FORMAT, mi.pgsp_total);
1621       st->print_cr("swap free      : " SIZE_FORMAT, mi.pgsp_free);
1622     } else {
1623       // PASE - Numbers are result of QWCRSSTS; they mean:
1624       // real_total: Sum of all system pools
1625       // real_free: always 0
1626       // pgsp_total: we take the size of the system ASP
1627       // pgsp_free: size of system ASP times percentage of system ASP unused
1628       st->print_cr("physical total     : " SIZE_FORMAT, mi.real_total);
1629       st->print_cr("system asp total   : " SIZE_FORMAT, mi.pgsp_total);
1630       st->print_cr("%% system asp used : " SIZE_FORMAT,
1631         mi.pgsp_total ? (100.0f * (mi.pgsp_total - mi.pgsp_free) / mi.pgsp_total) : -1.0f);
1632     }
1633     st->print_raw(buffer);


1634   }
1635   st->cr();
1636 
1637   // Print segments allocated with os::reserve_memory.
1638   st->print_cr("internal virtual memory regions used by vm:");
1639   vmembk_print_on(st);
1640 }
1641 
1642 // Get a string for the cpuinfo that is a summary of the cpu type
1643 void os::get_summary_cpu_info(char* buf, size_t buflen) {
1644   // This looks good
1645   libperfstat::cpuinfo_t ci;
1646   if (libperfstat::get_cpuinfo(&ci)) {
1647     strncpy(buf, ci.version, buflen);
1648   } else {
1649     strncpy(buf, "AIX", buflen);
1650   }
1651 }
1652 
1653 void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
1654   st->print("CPU:");
1655   st->print("total %d", os::processor_count());
1656   // It's not safe to query number of active processors after crash.
1657   // st->print("(active %d)", os::active_processor_count());
1658   st->print(" %s", VM_Version::cpu_features());
1659   st->cr();
1660 }
1661 
1662 void os::print_siginfo(outputStream* st, void* siginfo) {

1663   os::Posix::print_siginfo_brief(st, (const siginfo_t*) siginfo);
1664   st->cr();
1665 }
1666 
1667 static void print_signal_handler(outputStream* st, int sig,
1668                                  char* buf, size_t buflen);
1669 
1670 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1671   st->print_cr("Signal Handlers:");
1672   print_signal_handler(st, SIGSEGV, buf, buflen);
1673   print_signal_handler(st, SIGBUS , buf, buflen);
1674   print_signal_handler(st, SIGFPE , buf, buflen);
1675   print_signal_handler(st, SIGPIPE, buf, buflen);
1676   print_signal_handler(st, SIGXFSZ, buf, buflen);
1677   print_signal_handler(st, SIGILL , buf, buflen);
1678   print_signal_handler(st, SR_signum, buf, buflen);
1679   print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
1680   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
1681   print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
1682   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
1683   print_signal_handler(st, SIGTRAP, buf, buflen);
1684   print_signal_handler(st, SIGDANGER, buf, buflen);
1685 }
1686 
1687 static char saved_jvm_path[MAXPATHLEN] = {0};
1688 
1689 // Find the full path to the current module, libjvm.so.
1690 void os::jvm_path(char *buf, jint buflen) {
1691   // Error checking.
1692   if (buflen < MAXPATHLEN) {
1693     assert(false, "must use a large-enough buffer");
1694     buf[0] = '\0';
1695     return;
1696   }
1697   // Lazy resolve the path to current module.
1698   if (saved_jvm_path[0] != 0) {
1699     strcpy(buf, saved_jvm_path);
1700     return;
1701   }
1702 
1703   Dl_info dlinfo;
1704   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
1705   assert(ret != 0, "cannot locate libjvm");
1706   char* rp = realpath((char *)dlinfo.dli_fname, buf);
1707   assert(rp != NULL, "error in realpath(): maybe the 'path' argument is too long?");
1708 
1709   strncpy(saved_jvm_path, buf, sizeof(saved_jvm_path));
1710   saved_jvm_path[sizeof(saved_jvm_path) - 1] = '\0';
1711 }
1712 
1713 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1714   // no prefix required, not even "_"
1715 }
1716 
1717 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1718   // no suffix required
1719 }
1720 
1721 ////////////////////////////////////////////////////////////////////////////////
1722 // sun.misc.Signal support
1723 
1724 static volatile jint sigint_count = 0;
1725 
1726 static void
1727 UserHandler(int sig, void *siginfo, void *context) {
1728   // 4511530 - sem_post is serialized and handled by the manager thread. When
1729   // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
1730   // don't want to flood the manager thread with sem_post requests.
1731   if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
1732     return;
1733 
1734   // Ctrl-C is pressed during error reporting, likely because the error
1735   // handler fails to abort. Let VM die immediately.
1736   if (sig == SIGINT && is_error_reported()) {
1737     os::die();
1738   }
1739 
1740   os::signal_notify(sig);
1741 }
1742 
1743 void* os::user_handler() {
1744   return CAST_FROM_FN_PTR(void*, UserHandler);
1745 }
1746 
1747 extern "C" {
1748   typedef void (*sa_handler_t)(int);
1749   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
1750 }
1751 
1752 void* os::signal(int signal_number, void* handler) {
1753   struct sigaction sigAct, oldSigAct;
1754 
1755   sigfillset(&(sigAct.sa_mask));
1756 
1757   // Do not block out synchronous signals in the signal handler.
1758   // Blocking synchronous signals only makes sense if you can really
1759   // be sure that those signals won't happen during signal handling,
1760   // when the blocking applies. Normal signal handlers are lean and
1761   // do not cause signals. But our signal handlers tend to be "risky"
1762   // - secondary SIGSEGV, SIGILL, SIGBUS' may and do happen.
1763   // On AIX, PASE there was a case where a SIGSEGV happened, followed
1764   // by a SIGILL, which was blocked due to the signal mask. The process
1765   // just hung forever. Better to crash from a secondary signal than to hang.
1766   sigdelset(&(sigAct.sa_mask), SIGSEGV);
1767   sigdelset(&(sigAct.sa_mask), SIGBUS);
1768   sigdelset(&(sigAct.sa_mask), SIGILL);
1769   sigdelset(&(sigAct.sa_mask), SIGFPE);
1770   sigdelset(&(sigAct.sa_mask), SIGTRAP);
1771 
1772   sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;
1773 
1774   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
1775 
1776   if (sigaction(signal_number, &sigAct, &oldSigAct)) {
1777     // -1 means registration failed
1778     return (void *)-1;
1779   }
1780 
1781   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
1782 }
1783 
1784 void os::signal_raise(int signal_number) {
1785   ::raise(signal_number);
1786 }
1787 
1788 //
1789 // The following code is moved from os.cpp for making this
1790 // code platform specific, which it is by its very nature.
1791 //
1792 
1793 // Will be modified when max signal is changed to be dynamic
1794 int os::sigexitnum_pd() {
1795   return NSIG;
1796 }
1797 
1798 // a counter for each possible signal value
1799 static volatile jint pending_signals[NSIG+1] = { 0 };
1800 
1801 // Wrapper functions for: sem_init(), sem_post(), sem_wait()
1802 // On AIX, we use sem_init(), sem_post(), sem_wait()
1803 // On Pase, we need to use msem_lock() and msem_unlock(), because Posix Semaphores
1804 // do not seem to work at all on PASE (unimplemented, will cause SIGILL).
1805 // Note that just using msem_.. APIs for both PASE and AIX is not an option either, as
1806 // on AIX, msem_..() calls are suspected of causing problems.
1807 static sem_t sig_sem;
1808 static msemaphore* p_sig_msem = 0;
1809 
1810 static void local_sem_init() {
1811   if (os::Aix::on_aix()) {
1812     int rc = ::sem_init(&sig_sem, 0, 0);
1813     guarantee(rc != -1, "sem_init failed");
1814   } else {
1815     // Memory semaphores must live in shared mem.
1816     guarantee0(p_sig_msem == NULL);
1817     p_sig_msem = (msemaphore*)os::reserve_memory(sizeof(msemaphore), NULL);
1818     guarantee(p_sig_msem, "Cannot allocate memory for memory semaphore");
1819     guarantee(::msem_init(p_sig_msem, 0) == p_sig_msem, "msem_init failed");
1820   }
1821 }
1822 
1823 static void local_sem_post() {
1824   static bool warn_only_once = false;
1825   if (os::Aix::on_aix()) {
1826     int rc = ::sem_post(&sig_sem);
1827     if (rc == -1 && !warn_only_once) {
1828       trcVerbose("sem_post failed (errno = %d, %s)", errno, strerror(errno));
1829       warn_only_once = true;
1830     }
1831   } else {
1832     guarantee0(p_sig_msem != NULL);
1833     int rc = ::msem_unlock(p_sig_msem, 0);
1834     if (rc == -1 && !warn_only_once) {
1835       trcVerbose("msem_unlock failed (errno = %d, %s)", errno, strerror(errno));
1836       warn_only_once = true;
1837     }
1838   }
1839 }
1840 
1841 static void local_sem_wait() {
1842   static bool warn_only_once = false;
1843   if (os::Aix::on_aix()) {
1844     int rc = ::sem_wait(&sig_sem);
1845     if (rc == -1 && !warn_only_once) {
1846       trcVerbose("sem_wait failed (errno = %d, %s)", errno, strerror(errno));
1847       warn_only_once = true;
1848     }
1849   } else {
1850     guarantee0(p_sig_msem != NULL); // must init before use
1851     int rc = ::msem_lock(p_sig_msem, 0);
1852     if (rc == -1 && !warn_only_once) {
1853       trcVerbose("msem_lock failed (errno = %d, %s)", errno, strerror(errno));
1854       warn_only_once = true;
1855     }
1856   }
1857 }
1858 
1859 void os::signal_init_pd() {
1860   // Initialize signal structures
1861   ::memset((void*)pending_signals, 0, sizeof(pending_signals));
1862 
1863   // Initialize signal semaphore
1864   local_sem_init();

1865 }
1866 
1867 void os::signal_notify(int sig) {
1868   Atomic::inc(&pending_signals[sig]);
1869   local_sem_post();
1870 }
1871 
1872 static int check_pending_signals(bool wait) {
1873   Atomic::store(0, &sigint_count);
1874   for (;;) {
1875     for (int i = 0; i < NSIG + 1; i++) {
1876       jint n = pending_signals[i];
1877       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1878         return i;
1879       }
1880     }
1881     if (!wait) {
1882       return -1;
1883     }
1884     JavaThread *thread = JavaThread::current();
1885     ThreadBlockInVM tbivm(thread);
1886 
1887     bool threadIsSuspended;
1888     do {
1889       thread->set_suspend_equivalent();
1890       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1891 
1892       local_sem_wait();
1893 
1894       // were we externally suspended while we were waiting?
1895       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1896       if (threadIsSuspended) {
1897         //
1898         // The semaphore has been incremented, but while we were waiting
1899         // another thread suspended us. We don't want to continue running
1900         // while suspended because that would surprise the thread that
1901         // suspended us.
1902         //
1903 
1904         local_sem_post();
1905 
1906         thread->java_suspend_self();
1907       }
1908     } while (threadIsSuspended);
1909   }
1910 }
1911 
1912 int os::signal_lookup() {
1913   return check_pending_signals(false);
1914 }
1915 
1916 int os::signal_wait() {
1917   return check_pending_signals(true);
1918 }
1919 
1920 ////////////////////////////////////////////////////////////////////////////////
1921 // Virtual Memory
1922 
1923 // We need to keep small simple bookkeeping for os::reserve_memory and friends.
1924 
1925 #define VMEM_MAPPED  1
1926 #define VMEM_SHMATED 2
1927 
1928 struct vmembk_t {
1929   int type;         // 1 - mmap, 2 - shmat
1930   char* addr;
1931   size_t size;      // Real size, may be larger than usersize.
1932   size_t pagesize;  // page size of area
1933   vmembk_t* next;
1934 
1935   bool contains_addr(char* p) const {
1936     return p >= addr && p < (addr + size);
1937   }
1938 
1939   bool contains_range(char* p, size_t s) const {
1940     return contains_addr(p) && contains_addr(p + s - 1);
1941   }
1942 
1943   void print_on(outputStream* os) const {
1944     os->print("[" PTR_FORMAT " - " PTR_FORMAT "] (" UINTX_FORMAT
1945       " bytes, %d %s pages), %s",
1946       addr, addr + size - 1, size, size / pagesize, describe_pagesize(pagesize),
1947       (type == VMEM_SHMATED ? "shmat" : "mmap")
1948     );
1949   }
1950 
1951   // Check that range is a sub range of memory block (or equal to memory block);
1952   // also check that range is fully page aligned to the page size if the block.
1953   void assert_is_valid_subrange(char* p, size_t s) const {
1954     if (!contains_range(p, s)) {
1955       fprintf(stderr, "[" PTR_FORMAT " - " PTR_FORMAT "] is not a sub "
1956               "range of [" PTR_FORMAT " - " PTR_FORMAT "].\n",
1957               p, p + s, addr, addr + size);
1958       guarantee0(false);
1959     }
1960     if (!is_aligned_to(p, pagesize) || !is_aligned_to(p + s, pagesize)) {
1961       fprintf(stderr, "range [" PTR_FORMAT " - " PTR_FORMAT "] is not"
1962               " aligned to pagesize (%lu)\n", p, p + s, (unsigned long) pagesize);
1963       guarantee0(false);
1964     }
1965   }
1966 };
1967 
1968 static struct {
1969   vmembk_t* first;
1970   MiscUtils::CritSect cs;
1971 } vmem;
1972 
1973 static void vmembk_add(char* addr, size_t size, size_t pagesize, int type) {
1974   vmembk_t* p = (vmembk_t*) ::malloc(sizeof(vmembk_t));
1975   assert0(p);
1976   if (p) {
1977     MiscUtils::AutoCritSect lck(&vmem.cs);
1978     p->addr = addr; p->size = size;
1979     p->pagesize = pagesize;
1980     p->type = type;
1981     p->next = vmem.first;
1982     vmem.first = p;
1983   }
1984 }
1985 
1986 static vmembk_t* vmembk_find(char* addr) {
1987   MiscUtils::AutoCritSect lck(&vmem.cs);
1988   for (vmembk_t* p = vmem.first; p; p = p->next) {
1989     if (p->addr <= addr && (p->addr + p->size) > addr) {
1990       return p;
1991     }
1992   }
1993   return NULL;
1994 }
1995 
1996 static void vmembk_remove(vmembk_t* p0) {
1997   MiscUtils::AutoCritSect lck(&vmem.cs);
1998   assert0(p0);
1999   assert0(vmem.first); // List should not be empty.
2000   for (vmembk_t** pp = &(vmem.first); *pp; pp = &((*pp)->next)) {
2001     if (*pp == p0) {
2002       *pp = p0->next;
2003       ::free(p0);
2004       return;
2005     }
2006   }
2007   assert0(false); // Not found?
2008 }
2009 
2010 static void vmembk_print_on(outputStream* os) {
2011   MiscUtils::AutoCritSect lck(&vmem.cs);
2012   for (vmembk_t* vmi = vmem.first; vmi; vmi = vmi->next) {
2013     vmi->print_on(os);
2014     os->cr();
2015   }
2016 }
2017 
2018 // Reserve and attach a section of System V memory.
2019 // If <requested_addr> is not NULL, function will attempt to attach the memory at the given
2020 // address. Failing that, it will attach the memory anywhere.
2021 // If <requested_addr> is NULL, function will attach the memory anywhere.
2022 //
2023 // <alignment_hint> is being ignored by this function. It is very probable however that the
2024 // alignment requirements are met anyway, because shmat() attaches at 256M boundaries.
2025 // Should this be not enogh, we can put more work into it.
2026 static char* reserve_shmated_memory (
2027   size_t bytes,
2028   char* requested_addr,
2029   size_t alignment_hint) {
2030 
2031   trcVerbose("reserve_shmated_memory " UINTX_FORMAT " bytes, wishaddress "
2032     PTR_FORMAT ", alignment_hint " UINTX_FORMAT "...",
2033     bytes, requested_addr, alignment_hint);
2034 
2035   // Either give me wish address or wish alignment but not both.
2036   assert0(!(requested_addr != NULL && alignment_hint != 0));
2037 
2038   // We must prevent anyone from attaching too close to the
2039   // BRK because that may cause malloc OOM.
2040   if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
2041     trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
2042       "Will attach anywhere.", requested_addr);
2043     // Act like the OS refused to attach there.
2044     requested_addr = NULL;
2045   }
2046 
2047   // For old AS/400's (V5R4 and older) we should not even be here - System V shared memory is not
2048   // really supported (max size 4GB), so reserve_mmapped_memory should have been used instead.
2049   if (os::Aix::on_pase_V5R4_or_older()) {
2050     ShouldNotReachHere();
2051   }
2052 
2053   // Align size of shm up to 64K to avoid errors if we later try to change the page size.
2054   const size_t size = align_size_up(bytes, SIZE_64K);
2055 
2056   // Reserve the shared segment.
2057   int shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | S_IRUSR | S_IWUSR);
2058   if (shmid == -1) {
2059     trcVerbose("shmget(.., " UINTX_FORMAT ", ..) failed (errno: %d).", size, errno);
2060     return NULL;
2061   }
2062 
2063   // Important note:
2064   // It is very important that we, upon leaving this function, do not leave a shm segment alive.
2065   // We must right after attaching it remove it from the system. System V shm segments are global and
2066   // survive the process.
2067   // So, from here on: Do not assert, do not return, until we have called shmctl(IPC_RMID) (A).
2068 
2069   struct shmid_ds shmbuf;
2070   memset(&shmbuf, 0, sizeof(shmbuf));
2071   shmbuf.shm_pagesize = SIZE_64K;
2072   if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) != 0) {
2073     trcVerbose("Failed to set page size (need " UINTX_FORMAT " 64K pages) - shmctl failed with %d.",
2074                size / SIZE_64K, errno);
2075     // I want to know if this ever happens.
2076     assert(false, "failed to set page size for shmat");
2077   }
2078 
2079   // Now attach the shared segment.
2080   // Note that I attach with SHM_RND - which means that the requested address is rounded down, if
2081   // needed, to the next lowest segment boundary. Otherwise the attach would fail if the address
2082   // were not a segment boundary.
2083   char* const addr = (char*) shmat(shmid, requested_addr, SHM_RND);
2084   const int errno_shmat = errno;
2085 
2086   // (A) Right after shmat and before handing shmat errors delete the shm segment.
2087   if (::shmctl(shmid, IPC_RMID, NULL) == -1) {
2088     trcVerbose("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);
2089     assert(false, "failed to remove shared memory segment!");
2090   }
2091 
2092   // Handle shmat error. If we failed to attach, just return.
2093   if (addr == (char*)-1) {
2094     trcVerbose("Failed to attach segment at " PTR_FORMAT " (%d).", requested_addr, errno_shmat);
2095     return NULL;
2096   }
2097 
2098   // Just for info: query the real page size. In case setting the page size did not
2099   // work (see above), the system may have given us something other then 4K (LDR_CNTRL).
2100   const size_t real_pagesize = os::Aix::query_pagesize(addr);
2101   if (real_pagesize != shmbuf.shm_pagesize) {
2102     trcVerbose("pagesize is, surprisingly, %h.", real_pagesize);
2103   }
2104 
2105   if (addr) {
2106     trcVerbose("shm-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes, " UINTX_FORMAT " %s pages)",
2107       addr, addr + size - 1, size, size/real_pagesize, describe_pagesize(real_pagesize));
2108   } else {
2109     if (requested_addr != NULL) {
2110       trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at with address " PTR_FORMAT ".", size, requested_addr);
2111     } else {
2112       trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at any address.", size);
2113     }
2114   }
2115 
2116   // book-keeping
2117   vmembk_add(addr, size, real_pagesize, VMEM_SHMATED);
2118   assert0(is_aligned_to(addr, os::vm_page_size()));
2119 
2120   return addr;
2121 }
2122 
2123 static bool release_shmated_memory(char* addr, size_t size) {
2124 
2125   trcVerbose("release_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2126     addr, addr + size - 1);
2127 
2128   bool rc = false;
2129 
2130   // TODO: is there a way to verify shm size without doing bookkeeping?
2131   if (::shmdt(addr) != 0) {
2132     trcVerbose("error (%d).", errno);
2133   } else {
2134     trcVerbose("ok.");
2135     rc = true;
2136   }
2137   return rc;
2138 }
2139 
2140 static bool uncommit_shmated_memory(char* addr, size_t size) {
2141   trcVerbose("uncommit_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2142     addr, addr + size - 1);
2143 
2144   const bool rc = my_disclaim64(addr, size);
2145 
2146   if (!rc) {
2147     trcVerbose("my_disclaim64(" PTR_FORMAT ", " UINTX_FORMAT ") failed.\n", addr, size);
2148     return false;
2149   }
2150   return true;
2151 }
2152 
2153 ////////////////////////////////  mmap-based routines /////////////////////////////////
2154 
2155 // Reserve memory via mmap.
2156 // If <requested_addr> is given, an attempt is made to attach at the given address.
2157 // Failing that, memory is allocated at any address.
2158 // If <alignment_hint> is given and <requested_addr> is NULL, an attempt is made to
2159 // allocate at an address aligned with the given alignment. Failing that, memory
2160 // is aligned anywhere.
2161 static char* reserve_mmaped_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2162   trcVerbose("reserve_mmaped_memory " UINTX_FORMAT " bytes, wishaddress " PTR_FORMAT ", "
2163     "alignment_hint " UINTX_FORMAT "...",
2164     bytes, requested_addr, alignment_hint);
2165 
2166   // If a wish address is given, but not aligned to 4K page boundary, mmap will fail.
2167   if (requested_addr && !is_aligned_to(requested_addr, os::vm_page_size()) != 0) {
2168     trcVerbose("Wish address " PTR_FORMAT " not aligned to page boundary.", requested_addr);
2169     return NULL;
2170   }
2171 
2172   // We must prevent anyone from attaching too close to the
2173   // BRK because that may cause malloc OOM.
2174   if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
2175     trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
2176       "Will attach anywhere.", requested_addr);
2177     // Act like the OS refused to attach there.
2178     requested_addr = NULL;
2179   }
2180 
2181   // Specify one or the other but not both.
2182   assert0(!(requested_addr != NULL && alignment_hint > 0));
2183 
2184   // In 64K mode, we claim the global page size (os::vm_page_size())
2185   // is 64K. This is one of the few points where that illusion may
2186   // break, because mmap() will always return memory aligned to 4K. So
2187   // we must ensure we only ever return memory aligned to 64k.
2188   if (alignment_hint) {
2189     alignment_hint = lcm(alignment_hint, os::vm_page_size());
2190   } else {
2191     alignment_hint = os::vm_page_size();
2192   }
2193 
2194   // Size shall always be a multiple of os::vm_page_size (esp. in 64K mode).
2195   const size_t size = align_size_up(bytes, os::vm_page_size());
2196 
2197   // alignment: Allocate memory large enough to include an aligned range of the right size and
2198   // cut off the leading and trailing waste pages.
2199   assert0(alignment_hint != 0 && is_aligned_to(alignment_hint, os::vm_page_size())); // see above
2200   const size_t extra_size = size + alignment_hint;
2201 
2202   // Note: MAP_SHARED (instead of MAP_PRIVATE) needed to be able to
2203   // later use msync(MS_INVALIDATE) (see os::uncommit_memory).
2204   int flags = MAP_ANONYMOUS | MAP_SHARED;
2205 
2206   // MAP_FIXED is needed to enforce requested_addr - manpage is vague about what
2207   // it means if wishaddress is given but MAP_FIXED is not set.
2208   //
2209   // Important! Behaviour differs depending on whether SPEC1170 mode is active or not.
2210   // SPEC1170 mode active: behaviour like POSIX, MAP_FIXED will clobber existing mappings.
2211   // SPEC1170 mode not active: behaviour, unlike POSIX, is that no existing mappings will
2212   // get clobbered.
2213   if (requested_addr != NULL) {
2214     if (!os::Aix::xpg_sus_mode()) {  // not SPEC1170 Behaviour
2215       flags |= MAP_FIXED;
2216     }
2217   }
2218 
2219   char* addr = (char*)::mmap(requested_addr, extra_size,
2220       PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0);
2221 
2222   if (addr == MAP_FAILED) {
2223     trcVerbose("mmap(" PTR_FORMAT ", " UINTX_FORMAT ", ..) failed (%d)", requested_addr, size, errno);
2224     return NULL;
2225   }
2226 
2227   // Handle alignment.
2228   char* const addr_aligned = (char *)align_ptr_up(addr, alignment_hint);
2229   const size_t waste_pre = addr_aligned - addr;
2230   char* const addr_aligned_end = addr_aligned + size;
2231   const size_t waste_post = extra_size - waste_pre - size;
2232   if (waste_pre > 0) {
2233     ::munmap(addr, waste_pre);
2234   }
2235   if (waste_post > 0) {
2236     ::munmap(addr_aligned_end, waste_post);
2237   }
2238   addr = addr_aligned;
2239 
2240   if (addr) {
2241     trcVerbose("mmap-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes)",
2242       addr, addr + bytes, bytes);
2243   } else {
2244     if (requested_addr != NULL) {
2245       trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at wish address " PTR_FORMAT ".", bytes, requested_addr);
2246     } else {
2247       trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at any address.", bytes);
2248     }
2249   }
2250 
2251   // bookkeeping
2252   vmembk_add(addr, size, SIZE_4K, VMEM_MAPPED);
2253 
2254   // Test alignment, see above.
2255   assert0(is_aligned_to(addr, os::vm_page_size()));
2256 
2257   return addr;
2258 }
2259 
2260 static bool release_mmaped_memory(char* addr, size_t size) {
2261   assert0(is_aligned_to(addr, os::vm_page_size()));
2262   assert0(is_aligned_to(size, os::vm_page_size()));
2263 
2264   trcVerbose("release_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2265     addr, addr + size - 1);
2266   bool rc = false;
2267 
2268   if (::munmap(addr, size) != 0) {
2269     trcVerbose("failed (%d)\n", errno);
2270     rc = false;
2271   } else {
2272     trcVerbose("ok.");
2273     rc = true;
2274   }
2275 
2276   return rc;
2277 }
2278 
2279 static bool uncommit_mmaped_memory(char* addr, size_t size) {
2280 
2281   assert0(is_aligned_to(addr, os::vm_page_size()));
2282   assert0(is_aligned_to(size, os::vm_page_size()));
2283 
2284   trcVerbose("uncommit_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2285     addr, addr + size - 1);
2286   bool rc = false;
2287 
2288   // Uncommit mmap memory with msync MS_INVALIDATE.
2289   if (::msync(addr, size, MS_INVALIDATE) != 0) {
2290     trcVerbose("failed (%d)\n", errno);
2291     rc = false;
2292   } else {
2293     trcVerbose("ok.");
2294     rc = true;
2295   }
2296 
2297   return rc;
2298 }
2299 



2300 int os::vm_page_size() {
2301   // Seems redundant as all get out.
2302   assert(os::Aix::page_size() != -1, "must call os::init");
2303   return os::Aix::page_size();
2304 }
2305 
2306 // Aix allocates memory by pages.
2307 int os::vm_allocation_granularity() {
2308   assert(os::Aix::page_size() != -1, "must call os::init");
2309   return os::Aix::page_size();
2310 }
2311 
2312 #ifdef PRODUCT
2313 static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
2314                                     int err) {
2315   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2316           ", %d) failed; error='%s' (errno=%d)", addr, size, exec,
2317           strerror(err), err);
2318 }
2319 #endif
2320 
2321 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
2322                                   const char* mesg) {
2323   assert(mesg != NULL, "mesg must be specified");
2324   if (!pd_commit_memory(addr, size, exec)) {
2325     // Add extra info in product mode for vm_exit_out_of_memory():
2326     PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
2327     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
2328   }
2329 }
2330 
2331 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
2332 
2333   assert0(is_aligned_to(addr, os::vm_page_size()));
2334   assert0(is_aligned_to(size, os::vm_page_size()));
2335 
2336   vmembk_t* const vmi = vmembk_find(addr);
2337   guarantee0(vmi);
2338   vmi->assert_is_valid_subrange(addr, size);
2339 
2340   trcVerbose("commit_memory [" PTR_FORMAT " - " PTR_FORMAT "].", addr, addr + size - 1);
2341 
2342   if (UseExplicitCommit) {
2343     // AIX commits memory on touch. So, touch all pages to be committed.
2344     for (char* p = addr; p < (addr + size); p += SIZE_4K) {
2345       *p = '\0';
2346     }
2347   }
2348 
2349   return true;
2350 }
2351 
2352 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) {
2353   return pd_commit_memory(addr, size, exec);
2354 }
2355 
2356 void os::pd_commit_memory_or_exit(char* addr, size_t size,
2357                                   size_t alignment_hint, bool exec,
2358                                   const char* mesg) {
2359   // Alignment_hint is ignored on this OS.
2360   pd_commit_memory_or_exit(addr, size, exec, mesg);
2361 }
2362 
2363 bool os::pd_uncommit_memory(char* addr, size_t size) {
2364   assert0(is_aligned_to(addr, os::vm_page_size()));
2365   assert0(is_aligned_to(size, os::vm_page_size()));
2366 
2367   // Dynamically do different things for mmap/shmat.
2368   const vmembk_t* const vmi = vmembk_find(addr);
2369   guarantee0(vmi);
2370   vmi->assert_is_valid_subrange(addr, size);
2371 
2372   if (vmi->type == VMEM_SHMATED) {
2373     return uncommit_shmated_memory(addr, size);
2374   } else {
2375     return uncommit_mmaped_memory(addr, size);
2376   }
2377 }
2378 
2379 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
2380   // Do not call this; no need to commit stack pages on AIX.
2381   ShouldNotReachHere();
2382   return true;
2383 }
2384 
2385 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2386   // Do not call this; no need to commit stack pages on AIX.
2387   ShouldNotReachHere();
2388   return true;
2389 }
2390 
2391 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2392 }
2393 
2394 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
2395 }
2396 
2397 void os::numa_make_global(char *addr, size_t bytes) {
2398 }
2399 
2400 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2401 }
2402 
2403 bool os::numa_topology_changed() {
2404   return false;
2405 }
2406 
2407 size_t os::numa_get_groups_num() {
2408   return 1;
2409 }
2410 
2411 int os::numa_get_group_id() {
2412   return 0;
2413 }
2414 
2415 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2416   if (size > 0) {
2417     ids[0] = 0;
2418     return 1;
2419   }
2420   return 0;
2421 }
2422 
2423 bool os::get_page_info(char *start, page_info* info) {
2424   return false;
2425 }
2426 
2427 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2428   return end;
2429 }
2430 
2431 // Reserves and attaches a shared memory segment.
2432 // Will assert if a wish address is given and could not be obtained.
2433 char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2434 
2435   // All other Unices do a mmap(MAP_FIXED) if the addr is given,
2436   // thereby clobbering old mappings at that place. That is probably
2437   // not intended, never used and almost certainly an error were it
2438   // ever be used this way (to try attaching at a specified address
2439   // without clobbering old mappings an alternate API exists,
2440   // os::attempt_reserve_memory_at()).
2441   // Instead of mimicking the dangerous coding of the other platforms, here I
2442   // just ignore the request address (release) or assert(debug).
2443   assert0(requested_addr == NULL);
2444 
2445   // Always round to os::vm_page_size(), which may be larger than 4K.
2446   bytes = align_size_up(bytes, os::vm_page_size());
2447   const size_t alignment_hint0 =
2448     alignment_hint ? align_size_up(alignment_hint, os::vm_page_size()) : 0;
2449 
2450   // In 4K mode always use mmap.
2451   // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted.
2452   if (os::vm_page_size() == SIZE_4K) {
2453     return reserve_mmaped_memory(bytes, requested_addr, alignment_hint);
2454   } else {
2455     if (bytes >= Use64KPagesThreshold) {
2456       return reserve_shmated_memory(bytes, requested_addr, alignment_hint);
2457     } else {
2458       return reserve_mmaped_memory(bytes, requested_addr, alignment_hint);
2459     }
2460   }
2461 }
2462 
2463 bool os::pd_release_memory(char* addr, size_t size) {
2464 
2465   // Dynamically do different things for mmap/shmat.
2466   vmembk_t* const vmi = vmembk_find(addr);
2467   guarantee0(vmi);
2468 
2469   // Always round to os::vm_page_size(), which may be larger than 4K.
2470   size = align_size_up(size, os::vm_page_size());
2471   addr = (char *)align_ptr_up(addr, os::vm_page_size());
2472 
2473   bool rc = false;
2474   bool remove_bookkeeping = false;
2475   if (vmi->type == VMEM_SHMATED) {
2476     // For shmatted memory, we do:
2477     // - If user wants to release the whole range, release the memory (shmdt).
2478     // - If user only wants to release a partial range, uncommit (disclaim) that
2479     //   range. That way, at least, we do not use memory anymore (bust still page
2480     //   table space).
2481     vmi->assert_is_valid_subrange(addr, size);
2482     if (addr == vmi->addr && size == vmi->size) {
2483       rc = release_shmated_memory(addr, size);
2484       remove_bookkeeping = true;
2485     } else {
2486       rc = uncommit_shmated_memory(addr, size);
2487     }
2488   } else {
2489     // User may unmap partial regions but region has to be fully contained.
2490 #ifdef ASSERT
2491     vmi->assert_is_valid_subrange(addr, size);
2492 #endif
2493     rc = release_mmaped_memory(addr, size);
2494     remove_bookkeeping = true;
2495   }
2496 
2497   // update bookkeeping
2498   if (rc && remove_bookkeeping) {
2499     vmembk_remove(vmi);
2500   }
2501 
2502   return rc;
2503 }
2504 
2505 static bool checked_mprotect(char* addr, size_t size, int prot) {
2506 
2507   // Little problem here: if SPEC1170 behaviour is off, mprotect() on AIX will
2508   // not tell me if protection failed when trying to protect an un-protectable range.
2509   //
2510   // This means if the memory was allocated using shmget/shmat, protection wont work
2511   // but mprotect will still return 0:
2512   //
2513   // See http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/mprotect.htm
2514 
2515   bool rc = ::mprotect(addr, size, prot) == 0 ? true : false;
2516 
2517   if (!rc) {
2518     const char* const s_errno = strerror(errno);
2519     warning("mprotect(" PTR_FORMAT "-" PTR_FORMAT ", 0x%X) failed (%s).", addr, addr + size, prot, s_errno);
2520     return false;
2521   }
2522 
2523   // mprotect success check
2524   //
2525   // Mprotect said it changed the protection but can I believe it?
2526   //
2527   // To be sure I need to check the protection afterwards. Try to
2528   // read from protected memory and check whether that causes a segfault.
2529   //
2530   if (!os::Aix::xpg_sus_mode()) {
2531 
2532     if (CanUseSafeFetch32()) {
2533 
2534       const bool read_protected =
2535         (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&
2536          SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;
2537 
2538       if (prot & PROT_READ) {
2539         rc = !read_protected;
2540       } else {
2541         rc = read_protected;
2542       }
2543 
2544       if (!rc) {
2545         if (os::Aix::on_pase()) {
2546           // There is an issue on older PASE systems where mprotect() will return success but the
2547           // memory will not be protected.
2548           // This has nothing to do with the problem of using mproect() on SPEC1170 incompatible
2549           // machines; we only see it rarely, when using mprotect() to protect the guard page of
2550           // a stack. It is an OS error.
2551           //
2552           // A valid strategy is just to try again. This usually works. :-/
2553 
2554           MiscUtils::sleep_ms(1);
2555           if (::mprotect(addr, size, prot) == 0) {
2556             const bool read_protected_2 =
2557               (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&
2558               SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;
2559             rc = true;
2560           }
2561         }
2562       }


2563     }
2564   }
2565 
2566   assert(rc == true, "mprotect failed.");
2567 
2568   return rc;
2569 }
2570 
2571 // Set protections specified
2572 bool os::protect_memory(char* addr, size_t size, ProtType prot, bool is_committed) {
2573   unsigned int p = 0;
2574   switch (prot) {
2575   case MEM_PROT_NONE: p = PROT_NONE; break;
2576   case MEM_PROT_READ: p = PROT_READ; break;
2577   case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;
2578   case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
2579   default:
2580     ShouldNotReachHere();
2581   }
2582   // is_committed is unused.
2583   return checked_mprotect(addr, size, p);
2584 }
2585 
2586 bool os::guard_memory(char* addr, size_t size) {
2587   return checked_mprotect(addr, size, PROT_NONE);
2588 }
2589 
2590 bool os::unguard_memory(char* addr, size_t size) {
2591   return checked_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC);
2592 }
2593 
2594 // Large page support
2595 
2596 static size_t _large_page_size = 0;
2597 
2598 // Enable large page support if OS allows that.
2599 void os::large_page_init() {
2600   return; // Nothing to do. See query_multipage_support and friends.
2601 }
2602 
2603 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
2604   // reserve_memory_special() is used to allocate large paged memory. On AIX, we implement
2605   // 64k paged memory reservation using the normal memory allocation paths (os::reserve_memory()),
2606   // so this is not needed.
2607   assert(false, "should not be called on AIX");
2608   return NULL;
2609 }
2610 
2611 bool os::release_memory_special(char* base, size_t bytes) {
2612   // Detaching the SHM segment will also delete it, see reserve_memory_special().
2613   Unimplemented();
2614   return false;
2615 }
2616 
2617 size_t os::large_page_size() {
2618   return _large_page_size;
2619 }
2620 
2621 bool os::can_commit_large_page_memory() {
2622   // Does not matter, we do not support huge pages.
2623   return false;
2624 }
2625 
2626 bool os::can_execute_large_page_memory() {
2627   // Does not matter, we do not support huge pages.
2628   return false;
2629 }
2630 
2631 // Reserve memory at an arbitrary address, only if that area is
2632 // available (and not reserved for something else).
2633 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2634   char* addr = NULL;
2635 
2636   // Always round to os::vm_page_size(), which may be larger than 4K.
2637   bytes = align_size_up(bytes, os::vm_page_size());
2638 
2639   // In 4K mode always use mmap.
2640   // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted.
2641   if (os::vm_page_size() == SIZE_4K) {
2642     return reserve_mmaped_memory(bytes, requested_addr, 0);
2643   } else {
2644     if (bytes >= Use64KPagesThreshold) {
2645       return reserve_shmated_memory(bytes, requested_addr, 0);
2646     } else {
2647       return reserve_mmaped_memory(bytes, requested_addr, 0);
2648     }
2649   }
2650 
2651   return addr;
2652 }
2653 
2654 size_t os::read(int fd, void *buf, unsigned int nBytes) {
2655   return ::read(fd, buf, nBytes);
2656 }
2657 
2658 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
2659   return ::pread(fd, buf, nBytes, offset);
2660 }
2661 
2662 void os::naked_short_sleep(jlong ms) {
2663   struct timespec req;
2664 
2665   assert(ms < 1000, "Un-interruptable sleep, short time use only");
2666   req.tv_sec = 0;
2667   if (ms > 0) {
2668     req.tv_nsec = (ms % 1000) * 1000000;
2669   }
2670   else {
2671     req.tv_nsec = 1;
2672   }
2673 
2674   nanosleep(&req, NULL);
2675 
2676   return;
2677 }
2678 
2679 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
2680 void os::infinite_sleep() {
2681   while (true) {    // sleep forever ...
2682     ::sleep(100);   // ... 100 seconds at a time
2683   }
2684 }
2685 
2686 // Used to convert frequent JVM_Yield() to nops
2687 bool os::dont_yield() {
2688   return DontYieldALot;
2689 }
2690 
2691 void os::naked_yield() {
2692   sched_yield();
2693 }
2694 
2695 ////////////////////////////////////////////////////////////////////////////////
2696 // thread priority support
2697 
2698 // From AIX manpage to pthread_setschedparam
2699 // (see: http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?
2700 //    topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_setschedparam.htm):
2701 //
2702 // "If schedpolicy is SCHED_OTHER, then sched_priority must be in the
2703 // range from 40 to 80, where 40 is the least favored priority and 80
2704 // is the most favored."
2705 //
2706 // (Actually, I doubt this even has an impact on AIX, as we do kernel
2707 // scheduling there; however, this still leaves iSeries.)
2708 //
2709 // We use the same values for AIX and PASE.
2710 int os::java_to_os_priority[CriticalPriority + 1] = {
2711   54,             // 0 Entry should never be used
2712 
2713   55,             // 1 MinPriority
2714   55,             // 2
2715   56,             // 3
2716 
2717   56,             // 4
2718   57,             // 5 NormPriority
2719   57,             // 6
2720 
2721   58,             // 7
2722   58,             // 8
2723   59,             // 9 NearMaxPriority
2724 
2725   60,             // 10 MaxPriority
2726 
2727   60              // 11 CriticalPriority
2728 };
2729 
2730 OSReturn os::set_native_priority(Thread* thread, int newpri) {
2731   if (!UseThreadPriorities) return OS_OK;
2732   pthread_t thr = thread->osthread()->pthread_id();
2733   int policy = SCHED_OTHER;
2734   struct sched_param param;
2735   param.sched_priority = newpri;
2736   int ret = pthread_setschedparam(thr, policy, &param);
2737 
2738   if (ret != 0) {
2739     trcVerbose("Could not change priority for thread %d to %d (error %d, %s)",
2740         (int)thr, newpri, ret, strerror(ret));
2741   }
2742   return (ret == 0) ? OS_OK : OS_ERR;
2743 }
2744 
2745 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
2746   if (!UseThreadPriorities) {
2747     *priority_ptr = java_to_os_priority[NormPriority];
2748     return OS_OK;
2749   }
2750   pthread_t thr = thread->osthread()->pthread_id();
2751   int policy = SCHED_OTHER;
2752   struct sched_param param;
2753   int ret = pthread_getschedparam(thr, &policy, &param);
2754   *priority_ptr = param.sched_priority;
2755 
2756   return (ret == 0) ? OS_OK : OS_ERR;
2757 }
2758 
2759 // Hint to the underlying OS that a task switch would not be good.
2760 // Void return because it's a hint and can fail.
2761 void os::hint_no_preempt() {}
2762 
2763 ////////////////////////////////////////////////////////////////////////////////
2764 // suspend/resume support
2765 
2766 //  the low-level signal-based suspend/resume support is a remnant from the
2767 //  old VM-suspension that used to be for java-suspension, safepoints etc,
2768 //  within hotspot. Now there is a single use-case for this:
2769 //    - calling get_thread_pc() on the VMThread by the flat-profiler task
2770 //      that runs in the watcher thread.
2771 //  The remaining code is greatly simplified from the more general suspension
2772 //  code that used to be used.
2773 //
2774 //  The protocol is quite simple:
2775 //  - suspend:
2776 //      - sends a signal to the target thread
2777 //      - polls the suspend state of the osthread using a yield loop
2778 //      - target thread signal handler (SR_handler) sets suspend state
2779 //        and blocks in sigsuspend until continued
2780 //  - resume:
2781 //      - sets target osthread state to continue
2782 //      - sends signal to end the sigsuspend loop in the SR_handler
2783 //
2784 //  Note that the SR_lock plays no role in this suspend/resume protocol.
2785 //
2786 
2787 static void resume_clear_context(OSThread *osthread) {
2788   osthread->set_ucontext(NULL);
2789   osthread->set_siginfo(NULL);
2790 }
2791 
2792 static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
2793   osthread->set_ucontext(context);
2794   osthread->set_siginfo(siginfo);
2795 }
2796 
2797 //
2798 // Handler function invoked when a thread's execution is suspended or
2799 // resumed. We have to be careful that only async-safe functions are
2800 // called here (Note: most pthread functions are not async safe and
2801 // should be avoided.)
2802 //
2803 // Note: sigwait() is a more natural fit than sigsuspend() from an
2804 // interface point of view, but sigwait() prevents the signal hander
2805 // from being run. libpthread would get very confused by not having
2806 // its signal handlers run and prevents sigwait()'s use with the
2807 // mutex granting granting signal.
2808 //
2809 // Currently only ever called on the VMThread and JavaThreads (PC sampling).
2810 //
2811 static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) {
2812   // Save and restore errno to avoid confusing native code with EINTR
2813   // after sigsuspend.
2814   int old_errno = errno;
2815 
2816   Thread* thread = Thread::current();
2817   OSThread* osthread = thread->osthread();
2818   assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread");
2819 
2820   os::SuspendResume::State current = osthread->sr.state();
2821   if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
2822     suspend_save_context(osthread, siginfo, context);
2823 
2824     // attempt to switch the state, we assume we had a SUSPEND_REQUEST
2825     os::SuspendResume::State state = osthread->sr.suspended();
2826     if (state == os::SuspendResume::SR_SUSPENDED) {
2827       sigset_t suspend_set;  // signals for sigsuspend()
2828 
2829       // get current set of blocked signals and unblock resume signal
2830       pthread_sigmask(SIG_BLOCK, NULL, &suspend_set);
2831       sigdelset(&suspend_set, SR_signum);
2832 
2833       // wait here until we are resumed
2834       while (1) {
2835         sigsuspend(&suspend_set);
2836 
2837         os::SuspendResume::State result = osthread->sr.running();
2838         if (result == os::SuspendResume::SR_RUNNING) {
2839           break;
2840         }
2841       }
2842 
2843     } else if (state == os::SuspendResume::SR_RUNNING) {
2844       // request was cancelled, continue
2845     } else {
2846       ShouldNotReachHere();
2847     }
2848 
2849     resume_clear_context(osthread);
2850   } else if (current == os::SuspendResume::SR_RUNNING) {
2851     // request was cancelled, continue
2852   } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
2853     // ignore
2854   } else {
2855     ShouldNotReachHere();
2856   }
2857 
2858   errno = old_errno;
2859 }
2860 
2861 static int SR_initialize() {
2862   struct sigaction act;
2863   char *s;
2864   // Get signal number to use for suspend/resume
2865   if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
2866     int sig = ::strtol(s, 0, 10);
2867     if (sig > MAX2(SIGSEGV, SIGBUS) &&  // See 4355769.
2868         sig < NSIG) {                   // Must be legal signal and fit into sigflags[].
2869       SR_signum = sig;
2870     } else {
2871       warning("You set _JAVA_SR_SIGNUM=%d. It must be in range [%d, %d]. Using %d instead.",
2872               sig, MAX2(SIGSEGV, SIGBUS)+1, NSIG-1, SR_signum);
2873     }
2874   }
2875 
2876   assert(SR_signum > SIGSEGV && SR_signum > SIGBUS,
2877         "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
2878 
2879   sigemptyset(&SR_sigset);
2880   sigaddset(&SR_sigset, SR_signum);
2881 
2882   // Set up signal handler for suspend/resume.
2883   act.sa_flags = SA_RESTART|SA_SIGINFO;
2884   act.sa_handler = (void (*)(int)) SR_handler;
2885 
2886   // SR_signum is blocked by default.
2887   // 4528190 - We also need to block pthread restart signal (32 on all
2888   // supported Linux platforms). Note that LinuxThreads need to block
2889   // this signal for all threads to work properly. So we don't have
2890   // to use hard-coded signal number when setting up the mask.
2891   pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask);
2892 
2893   if (sigaction(SR_signum, &act, 0) == -1) {
2894     return -1;
2895   }
2896 
2897   // Save signal flag
2898   os::Aix::set_our_sigflags(SR_signum, act.sa_flags);
2899   return 0;
2900 }
2901 
2902 static int SR_finalize() {
2903   return 0;
2904 }
2905 
2906 static int sr_notify(OSThread* osthread) {
2907   int status = pthread_kill(osthread->pthread_id(), SR_signum);
2908   assert_status(status == 0, status, "pthread_kill");
2909   return status;
2910 }
2911 
2912 // "Randomly" selected value for how long we want to spin
2913 // before bailing out on suspending a thread, also how often
2914 // we send a signal to a thread we want to resume
2915 static const int RANDOMLY_LARGE_INTEGER = 1000000;
2916 static const int RANDOMLY_LARGE_INTEGER2 = 100;
2917 
2918 // returns true on success and false on error - really an error is fatal
2919 // but this seems the normal response to library errors
2920 static bool do_suspend(OSThread* osthread) {
2921   assert(osthread->sr.is_running(), "thread should be running");
2922   // mark as suspended and send signal
2923 
2924   if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
2925     // failed to switch, state wasn't running?
2926     ShouldNotReachHere();
2927     return false;
2928   }
2929 
2930   if (sr_notify(osthread) != 0) {
2931     // try to cancel, switch to running
2932 
2933     os::SuspendResume::State result = osthread->sr.cancel_suspend();
2934     if (result == os::SuspendResume::SR_RUNNING) {
2935       // cancelled
2936       return false;
2937     } else if (result == os::SuspendResume::SR_SUSPENDED) {
2938       // somehow managed to suspend
2939       return true;
2940     } else {
2941       ShouldNotReachHere();
2942       return false;
2943     }
2944   }
2945 
2946   // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED
2947 
2948   for (int n = 0; !osthread->sr.is_suspended(); n++) {
2949     for (int i = 0; i < RANDOMLY_LARGE_INTEGER2 && !osthread->sr.is_suspended(); i++) {
2950       os::naked_yield();
2951     }
2952 
2953     // timeout, try to cancel the request
2954     if (n >= RANDOMLY_LARGE_INTEGER) {
2955       os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
2956       if (cancelled == os::SuspendResume::SR_RUNNING) {
2957         return false;
2958       } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
2959         return true;
2960       } else {
2961         ShouldNotReachHere();
2962         return false;
2963       }
2964     }
2965   }
2966 
2967   guarantee(osthread->sr.is_suspended(), "Must be suspended");
2968   return true;
2969 }
2970 
2971 static void do_resume(OSThread* osthread) {
2972   //assert(osthread->sr.is_suspended(), "thread should be suspended");
2973 
2974   if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
2975     // failed to switch to WAKEUP_REQUEST
2976     ShouldNotReachHere();
2977     return;
2978   }
2979 
2980   while (!osthread->sr.is_running()) {
2981     if (sr_notify(osthread) == 0) {
2982       for (int n = 0; n < RANDOMLY_LARGE_INTEGER && !osthread->sr.is_running(); n++) {
2983         for (int i = 0; i < 100 && !osthread->sr.is_running(); i++) {
2984           os::naked_yield();
2985         }
2986       }
2987     } else {
2988       ShouldNotReachHere();
2989     }
2990   }
2991 
2992   guarantee(osthread->sr.is_running(), "Must be running!");
2993 }
2994 
2995 ///////////////////////////////////////////////////////////////////////////////////
2996 // signal handling (except suspend/resume)
2997 
2998 // This routine may be used by user applications as a "hook" to catch signals.
2999 // The user-defined signal handler must pass unrecognized signals to this
3000 // routine, and if it returns true (non-zero), then the signal handler must
3001 // return immediately. If the flag "abort_if_unrecognized" is true, then this
3002 // routine will never retun false (zero), but instead will execute a VM panic
3003 // routine kill the process.
3004 //
3005 // If this routine returns false, it is OK to call it again. This allows
3006 // the user-defined signal handler to perform checks either before or after
3007 // the VM performs its own checks. Naturally, the user code would be making
3008 // a serious error if it tried to handle an exception (such as a null check
3009 // or breakpoint) that the VM was generating for its own correct operation.
3010 //
3011 // This routine may recognize any of the following kinds of signals:
3012 //   SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1.
3013 // It should be consulted by handlers for any of those signals.
3014 //
3015 // The caller of this routine must pass in the three arguments supplied
3016 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
3017 // field of the structure passed to sigaction(). This routine assumes that
3018 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
3019 //
3020 // Note that the VM will print warnings if it detects conflicting signal
3021 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
3022 //
3023 extern "C" JNIEXPORT int
3024 JVM_handle_aix_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized);
3025 
3026 // Set thread signal mask (for some reason on AIX sigthreadmask() seems
3027 // to be the thing to call; documentation is not terribly clear about whether
3028 // pthread_sigmask also works, and if it does, whether it does the same.
3029 bool set_thread_signal_mask(int how, const sigset_t* set, sigset_t* oset) {
3030   const int rc = ::pthread_sigmask(how, set, oset);
3031   // return value semantics differ slightly for error case:
3032   // pthread_sigmask returns error number, sigthreadmask -1 and sets global errno
3033   // (so, pthread_sigmask is more theadsafe for error handling)
3034   // But success is always 0.
3035   return rc == 0 ? true : false;
3036 }
3037 
3038 // Function to unblock all signals which are, according
3039 // to POSIX, typical program error signals. If they happen while being blocked,
3040 // they typically will bring down the process immediately.
3041 bool unblock_program_error_signals() {
3042   sigset_t set;
3043   ::sigemptyset(&set);
3044   ::sigaddset(&set, SIGILL);
3045   ::sigaddset(&set, SIGBUS);
3046   ::sigaddset(&set, SIGFPE);
3047   ::sigaddset(&set, SIGSEGV);
3048   return set_thread_signal_mask(SIG_UNBLOCK, &set, NULL);
3049 }
3050 
3051 // Renamed from 'signalHandler' to avoid collision with other shared libs.
3052 void javaSignalHandler(int sig, siginfo_t* info, void* uc) {
3053   assert(info != NULL && uc != NULL, "it must be old kernel");
3054 
3055   // Never leave program error signals blocked;
3056   // on all our platforms they would bring down the process immediately when
3057   // getting raised while being blocked.
3058   unblock_program_error_signals();
3059 
3060   int orig_errno = errno;  // Preserve errno value over signal handler.
3061   JVM_handle_aix_signal(sig, info, uc, true);
3062   errno = orig_errno;
3063 }
3064 
3065 // This boolean allows users to forward their own non-matching signals
3066 // to JVM_handle_aix_signal, harmlessly.
3067 bool os::Aix::signal_handlers_are_installed = false;
3068 
3069 // For signal-chaining
3070 struct sigaction sigact[NSIG];
3071 sigset_t sigs;
3072 bool os::Aix::libjsig_is_loaded = false;
3073 typedef struct sigaction *(*get_signal_t)(int);
3074 get_signal_t os::Aix::get_signal_action = NULL;
3075 
3076 struct sigaction* os::Aix::get_chained_signal_action(int sig) {
3077   struct sigaction *actp = NULL;
3078 
3079   if (libjsig_is_loaded) {
3080     // Retrieve the old signal handler from libjsig
3081     actp = (*get_signal_action)(sig);
3082   }
3083   if (actp == NULL) {
3084     // Retrieve the preinstalled signal handler from jvm
3085     actp = get_preinstalled_handler(sig);
3086   }
3087 
3088   return actp;
3089 }
3090 
3091 static bool call_chained_handler(struct sigaction *actp, int sig,
3092                                  siginfo_t *siginfo, void *context) {
3093   // Call the old signal handler
3094   if (actp->sa_handler == SIG_DFL) {
3095     // It's more reasonable to let jvm treat it as an unexpected exception
3096     // instead of taking the default action.
3097     return false;
3098   } else if (actp->sa_handler != SIG_IGN) {
3099     if ((actp->sa_flags & SA_NODEFER) == 0) {
3100       // automaticlly block the signal
3101       sigaddset(&(actp->sa_mask), sig);
3102     }
3103 
3104     sa_handler_t hand = NULL;
3105     sa_sigaction_t sa = NULL;
3106     bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
3107     // retrieve the chained handler
3108     if (siginfo_flag_set) {
3109       sa = actp->sa_sigaction;
3110     } else {
3111       hand = actp->sa_handler;
3112     }
3113 
3114     if ((actp->sa_flags & SA_RESETHAND) != 0) {
3115       actp->sa_handler = SIG_DFL;
3116     }
3117 
3118     // try to honor the signal mask
3119     sigset_t oset;
3120     pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset);
3121 
3122     // call into the chained handler
3123     if (siginfo_flag_set) {
3124       (*sa)(sig, siginfo, context);
3125     } else {
3126       (*hand)(sig);
3127     }
3128 
3129     // restore the signal mask
3130     pthread_sigmask(SIG_SETMASK, &oset, 0);
3131   }
3132   // Tell jvm's signal handler the signal is taken care of.
3133   return true;
3134 }
3135 
3136 bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) {
3137   bool chained = false;
3138   // signal-chaining
3139   if (UseSignalChaining) {
3140     struct sigaction *actp = get_chained_signal_action(sig);
3141     if (actp != NULL) {
3142       chained = call_chained_handler(actp, sig, siginfo, context);
3143     }
3144   }
3145   return chained;
3146 }
3147 
3148 struct sigaction* os::Aix::get_preinstalled_handler(int sig) {
3149   if (sigismember(&sigs, sig)) {
3150     return &sigact[sig];
3151   }
3152   return NULL;
3153 }
3154 
3155 void os::Aix::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
3156   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3157   sigact[sig] = oldAct;
3158   sigaddset(&sigs, sig);
3159 }
3160 
3161 // for diagnostic
3162 int sigflags[NSIG];
3163 
3164 int os::Aix::get_our_sigflags(int sig) {
3165   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3166   return sigflags[sig];
3167 }
3168 
3169 void os::Aix::set_our_sigflags(int sig, int flags) {
3170   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3171   if (sig > 0 && sig < NSIG) {
3172     sigflags[sig] = flags;
3173   }
3174 }
3175 
3176 void os::Aix::set_signal_handler(int sig, bool set_installed) {
3177   // Check for overwrite.
3178   struct sigaction oldAct;
3179   sigaction(sig, (struct sigaction*)NULL, &oldAct);
3180 
3181   void* oldhand = oldAct.sa_sigaction
3182     ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3183     : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);

3184   if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
3185       oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
3186       oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) {
3187     if (AllowUserSignalHandlers || !set_installed) {
3188       // Do not overwrite; user takes responsibility to forward to us.
3189       return;
3190     } else if (UseSignalChaining) {
3191       // save the old handler in jvm
3192       save_preinstalled_handler(sig, oldAct);
3193       // libjsig also interposes the sigaction() call below and saves the
3194       // old sigaction on it own.
3195     } else {
3196       fatal("Encountered unexpected pre-existing sigaction handler "
3197             "%#lx for signal %d.", (long)oldhand, sig);
3198     }
3199   }
3200 
3201   struct sigaction sigAct;
3202   sigfillset(&(sigAct.sa_mask));
3203   if (!set_installed) {
3204     sigAct.sa_handler = SIG_DFL;
3205     sigAct.sa_flags = SA_RESTART;
3206   } else {

3207     sigAct.sa_sigaction = javaSignalHandler;
3208     sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
3209   }
3210   // Save flags, which are set by ours
3211   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3212   sigflags[sig] = sigAct.sa_flags;
3213 
3214   int ret = sigaction(sig, &sigAct, &oldAct);
3215   assert(ret == 0, "check");
3216 
3217   void* oldhand2 = oldAct.sa_sigaction
3218                  ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3219                  : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3220   assert(oldhand2 == oldhand, "no concurrent signal handler installation");
3221 }
3222 
3223 // install signal handlers for signals that HotSpot needs to
3224 // handle in order to support Java-level exception handling.
3225 void os::Aix::install_signal_handlers() {
3226   if (!signal_handlers_are_installed) {
3227     signal_handlers_are_installed = true;
3228 
3229     // signal-chaining
3230     typedef void (*signal_setting_t)();
3231     signal_setting_t begin_signal_setting = NULL;
3232     signal_setting_t end_signal_setting = NULL;
3233     begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3234                              dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
3235     if (begin_signal_setting != NULL) {
3236       end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3237                              dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
3238       get_signal_action = CAST_TO_FN_PTR(get_signal_t,
3239                             dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
3240       libjsig_is_loaded = true;
3241       assert(UseSignalChaining, "should enable signal-chaining");
3242     }
3243     if (libjsig_is_loaded) {
3244       // Tell libjsig jvm is setting signal handlers.
3245       (*begin_signal_setting)();
3246     }
3247 
3248     ::sigemptyset(&sigs);
3249     set_signal_handler(SIGSEGV, true);
3250     set_signal_handler(SIGPIPE, true);
3251     set_signal_handler(SIGBUS, true);
3252     set_signal_handler(SIGILL, true);
3253     set_signal_handler(SIGFPE, true);
3254     set_signal_handler(SIGTRAP, true);
3255     set_signal_handler(SIGXFSZ, true);
3256     set_signal_handler(SIGDANGER, true);
3257 
3258     if (libjsig_is_loaded) {
3259       // Tell libjsig jvm finishes setting signal handlers.
3260       (*end_signal_setting)();
3261     }
3262 
3263     // We don't activate signal checker if libjsig is in place, we trust ourselves
3264     // and if UserSignalHandler is installed all bets are off.
3265     // Log that signal checking is off only if -verbose:jni is specified.
3266     if (CheckJNICalls) {
3267       if (libjsig_is_loaded) {
3268         tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
3269         check_signals = false;
3270       }
3271       if (AllowUserSignalHandlers) {
3272         tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
3273         check_signals = false;
3274       }
3275       // Need to initialize check_signal_done.
3276       ::sigemptyset(&check_signal_done);
3277     }
3278   }
3279 }
3280 
3281 static const char* get_signal_handler_name(address handler,
3282                                            char* buf, int buflen) {
3283   int offset;
3284   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
3285   if (found) {
3286     // skip directory names
3287     const char *p1, *p2;
3288     p1 = buf;
3289     size_t len = strlen(os::file_separator());
3290     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
3291     // The way os::dll_address_to_library_name is implemented on Aix
3292     // right now, it always returns -1 for the offset which is not
3293     // terribly informative.
3294     // Will fix that. For now, omit the offset.
3295     jio_snprintf(buf, buflen, "%s", p1);
3296   } else {
3297     jio_snprintf(buf, buflen, PTR_FORMAT, handler);
3298   }
3299   return buf;
3300 }
3301 
3302 static void print_signal_handler(outputStream* st, int sig,
3303                                  char* buf, size_t buflen) {
3304   struct sigaction sa;
3305   sigaction(sig, NULL, &sa);
3306 
3307   st->print("%s: ", os::exception_name(sig, buf, buflen));
3308 
3309   address handler = (sa.sa_flags & SA_SIGINFO)
3310     ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
3311     : CAST_FROM_FN_PTR(address, sa.sa_handler);
3312 
3313   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
3314     st->print("SIG_DFL");
3315   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
3316     st->print("SIG_IGN");
3317   } else {
3318     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
3319   }
3320 
3321   // Print readable mask.
3322   st->print(", sa_mask[0]=");
3323   os::Posix::print_signal_set_short(st, &sa.sa_mask);
3324 
3325   address rh = VMError::get_resetted_sighandler(sig);
3326   // May be, handler was resetted by VMError?
3327   if (rh != NULL) {
3328     handler = rh;
3329     sa.sa_flags = VMError::get_resetted_sigflags(sig);
3330   }
3331 
3332   // Print textual representation of sa_flags.
3333   st->print(", sa_flags=");
3334   os::Posix::print_sa_flags(st, sa.sa_flags);
3335 
3336   // Check: is it our handler?
3337   if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler) ||
3338       handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
3339     // It is our signal handler.
3340     // Check for flags, reset system-used one!
3341     if ((int)sa.sa_flags != os::Aix::get_our_sigflags(sig)) {
3342       st->print(", flags was changed from " PTR32_FORMAT ", consider using jsig library",
3343                 os::Aix::get_our_sigflags(sig));
3344     }
3345   }
3346   st->cr();
3347 }
3348 
3349 #define DO_SIGNAL_CHECK(sig) \
3350   if (!sigismember(&check_signal_done, sig)) \
3351     os::Aix::check_signal_handler(sig)
3352 
3353 // This method is a periodic task to check for misbehaving JNI applications
3354 // under CheckJNI, we can add any periodic checks here
3355 
3356 void os::run_periodic_checks() {
3357 
3358   if (check_signals == false) return;
3359 
3360   // SEGV and BUS if overridden could potentially prevent
3361   // generation of hs*.log in the event of a crash, debugging
3362   // such a case can be very challenging, so we absolutely
3363   // check the following for a good measure:
3364   DO_SIGNAL_CHECK(SIGSEGV);
3365   DO_SIGNAL_CHECK(SIGILL);
3366   DO_SIGNAL_CHECK(SIGFPE);
3367   DO_SIGNAL_CHECK(SIGBUS);
3368   DO_SIGNAL_CHECK(SIGPIPE);
3369   DO_SIGNAL_CHECK(SIGXFSZ);
3370   if (UseSIGTRAP) {
3371     DO_SIGNAL_CHECK(SIGTRAP);
3372   }
3373   DO_SIGNAL_CHECK(SIGDANGER);
3374 
3375   // ReduceSignalUsage allows the user to override these handlers
3376   // see comments at the very top and jvm_solaris.h
3377   if (!ReduceSignalUsage) {
3378     DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
3379     DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
3380     DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
3381     DO_SIGNAL_CHECK(BREAK_SIGNAL);
3382   }
3383 
3384   DO_SIGNAL_CHECK(SR_signum);
3385 }
3386 
3387 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
3388 
3389 static os_sigaction_t os_sigaction = NULL;
3390 
3391 void os::Aix::check_signal_handler(int sig) {
3392   char buf[O_BUFLEN];
3393   address jvmHandler = NULL;
3394 
3395   struct sigaction act;
3396   if (os_sigaction == NULL) {
3397     // only trust the default sigaction, in case it has been interposed
3398     os_sigaction = CAST_TO_FN_PTR(os_sigaction_t, dlsym(RTLD_DEFAULT, "sigaction"));
3399     if (os_sigaction == NULL) return;
3400   }
3401 
3402   os_sigaction(sig, (struct sigaction*)NULL, &act);
3403 
3404   address thisHandler = (act.sa_flags & SA_SIGINFO)
3405     ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
3406     : CAST_FROM_FN_PTR(address, act.sa_handler);
3407 
3408   switch(sig) {
3409   case SIGSEGV:
3410   case SIGBUS:
3411   case SIGFPE:
3412   case SIGPIPE:
3413   case SIGILL:
3414   case SIGXFSZ:

3415     jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler);
3416     break;
3417 
3418   case SHUTDOWN1_SIGNAL:
3419   case SHUTDOWN2_SIGNAL:
3420   case SHUTDOWN3_SIGNAL:
3421   case BREAK_SIGNAL:
3422     jvmHandler = (address)user_handler();
3423     break;
3424 
3425   default:
3426     if (sig == SR_signum) {
3427       jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler);
3428     } else {
3429       return;
3430     }
3431     break;
3432   }
3433 
3434   if (thisHandler != jvmHandler) {
3435     tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
3436     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
3437     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
3438     // No need to check this sig any longer
3439     sigaddset(&check_signal_done, sig);
3440     // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN
3441     if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) {
3442       tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell",
3443                     exception_name(sig, buf, O_BUFLEN));
3444     }
3445   } else if (os::Aix::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Aix::get_our_sigflags(sig)) {
3446     tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
3447     tty->print("expected:" PTR32_FORMAT, os::Aix::get_our_sigflags(sig));
3448     tty->print_cr("  found:" PTR32_FORMAT, act.sa_flags);
3449     // No need to check this sig any longer
3450     sigaddset(&check_signal_done, sig);
3451   }
3452 
3453   // Dump all the signal
3454   if (sigismember(&check_signal_done, sig)) {
3455     print_signal_handlers(tty, buf, O_BUFLEN);
3456   }
3457 }
3458 
3459 extern bool signal_name(int signo, char* buf, size_t len);
3460 
3461 const char* os::exception_name(int exception_code, char* buf, size_t size) {
3462   if (0 < exception_code && exception_code <= SIGRTMAX) {
3463     // signal
3464     if (!signal_name(exception_code, buf, size)) {
3465       jio_snprintf(buf, size, "SIG%d", exception_code);
3466     }
3467     return buf;
3468   } else {
3469     return NULL;
3470   }
3471 }
3472 
3473 // To install functions for atexit system call
3474 extern "C" {
3475   static void perfMemory_exit_helper() {
3476     perfMemory_exit();
3477   }
3478 }
3479 
3480 // This is called _before_ the most of global arguments have been parsed.
3481 void os::init(void) {
3482   // This is basic, we want to know if that ever changes.
3483   // (Shared memory boundary is supposed to be a 256M aligned.)
3484   assert(SHMLBA == ((uint64_t)0x10000000ULL)/*256M*/, "unexpected");
3485 
3486   // Record process break at startup.
3487   g_brk_at_startup = (address) ::sbrk(0);
3488   assert(g_brk_at_startup != (address) -1, "sbrk failed");
3489 
3490   // First off, we need to know whether we run on AIX or PASE, and
3491   // the OS level we run on.
3492   os::Aix::initialize_os_info();
3493 
3494   // Scan environment (SPEC1170 behaviour, etc).
3495   os::Aix::scan_environment();
3496 
3497   // Probe multipage support.
3498   query_multipage_support();
3499 
3500   // Act like we only have one page size by eliminating corner cases which
3501   // we did not support very well anyway.
3502   // We have two input conditions:
3503   // 1) Data segment page size. This is controlled by linker setting (datapsize) on the
3504   //    launcher, and/or by LDR_CNTRL environment variable. The latter overrules the linker
3505   //    setting.
3506   //    Data segment page size is important for us because it defines the thread stack page
3507   //    size, which is needed for guard page handling, stack banging etc.
3508   // 2) The ability to allocate 64k pages dynamically. If this is a given, java heap can
3509   //    and should be allocated with 64k pages.
3510   //
3511   // So, we do the following:
3512   // LDR_CNTRL    can_use_64K_pages_dynamically       what we do                      remarks
3513   // 4K           no                                  4K                              old systems (aix 5.2, as/400 v5r4) or new systems with AME activated
3514   // 4k           yes                                 64k (treat 4k stacks as 64k)    different loader than java and standard settings
3515   // 64k          no              --- AIX 5.2 ? ---
3516   // 64k          yes                                 64k                             new systems and standard java loader (we set datapsize=64k when linking)
3517 
3518   // We explicitly leave no option to change page size, because only upgrading would work,
3519   // not downgrading (if stack page size is 64k you cannot pretend its 4k).
3520 
3521   if (g_multipage_support.datapsize == SIZE_4K) {
3522     // datapsize = 4K. Data segment, thread stacks are 4K paged.
3523     if (g_multipage_support.can_use_64K_pages) {
3524       // .. but we are able to use 64K pages dynamically.
3525       // This would be typical for java launchers which are not linked
3526       // with datapsize=64K (like, any other launcher but our own).
3527       //
3528       // In this case it would be smart to allocate the java heap with 64K
3529       // to get the performance benefit, and to fake 64k pages for the
3530       // data segment (when dealing with thread stacks).
3531       //
3532       // However, leave a possibility to downgrade to 4K, using
3533       // -XX:-Use64KPages.
3534       if (Use64KPages) {
3535         trcVerbose("64K page mode (faked for data segment)");
3536         Aix::_page_size = SIZE_64K;
3537       } else {
3538         trcVerbose("4K page mode (Use64KPages=off)");
3539         Aix::_page_size = SIZE_4K;
3540       }
3541     } else {
3542       // .. and not able to allocate 64k pages dynamically. Here, just
3543       // fall back to 4K paged mode and use mmap for everything.
3544       trcVerbose("4K page mode");
3545       Aix::_page_size = SIZE_4K;
3546       FLAG_SET_ERGO(bool, Use64KPages, false);
3547     }
3548   } else {
3549     // datapsize = 64k. Data segment, thread stacks are 64k paged.
3550     // This normally means that we can allocate 64k pages dynamically.
3551     // (There is one special case where this may be false: EXTSHM=on.
3552     // but we decided to not support that mode).
3553     assert0(g_multipage_support.can_use_64K_pages);
3554     Aix::_page_size = SIZE_64K;
3555     trcVerbose("64K page mode");
3556     FLAG_SET_ERGO(bool, Use64KPages, true);
3557   }
3558 
3559   // Short-wire stack page size to base page size; if that works, we just remove
3560   // that stack page size altogether.
3561   Aix::_stack_page_size = Aix::_page_size;
3562 
3563   // For now UseLargePages is just ignored.
3564   FLAG_SET_ERGO(bool, UseLargePages, false);
3565   _page_sizes[0] = 0;
3566   _large_page_size = -1;
3567 
3568   // debug trace
3569   trcVerbose("os::vm_page_size %s", describe_pagesize(os::vm_page_size()));
3570 
3571   // Next, we need to initialize libo4 and libperfstat libraries.
3572   if (os::Aix::on_pase()) {
3573     os::Aix::initialize_libo4();
3574   } else {
3575     os::Aix::initialize_libperfstat();
3576   }
3577 
3578   // Reset the perfstat information provided by ODM.
3579   if (os::Aix::on_aix()) {
3580     libperfstat::perfstat_reset();
3581   }
3582 
3583   // Now initialze basic system properties. Note that for some of the values we
3584   // need libperfstat etc.
3585   os::Aix::initialize_system_info();
3586 


3587   clock_tics_per_sec = sysconf(_SC_CLK_TCK);
3588 
3589   init_random(1234567);
3590 
3591   ThreadCritical::initialize();
3592 
3593   // Main_thread points to the aboriginal thread.
3594   Aix::_main_thread = pthread_self();
3595 
3596   initial_time_count = os::elapsed_counter();
3597 
3598   // If the pagesize of the VM is greater than 8K determine the appropriate
3599   // number of initial guard pages. The user can change this with the
3600   // command line arguments, if needed.
3601   if (vm_page_size() > (int)Aix::vm_default_page_size()) {
3602     StackYellowPages = 1;
3603     StackRedPages = 1;
3604     StackShadowPages = round_to((StackShadowPages*Aix::vm_default_page_size()), vm_page_size()) / vm_page_size();
3605   }
3606 }
3607 
3608 // This is called _after_ the global arguments have been parsed.
3609 jint os::init_2(void) {
3610 
3611   if (os::Aix::on_pase()) {
3612     trcVerbose("Running on PASE.");
3613   } else {
3614     trcVerbose("Running on AIX (not PASE).");
3615   }
3616 
3617   trcVerbose("processor count: %d", os::_processor_count);
3618   trcVerbose("physical memory: %lu", Aix::_physical_memory);
3619 
3620   // Initially build up the loaded dll map.
3621   LoadedLibraries::reload();
3622   if (Verbose) {
3623     trcVerbose("Loaded Libraries: ");
3624     LoadedLibraries::print(tty);
3625   }
3626 
3627   const int page_size = Aix::page_size();
3628   const int map_size = page_size;
3629 
3630   address map_address = (address) MAP_FAILED;
3631   const int prot  = PROT_READ;
3632   const int flags = MAP_PRIVATE|MAP_ANONYMOUS;
3633 
3634   // Use optimized addresses for the polling page,
3635   // e.g. map it to a special 32-bit address.
3636   if (OptimizePollingPageLocation) {
3637     // architecture-specific list of address wishes:
3638     address address_wishes[] = {
3639       // AIX: addresses lower than 0x30000000 don't seem to work on AIX.
3640       // PPC64: all address wishes are non-negative 32 bit values where
3641       // the lower 16 bits are all zero. we can load these addresses
3642       // with a single ppc_lis instruction.
3643       (address) 0x30000000, (address) 0x31000000,
3644       (address) 0x32000000, (address) 0x33000000,
3645       (address) 0x40000000, (address) 0x41000000,
3646       (address) 0x42000000, (address) 0x43000000,
3647       (address) 0x50000000, (address) 0x51000000,
3648       (address) 0x52000000, (address) 0x53000000,
3649       (address) 0x60000000, (address) 0x61000000,
3650       (address) 0x62000000, (address) 0x63000000
3651     };
3652     int address_wishes_length = sizeof(address_wishes)/sizeof(address);
3653 
3654     // iterate over the list of address wishes:
3655     for (int i=0; i<address_wishes_length; i++) {
3656       // Try to map with current address wish.
3657       // AIX: AIX needs MAP_FIXED if we provide an address and mmap will
3658       // fail if the address is already mapped.
3659       map_address = (address) ::mmap(address_wishes[i] - (ssize_t)page_size,
3660                                      map_size, prot,
3661                                      flags | MAP_FIXED,
3662                                      -1, 0);
3663       trcVerbose("SafePoint Polling  Page address: %p (wish) => %p",

3664                    address_wishes[i], map_address + (ssize_t)page_size);

3665 
3666       if (map_address + (ssize_t)page_size == address_wishes[i]) {
3667         // Map succeeded and map_address is at wished address, exit loop.
3668         break;
3669       }
3670 
3671       if (map_address != (address) MAP_FAILED) {
3672         // Map succeeded, but polling_page is not at wished address, unmap and continue.
3673         ::munmap(map_address, map_size);
3674         map_address = (address) MAP_FAILED;
3675       }
3676       // Map failed, continue loop.
3677     }
3678   } // end OptimizePollingPageLocation
3679 
3680   if (map_address == (address) MAP_FAILED) {
3681     map_address = (address) ::mmap(NULL, map_size, prot, flags, -1, 0);
3682   }
3683   guarantee(map_address != MAP_FAILED, "os::init_2: failed to allocate polling page");
3684   os::set_polling_page(map_address);
3685 
3686   if (!UseMembar) {
3687     address mem_serialize_page = (address) ::mmap(NULL, Aix::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
3688     guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
3689     os::set_memory_serialize_page(mem_serialize_page);
3690 
3691     trcVerbose("Memory Serialize  Page address: %p - %p, size %IX (%IB)",
3692         mem_serialize_page, mem_serialize_page + Aix::page_size(),
3693         Aix::page_size(), Aix::page_size());


3694   }
3695 
3696   // initialize suspend/resume support - must do this before signal_sets_init()
3697   if (SR_initialize() != 0) {
3698     perror("SR_initialize failed");
3699     return JNI_ERR;
3700   }
3701 
3702   Aix::signal_sets_init();
3703   Aix::install_signal_handlers();
3704 
3705   // Check minimum allowable stack size for thread creation and to initialize
3706   // the java system classes, including StackOverflowError - depends on page
3707   // size. Add a page for compiler2 recursion in main thread.
3708   // Add in 2*BytesPerWord times page size to account for VM stack during
3709   // class initialization depending on 32 or 64 bit VM.
3710   os::Aix::min_stack_allowed = MAX2(os::Aix::min_stack_allowed,
3711             (size_t)(StackYellowPages+StackRedPages+StackShadowPages) * Aix::page_size() +
3712                      (2*BytesPerWord COMPILER2_PRESENT(+1)) * Aix::vm_default_page_size());
3713 
3714   os::Aix::min_stack_allowed = align_size_up(os::Aix::min_stack_allowed, os::Aix::page_size());
3715 
3716   size_t threadStackSizeInBytes = ThreadStackSize * K;
3717   if (threadStackSizeInBytes != 0 &&
3718       threadStackSizeInBytes < os::Aix::min_stack_allowed) {
3719     tty->print_cr("\nThe stack size specified is too small, "
3720                   "Specify at least %dk",
3721                   os::Aix::min_stack_allowed / K);
3722     return JNI_ERR;
3723   }
3724 
3725   // Make the stack size a multiple of the page size so that
3726   // the yellow/red zones can be guarded.
3727   // Note that this can be 0, if no default stacksize was set.
3728   JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, vm_page_size()));
3729 
3730   if (UseNUMA) {
3731     UseNUMA = false;
3732     warning("NUMA optimizations are not available on this OS.");
3733   }
3734 
3735   if (MaxFDLimit) {
3736     // Set the number of file descriptors to max. print out error
3737     // if getrlimit/setrlimit fails but continue regardless.
3738     struct rlimit nbr_files;
3739     int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
3740     if (status != 0) {
3741       if (PrintMiscellaneous && (Verbose || WizardMode))
3742         perror("os::init_2 getrlimit failed");
3743     } else {
3744       nbr_files.rlim_cur = nbr_files.rlim_max;
3745       status = setrlimit(RLIMIT_NOFILE, &nbr_files);
3746       if (status != 0) {
3747         if (PrintMiscellaneous && (Verbose || WizardMode))
3748           perror("os::init_2 setrlimit failed");
3749       }
3750     }
3751   }
3752 
3753   if (PerfAllowAtExitRegistration) {
3754     // Only register atexit functions if PerfAllowAtExitRegistration is set.
3755     // At exit functions can be delayed until process exit time, which
3756     // can be problematic for embedded VM situations. Embedded VMs should
3757     // call DestroyJavaVM() to assure that VM resources are released.
3758 
3759     // Note: perfMemory_exit_helper atexit function may be removed in
3760     // the future if the appropriate cleanup code can be added to the
3761     // VM_Exit VMOperation's doit method.
3762     if (atexit(perfMemory_exit_helper) != 0) {
3763       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3764     }
3765   }
3766 
3767   return JNI_OK;
3768 }
3769 
3770 // Mark the polling page as unreadable
3771 void os::make_polling_page_unreadable(void) {
3772   if (!guard_memory((char*)_polling_page, Aix::page_size())) {
3773     fatal("Could not disable polling page");
3774   }
3775 };
3776 
3777 // Mark the polling page as readable
3778 void os::make_polling_page_readable(void) {
3779   // Changed according to os_linux.cpp.
3780   if (!checked_mprotect((char *)_polling_page, Aix::page_size(), PROT_READ)) {
3781     fatal("Could not enable polling page at " PTR_FORMAT, _polling_page);
3782   }
3783 };
3784 
3785 int os::active_processor_count() {
3786   int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
3787   assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
3788   return online_cpus;
3789 }
3790 
3791 void os::set_native_thread_name(const char *name) {
3792   // Not yet implemented.
3793   return;
3794 }
3795 
3796 bool os::distribute_processes(uint length, uint* distribution) {
3797   // Not yet implemented.
3798   return false;
3799 }
3800 
3801 bool os::bind_to_processor(uint processor_id) {
3802   // Not yet implemented.
3803   return false;
3804 }
3805 
3806 void os::SuspendedThreadTask::internal_do_task() {
3807   if (do_suspend(_thread->osthread())) {
3808     SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext());
3809     do_task(context);
3810     do_resume(_thread->osthread());
3811   }
3812 }
3813 
3814 class PcFetcher : public os::SuspendedThreadTask {
3815 public:
3816   PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
3817   ExtendedPC result();
3818 protected:
3819   void do_task(const os::SuspendedThreadTaskContext& context);
3820 private:
3821   ExtendedPC _epc;
3822 };
3823 
3824 ExtendedPC PcFetcher::result() {
3825   guarantee(is_done(), "task is not done yet.");
3826   return _epc;
3827 }
3828 
3829 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
3830   Thread* thread = context.thread();
3831   OSThread* osthread = thread->osthread();
3832   if (osthread->ucontext() != NULL) {
3833     _epc = os::Aix::ucontext_get_pc((ucontext_t *) context.ucontext());
3834   } else {
3835     // NULL context is unexpected, double-check this is the VMThread.
3836     guarantee(thread->is_VM_thread(), "can only be called for VMThread");
3837   }
3838 }
3839 
3840 // Suspends the target using the signal mechanism and then grabs the PC before
3841 // resuming the target. Used by the flat-profiler only
3842 ExtendedPC os::get_thread_pc(Thread* thread) {
3843   // Make sure that it is called by the watcher for the VMThread.
3844   assert(Thread::current()->is_Watcher_thread(), "Must be watcher");
3845   assert(thread->is_VM_thread(), "Can only be called for VMThread");
3846 
3847   PcFetcher fetcher(thread);
3848   fetcher.run();
3849   return fetcher.result();
3850 }
3851 
3852 ////////////////////////////////////////////////////////////////////////////////
3853 // debug support
3854 










3855 bool os::find(address addr, outputStream* st) {
3856 
3857   st->print(PTR_FORMAT ": ", addr);
3858 
3859   loaded_module_t lm;
3860   if (LoadedLibraries::find_for_text_address(addr, &lm) != NULL ||
3861       LoadedLibraries::find_for_data_address(addr, &lm) != NULL) {
3862     st->print("%s", lm.path);
3863     return true;
3864   }
3865 
3866   return false;
3867 }
3868 
3869 ////////////////////////////////////////////////////////////////////////////////
3870 // misc
3871 
3872 // This does not do anything on Aix. This is basically a hook for being
3873 // able to use structured exception handling (thread-local exception filters)
3874 // on, e.g., Win32.
3875 void
3876 os::os_exception_wrapper(java_call_t f, JavaValue* value, const methodHandle& method,
3877                          JavaCallArguments* args, Thread* thread) {
3878   f(value, method, args, thread);
3879 }
3880 
3881 void os::print_statistics() {
3882 }
3883 
3884 int os::message_box(const char* title, const char* message) {
3885   int i;
3886   fdStream err(defaultStream::error_fd());
3887   for (i = 0; i < 78; i++) err.print_raw("=");
3888   err.cr();
3889   err.print_raw_cr(title);
3890   for (i = 0; i < 78; i++) err.print_raw("-");
3891   err.cr();
3892   err.print_raw_cr(message);
3893   for (i = 0; i < 78; i++) err.print_raw("=");
3894   err.cr();
3895 
3896   char buf[16];
3897   // Prevent process from exiting upon "read error" without consuming all CPU
3898   while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
3899 
3900   return buf[0] == 'y' || buf[0] == 'Y';
3901 }
3902 
3903 int os::stat(const char *path, struct stat *sbuf) {
3904   char pathbuf[MAX_PATH];
3905   if (strlen(path) > MAX_PATH - 1) {
3906     errno = ENAMETOOLONG;
3907     return -1;
3908   }
3909   os::native_path(strcpy(pathbuf, path));
3910   return ::stat(pathbuf, sbuf);
3911 }
3912 
3913 bool os::check_heap(bool force) {
3914   return true;
3915 }
3916 
3917 // Is a (classpath) directory empty?
3918 bool os::dir_is_empty(const char* path) {
3919   DIR *dir = NULL;
3920   struct dirent *ptr;
3921 
3922   dir = opendir(path);
3923   if (dir == NULL) return true;
3924 
3925   /* Scan the directory */
3926   bool result = true;
3927   char buf[sizeof(struct dirent) + MAX_PATH];
3928   while (result && (ptr = ::readdir(dir)) != NULL) {
3929     if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
3930       result = false;
3931     }
3932   }
3933   closedir(dir);
3934   return result;
3935 }
3936 
3937 // This code originates from JDK's sysOpen and open64_w
3938 // from src/solaris/hpi/src/system_md.c
3939 
3940 int os::open(const char *path, int oflag, int mode) {
3941 
3942   if (strlen(path) > MAX_PATH - 1) {
3943     errno = ENAMETOOLONG;
3944     return -1;
3945   }
3946   int fd;
3947 
3948   fd = ::open64(path, oflag, mode);
3949   if (fd == -1) return -1;
3950 
3951   // If the open succeeded, the file might still be a directory.
3952   {
3953     struct stat64 buf64;
3954     int ret = ::fstat64(fd, &buf64);
3955     int st_mode = buf64.st_mode;
3956 
3957     if (ret != -1) {
3958       if ((st_mode & S_IFMT) == S_IFDIR) {
3959         errno = EISDIR;
3960         ::close(fd);
3961         return -1;
3962       }
3963     } else {
3964       ::close(fd);
3965       return -1;
3966     }
3967   }
3968 
3969   // All file descriptors that are opened in the JVM and not
3970   // specifically destined for a subprocess should have the
3971   // close-on-exec flag set. If we don't set it, then careless 3rd
3972   // party native code might fork and exec without closing all
3973   // appropriate file descriptors (e.g. as we do in closeDescriptors in
3974   // UNIXProcess.c), and this in turn might:
3975   //
3976   // - cause end-of-file to fail to be detected on some file
3977   //   descriptors, resulting in mysterious hangs, or
3978   //
3979   // - might cause an fopen in the subprocess to fail on a system
3980   //   suffering from bug 1085341.
3981   //
3982   // (Yes, the default setting of the close-on-exec flag is a Unix
3983   // design flaw.)
3984   //
3985   // See:
3986   // 1085341: 32-bit stdio routines should support file descriptors >255
3987   // 4843136: (process) pipe file descriptor from Runtime.exec not being closed
3988   // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
3989 #ifdef FD_CLOEXEC
3990   {
3991     int flags = ::fcntl(fd, F_GETFD);
3992     if (flags != -1)
3993       ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
3994   }
3995 #endif
3996 
3997   return fd;
3998 }
3999 
4000 // create binary file, rewriting existing file if required
4001 int os::create_binary_file(const char* path, bool rewrite_existing) {
4002   int oflags = O_WRONLY | O_CREAT;
4003   if (!rewrite_existing) {
4004     oflags |= O_EXCL;
4005   }
4006   return ::open64(path, oflags, S_IREAD | S_IWRITE);
4007 }
4008 
4009 // return current position of file pointer
4010 jlong os::current_file_offset(int fd) {
4011   return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
4012 }
4013 
4014 // move file pointer to the specified offset
4015 jlong os::seek_to_file_offset(int fd, jlong offset) {
4016   return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
4017 }
4018 
4019 // This code originates from JDK's sysAvailable
4020 // from src/solaris/hpi/src/native_threads/src/sys_api_td.c
4021 
4022 int os::available(int fd, jlong *bytes) {
4023   jlong cur, end;
4024   int mode;
4025   struct stat64 buf64;
4026 
4027   if (::fstat64(fd, &buf64) >= 0) {
4028     mode = buf64.st_mode;
4029     if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
4030       int n;
4031       if (::ioctl(fd, FIONREAD, &n) >= 0) {
4032         *bytes = n;
4033         return 1;
4034       }
4035     }
4036   }
4037   if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
4038     return 0;
4039   } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
4040     return 0;
4041   } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
4042     return 0;
4043   }
4044   *bytes = end - cur;
4045   return 1;
4046 }
4047 
4048 // Map a block of memory.
4049 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4050                         char *addr, size_t bytes, bool read_only,
4051                         bool allow_exec) {
4052   int prot;
4053   int flags = MAP_PRIVATE;
4054 
4055   if (read_only) {
4056     prot = PROT_READ;
4057     flags = MAP_SHARED;
4058   } else {
4059     prot = PROT_READ | PROT_WRITE;
4060     flags = MAP_PRIVATE;
4061   }
4062 
4063   if (allow_exec) {
4064     prot |= PROT_EXEC;
4065   }
4066 
4067   if (addr != NULL) {
4068     flags |= MAP_FIXED;
4069   }
4070 
4071   // Allow anonymous mappings if 'fd' is -1.
4072   if (fd == -1) {
4073     flags |= MAP_ANONYMOUS;
4074   }
4075 
4076   char* mapped_address = (char*)::mmap(addr, (size_t)bytes, prot, flags,
4077                                      fd, file_offset);
4078   if (mapped_address == MAP_FAILED) {
4079     return NULL;
4080   }
4081   return mapped_address;
4082 }
4083 
4084 // Remap a block of memory.
4085 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4086                           char *addr, size_t bytes, bool read_only,
4087                           bool allow_exec) {
4088   // same as map_memory() on this OS
4089   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4090                         allow_exec);
4091 }
4092 
4093 // Unmap a block of memory.
4094 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4095   return munmap(addr, bytes) == 0;
4096 }
4097 
4098 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4099 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4100 // of a thread.
4101 //
4102 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4103 // the fast estimate available on the platform.
4104 
4105 jlong os::current_thread_cpu_time() {
4106   // return user + sys since the cost is the same
4107   const jlong n = os::thread_cpu_time(Thread::current(), true /* user + sys */);
4108   assert(n >= 0, "negative CPU time");
4109   return n;
4110 }
4111 
4112 jlong os::thread_cpu_time(Thread* thread) {
4113   // consistent with what current_thread_cpu_time() returns
4114   const jlong n = os::thread_cpu_time(thread, true /* user + sys */);
4115   assert(n >= 0, "negative CPU time");
4116   return n;
4117 }
4118 
4119 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4120   const jlong n = os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4121   assert(n >= 0, "negative CPU time");
4122   return n;
4123 }
4124 
4125 static bool thread_cpu_time_unchecked(Thread* thread, jlong* p_sys_time, jlong* p_user_time) {
4126   bool error = false;
4127 
4128   jlong sys_time = 0;
4129   jlong user_time = 0;
4130 
4131   // Reimplemented using getthrds64().
4132   //
4133   // Works like this:
4134   // For the thread in question, get the kernel thread id. Then get the
4135   // kernel thread statistics using that id.
4136   //
4137   // This only works of course when no pthread scheduling is used,
4138   // i.e. there is a 1:1 relationship to kernel threads.
4139   // On AIX, see AIXTHREAD_SCOPE variable.
4140 
4141   pthread_t pthtid = thread->osthread()->pthread_id();
4142 
4143   // retrieve kernel thread id for the pthread:
4144   tid64_t tid = 0;
4145   struct __pthrdsinfo pinfo;
4146   // I just love those otherworldly IBM APIs which force me to hand down
4147   // dummy buffers for stuff I dont care for...
4148   char dummy[1];
4149   int dummy_size = sizeof(dummy);
4150   if (pthread_getthrds_np(&pthtid, PTHRDSINFO_QUERY_TID, &pinfo, sizeof(pinfo),
4151                           dummy, &dummy_size) == 0) {
4152     tid = pinfo.__pi_tid;
4153   } else {
4154     tty->print_cr("pthread_getthrds_np failed.");
4155     error = true;
4156   }
4157 
4158   // retrieve kernel timing info for that kernel thread
4159   if (!error) {
4160     struct thrdentry64 thrdentry;
4161     if (getthrds64(getpid(), &thrdentry, sizeof(thrdentry), &tid, 1) == 1) {
4162       sys_time = thrdentry.ti_ru.ru_stime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_stime.tv_usec * 1000LL;
4163       user_time = thrdentry.ti_ru.ru_utime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_utime.tv_usec * 1000LL;
4164     } else {
4165       tty->print_cr("pthread_getthrds_np failed.");
4166       error = true;
4167     }
4168   }
4169 
4170   if (p_sys_time) {
4171     *p_sys_time = sys_time;
4172   }
4173 
4174   if (p_user_time) {
4175     *p_user_time = user_time;
4176   }
4177 
4178   if (error) {
4179     return false;
4180   }
4181 
4182   return true;
4183 }
4184 
4185 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
4186   jlong sys_time;
4187   jlong user_time;
4188 
4189   if (!thread_cpu_time_unchecked(thread, &sys_time, &user_time)) {
4190     return -1;
4191   }
4192 
4193   return user_sys_cpu_time ? sys_time + user_time : user_time;
4194 }
4195 
4196 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4197   info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4198   info_ptr->may_skip_backward = false;     // elapsed time not wall time
4199   info_ptr->may_skip_forward = false;      // elapsed time not wall time
4200   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4201 }
4202 
4203 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4204   info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4205   info_ptr->may_skip_backward = false;     // elapsed time not wall time
4206   info_ptr->may_skip_forward = false;      // elapsed time not wall time
4207   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4208 }
4209 
4210 bool os::is_thread_cpu_time_supported() {
4211   return true;
4212 }
4213 
4214 // System loadavg support. Returns -1 if load average cannot be obtained.
4215 // For now just return the system wide load average (no processor sets).
4216 int os::loadavg(double values[], int nelem) {
4217 


4218   guarantee(nelem >= 0 && nelem <= 3, "argument error");
4219   guarantee(values, "argument error");
4220 
4221   if (os::Aix::on_pase()) {
4222 
4223     // AS/400 PASE: use libo4 porting library
4224     double v[3] = { 0.0, 0.0, 0.0 };
4225 
4226     if (libo4::get_load_avg(v, v + 1, v + 2)) {
4227       for (int i = 0; i < nelem; i ++) {
4228         values[i] = v[i];
4229       }
4230       return nelem;
4231     } else {
4232       return -1;
4233     }
4234 
4235   } else {
4236 
4237     // AIX: use libperfstat
4238     libperfstat::cpuinfo_t ci;
4239     if (libperfstat::get_cpuinfo(&ci)) {






4240       for (int i = 0; i < nelem; i++) {
4241         values[i] = ci.loadavg[i];
4242       }
4243     } else {
4244       return -1;
4245     }
4246     return nelem;
4247   }
4248 }
4249 
4250 void os::pause() {
4251   char filename[MAX_PATH];
4252   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4253     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4254   } else {
4255     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4256   }
4257 
4258   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4259   if (fd != -1) {
4260     struct stat buf;
4261     ::close(fd);
4262     while (::stat(filename, &buf) == 0) {
4263       (void)::poll(NULL, 0, 100);
4264     }
4265   } else {
4266     jio_fprintf(stderr,
4267       "Could not open pause file '%s', continuing immediately.\n", filename);
4268   }
4269 }
4270 
4271 bool os::Aix::is_primordial_thread() {
4272   if (pthread_self() == (pthread_t)1) {
4273     return true;
4274   } else {
4275     return false;
4276   }
4277 }
4278 
4279 // OS recognitions (PASE/AIX, OS level) call this before calling any
4280 // one of Aix::on_pase(), Aix::os_version() static
4281 void os::Aix::initialize_os_info() {
4282 
4283   assert(_on_pase == -1 && _os_version == -1, "already called.");
4284 
4285   struct utsname uts;
4286   memset(&uts, 0, sizeof(uts));
4287   strcpy(uts.sysname, "?");
4288   if (::uname(&uts) == -1) {
4289     trcVerbose("uname failed (%d)", errno);
4290     guarantee(0, "Could not determine whether we run on AIX or PASE");
4291   } else {
4292     trcVerbose("uname says: sysname \"%s\" version \"%s\" release \"%s\" "
4293                "node \"%s\" machine \"%s\"\n",
4294                uts.sysname, uts.version, uts.release, uts.nodename, uts.machine);
4295     const int major = atoi(uts.version);
4296     assert(major > 0, "invalid OS version");
4297     const int minor = atoi(uts.release);
4298     assert(minor > 0, "invalid OS release");
4299     _os_version = (major << 8) | minor;
4300     if (strcmp(uts.sysname, "OS400") == 0) {
4301       // We run on AS/400 PASE. We do not support versions older than V5R4M0.
4302       _on_pase = 1;
4303       if (_os_version < 0x0504) {
4304         trcVerbose("OS/400 releases older than V5R4M0 not supported.");
4305         assert(false, "OS/400 release too old.");
4306       } else {
4307         trcVerbose("We run on OS/400 (pase) V%dR%d", major, minor);
4308       }
4309     } else if (strcmp(uts.sysname, "AIX") == 0) {
4310       // We run on AIX. We do not support versions older than AIX 5.3.
4311       _on_pase = 0;
4312       if (_os_version < 0x0503) {
4313         trcVerbose("AIX release older than AIX 5.3 not supported.");
4314         assert(false, "AIX release too old.");
4315       } else {
4316         trcVerbose("We run on AIX %d.%d", major, minor);
4317       }
4318     } else {
4319       assert(false, "unknown OS");
4320     }
4321   }
4322 
4323   guarantee(_on_pase != -1 && _os_version, "Could not determine AIX/OS400 release");
4324 } // end: os::Aix::initialize_os_info()
4325 
4326 // Scan environment for important settings which might effect the VM.
4327 // Trace out settings. Warn about invalid settings and/or correct them.
4328 //
4329 // Must run after os::Aix::initialue_os_info().
4330 void os::Aix::scan_environment() {
4331 
4332   char* p;
4333   int rc;
4334 
4335   // Warn explicity if EXTSHM=ON is used. That switch changes how
4336   // System V shared memory behaves. One effect is that page size of
4337   // shared memory cannot be change dynamically, effectivly preventing
4338   // large pages from working.
4339   // This switch was needed on AIX 32bit, but on AIX 64bit the general
4340   // recommendation is (in OSS notes) to switch it off.
4341   p = ::getenv("EXTSHM");
4342   trcVerbose("EXTSHM=%s.", p ? p : "<unset>");


4343   if (p && strcasecmp(p, "ON") == 0) {

4344     _extshm = 1;
4345     trcVerbose("*** Unsupported mode! Please remove EXTSHM from your environment! ***");
4346     if (!AllowExtshm) {
4347       // We allow under certain conditions the user to continue. However, we want this
4348       // to be a fatal error by default. On certain AIX systems, leaving EXTSHM=ON means
4349       // that the VM is not able to allocate 64k pages for the heap.
4350       // We do not want to run with reduced performance.
4351       vm_exit_during_initialization("EXTSHM is ON. Please remove EXTSHM from your environment.");
4352     }
4353   } else {
4354     _extshm = 0;
4355   }
4356 
4357   // SPEC1170 behaviour: will change the behaviour of a number of POSIX APIs.
4358   // Not tested, not supported.
4359   //
4360   // Note that it might be worth the trouble to test and to require it, if only to
4361   // get useful return codes for mprotect.
4362   //
4363   // Note: Setting XPG_SUS_ENV in the process is too late. Must be set earlier (before
4364   // exec() ? before loading the libjvm ? ....)
4365   p = ::getenv("XPG_SUS_ENV");
4366   trcVerbose("XPG_SUS_ENV=%s.", p ? p : "<unset>");
4367   if (p && strcmp(p, "ON") == 0) {
4368     _xpg_sus_mode = 1;
4369     trcVerbose("Unsupported setting: XPG_SUS_ENV=ON");
4370     // This is not supported. Worst of all, it changes behaviour of mmap MAP_FIXED to
4371     // clobber address ranges. If we ever want to support that, we have to do some
4372     // testing first.
4373     guarantee(false, "XPG_SUS_ENV=ON not supported");
4374   } else {
4375     _xpg_sus_mode = 0;
4376   }
4377 
4378   if (os::Aix::on_pase()) {
4379     p = ::getenv("QIBM_MULTI_THREADED");
4380     trcVerbose("QIBM_MULTI_THREADED=%s.", p ? p : "<unset>");
4381   }
4382 
4383   p = ::getenv("LDR_CNTRL");
4384   trcVerbose("LDR_CNTRL=%s.", p ? p : "<unset>");
4385   if (os::Aix::on_pase() && os::Aix::os_version() == 0x0701) {
4386     if (p && ::strstr(p, "TEXTPSIZE")) {
4387       trcVerbose("*** WARNING - LDR_CNTRL contains TEXTPSIZE. "
4388         "you may experience hangs or crashes on OS/400 V7R1.");
4389     }
4390   }
4391 
4392   p = ::getenv("AIXTHREAD_GUARDPAGES");
4393   trcVerbose("AIXTHREAD_GUARDPAGES=%s.", p ? p : "<unset>");


4394 
4395 } // end: os::Aix::scan_environment()
4396 
4397 // PASE: initialize the libo4 library (PASE porting library).
4398 void os::Aix::initialize_libo4() {
4399   guarantee(os::Aix::on_pase(), "OS/400 only.");
4400   if (!libo4::init()) {
4401     trcVerbose("libo4 initialization failed.");
4402     assert(false, "libo4 initialization failed");
4403   } else {
4404     trcVerbose("libo4 initialized.");
4405   }
4406 }
4407 
4408 // AIX: initialize the libperfstat library.

4409 void os::Aix::initialize_libperfstat() {

4410   assert(os::Aix::on_aix(), "AIX only");

4411   if (!libperfstat::init()) {
4412     trcVerbose("libperfstat initialization failed.");
4413     assert(false, "libperfstat initialization failed");
4414   } else {
4415     trcVerbose("libperfstat initialized.");


4416   }
4417 }
4418 
4419 /////////////////////////////////////////////////////////////////////////////
4420 // thread stack
4421 
4422 // Function to query the current stack size using pthread_getthrds_np.
4423 static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size) {
4424   // This only works when invoked on a pthread. As we agreed not to use
4425   // primordial threads anyway, I assert here.
4426   guarantee(!os::Aix::is_primordial_thread(), "not allowed on the primordial thread");
4427 
4428   // Information about this api can be found (a) in the pthread.h header and
4429   // (b) in http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_getthrds_np.htm
4430   //
4431   // The use of this API to find out the current stack is kind of undefined.
4432   // But after a lot of tries and asking IBM about it, I concluded that it is safe
4433   // enough for cases where I let the pthread library create its stacks. For cases
4434   // where I create an own stack and pass this to pthread_create, it seems not to
4435   // work (the returned stack size in that case is 0).
4436 
4437   pthread_t tid = pthread_self();
4438   struct __pthrdsinfo pinfo;
4439   char dummy[1]; // We only need this to satisfy the api and to not get E.
4440   int dummy_size = sizeof(dummy);
4441 
4442   memset(&pinfo, 0, sizeof(pinfo));
4443 
4444   const int rc = pthread_getthrds_np(&tid, PTHRDSINFO_QUERY_ALL, &pinfo,
4445                                      sizeof(pinfo), dummy, &dummy_size);
4446 
4447   if (rc != 0) {
4448     assert0(false);
4449     trcVerbose("pthread_getthrds_np failed (%d)", rc);
4450     return false;
4451   }
4452   guarantee0(pinfo.__pi_stackend);
4453 
4454   // The following can happen when invoking pthread_getthrds_np on a pthread running
4455   // on a user provided stack (when handing down a stack to pthread create, see
4456   // pthread_attr_setstackaddr).
4457   // Not sure what to do here - I feel inclined to forbid this use case completely.
4458   guarantee0(pinfo.__pi_stacksize);
4459 
4460   // Note: the pthread stack on AIX seems to look like this:
4461   //
4462   // ---------------------   real base ? at page border ?
4463   //
4464   //     pthread internal data, like ~2K, see also
4465   //     http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/thread_supp_tun_params.htm
4466   //
4467   // ---------------------   __pi_stackend - not page aligned, (xxxxF890)
4468   //
4469   //     stack
4470   //      ....
4471   //
4472   //     stack
4473   //
4474   // ---------------------   __pi_stackend  - __pi_stacksize
4475   //
4476   //     padding due to AIX guard pages (?) see AIXTHREAD_GUARDPAGES
4477   // ---------------------   __pi_stackaddr  (page aligned if AIXTHREAD_GUARDPAGES > 0)
4478   //
4479   //   AIX guard pages (?)
4480   //
4481 
4482   // So, the safe thing to do is to use the area from __pi_stackend to __pi_stackaddr;
4483   // __pi_stackend however is almost never page aligned.
4484   //
4485 
4486   if (p_stack_base) {
4487     (*p_stack_base) = (address) (pinfo.__pi_stackend);
4488   }
4489 
4490   if (p_stack_size) {
4491     (*p_stack_size) = pinfo.__pi_stackend - pinfo.__pi_stackaddr;
4492   }
4493 
4494   return true;
4495 }
4496 
4497 // Get the current stack base from the OS (actually, the pthread library).
4498 address os::current_stack_base() {
4499   address p;
4500   query_stack_dimensions(&p, 0);
4501   return p;
4502 }
4503 
4504 // Get the current stack size from the OS (actually, the pthread library).
4505 size_t os::current_stack_size() {
4506   size_t s;
4507   query_stack_dimensions(0, &s);
4508   return s;
4509 }
4510 
4511 // Refer to the comments in os_solaris.cpp park-unpark.
4512 //
4513 // Beware -- Some versions of NPTL embody a flaw where pthread_cond_timedwait() can
4514 // hang indefinitely. For instance NPTL 0.60 on 2.4.21-4ELsmp is vulnerable.
4515 // For specifics regarding the bug see GLIBC BUGID 261237 :
4516 //    http://www.mail-archive.com/debian-glibc@lists.debian.org/msg10837.html.
4517 // Briefly, pthread_cond_timedwait() calls with an expiry time that's not in the future
4518 // will either hang or corrupt the condvar, resulting in subsequent hangs if the condvar
4519 // is used. (The simple C test-case provided in the GLIBC bug report manifests the
4520 // hang). The JVM is vulernable via sleep(), Object.wait(timo), LockSupport.parkNanos()
4521 // and monitorenter when we're using 1-0 locking. All those operations may result in
4522 // calls to pthread_cond_timedwait(). Using LD_ASSUME_KERNEL to use an older version
4523 // of libpthread avoids the problem, but isn't practical.
4524 //
4525 // Possible remedies:
4526 //
4527 // 1.   Establish a minimum relative wait time. 50 to 100 msecs seems to work.
4528 //      This is palliative and probabilistic, however. If the thread is preempted
4529 //      between the call to compute_abstime() and pthread_cond_timedwait(), more
4530 //      than the minimum period may have passed, and the abstime may be stale (in the
4531 //      past) resultin in a hang. Using this technique reduces the odds of a hang
4532 //      but the JVM is still vulnerable, particularly on heavily loaded systems.
4533 //
4534 // 2.   Modify park-unpark to use per-thread (per ParkEvent) pipe-pairs instead
4535 //      of the usual flag-condvar-mutex idiom. The write side of the pipe is set
4536 //      NDELAY. unpark() reduces to write(), park() reduces to read() and park(timo)
4537 //      reduces to poll()+read(). This works well, but consumes 2 FDs per extant
4538 //      thread.
4539 //
4540 // 3.   Embargo pthread_cond_timedwait() and implement a native "chron" thread
4541 //      that manages timeouts. We'd emulate pthread_cond_timedwait() by enqueuing
4542 //      a timeout request to the chron thread and then blocking via pthread_cond_wait().
4543 //      This also works well. In fact it avoids kernel-level scalability impediments
4544 //      on certain platforms that don't handle lots of active pthread_cond_timedwait()
4545 //      timers in a graceful fashion.
4546 //
4547 // 4.   When the abstime value is in the past it appears that control returns
4548 //      correctly from pthread_cond_timedwait(), but the condvar is left corrupt.
4549 //      Subsequent timedwait/wait calls may hang indefinitely. Given that, we
4550 //      can avoid the problem by reinitializing the condvar -- by cond_destroy()
4551 //      followed by cond_init() -- after all calls to pthread_cond_timedwait().
4552 //      It may be possible to avoid reinitialization by checking the return
4553 //      value from pthread_cond_timedwait(). In addition to reinitializing the
4554 //      condvar we must establish the invariant that cond_signal() is only called
4555 //      within critical sections protected by the adjunct mutex. This prevents
4556 //      cond_signal() from "seeing" a condvar that's in the midst of being
4557 //      reinitialized or that is corrupt. Sadly, this invariant obviates the
4558 //      desirable signal-after-unlock optimization that avoids futile context switching.
4559 //
4560 //      I'm also concerned that some versions of NTPL might allocate an auxilliary
4561 //      structure when a condvar is used or initialized. cond_destroy() would
4562 //      release the helper structure. Our reinitialize-after-timedwait fix
4563 //      put excessive stress on malloc/free and locks protecting the c-heap.
4564 //
4565 // We currently use (4). See the WorkAroundNTPLTimedWaitHang flag.
4566 // It may be possible to refine (4) by checking the kernel and NTPL verisons
4567 // and only enabling the work-around for vulnerable environments.
4568 
4569 // utility to compute the abstime argument to timedwait:
4570 // millis is the relative timeout time
4571 // abstime will be the absolute timeout time
4572 // TODO: replace compute_abstime() with unpackTime()
4573 
4574 static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
4575   if (millis < 0) millis = 0;
4576   struct timeval now;
4577   int status = gettimeofday(&now, NULL);
4578   assert(status == 0, "gettimeofday");
4579   jlong seconds = millis / 1000;
4580   millis %= 1000;
4581   if (seconds > 50000000) { // see man cond_timedwait(3T)
4582     seconds = 50000000;
4583   }
4584   abstime->tv_sec = now.tv_sec  + seconds;
4585   long       usec = now.tv_usec + millis * 1000;
4586   if (usec >= 1000000) {
4587     abstime->tv_sec += 1;
4588     usec -= 1000000;
4589   }
4590   abstime->tv_nsec = usec * 1000;
4591   return abstime;
4592 }
4593 
4594 // Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
4595 // Conceptually TryPark() should be equivalent to park(0).
4596 
4597 int os::PlatformEvent::TryPark() {
4598   for (;;) {
4599     const int v = _Event;
4600     guarantee ((v == 0) || (v == 1), "invariant");
4601     if (Atomic::cmpxchg (0, &_Event, v) == v) return v;
4602   }
4603 }
4604 
4605 void os::PlatformEvent::park() {       // AKA "down()"
4606   // Invariant: Only the thread associated with the Event/PlatformEvent
4607   // may call park().
4608   // TODO: assert that _Assoc != NULL or _Assoc == Self
4609   int v;
4610   for (;;) {
4611     v = _Event;
4612     if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4613   }
4614   guarantee (v >= 0, "invariant");
4615   if (v == 0) {
4616     // Do this the hard way by blocking ...
4617     int status = pthread_mutex_lock(_mutex);
4618     assert_status(status == 0, status, "mutex_lock");
4619     guarantee (_nParked == 0, "invariant");
4620     ++ _nParked;
4621     while (_Event < 0) {
4622       status = pthread_cond_wait(_cond, _mutex);
4623       assert_status(status == 0 || status == ETIMEDOUT, status, "cond_timedwait");
4624     }
4625     -- _nParked;
4626 
4627     // In theory we could move the ST of 0 into _Event past the unlock(),
4628     // but then we'd need a MEMBAR after the ST.
4629     _Event = 0;
4630     status = pthread_mutex_unlock(_mutex);
4631     assert_status(status == 0, status, "mutex_unlock");
4632   }
4633   guarantee (_Event >= 0, "invariant");
4634 }
4635 
4636 int os::PlatformEvent::park(jlong millis) {
4637   guarantee (_nParked == 0, "invariant");
4638 
4639   int v;
4640   for (;;) {
4641     v = _Event;
4642     if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4643   }
4644   guarantee (v >= 0, "invariant");
4645   if (v != 0) return OS_OK;
4646 
4647   // We do this the hard way, by blocking the thread.
4648   // Consider enforcing a minimum timeout value.
4649   struct timespec abst;
4650   compute_abstime(&abst, millis);
4651 
4652   int ret = OS_TIMEOUT;
4653   int status = pthread_mutex_lock(_mutex);
4654   assert_status(status == 0, status, "mutex_lock");
4655   guarantee (_nParked == 0, "invariant");
4656   ++_nParked;
4657 
4658   // Object.wait(timo) will return because of
4659   // (a) notification
4660   // (b) timeout
4661   // (c) thread.interrupt
4662   //
4663   // Thread.interrupt and object.notify{All} both call Event::set.
4664   // That is, we treat thread.interrupt as a special case of notification.
4665   // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
4666   // We assume all ETIME returns are valid.
4667   //
4668   // TODO: properly differentiate simultaneous notify+interrupt.
4669   // In that case, we should propagate the notify to another waiter.
4670 
4671   while (_Event < 0) {
4672     status = pthread_cond_timedwait(_cond, _mutex, &abst);
4673     assert_status(status == 0 || status == ETIMEDOUT,
4674                   status, "cond_timedwait");
4675     if (!FilterSpuriousWakeups) break;         // previous semantics
4676     if (status == ETIMEDOUT) break;
4677     // We consume and ignore EINTR and spurious wakeups.
4678   }
4679   --_nParked;
4680   if (_Event >= 0) {
4681      ret = OS_OK;
4682   }
4683   _Event = 0;
4684   status = pthread_mutex_unlock(_mutex);
4685   assert_status(status == 0, status, "mutex_unlock");
4686   assert (_nParked == 0, "invariant");
4687   return ret;
4688 }
4689 
4690 void os::PlatformEvent::unpark() {
4691   int v, AnyWaiters;
4692   for (;;) {
4693     v = _Event;
4694     if (v > 0) {
4695       // The LD of _Event could have reordered or be satisfied
4696       // by a read-aside from this processor's write buffer.
4697       // To avoid problems execute a barrier and then
4698       // ratify the value.
4699       OrderAccess::fence();
4700       if (_Event == v) return;
4701       continue;
4702     }
4703     if (Atomic::cmpxchg (v+1, &_Event, v) == v) break;
4704   }
4705   if (v < 0) {
4706     // Wait for the thread associated with the event to vacate
4707     int status = pthread_mutex_lock(_mutex);
4708     assert_status(status == 0, status, "mutex_lock");
4709     AnyWaiters = _nParked;
4710 
4711     if (AnyWaiters != 0) {
4712       // We intentional signal *after* dropping the lock
4713       // to avoid a common class of futile wakeups.
4714       status = pthread_cond_signal(_cond);
4715       assert_status(status == 0, status, "cond_signal");
4716     }
4717     // Mutex should be locked for pthread_cond_signal(_cond).
4718     status = pthread_mutex_unlock(_mutex);
4719     assert_status(status == 0, status, "mutex_unlock");
4720   }
4721 
4722   // Note that we signal() _after dropping the lock for "immortal" Events.
4723   // This is safe and avoids a common class of futile wakeups. In rare
4724   // circumstances this can cause a thread to return prematurely from
4725   // cond_{timed}wait() but the spurious wakeup is benign and the victim will
4726   // simply re-test the condition and re-park itself.
4727 }
4728 
4729 
4730 // JSR166
4731 // -------------------------------------------------------
4732 
4733 //
4734 // The solaris and linux implementations of park/unpark are fairly
4735 // conservative for now, but can be improved. They currently use a
4736 // mutex/condvar pair, plus a a count.
4737 // Park decrements count if > 0, else does a condvar wait. Unpark
4738 // sets count to 1 and signals condvar. Only one thread ever waits
4739 // on the condvar. Contention seen when trying to park implies that someone
4740 // is unparking you, so don't wait. And spurious returns are fine, so there
4741 // is no need to track notifications.
4742 //
4743 
4744 #define MAX_SECS 100000000
4745 //
4746 // This code is common to linux and solaris and will be moved to a
4747 // common place in dolphin.
4748 //
4749 // The passed in time value is either a relative time in nanoseconds
4750 // or an absolute time in milliseconds. Either way it has to be unpacked
4751 // into suitable seconds and nanoseconds components and stored in the
4752 // given timespec structure.
4753 // Given time is a 64-bit value and the time_t used in the timespec is only
4754 // a signed-32-bit value (except on 64-bit Linux) we have to watch for
4755 // overflow if times way in the future are given. Further on Solaris versions
4756 // prior to 10 there is a restriction (see cond_timedwait) that the specified
4757 // number of seconds, in abstime, is less than current_time + 100,000,000.
4758 // As it will be 28 years before "now + 100000000" will overflow we can
4759 // ignore overflow and just impose a hard-limit on seconds using the value
4760 // of "now + 100,000,000". This places a limit on the timeout of about 3.17
4761 // years from "now".
4762 //
4763 
4764 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
4765   assert (time > 0, "convertTime");
4766 
4767   struct timeval now;
4768   int status = gettimeofday(&now, NULL);
4769   assert(status == 0, "gettimeofday");
4770 
4771   time_t max_secs = now.tv_sec + MAX_SECS;
4772 
4773   if (isAbsolute) {
4774     jlong secs = time / 1000;
4775     if (secs > max_secs) {
4776       absTime->tv_sec = max_secs;
4777     }
4778     else {
4779       absTime->tv_sec = secs;
4780     }
4781     absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
4782   }
4783   else {
4784     jlong secs = time / NANOSECS_PER_SEC;
4785     if (secs >= MAX_SECS) {
4786       absTime->tv_sec = max_secs;
4787       absTime->tv_nsec = 0;
4788     }
4789     else {
4790       absTime->tv_sec = now.tv_sec + secs;
4791       absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
4792       if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
4793         absTime->tv_nsec -= NANOSECS_PER_SEC;
4794         ++absTime->tv_sec; // note: this must be <= max_secs
4795       }
4796     }
4797   }
4798   assert(absTime->tv_sec >= 0, "tv_sec < 0");
4799   assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
4800   assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
4801   assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
4802 }
4803 
4804 void Parker::park(bool isAbsolute, jlong time) {
4805   // Optional fast-path check:
4806   // Return immediately if a permit is available.
4807   if (_counter > 0) {
4808     _counter = 0;
4809     OrderAccess::fence();
4810     return;
4811   }
4812 
4813   Thread* thread = Thread::current();
4814   assert(thread->is_Java_thread(), "Must be JavaThread");
4815   JavaThread *jt = (JavaThread *)thread;
4816 
4817   // Optional optimization -- avoid state transitions if there's an interrupt pending.
4818   // Check interrupt before trying to wait
4819   if (Thread::is_interrupted(thread, false)) {
4820     return;
4821   }
4822 
4823   // Next, demultiplex/decode time arguments
4824   timespec absTime;
4825   if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
4826     return;
4827   }
4828   if (time > 0) {
4829     unpackTime(&absTime, isAbsolute, time);
4830   }
4831 
4832   // Enter safepoint region
4833   // Beware of deadlocks such as 6317397.
4834   // The per-thread Parker:: mutex is a classic leaf-lock.
4835   // In particular a thread must never block on the Threads_lock while
4836   // holding the Parker:: mutex. If safepoints are pending both the
4837   // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
4838   ThreadBlockInVM tbivm(jt);
4839 
4840   // Don't wait if cannot get lock since interference arises from
4841   // unblocking. Also. check interrupt before trying wait
4842   if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
4843     return;
4844   }
4845 
4846   int status;
4847   if (_counter > 0) { // no wait needed
4848     _counter = 0;
4849     status = pthread_mutex_unlock(_mutex);
4850     assert (status == 0, "invariant");
4851     OrderAccess::fence();
4852     return;
4853   }
4854 
4855 #ifdef ASSERT
4856   // Don't catch signals while blocked; let the running threads have the signals.
4857   // (This allows a debugger to break into the running thread.)
4858   sigset_t oldsigs;
4859   sigset_t* allowdebug_blocked = os::Aix::allowdebug_blocked_signals();
4860   pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
4861 #endif
4862 
4863   OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4864   jt->set_suspend_equivalent();
4865   // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
4866 
4867   if (time == 0) {
4868     status = pthread_cond_wait (_cond, _mutex);
4869   } else {
4870     status = pthread_cond_timedwait (_cond, _mutex, &absTime);
4871     if (status != 0 && WorkAroundNPTLTimedWaitHang) {
4872       pthread_cond_destroy (_cond);
4873       pthread_cond_init    (_cond, NULL);
4874     }
4875   }
4876   assert_status(status == 0 || status == EINTR ||
4877                 status == ETIME || status == ETIMEDOUT,
4878                 status, "cond_timedwait");
4879 
4880 #ifdef ASSERT
4881   pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
4882 #endif
4883 
4884   _counter = 0;
4885   status = pthread_mutex_unlock(_mutex);
4886   assert_status(status == 0, status, "invariant");
4887   // If externally suspended while waiting, re-suspend
4888   if (jt->handle_special_suspend_equivalent_condition()) {
4889     jt->java_suspend_self();
4890   }
4891 
4892   OrderAccess::fence();
4893 }
4894 
4895 void Parker::unpark() {
4896   int s, status;
4897   status = pthread_mutex_lock(_mutex);
4898   assert (status == 0, "invariant");
4899   s = _counter;
4900   _counter = 1;
4901   if (s < 1) {
4902     if (WorkAroundNPTLTimedWaitHang) {
4903       status = pthread_cond_signal (_cond);
4904       assert (status == 0, "invariant");
4905       status = pthread_mutex_unlock(_mutex);
4906       assert (status == 0, "invariant");
4907     } else {
4908       status = pthread_mutex_unlock(_mutex);
4909       assert (status == 0, "invariant");
4910       status = pthread_cond_signal (_cond);
4911       assert (status == 0, "invariant");
4912     }
4913   } else {
4914     pthread_mutex_unlock(_mutex);
4915     assert (status == 0, "invariant");
4916   }
4917 }
4918 
4919 extern char** environ;
4920 
4921 // Run the specified command in a separate process. Return its exit value,
4922 // or -1 on failure (e.g. can't fork a new process).
4923 // Unlike system(), this function can be called from signal handler. It
4924 // doesn't block SIGINT et al.
4925 int os::fork_and_exec(char* cmd) {
4926   char * argv[4] = {"sh", "-c", cmd, NULL};
4927 
4928   pid_t pid = fork();
4929 
4930   if (pid < 0) {
4931     // fork failed
4932     return -1;
4933 
4934   } else if (pid == 0) {
4935     // child process
4936 
4937     // Try to be consistent with system(), which uses "/usr/bin/sh" on AIX.
4938     execve("/usr/bin/sh", argv, environ);
4939 
4940     // execve failed
4941     _exit(-1);
4942 
4943   } else {
4944     // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
4945     // care about the actual exit code, for now.
4946 
4947     int status;
4948 
4949     // Wait for the child process to exit. This returns immediately if
4950     // the child has already exited. */
4951     while (waitpid(pid, &status, 0) < 0) {
4952       switch (errno) {
4953         case ECHILD: return 0;
4954         case EINTR: break;
4955         default: return -1;
4956       }
4957     }
4958 
4959     if (WIFEXITED(status)) {
4960       // The child exited normally; get its exit code.
4961       return WEXITSTATUS(status);
4962     } else if (WIFSIGNALED(status)) {
4963       // The child exited because of a signal.
4964       // The best value to return is 0x80 + signal number,
4965       // because that is what all Unix shells do, and because
4966       // it allows callers to distinguish between process exit and
4967       // process death by signal.
4968       return 0x80 + WTERMSIG(status);
4969     } else {
4970       // Unknown exit code; pass it through.
4971       return status;
4972     }
4973   }
4974   return -1;
4975 }
4976 
4977 // is_headless_jre()
4978 //
4979 // Test for the existence of xawt/libmawt.so or libawt_xawt.so
4980 // in order to report if we are running in a headless jre.
4981 //
4982 // Since JDK8 xawt/libmawt.so is moved into the same directory
4983 // as libawt.so, and renamed libawt_xawt.so
4984 bool os::is_headless_jre() {
4985   struct stat statbuf;
4986   char buf[MAXPATHLEN];
4987   char libmawtpath[MAXPATHLEN];
4988   const char *xawtstr = "/xawt/libmawt.so";
4989   const char *new_xawtstr = "/libawt_xawt.so";
4990 
4991   char *p;
4992 
4993   // Get path to libjvm.so
4994   os::jvm_path(buf, sizeof(buf));
4995 
4996   // Get rid of libjvm.so
4997   p = strrchr(buf, '/');
4998   if (p == NULL) return false;
4999   else *p = '\0';
5000 
5001   // Get rid of client or server
5002   p = strrchr(buf, '/');
5003   if (p == NULL) return false;
5004   else *p = '\0';
5005 
5006   // check xawt/libmawt.so
5007   strcpy(libmawtpath, buf);
5008   strcat(libmawtpath, xawtstr);
5009   if (::stat(libmawtpath, &statbuf) == 0) return false;
5010 
5011   // check libawt_xawt.so
5012   strcpy(libmawtpath, buf);
5013   strcat(libmawtpath, new_xawtstr);
5014   if (::stat(libmawtpath, &statbuf) == 0) return false;
5015 
5016   return true;
5017 }
5018 
5019 // Get the default path to the core file
5020 // Returns the length of the string
5021 int os::get_core_path(char* buffer, size_t bufferSize) {
5022   const char* p = get_current_directory(buffer, bufferSize);
5023 
5024   if (p == NULL) {
5025     assert(p != NULL, "failed to get current directory");
5026     return 0;
5027   }
5028 
5029   jio_snprintf(buffer, bufferSize, "%s/core or core.%d",
5030                                                p, current_process_id());
5031 
5032   return strlen(buffer);
5033 }
5034 
5035 #ifndef PRODUCT
5036 void TestReserveMemorySpecial_test() {
5037   // No tests available for this platform
5038 }
5039 #endif
--- EOF ---