rev 12283 : 8169373: Work around linux NPTL stack guard error.
Summary: Also streamline OS guard page handling on linuxs390, linuxppc, aixppc.

   1 /*
   2  * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2012, 2016 SAP SE. 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 "logging/log.hpp"
  40 #include "libo4.hpp"
  41 #include "libperfstat_aix.hpp"
  42 #include "libodm_aix.hpp"
  43 #include "loadlib_aix.hpp"
  44 #include "memory/allocation.inline.hpp"
  45 #include "memory/filemap.hpp"
  46 #include "misc_aix.hpp"
  47 #include "oops/oop.inline.hpp"
  48 #include "os_aix.inline.hpp"
  49 #include "os_share_aix.hpp"
  50 #include "porting_aix.hpp"
  51 #include "prims/jniFastGetField.hpp"
  52 #include "prims/jvm.h"
  53 #include "prims/jvm_misc.hpp"
  54 #include "runtime/arguments.hpp"
  55 #include "runtime/atomic.hpp"
  56 #include "runtime/extendedPC.hpp"
  57 #include "runtime/globals.hpp"
  58 #include "runtime/interfaceSupport.hpp"
  59 #include "runtime/java.hpp"
  60 #include "runtime/javaCalls.hpp"
  61 #include "runtime/mutexLocker.hpp"
  62 #include "runtime/objectMonitor.hpp"
  63 #include "runtime/orderAccess.inline.hpp"
  64 #include "runtime/os.hpp"
  65 #include "runtime/osThread.hpp"
  66 #include "runtime/perfMemory.hpp"
  67 #include "runtime/sharedRuntime.hpp"
  68 #include "runtime/statSampler.hpp"
  69 #include "runtime/stubRoutines.hpp"
  70 #include "runtime/thread.inline.hpp"
  71 #include "runtime/threadCritical.hpp"
  72 #include "runtime/timer.hpp"
  73 #include "runtime/vm_version.hpp"
  74 #include "services/attachListener.hpp"
  75 #include "services/runtimeService.hpp"
  76 #include "utilities/decoder.hpp"
  77 #include "utilities/defaultStream.hpp"
  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 // Query dimensions of the stack of the calling thread.
 134 static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size);
 135 static address resolve_function_descriptor_to_code_pointer(address p);
 136 
 137 static void vmembk_print_on(outputStream* os);
 138 
 139 ////////////////////////////////////////////////////////////////////////////////
 140 // global variables (for a description see os_aix.hpp)
 141 
 142 julong    os::Aix::_physical_memory = 0;
 143 
 144 pthread_t os::Aix::_main_thread = ((pthread_t)0);
 145 int       os::Aix::_page_size = -1;
 146 
 147 // -1 = uninitialized, 0 if AIX, 1 if OS/400 pase
 148 int       os::Aix::_on_pase = -1;
 149 
 150 // 0 = uninitialized, otherwise 32 bit number:
 151 //  0xVVRRTTSS
 152 //  VV - major version
 153 //  RR - minor version
 154 //  TT - tech level, if known, 0 otherwise
 155 //  SS - service pack, if known, 0 otherwise
 156 uint32_t  os::Aix::_os_version = 0;
 157 
 158 // -1 = uninitialized, 0 - no, 1 - yes
 159 int       os::Aix::_xpg_sus_mode = -1;
 160 
 161 // -1 = uninitialized, 0 - no, 1 - yes
 162 int       os::Aix::_extshm = -1;
 163 
 164 ////////////////////////////////////////////////////////////////////////////////
 165 // local variables
 166 
 167 static jlong    initial_time_count = 0;
 168 static int      clock_tics_per_sec = 100;
 169 static sigset_t check_signal_done;         // For diagnostics to print a message once (see run_periodic_checks)
 170 static bool     check_signals      = true;
 171 static int      SR_signum          = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769)
 172 static sigset_t SR_sigset;
 173 
 174 // Process break recorded at startup.
 175 static address g_brk_at_startup = NULL;
 176 
 177 // This describes the state of multipage support of the underlying
 178 // OS. Note that this is of no interest to the outsize world and
 179 // therefore should not be defined in AIX class.
 180 //
 181 // AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The
 182 // latter two (16M "large" resp. 16G "huge" pages) require special
 183 // setup and are normally not available.
 184 //
 185 // AIX supports multiple page sizes per process, for:
 186 //  - Stack (of the primordial thread, so not relevant for us)
 187 //  - Data - data, bss, heap, for us also pthread stacks
 188 //  - Text - text code
 189 //  - shared memory
 190 //
 191 // Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...)
 192 // and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...).
 193 //
 194 // For shared memory, page size can be set dynamically via
 195 // shmctl(). Different shared memory regions can have different page
 196 // sizes.
 197 //
 198 // More information can be found at AIBM info center:
 199 //   http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm
 200 //
 201 static struct {
 202   size_t pagesize;            // sysconf _SC_PAGESIZE (4K)
 203   size_t datapsize;           // default data page size (LDR_CNTRL DATAPSIZE)
 204   size_t shmpsize;            // default shared memory page size (LDR_CNTRL SHMPSIZE)
 205   size_t pthr_stack_pagesize; // stack page size of pthread threads
 206   size_t textpsize;           // default text page size (LDR_CNTRL STACKPSIZE)
 207   bool can_use_64K_pages;     // True if we can alloc 64K pages dynamically with Sys V shm.
 208   bool can_use_16M_pages;     // True if we can alloc 16M pages dynamically with Sys V shm.
 209   int error;                  // Error describing if something went wrong at multipage init.
 210 } g_multipage_support = {
 211   (size_t) -1,
 212   (size_t) -1,
 213   (size_t) -1,
 214   (size_t) -1,
 215   (size_t) -1,
 216   false, false,
 217   0
 218 };
 219 
 220 // We must not accidentally allocate memory close to the BRK - even if
 221 // that would work - because then we prevent the BRK segment from
 222 // growing which may result in a malloc OOM even though there is
 223 // enough memory. The problem only arises if we shmat() or mmap() at
 224 // a specific wish address, e.g. to place the heap in a
 225 // compressed-oops-friendly way.
 226 static bool is_close_to_brk(address a) {
 227   assert0(g_brk_at_startup != NULL);
 228   if (a >= g_brk_at_startup &&
 229       a < (g_brk_at_startup + MaxExpectedDataSegmentSize)) {
 230     return true;
 231   }
 232   return false;
 233 }
 234 
 235 julong os::available_memory() {
 236   return Aix::available_memory();
 237 }
 238 
 239 julong os::Aix::available_memory() {
 240   // Avoid expensive API call here, as returned value will always be null.
 241   if (os::Aix::on_pase()) {
 242     return 0x0LL;
 243   }
 244   os::Aix::meminfo_t mi;
 245   if (os::Aix::get_meminfo(&mi)) {
 246     return mi.real_free;
 247   } else {
 248     return ULONG_MAX;
 249   }
 250 }
 251 
 252 julong os::physical_memory() {
 253   return Aix::physical_memory();
 254 }
 255 
 256 // Return true if user is running as root.
 257 
 258 bool os::have_special_privileges() {
 259   static bool init = false;
 260   static bool privileges = false;
 261   if (!init) {
 262     privileges = (getuid() != geteuid()) || (getgid() != getegid());
 263     init = true;
 264   }
 265   return privileges;
 266 }
 267 
 268 // Helper function, emulates disclaim64 using multiple 32bit disclaims
 269 // because we cannot use disclaim64() on AS/400 and old AIX releases.
 270 static bool my_disclaim64(char* addr, size_t size) {
 271 
 272   if (size == 0) {
 273     return true;
 274   }
 275 
 276   // Maximum size 32bit disclaim() accepts. (Theoretically 4GB, but I just do not trust that.)
 277   const unsigned int maxDisclaimSize = 0x40000000;
 278 
 279   const unsigned int numFullDisclaimsNeeded = (size / maxDisclaimSize);
 280   const unsigned int lastDisclaimSize = (size % maxDisclaimSize);
 281 
 282   char* p = addr;
 283 
 284   for (int i = 0; i < numFullDisclaimsNeeded; i ++) {
 285     if (::disclaim(p, maxDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
 286       trcVerbose("Cannot disclaim %p - %p (errno %d)\n", p, p + maxDisclaimSize, errno);
 287       return false;
 288     }
 289     p += maxDisclaimSize;
 290   }
 291 
 292   if (lastDisclaimSize > 0) {
 293     if (::disclaim(p, lastDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
 294       trcVerbose("Cannot disclaim %p - %p (errno %d)\n", p, p + lastDisclaimSize, errno);
 295       return false;
 296     }
 297   }
 298 
 299   return true;
 300 }
 301 
 302 // Cpu architecture string
 303 #if defined(PPC32)
 304 static char cpu_arch[] = "ppc";
 305 #elif defined(PPC64)
 306 static char cpu_arch[] = "ppc64";
 307 #else
 308 #error Add appropriate cpu_arch setting
 309 #endif
 310 
 311 // Wrap the function "vmgetinfo" which is not available on older OS releases.
 312 static int checked_vmgetinfo(void *out, int command, int arg) {
 313   if (os::Aix::on_pase() && os::Aix::os_version_short() < 0x0601) {
 314     guarantee(false, "cannot call vmgetinfo on AS/400 older than V6R1");
 315   }
 316   return ::vmgetinfo(out, command, arg);
 317 }
 318 
 319 // Given an address, returns the size of the page backing that address.
 320 size_t os::Aix::query_pagesize(void* addr) {
 321 
 322   if (os::Aix::on_pase() && os::Aix::os_version_short() < 0x0601) {
 323     // AS/400 older than V6R1: no vmgetinfo here, default to 4K
 324     return 4*K;
 325   }
 326 
 327   vm_page_info pi;
 328   pi.addr = (uint64_t)addr;
 329   if (checked_vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) {
 330     return pi.pagesize;
 331   } else {
 332     assert(false, "vmgetinfo failed to retrieve page size");
 333     return 4*K;
 334   }
 335 }
 336 
 337 void os::Aix::initialize_system_info() {
 338 
 339   // Get the number of online(logical) cpus instead of configured.
 340   os::_processor_count = sysconf(_SC_NPROCESSORS_ONLN);
 341   assert(_processor_count > 0, "_processor_count must be > 0");
 342 
 343   // Retrieve total physical storage.
 344   os::Aix::meminfo_t mi;
 345   if (!os::Aix::get_meminfo(&mi)) {
 346     assert(false, "os::Aix::get_meminfo failed.");
 347   }
 348   _physical_memory = (julong) mi.real_total;
 349 }
 350 
 351 // Helper function for tracing page sizes.
 352 static const char* describe_pagesize(size_t pagesize) {
 353   switch (pagesize) {
 354     case 4*K : return "4K";
 355     case 64*K: return "64K";
 356     case 16*M: return "16M";
 357     case 16*G: return "16G";
 358     default:
 359       assert(false, "surprise");
 360       return "??";
 361   }
 362 }
 363 
 364 // Probe OS for multipage support.
 365 // Will fill the global g_multipage_support structure.
 366 // Must be called before calling os::large_page_init().
 367 static void query_multipage_support() {
 368 
 369   guarantee(g_multipage_support.pagesize == -1,
 370             "do not call twice");
 371 
 372   g_multipage_support.pagesize = ::sysconf(_SC_PAGESIZE);
 373 
 374   // This really would surprise me.
 375   assert(g_multipage_support.pagesize == 4*K, "surprise!");
 376 
 377   // Query default data page size (default page size for C-Heap, pthread stacks and .bss).
 378   // Default data page size is defined either by linker options (-bdatapsize)
 379   // or by environment variable LDR_CNTRL (suboption DATAPSIZE). If none is given,
 380   // default should be 4K.
 381   {
 382     void* p = ::malloc(16*M);
 383     g_multipage_support.datapsize = os::Aix::query_pagesize(p);
 384     ::free(p);
 385   }
 386 
 387   // Query default shm page size (LDR_CNTRL SHMPSIZE).
 388   // Note that this is pure curiosity. We do not rely on default page size but set
 389   // our own page size after allocated.
 390   {
 391     const int shmid = ::shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR | S_IWUSR);
 392     guarantee(shmid != -1, "shmget failed");
 393     void* p = ::shmat(shmid, NULL, 0);
 394     ::shmctl(shmid, IPC_RMID, NULL);
 395     guarantee(p != (void*) -1, "shmat failed");
 396     g_multipage_support.shmpsize = os::Aix::query_pagesize(p);
 397     ::shmdt(p);
 398   }
 399 
 400   // Before querying the stack page size, make sure we are not running as primordial
 401   // thread (because primordial thread's stack may have different page size than
 402   // pthread thread stacks). Running a VM on the primordial thread won't work for a
 403   // number of reasons so we may just as well guarantee it here.
 404   guarantee0(!os::Aix::is_primordial_thread());
 405 
 406   // Query pthread stack page size. Should be the same as data page size because
 407   // pthread stacks are allocated from C-Heap.
 408   {
 409     int dummy = 0;
 410     g_multipage_support.pthr_stack_pagesize = os::Aix::query_pagesize(&dummy);
 411   }
 412 
 413   // Query default text page size (LDR_CNTRL TEXTPSIZE).
 414   {
 415     address any_function =
 416       resolve_function_descriptor_to_code_pointer((address)describe_pagesize);
 417     g_multipage_support.textpsize = os::Aix::query_pagesize(any_function);
 418   }
 419 
 420   // Now probe for support of 64K pages and 16M pages.
 421 
 422   // Before OS/400 V6R1, there is no support for pages other than 4K.
 423   if (os::Aix::on_pase_V5R4_or_older()) {
 424     trcVerbose("OS/400 < V6R1 - no large page support.");
 425     g_multipage_support.error = ERROR_MP_OS_TOO_OLD;
 426     goto query_multipage_support_end;
 427   }
 428 
 429   // Now check which page sizes the OS claims it supports, and of those, which actually can be used.
 430   {
 431     const int MAX_PAGE_SIZES = 4;
 432     psize_t sizes[MAX_PAGE_SIZES];
 433     const int num_psizes = checked_vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES);
 434     if (num_psizes == -1) {
 435       trcVerbose("vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)", errno);
 436       trcVerbose("disabling multipage support.");
 437       g_multipage_support.error = ERROR_MP_VMGETINFO_FAILED;
 438       goto query_multipage_support_end;
 439     }
 440     guarantee(num_psizes > 0, "vmgetinfo(.., VMINFO_GETPSIZES, ...) failed.");
 441     assert(num_psizes <= MAX_PAGE_SIZES, "Surprise! more than 4 page sizes?");
 442     trcVerbose("vmgetinfo(.., VMINFO_GETPSIZES, ...) returns %d supported page sizes: ", num_psizes);
 443     for (int i = 0; i < num_psizes; i ++) {
 444       trcVerbose(" %s ", describe_pagesize(sizes[i]));
 445     }
 446 
 447     // Can we use 64K, 16M pages?
 448     for (int i = 0; i < num_psizes; i ++) {
 449       const size_t pagesize = sizes[i];
 450       if (pagesize != 64*K && pagesize != 16*M) {
 451         continue;
 452       }
 453       bool can_use = false;
 454       trcVerbose("Probing support for %s pages...", describe_pagesize(pagesize));
 455       const int shmid = ::shmget(IPC_PRIVATE, pagesize,
 456         IPC_CREAT | S_IRUSR | S_IWUSR);
 457       guarantee0(shmid != -1); // Should always work.
 458       // Try to set pagesize.
 459       struct shmid_ds shm_buf = { 0 };
 460       shm_buf.shm_pagesize = pagesize;
 461       if (::shmctl(shmid, SHM_PAGESIZE, &shm_buf) != 0) {
 462         const int en = errno;
 463         ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
 464         trcVerbose("shmctl(SHM_PAGESIZE) failed with errno=%n",
 465           errno);
 466       } else {
 467         // Attach and double check pageisze.
 468         void* p = ::shmat(shmid, NULL, 0);
 469         ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
 470         guarantee0(p != (void*) -1); // Should always work.
 471         const size_t real_pagesize = os::Aix::query_pagesize(p);
 472         if (real_pagesize != pagesize) {
 473           trcVerbose("real page size (0x%llX) differs.", real_pagesize);
 474         } else {
 475           can_use = true;
 476         }
 477         ::shmdt(p);
 478       }
 479       trcVerbose("Can use: %s", (can_use ? "yes" : "no"));
 480       if (pagesize == 64*K) {
 481         g_multipage_support.can_use_64K_pages = can_use;
 482       } else if (pagesize == 16*M) {
 483         g_multipage_support.can_use_16M_pages = can_use;
 484       }
 485     }
 486 
 487   } // end: check which pages can be used for shared memory
 488 
 489 query_multipage_support_end:
 490 
 491   trcVerbose("base page size (sysconf _SC_PAGESIZE): %s",
 492       describe_pagesize(g_multipage_support.pagesize));
 493   trcVerbose("Data page size (C-Heap, bss, etc): %s",
 494       describe_pagesize(g_multipage_support.datapsize));
 495   trcVerbose("Text page size: %s",
 496       describe_pagesize(g_multipage_support.textpsize));
 497   trcVerbose("Thread stack page size (pthread): %s",
 498       describe_pagesize(g_multipage_support.pthr_stack_pagesize));
 499   trcVerbose("Default shared memory page size: %s",
 500       describe_pagesize(g_multipage_support.shmpsize));
 501   trcVerbose("Can use 64K pages dynamically with shared meory: %s",
 502       (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
 503   trcVerbose("Can use 16M pages dynamically with shared memory: %s",
 504       (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
 505   trcVerbose("Multipage error details: %d",
 506       g_multipage_support.error);
 507 
 508   // sanity checks
 509   assert0(g_multipage_support.pagesize == 4*K);
 510   assert0(g_multipage_support.datapsize == 4*K || g_multipage_support.datapsize == 64*K);
 511   assert0(g_multipage_support.textpsize == 4*K || g_multipage_support.textpsize == 64*K);
 512   assert0(g_multipage_support.pthr_stack_pagesize == g_multipage_support.datapsize);
 513   assert0(g_multipage_support.shmpsize == 4*K || g_multipage_support.shmpsize == 64*K);
 514 
 515 }
 516 
 517 void os::init_system_properties_values() {
 518 
 519 #define DEFAULT_LIBPATH "/lib:/usr/lib"
 520 #define EXTENSIONS_DIR  "/lib/ext"
 521 
 522   // Buffer that fits several sprintfs.
 523   // Note that the space for the trailing null is provided
 524   // by the nulls included by the sizeof operator.
 525   const size_t bufsize =
 526     MAX2((size_t)MAXPATHLEN,  // For dll_dir & friends.
 527          (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR)); // extensions dir
 528   char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
 529 
 530   // sysclasspath, java_home, dll_dir
 531   {
 532     char *pslash;
 533     os::jvm_path(buf, bufsize);
 534 
 535     // Found the full path to libjvm.so.
 536     // Now cut the path to <java_home>/jre if we can.
 537     pslash = strrchr(buf, '/');
 538     if (pslash != NULL) {
 539       *pslash = '\0';            // Get rid of /libjvm.so.
 540     }
 541     pslash = strrchr(buf, '/');
 542     if (pslash != NULL) {
 543       *pslash = '\0';            // Get rid of /{client|server|hotspot}.
 544     }
 545     Arguments::set_dll_dir(buf);
 546 
 547     if (pslash != NULL) {
 548       pslash = strrchr(buf, '/');
 549       if (pslash != NULL) {
 550         *pslash = '\0';          // Get rid of /<arch>.
 551         pslash = strrchr(buf, '/');
 552         if (pslash != NULL) {
 553           *pslash = '\0';        // Get rid of /lib.
 554         }
 555       }
 556     }
 557     Arguments::set_java_home(buf);
 558     set_boot_path('/', ':');
 559   }
 560 
 561   // Where to look for native libraries.
 562 
 563   // On Aix we get the user setting of LIBPATH.
 564   // Eventually, all the library path setting will be done here.
 565   // Get the user setting of LIBPATH.
 566   const char *v = ::getenv("LIBPATH");
 567   const char *v_colon = ":";
 568   if (v == NULL) { v = ""; v_colon = ""; }
 569 
 570   // Concatenate user and invariant part of ld_library_path.
 571   // That's +1 for the colon and +1 for the trailing '\0'.
 572   char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal);
 573   sprintf(ld_library_path, "%s%s" DEFAULT_LIBPATH, v, v_colon);
 574   Arguments::set_library_path(ld_library_path);
 575   FREE_C_HEAP_ARRAY(char, ld_library_path);
 576 
 577   // Extensions directories.
 578   sprintf(buf, "%s" EXTENSIONS_DIR, Arguments::get_java_home());
 579   Arguments::set_ext_dirs(buf);
 580 
 581   FREE_C_HEAP_ARRAY(char, buf);
 582 
 583 #undef DEFAULT_LIBPATH
 584 #undef EXTENSIONS_DIR
 585 }
 586 
 587 ////////////////////////////////////////////////////////////////////////////////
 588 // breakpoint support
 589 
 590 void os::breakpoint() {
 591   BREAKPOINT;
 592 }
 593 
 594 extern "C" void breakpoint() {
 595   // use debugger to set breakpoint here
 596 }
 597 
 598 ////////////////////////////////////////////////////////////////////////////////
 599 // signal support
 600 
 601 debug_only(static bool signal_sets_initialized = false);
 602 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
 603 
 604 bool os::Aix::is_sig_ignored(int sig) {
 605   struct sigaction oact;
 606   sigaction(sig, (struct sigaction*)NULL, &oact);
 607   void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
 608     : CAST_FROM_FN_PTR(void*, oact.sa_handler);
 609   if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
 610     return true;
 611   } else {
 612     return false;
 613   }
 614 }
 615 
 616 void os::Aix::signal_sets_init() {
 617   // Should also have an assertion stating we are still single-threaded.
 618   assert(!signal_sets_initialized, "Already initialized");
 619   // Fill in signals that are necessarily unblocked for all threads in
 620   // the VM. Currently, we unblock the following signals:
 621   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
 622   //                         by -Xrs (=ReduceSignalUsage));
 623   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
 624   // other threads. The "ReduceSignalUsage" boolean tells us not to alter
 625   // the dispositions or masks wrt these signals.
 626   // Programs embedding the VM that want to use the above signals for their
 627   // own purposes must, at this time, use the "-Xrs" option to prevent
 628   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
 629   // (See bug 4345157, and other related bugs).
 630   // In reality, though, unblocking these signals is really a nop, since
 631   // these signals are not blocked by default.
 632   sigemptyset(&unblocked_sigs);
 633   sigemptyset(&allowdebug_blocked_sigs);
 634   sigaddset(&unblocked_sigs, SIGILL);
 635   sigaddset(&unblocked_sigs, SIGSEGV);
 636   sigaddset(&unblocked_sigs, SIGBUS);
 637   sigaddset(&unblocked_sigs, SIGFPE);
 638   sigaddset(&unblocked_sigs, SIGTRAP);
 639   sigaddset(&unblocked_sigs, SIGDANGER);
 640   sigaddset(&unblocked_sigs, SR_signum);
 641 
 642   if (!ReduceSignalUsage) {
 643    if (!os::Aix::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
 644      sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
 645      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
 646    }
 647    if (!os::Aix::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
 648      sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
 649      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
 650    }
 651    if (!os::Aix::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
 652      sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
 653      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
 654    }
 655   }
 656   // Fill in signals that are blocked by all but the VM thread.
 657   sigemptyset(&vm_sigs);
 658   if (!ReduceSignalUsage)
 659     sigaddset(&vm_sigs, BREAK_SIGNAL);
 660   debug_only(signal_sets_initialized = true);
 661 }
 662 
 663 // These are signals that are unblocked while a thread is running Java.
 664 // (For some reason, they get blocked by default.)
 665 sigset_t* os::Aix::unblocked_signals() {
 666   assert(signal_sets_initialized, "Not initialized");
 667   return &unblocked_sigs;
 668 }
 669 
 670 // These are the signals that are blocked while a (non-VM) thread is
 671 // running Java. Only the VM thread handles these signals.
 672 sigset_t* os::Aix::vm_signals() {
 673   assert(signal_sets_initialized, "Not initialized");
 674   return &vm_sigs;
 675 }
 676 
 677 // These are signals that are blocked during cond_wait to allow debugger in
 678 sigset_t* os::Aix::allowdebug_blocked_signals() {
 679   assert(signal_sets_initialized, "Not initialized");
 680   return &allowdebug_blocked_sigs;
 681 }
 682 
 683 void os::Aix::hotspot_sigmask(Thread* thread) {
 684 
 685   //Save caller's signal mask before setting VM signal mask
 686   sigset_t caller_sigmask;
 687   pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);
 688 
 689   OSThread* osthread = thread->osthread();
 690   osthread->set_caller_sigmask(caller_sigmask);
 691 
 692   pthread_sigmask(SIG_UNBLOCK, os::Aix::unblocked_signals(), NULL);
 693 
 694   if (!ReduceSignalUsage) {
 695     if (thread->is_VM_thread()) {
 696       // Only the VM thread handles BREAK_SIGNAL ...
 697       pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);
 698     } else {
 699       // ... all other threads block BREAK_SIGNAL
 700       pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);
 701     }
 702   }
 703 }
 704 
 705 // retrieve memory information.
 706 // Returns false if something went wrong;
 707 // content of pmi undefined in this case.
 708 bool os::Aix::get_meminfo(meminfo_t* pmi) {
 709 
 710   assert(pmi, "get_meminfo: invalid parameter");
 711 
 712   memset(pmi, 0, sizeof(meminfo_t));
 713 
 714   if (os::Aix::on_pase()) {
 715     // On PASE, use the libo4 porting library.
 716 
 717     unsigned long long virt_total = 0;
 718     unsigned long long real_total = 0;
 719     unsigned long long real_free = 0;
 720     unsigned long long pgsp_total = 0;
 721     unsigned long long pgsp_free = 0;
 722     if (libo4::get_memory_info(&virt_total, &real_total, &real_free, &pgsp_total, &pgsp_free)) {
 723       pmi->virt_total = virt_total;
 724       pmi->real_total = real_total;
 725       pmi->real_free = real_free;
 726       pmi->pgsp_total = pgsp_total;
 727       pmi->pgsp_free = pgsp_free;
 728       return true;
 729     }
 730     return false;
 731 
 732   } else {
 733 
 734     // On AIX, I use the (dynamically loaded) perfstat library to retrieve memory statistics
 735     // See:
 736     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 737     //        ?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_memtot.htm
 738     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 739     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
 740 
 741     perfstat_memory_total_t psmt;
 742     memset (&psmt, '\0', sizeof(psmt));
 743     const int rc = libperfstat::perfstat_memory_total(NULL, &psmt, sizeof(psmt), 1);
 744     if (rc == -1) {
 745       trcVerbose("perfstat_memory_total() failed (errno=%d)", errno);
 746       assert(0, "perfstat_memory_total() failed");
 747       return false;
 748     }
 749 
 750     assert(rc == 1, "perfstat_memory_total() - weird return code");
 751 
 752     // excerpt from
 753     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
 754     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
 755     // The fields of perfstat_memory_total_t:
 756     // u_longlong_t virt_total         Total virtual memory (in 4 KB pages).
 757     // u_longlong_t real_total         Total real memory (in 4 KB pages).
 758     // u_longlong_t real_free          Free real memory (in 4 KB pages).
 759     // u_longlong_t pgsp_total         Total paging space (in 4 KB pages).
 760     // u_longlong_t pgsp_free          Free paging space (in 4 KB pages).
 761 
 762     pmi->virt_total = psmt.virt_total * 4096;
 763     pmi->real_total = psmt.real_total * 4096;
 764     pmi->real_free = psmt.real_free * 4096;
 765     pmi->pgsp_total = psmt.pgsp_total * 4096;
 766     pmi->pgsp_free = psmt.pgsp_free * 4096;
 767 
 768     return true;
 769 
 770   }
 771 } // end os::Aix::get_meminfo
 772 
 773 //////////////////////////////////////////////////////////////////////////////
 774 // create new thread
 775 
 776 // Thread start routine for all newly created threads
 777 static void *thread_native_entry(Thread *thread) {
 778 
 779   // find out my own stack dimensions
 780   {
 781     // actually, this should do exactly the same as thread->record_stack_base_and_size...
 782     address base = 0;
 783     size_t size = 0;
 784     query_stack_dimensions(&base, &size);
 785     thread->set_stack_base(base);
 786     thread->set_stack_size(size);
 787   }
 788 
 789   const pthread_t pthread_id = ::pthread_self();
 790   const tid_t kernel_thread_id = ::thread_self();
 791 
 792   log_info(os, thread)("Thread is alive (tid: " UINTX_FORMAT ", kernel thread id: " UINTX_FORMAT ").",
 793     os::current_thread_id(), (uintx) kernel_thread_id);
 794 
 795   // Normally, pthread stacks on AIX live in the data segment (are allocated with malloc()
 796   // by the pthread library). In rare cases, this may not be the case, e.g. when third-party
 797   // tools hook pthread_create(). In this case, we may run into problems establishing
 798   // guard pages on those stacks, because the stacks may reside in memory which is not
 799   // protectable (shmated).
 800   if (thread->stack_base() > ::sbrk(0)) {
 801     log_warning(os, thread)("Thread stack not in data segment.");
 802   }
 803 
 804   // Try to randomize the cache line index of hot stack frames.
 805   // This helps when threads of the same stack traces evict each other's
 806   // cache lines. The threads can be either from the same JVM instance, or
 807   // from different JVM instances. The benefit is especially true for
 808   // processors with hyperthreading technology.
 809 
 810   static int counter = 0;
 811   int pid = os::current_process_id();
 812   alloca(((pid ^ counter++) & 7) * 128);
 813 
 814   thread->initialize_thread_current();
 815 
 816   OSThread* osthread = thread->osthread();
 817 
 818   // Thread_id is pthread id.
 819   osthread->set_thread_id(pthread_id);
 820 
 821   // .. but keep kernel thread id too for diagnostics
 822   osthread->set_kernel_thread_id(kernel_thread_id);
 823 
 824   // Initialize signal mask for this thread.
 825   os::Aix::hotspot_sigmask(thread);
 826 
 827   // Initialize floating point control register.
 828   os::Aix::init_thread_fpu_state();
 829 
 830   assert(osthread->get_state() == RUNNABLE, "invalid os thread state");
 831 
 832   // Call one more level start routine.
 833   thread->run();
 834 
 835   log_info(os, thread)("Thread finished (tid: " UINTX_FORMAT ", kernel thread id: " UINTX_FORMAT ").",
 836     os::current_thread_id(), (uintx) kernel_thread_id);
 837 
 838   // If a thread has not deleted itself ("delete this") as part of its
 839   // termination sequence, we have to ensure thread-local-storage is
 840   // cleared before we actually terminate. No threads should ever be
 841   // deleted asynchronously with respect to their termination.
 842   if (Thread::current_or_null_safe() != NULL) {
 843     assert(Thread::current_or_null_safe() == thread, "current thread is wrong");
 844     thread->clear_thread_current();
 845   }
 846 
 847   return 0;
 848 }
 849 
 850 bool os::create_thread(Thread* thread, ThreadType thr_type,
 851                        size_t req_stack_size) {
 852 
 853   assert(thread->osthread() == NULL, "caller responsible");
 854 
 855   // Allocate the OSThread object.
 856   OSThread* osthread = new OSThread(NULL, NULL);
 857   if (osthread == NULL) {
 858     return false;
 859   }
 860 
 861   // Set the correct thread state.
 862   osthread->set_thread_type(thr_type);
 863 
 864   // Initial state is ALLOCATED but not INITIALIZED
 865   osthread->set_state(ALLOCATED);
 866 
 867   thread->set_osthread(osthread);
 868 
 869   // Init thread attributes.
 870   pthread_attr_t attr;
 871   pthread_attr_init(&attr);
 872   guarantee(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0, "???");
 873 
 874   // Make sure we run in 1:1 kernel-user-thread mode.
 875   if (os::Aix::on_aix()) {
 876     guarantee(pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0, "???");
 877     guarantee(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0, "???");
 878   }
 879 
 880   // Start in suspended state, and in os::thread_start, wake the thread up.
 881   guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???");
 882 
 883   // Calculate stack size if it's not specified by caller.
 884   size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
 885   pthread_attr_setstacksize(&attr, stack_size);
 886 
 887   // libc guard page
 888   pthread_attr_setguardsize(&attr, os::Aix::default_guard_size(thr_type));
 889 
 890   pthread_t tid;
 891   int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
 892 
 893   char buf[64];
 894   if (ret == 0) {
 895     log_info(os, thread)("Thread started (pthread id: " UINTX_FORMAT ", attributes: %s). ",
 896       (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
 897   } else {
 898     log_warning(os, thread)("Failed to start thread - pthread_create failed (%d=%s) for attributes: %s.",
 899       ret, os::errno_name(ret), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));
 900   }
 901 
 902   pthread_attr_destroy(&attr);
 903 
 904   if (ret != 0) {
 905     // Need to clean up stuff we've allocated so far.
 906     thread->set_osthread(NULL);
 907     delete osthread;
 908     return false;
 909   }
 910 
 911   // OSThread::thread_id is the pthread id.
 912   osthread->set_thread_id(tid);
 913 
 914   return true;
 915 }
 916 
 917 /////////////////////////////////////////////////////////////////////////////
 918 // attach existing thread
 919 
 920 // bootstrap the main thread
 921 bool os::create_main_thread(JavaThread* thread) {
 922   assert(os::Aix::_main_thread == pthread_self(), "should be called inside main thread");
 923   return create_attached_thread(thread);
 924 }
 925 
 926 bool os::create_attached_thread(JavaThread* thread) {
 927 #ifdef ASSERT
 928     thread->verify_not_published();
 929 #endif
 930 
 931   // Allocate the OSThread object
 932   OSThread* osthread = new OSThread(NULL, NULL);
 933 
 934   if (osthread == NULL) {
 935     return false;
 936   }
 937 
 938   const pthread_t pthread_id = ::pthread_self();
 939   const tid_t kernel_thread_id = ::thread_self();
 940 
 941   // OSThread::thread_id is the pthread id.
 942   osthread->set_thread_id(pthread_id);
 943 
 944   // .. but keep kernel thread id too for diagnostics
 945   osthread->set_kernel_thread_id(kernel_thread_id);
 946 
 947   // initialize floating point control register
 948   os::Aix::init_thread_fpu_state();
 949 
 950   // Initial thread state is RUNNABLE
 951   osthread->set_state(RUNNABLE);
 952 
 953   thread->set_osthread(osthread);
 954 
 955   if (UseNUMA) {
 956     int lgrp_id = os::numa_get_group_id();
 957     if (lgrp_id != -1) {
 958       thread->set_lgrp_id(lgrp_id);
 959     }
 960   }
 961 
 962   // initialize signal mask for this thread
 963   // and save the caller's signal mask
 964   os::Aix::hotspot_sigmask(thread);
 965 
 966   log_info(os, thread)("Thread attached (tid: " UINTX_FORMAT ", kernel thread id: " UINTX_FORMAT ").",
 967     os::current_thread_id(), (uintx) kernel_thread_id);
 968 
 969   return true;
 970 }
 971 
 972 void os::pd_start_thread(Thread* thread) {
 973   int status = pthread_continue_np(thread->osthread()->pthread_id());
 974   assert(status == 0, "thr_continue failed");
 975 }
 976 
 977 // Free OS resources related to the OSThread
 978 void os::free_thread(OSThread* osthread) {
 979   assert(osthread != NULL, "osthread not set");
 980 
 981   // We are told to free resources of the argument thread,
 982   // but we can only really operate on the current thread.
 983   assert(Thread::current()->osthread() == osthread,
 984          "os::free_thread but not current thread");
 985 
 986   // Restore caller's signal mask
 987   sigset_t sigmask = osthread->caller_sigmask();
 988   pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
 989 
 990   delete osthread;
 991 }
 992 
 993 ////////////////////////////////////////////////////////////////////////////////
 994 // time support
 995 
 996 // Time since start-up in seconds to a fine granularity.
 997 // Used by VMSelfDestructTimer and the MemProfiler.
 998 double os::elapsedTime() {
 999   return (double)(os::elapsed_counter()) * 0.000001;
1000 }
1001 
1002 jlong os::elapsed_counter() {
1003   timeval time;
1004   int status = gettimeofday(&time, NULL);
1005   return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;
1006 }
1007 
1008 jlong os::elapsed_frequency() {
1009   return (1000 * 1000);
1010 }
1011 
1012 bool os::supports_vtime() { return true; }
1013 bool os::enable_vtime()   { return false; }
1014 bool os::vtime_enabled()  { return false; }
1015 
1016 double os::elapsedVTime() {
1017   struct rusage usage;
1018   int retval = getrusage(RUSAGE_THREAD, &usage);
1019   if (retval == 0) {
1020     return usage.ru_utime.tv_sec + usage.ru_stime.tv_sec + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec) / (1000.0 * 1000);
1021   } else {
1022     // better than nothing, but not much
1023     return elapsedTime();
1024   }
1025 }
1026 
1027 jlong os::javaTimeMillis() {
1028   timeval time;
1029   int status = gettimeofday(&time, NULL);
1030   assert(status != -1, "aix error at gettimeofday()");
1031   return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000);
1032 }
1033 
1034 void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) {
1035   timeval time;
1036   int status = gettimeofday(&time, NULL);
1037   assert(status != -1, "aix error at gettimeofday()");
1038   seconds = jlong(time.tv_sec);
1039   nanos = jlong(time.tv_usec) * 1000;
1040 }
1041 
1042 jlong os::javaTimeNanos() {
1043   if (os::Aix::on_pase()) {
1044 
1045     timeval time;
1046     int status = gettimeofday(&time, NULL);
1047     assert(status != -1, "PASE error at gettimeofday()");
1048     jlong usecs = jlong((unsigned long long) time.tv_sec * (1000 * 1000) + time.tv_usec);
1049     return 1000 * usecs;
1050 
1051   } else {
1052     // On AIX use the precision of processors real time clock
1053     // or time base registers.
1054     timebasestruct_t time;
1055     int rc;
1056 
1057     // If the CPU has a time register, it will be used and
1058     // we have to convert to real time first. After convertion we have following data:
1059     // time.tb_high [seconds since 00:00:00 UTC on 1.1.1970]
1060     // time.tb_low  [nanoseconds after the last full second above]
1061     // We better use mread_real_time here instead of read_real_time
1062     // to ensure that we will get a monotonic increasing time.
1063     if (mread_real_time(&time, TIMEBASE_SZ) != RTC_POWER) {
1064       rc = time_base_to_time(&time, TIMEBASE_SZ);
1065       assert(rc != -1, "aix error at time_base_to_time()");
1066     }
1067     return jlong(time.tb_high) * (1000 * 1000 * 1000) + jlong(time.tb_low);
1068   }
1069 }
1070 
1071 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1072   info_ptr->max_value = ALL_64_BITS;
1073   // mread_real_time() is monotonic (see 'os::javaTimeNanos()')
1074   info_ptr->may_skip_backward = false;
1075   info_ptr->may_skip_forward = false;
1076   info_ptr->kind = JVMTI_TIMER_ELAPSED;    // elapsed not CPU time
1077 }
1078 
1079 // Return the real, user, and system times in seconds from an
1080 // arbitrary fixed point in the past.
1081 bool os::getTimesSecs(double* process_real_time,
1082                       double* process_user_time,
1083                       double* process_system_time) {
1084   struct tms ticks;
1085   clock_t real_ticks = times(&ticks);
1086 
1087   if (real_ticks == (clock_t) (-1)) {
1088     return false;
1089   } else {
1090     double ticks_per_second = (double) clock_tics_per_sec;
1091     *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1092     *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1093     *process_real_time = ((double) real_ticks) / ticks_per_second;
1094 
1095     return true;
1096   }
1097 }
1098 
1099 char * os::local_time_string(char *buf, size_t buflen) {
1100   struct tm t;
1101   time_t long_time;
1102   time(&long_time);
1103   localtime_r(&long_time, &t);
1104   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1105                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1106                t.tm_hour, t.tm_min, t.tm_sec);
1107   return buf;
1108 }
1109 
1110 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
1111   return localtime_r(clock, res);
1112 }
1113 
1114 ////////////////////////////////////////////////////////////////////////////////
1115 // runtime exit support
1116 
1117 // Note: os::shutdown() might be called very early during initialization, or
1118 // called from signal handler. Before adding something to os::shutdown(), make
1119 // sure it is async-safe and can handle partially initialized VM.
1120 void os::shutdown() {
1121 
1122   // allow PerfMemory to attempt cleanup of any persistent resources
1123   perfMemory_exit();
1124 
1125   // needs to remove object in file system
1126   AttachListener::abort();
1127 
1128   // flush buffered output, finish log files
1129   ostream_abort();
1130 
1131   // Check for abort hook
1132   abort_hook_t abort_hook = Arguments::abort_hook();
1133   if (abort_hook != NULL) {
1134     abort_hook();
1135   }
1136 }
1137 
1138 // Note: os::abort() might be called very early during initialization, or
1139 // called from signal handler. Before adding something to os::abort(), make
1140 // sure it is async-safe and can handle partially initialized VM.
1141 void os::abort(bool dump_core, void* siginfo, const void* context) {
1142   os::shutdown();
1143   if (dump_core) {
1144 #ifndef PRODUCT
1145     fdStream out(defaultStream::output_fd());
1146     out.print_raw("Current thread is ");
1147     char buf[16];
1148     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1149     out.print_raw_cr(buf);
1150     out.print_raw_cr("Dumping core ...");
1151 #endif
1152     ::abort(); // dump core
1153   }
1154 
1155   ::exit(1);
1156 }
1157 
1158 // Die immediately, no exit hook, no abort hook, no cleanup.
1159 void os::die() {
1160   ::abort();
1161 }
1162 
1163 // This method is a copy of JDK's sysGetLastErrorString
1164 // from src/solaris/hpi/src/system_md.c
1165 
1166 size_t os::lasterror(char *buf, size_t len) {
1167   if (errno == 0) return 0;
1168 
1169   const char *s = os::strerror(errno);
1170   size_t n = ::strlen(s);
1171   if (n >= len) {
1172     n = len - 1;
1173   }
1174   ::strncpy(buf, s, n);
1175   buf[n] = '\0';
1176   return n;
1177 }
1178 
1179 intx os::current_thread_id() {
1180   return (intx)pthread_self();
1181 }
1182 
1183 int os::current_process_id() {
1184   return getpid();
1185 }
1186 
1187 // DLL functions
1188 
1189 const char* os::dll_file_extension() { return ".so"; }
1190 
1191 // This must be hard coded because it's the system's temporary
1192 // directory not the java application's temp directory, ala java.io.tmpdir.
1193 const char* os::get_temp_directory() { return "/tmp"; }
1194 
1195 static bool file_exists(const char* filename) {
1196   struct stat statbuf;
1197   if (filename == NULL || strlen(filename) == 0) {
1198     return false;
1199   }
1200   return os::stat(filename, &statbuf) == 0;
1201 }
1202 
1203 bool os::dll_build_name(char* buffer, size_t buflen,
1204                         const char* pname, const char* fname) {
1205   bool retval = false;
1206   // Copied from libhpi
1207   const size_t pnamelen = pname ? strlen(pname) : 0;
1208 
1209   // Return error on buffer overflow.
1210   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1211     *buffer = '\0';
1212     return retval;
1213   }
1214 
1215   if (pnamelen == 0) {
1216     snprintf(buffer, buflen, "lib%s.so", fname);
1217     retval = true;
1218   } else if (strchr(pname, *os::path_separator()) != NULL) {
1219     int n;
1220     char** pelements = split_path(pname, &n);
1221     if (pelements == NULL) {
1222       return false;
1223     }
1224     for (int i = 0; i < n; i++) {
1225       // Really shouldn't be NULL, but check can't hurt
1226       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1227         continue; // skip the empty path values
1228       }
1229       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1230       if (file_exists(buffer)) {
1231         retval = true;
1232         break;
1233       }
1234     }
1235     // release the storage
1236     for (int i = 0; i < n; i++) {
1237       if (pelements[i] != NULL) {
1238         FREE_C_HEAP_ARRAY(char, pelements[i]);
1239       }
1240     }
1241     if (pelements != NULL) {
1242       FREE_C_HEAP_ARRAY(char*, pelements);
1243     }
1244   } else {
1245     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1246     retval = true;
1247   }
1248   return retval;
1249 }
1250 
1251 // Check if addr is inside libjvm.so.
1252 bool os::address_is_in_vm(address addr) {
1253 
1254   // Input could be a real pc or a function pointer literal. The latter
1255   // would be a function descriptor residing in the data segment of a module.
1256   loaded_module_t lm;
1257   if (LoadedLibraries::find_for_text_address(addr, &lm) != NULL) {
1258     return lm.is_in_vm;
1259   } else if (LoadedLibraries::find_for_data_address(addr, &lm) != NULL) {
1260     return lm.is_in_vm;
1261   } else {
1262     return false;
1263   }
1264 
1265 }
1266 
1267 // Resolve an AIX function descriptor literal to a code pointer.
1268 // If the input is a valid code pointer to a text segment of a loaded module,
1269 //   it is returned unchanged.
1270 // If the input is a valid AIX function descriptor, it is resolved to the
1271 //   code entry point.
1272 // If the input is neither a valid function descriptor nor a valid code pointer,
1273 //   NULL is returned.
1274 static address resolve_function_descriptor_to_code_pointer(address p) {
1275 
1276   if (LoadedLibraries::find_for_text_address(p, NULL) != NULL) {
1277     // It is a real code pointer.
1278     return p;
1279   } else if (LoadedLibraries::find_for_data_address(p, NULL) != NULL) {
1280     // Pointer to data segment, potential function descriptor.
1281     address code_entry = (address)(((FunctionDescriptor*)p)->entry());
1282     if (LoadedLibraries::find_for_text_address(code_entry, NULL) != NULL) {
1283       // It is a function descriptor.
1284       return code_entry;
1285     }
1286   }
1287 
1288   return NULL;
1289 }
1290 
1291 bool os::dll_address_to_function_name(address addr, char *buf,
1292                                       int buflen, int *offset,
1293                                       bool demangle) {
1294   if (offset) {
1295     *offset = -1;
1296   }
1297   // Buf is not optional, but offset is optional.
1298   assert(buf != NULL, "sanity check");
1299   buf[0] = '\0';
1300 
1301   // Resolve function ptr literals first.
1302   addr = resolve_function_descriptor_to_code_pointer(addr);
1303   if (!addr) {
1304     return false;
1305   }
1306 
1307   return AixSymbols::get_function_name(addr, buf, buflen, offset, NULL, demangle);
1308 }
1309 
1310 bool os::dll_address_to_library_name(address addr, char* buf,
1311                                      int buflen, int* offset) {
1312   if (offset) {
1313     *offset = -1;
1314   }
1315   // Buf is not optional, but offset is optional.
1316   assert(buf != NULL, "sanity check");
1317   buf[0] = '\0';
1318 
1319   // Resolve function ptr literals first.
1320   addr = resolve_function_descriptor_to_code_pointer(addr);
1321   if (!addr) {
1322     return false;
1323   }
1324 
1325   return AixSymbols::get_module_name(addr, buf, buflen);
1326 }
1327 
1328 // Loads .dll/.so and in case of error it checks if .dll/.so was built
1329 // for the same architecture as Hotspot is running on.
1330 void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {
1331 
1332   if (ebuf && ebuflen > 0) {
1333     ebuf[0] = '\0';
1334     ebuf[ebuflen - 1] = '\0';
1335   }
1336 
1337   if (!filename || strlen(filename) == 0) {
1338     ::strncpy(ebuf, "dll_load: empty filename specified", ebuflen - 1);
1339     return NULL;
1340   }
1341 
1342   // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants.
1343   void * result= ::dlopen(filename, RTLD_LAZY);
1344   if (result != NULL) {
1345     // Reload dll cache. Don't do this in signal handling.
1346     LoadedLibraries::reload();
1347     return result;
1348   } else {
1349     // error analysis when dlopen fails
1350     const char* const error_report = ::dlerror();
1351     if (error_report && ebuf && ebuflen > 0) {
1352       snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s",
1353                filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report);
1354     }
1355   }
1356   return NULL;
1357 }
1358 
1359 void* os::dll_lookup(void* handle, const char* name) {
1360   void* res = dlsym(handle, name);
1361   return res;
1362 }
1363 
1364 void* os::get_default_process_handle() {
1365   return (void*)::dlopen(NULL, RTLD_LAZY);
1366 }
1367 
1368 void os::print_dll_info(outputStream *st) {
1369   st->print_cr("Dynamic libraries:");
1370   LoadedLibraries::print(st);
1371 }
1372 
1373 void os::get_summary_os_info(char* buf, size_t buflen) {
1374   // There might be something more readable than uname results for AIX.
1375   struct utsname name;
1376   uname(&name);
1377   snprintf(buf, buflen, "%s %s", name.release, name.version);
1378 }
1379 
1380 void os::print_os_info(outputStream* st) {
1381   st->print("OS:");
1382 
1383   st->print("uname:");
1384   struct utsname name;
1385   uname(&name);
1386   st->print(name.sysname); st->print(" ");
1387   st->print(name.nodename); st->print(" ");
1388   st->print(name.release); st->print(" ");
1389   st->print(name.version); st->print(" ");
1390   st->print(name.machine);
1391   st->cr();
1392 
1393   uint32_t ver = os::Aix::os_version();
1394   st->print_cr("AIX kernel version %u.%u.%u.%u",
1395                (ver >> 24) & 0xFF, (ver >> 16) & 0xFF, (ver >> 8) & 0xFF, ver & 0xFF);
1396 
1397   // rlimit
1398   st->print("rlimit:");
1399   struct rlimit rlim;
1400 
1401   st->print(" STACK ");
1402   getrlimit(RLIMIT_STACK, &rlim);
1403   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1404   else st->print("%uk", rlim.rlim_cur >> 10);
1405 
1406   st->print(", CORE ");
1407   getrlimit(RLIMIT_CORE, &rlim);
1408   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1409   else st->print("%uk", rlim.rlim_cur >> 10);
1410 
1411   st->print(", NPROC ");
1412   st->print("%d", sysconf(_SC_CHILD_MAX));
1413 
1414   st->print(", NOFILE ");
1415   getrlimit(RLIMIT_NOFILE, &rlim);
1416   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1417   else st->print("%d", rlim.rlim_cur);
1418 
1419   st->print(", AS ");
1420   getrlimit(RLIMIT_AS, &rlim);
1421   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1422   else st->print("%uk", rlim.rlim_cur >> 10);
1423 
1424   // Print limits on DATA, because it limits the C-heap.
1425   st->print(", DATA ");
1426   getrlimit(RLIMIT_DATA, &rlim);
1427   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1428   else st->print("%uk", rlim.rlim_cur >> 10);
1429   st->cr();
1430 
1431   // load average
1432   st->print("load average:");
1433   double loadavg[3] = {-1.L, -1.L, -1.L};
1434   os::loadavg(loadavg, 3);
1435   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
1436   st->cr();
1437 
1438   // print wpar info
1439   libperfstat::wparinfo_t wi;
1440   if (libperfstat::get_wparinfo(&wi)) {
1441     st->print_cr("wpar info");
1442     st->print_cr("name: %s", wi.name);
1443     st->print_cr("id:   %d", wi.wpar_id);
1444     st->print_cr("type: %s", (wi.app_wpar ? "application" : "system"));
1445   }
1446 
1447   // print partition info
1448   libperfstat::partitioninfo_t pi;
1449   if (libperfstat::get_partitioninfo(&pi)) {
1450     st->print_cr("partition info");
1451     st->print_cr(" name: %s", pi.name);
1452   }
1453 
1454 }
1455 
1456 void os::print_memory_info(outputStream* st) {
1457 
1458   st->print_cr("Memory:");
1459 
1460   st->print_cr("  Base page size (sysconf _SC_PAGESIZE):  %s",
1461     describe_pagesize(g_multipage_support.pagesize));
1462   st->print_cr("  Data page size (C-Heap, bss, etc):      %s",
1463     describe_pagesize(g_multipage_support.datapsize));
1464   st->print_cr("  Text page size:                         %s",
1465     describe_pagesize(g_multipage_support.textpsize));
1466   st->print_cr("  Thread stack page size (pthread):       %s",
1467     describe_pagesize(g_multipage_support.pthr_stack_pagesize));
1468   st->print_cr("  Default shared memory page size:        %s",
1469     describe_pagesize(g_multipage_support.shmpsize));
1470   st->print_cr("  Can use 64K pages dynamically with shared meory:  %s",
1471     (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
1472   st->print_cr("  Can use 16M pages dynamically with shared memory: %s",
1473     (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
1474   st->print_cr("  Multipage error: %d",
1475     g_multipage_support.error);
1476   st->cr();
1477   st->print_cr("  os::vm_page_size:       %s", describe_pagesize(os::vm_page_size()));
1478 
1479   // print out LDR_CNTRL because it affects the default page sizes
1480   const char* const ldr_cntrl = ::getenv("LDR_CNTRL");
1481   st->print_cr("  LDR_CNTRL=%s.", ldr_cntrl ? ldr_cntrl : "<unset>");
1482 
1483   // Print out EXTSHM because it is an unsupported setting.
1484   const char* const extshm = ::getenv("EXTSHM");
1485   st->print_cr("  EXTSHM=%s.", extshm ? extshm : "<unset>");
1486   if ( (strcmp(extshm, "on") == 0) || (strcmp(extshm, "ON") == 0) ) {
1487     st->print_cr("  *** Unsupported! Please remove EXTSHM from your environment! ***");
1488   }
1489 
1490   // Print out AIXTHREAD_GUARDPAGES because it affects the size of pthread stacks.
1491   const char* const aixthread_guardpages = ::getenv("AIXTHREAD_GUARDPAGES");
1492   st->print_cr("  AIXTHREAD_GUARDPAGES=%s.",
1493       aixthread_guardpages ? aixthread_guardpages : "<unset>");
1494 
1495   os::Aix::meminfo_t mi;
1496   if (os::Aix::get_meminfo(&mi)) {
1497     char buffer[256];
1498     if (os::Aix::on_aix()) {
1499       st->print_cr("physical total : " SIZE_FORMAT, mi.real_total);
1500       st->print_cr("physical free  : " SIZE_FORMAT, mi.real_free);
1501       st->print_cr("swap total     : " SIZE_FORMAT, mi.pgsp_total);
1502       st->print_cr("swap free      : " SIZE_FORMAT, mi.pgsp_free);
1503     } else {
1504       // PASE - Numbers are result of QWCRSSTS; they mean:
1505       // real_total: Sum of all system pools
1506       // real_free: always 0
1507       // pgsp_total: we take the size of the system ASP
1508       // pgsp_free: size of system ASP times percentage of system ASP unused
1509       st->print_cr("physical total     : " SIZE_FORMAT, mi.real_total);
1510       st->print_cr("system asp total   : " SIZE_FORMAT, mi.pgsp_total);
1511       st->print_cr("%% system asp used : " SIZE_FORMAT,
1512         mi.pgsp_total ? (100.0f * (mi.pgsp_total - mi.pgsp_free) / mi.pgsp_total) : -1.0f);
1513     }
1514     st->print_raw(buffer);
1515   }
1516   st->cr();
1517 
1518   // Print segments allocated with os::reserve_memory.
1519   st->print_cr("internal virtual memory regions used by vm:");
1520   vmembk_print_on(st);
1521 }
1522 
1523 // Get a string for the cpuinfo that is a summary of the cpu type
1524 void os::get_summary_cpu_info(char* buf, size_t buflen) {
1525   // This looks good
1526   libperfstat::cpuinfo_t ci;
1527   if (libperfstat::get_cpuinfo(&ci)) {
1528     strncpy(buf, ci.version, buflen);
1529   } else {
1530     strncpy(buf, "AIX", buflen);
1531   }
1532 }
1533 
1534 void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
1535   st->print("CPU:");
1536   st->print("total %d", os::processor_count());
1537   // It's not safe to query number of active processors after crash.
1538   // st->print("(active %d)", os::active_processor_count());
1539   st->print(" %s", VM_Version::features());
1540   st->cr();
1541 }
1542 
1543 static void print_signal_handler(outputStream* st, int sig,
1544                                  char* buf, size_t buflen);
1545 
1546 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1547   st->print_cr("Signal Handlers:");
1548   print_signal_handler(st, SIGSEGV, buf, buflen);
1549   print_signal_handler(st, SIGBUS , buf, buflen);
1550   print_signal_handler(st, SIGFPE , buf, buflen);
1551   print_signal_handler(st, SIGPIPE, buf, buflen);
1552   print_signal_handler(st, SIGXFSZ, buf, buflen);
1553   print_signal_handler(st, SIGILL , buf, buflen);
1554   print_signal_handler(st, SR_signum, buf, buflen);
1555   print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
1556   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
1557   print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
1558   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
1559   print_signal_handler(st, SIGTRAP, buf, buflen);
1560   print_signal_handler(st, SIGDANGER, buf, buflen);
1561 }
1562 
1563 static char saved_jvm_path[MAXPATHLEN] = {0};
1564 
1565 // Find the full path to the current module, libjvm.so.
1566 void os::jvm_path(char *buf, jint buflen) {
1567   // Error checking.
1568   if (buflen < MAXPATHLEN) {
1569     assert(false, "must use a large-enough buffer");
1570     buf[0] = '\0';
1571     return;
1572   }
1573   // Lazy resolve the path to current module.
1574   if (saved_jvm_path[0] != 0) {
1575     strcpy(buf, saved_jvm_path);
1576     return;
1577   }
1578 
1579   Dl_info dlinfo;
1580   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
1581   assert(ret != 0, "cannot locate libjvm");
1582   char* rp = realpath((char *)dlinfo.dli_fname, buf);
1583   assert(rp != NULL, "error in realpath(): maybe the 'path' argument is too long?");
1584 
1585   strncpy(saved_jvm_path, buf, sizeof(saved_jvm_path));
1586   saved_jvm_path[sizeof(saved_jvm_path) - 1] = '\0';
1587 }
1588 
1589 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1590   // no prefix required, not even "_"
1591 }
1592 
1593 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1594   // no suffix required
1595 }
1596 
1597 ////////////////////////////////////////////////////////////////////////////////
1598 // sun.misc.Signal support
1599 
1600 static volatile jint sigint_count = 0;
1601 
1602 static void
1603 UserHandler(int sig, void *siginfo, void *context) {
1604   // 4511530 - sem_post is serialized and handled by the manager thread. When
1605   // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
1606   // don't want to flood the manager thread with sem_post requests.
1607   if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
1608     return;
1609 
1610   // Ctrl-C is pressed during error reporting, likely because the error
1611   // handler fails to abort. Let VM die immediately.
1612   if (sig == SIGINT && is_error_reported()) {
1613     os::die();
1614   }
1615 
1616   os::signal_notify(sig);
1617 }
1618 
1619 void* os::user_handler() {
1620   return CAST_FROM_FN_PTR(void*, UserHandler);
1621 }
1622 
1623 extern "C" {
1624   typedef void (*sa_handler_t)(int);
1625   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
1626 }
1627 
1628 void* os::signal(int signal_number, void* handler) {
1629   struct sigaction sigAct, oldSigAct;
1630 
1631   sigfillset(&(sigAct.sa_mask));
1632 
1633   // Do not block out synchronous signals in the signal handler.
1634   // Blocking synchronous signals only makes sense if you can really
1635   // be sure that those signals won't happen during signal handling,
1636   // when the blocking applies. Normal signal handlers are lean and
1637   // do not cause signals. But our signal handlers tend to be "risky"
1638   // - secondary SIGSEGV, SIGILL, SIGBUS' may and do happen.
1639   // On AIX, PASE there was a case where a SIGSEGV happened, followed
1640   // by a SIGILL, which was blocked due to the signal mask. The process
1641   // just hung forever. Better to crash from a secondary signal than to hang.
1642   sigdelset(&(sigAct.sa_mask), SIGSEGV);
1643   sigdelset(&(sigAct.sa_mask), SIGBUS);
1644   sigdelset(&(sigAct.sa_mask), SIGILL);
1645   sigdelset(&(sigAct.sa_mask), SIGFPE);
1646   sigdelset(&(sigAct.sa_mask), SIGTRAP);
1647 
1648   sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;
1649 
1650   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
1651 
1652   if (sigaction(signal_number, &sigAct, &oldSigAct)) {
1653     // -1 means registration failed
1654     return (void *)-1;
1655   }
1656 
1657   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
1658 }
1659 
1660 void os::signal_raise(int signal_number) {
1661   ::raise(signal_number);
1662 }
1663 
1664 //
1665 // The following code is moved from os.cpp for making this
1666 // code platform specific, which it is by its very nature.
1667 //
1668 
1669 // Will be modified when max signal is changed to be dynamic
1670 int os::sigexitnum_pd() {
1671   return NSIG;
1672 }
1673 
1674 // a counter for each possible signal value
1675 static volatile jint pending_signals[NSIG+1] = { 0 };
1676 
1677 // Wrapper functions for: sem_init(), sem_post(), sem_wait()
1678 // On AIX, we use sem_init(), sem_post(), sem_wait()
1679 // On Pase, we need to use msem_lock() and msem_unlock(), because Posix Semaphores
1680 // do not seem to work at all on PASE (unimplemented, will cause SIGILL).
1681 // Note that just using msem_.. APIs for both PASE and AIX is not an option either, as
1682 // on AIX, msem_..() calls are suspected of causing problems.
1683 static sem_t sig_sem;
1684 static msemaphore* p_sig_msem = 0;
1685 
1686 static void local_sem_init() {
1687   if (os::Aix::on_aix()) {
1688     int rc = ::sem_init(&sig_sem, 0, 0);
1689     guarantee(rc != -1, "sem_init failed");
1690   } else {
1691     // Memory semaphores must live in shared mem.
1692     guarantee0(p_sig_msem == NULL);
1693     p_sig_msem = (msemaphore*)os::reserve_memory(sizeof(msemaphore), NULL);
1694     guarantee(p_sig_msem, "Cannot allocate memory for memory semaphore");
1695     guarantee(::msem_init(p_sig_msem, 0) == p_sig_msem, "msem_init failed");
1696   }
1697 }
1698 
1699 static void local_sem_post() {
1700   static bool warn_only_once = false;
1701   if (os::Aix::on_aix()) {
1702     int rc = ::sem_post(&sig_sem);
1703     if (rc == -1 && !warn_only_once) {
1704       trcVerbose("sem_post failed (errno = %d, %s)", errno, os::errno_name(errno));
1705       warn_only_once = true;
1706     }
1707   } else {
1708     guarantee0(p_sig_msem != NULL);
1709     int rc = ::msem_unlock(p_sig_msem, 0);
1710     if (rc == -1 && !warn_only_once) {
1711       trcVerbose("msem_unlock failed (errno = %d, %s)", errno, os::errno_name(errno));
1712       warn_only_once = true;
1713     }
1714   }
1715 }
1716 
1717 static void local_sem_wait() {
1718   static bool warn_only_once = false;
1719   if (os::Aix::on_aix()) {
1720     int rc = ::sem_wait(&sig_sem);
1721     if (rc == -1 && !warn_only_once) {
1722       trcVerbose("sem_wait failed (errno = %d, %s)", errno, os::errno_name(errno));
1723       warn_only_once = true;
1724     }
1725   } else {
1726     guarantee0(p_sig_msem != NULL); // must init before use
1727     int rc = ::msem_lock(p_sig_msem, 0);
1728     if (rc == -1 && !warn_only_once) {
1729       trcVerbose("msem_lock failed (errno = %d, %s)", errno, os::errno_name(errno));
1730       warn_only_once = true;
1731     }
1732   }
1733 }
1734 
1735 void os::signal_init_pd() {
1736   // Initialize signal structures
1737   ::memset((void*)pending_signals, 0, sizeof(pending_signals));
1738 
1739   // Initialize signal semaphore
1740   local_sem_init();
1741 }
1742 
1743 void os::signal_notify(int sig) {
1744   Atomic::inc(&pending_signals[sig]);
1745   local_sem_post();
1746 }
1747 
1748 static int check_pending_signals(bool wait) {
1749   Atomic::store(0, &sigint_count);
1750   for (;;) {
1751     for (int i = 0; i < NSIG + 1; i++) {
1752       jint n = pending_signals[i];
1753       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1754         return i;
1755       }
1756     }
1757     if (!wait) {
1758       return -1;
1759     }
1760     JavaThread *thread = JavaThread::current();
1761     ThreadBlockInVM tbivm(thread);
1762 
1763     bool threadIsSuspended;
1764     do {
1765       thread->set_suspend_equivalent();
1766       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1767 
1768       local_sem_wait();
1769 
1770       // were we externally suspended while we were waiting?
1771       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1772       if (threadIsSuspended) {
1773         //
1774         // The semaphore has been incremented, but while we were waiting
1775         // another thread suspended us. We don't want to continue running
1776         // while suspended because that would surprise the thread that
1777         // suspended us.
1778         //
1779 
1780         local_sem_post();
1781 
1782         thread->java_suspend_self();
1783       }
1784     } while (threadIsSuspended);
1785   }
1786 }
1787 
1788 int os::signal_lookup() {
1789   return check_pending_signals(false);
1790 }
1791 
1792 int os::signal_wait() {
1793   return check_pending_signals(true);
1794 }
1795 
1796 ////////////////////////////////////////////////////////////////////////////////
1797 // Virtual Memory
1798 
1799 // We need to keep small simple bookkeeping for os::reserve_memory and friends.
1800 
1801 #define VMEM_MAPPED  1
1802 #define VMEM_SHMATED 2
1803 
1804 struct vmembk_t {
1805   int type;         // 1 - mmap, 2 - shmat
1806   char* addr;
1807   size_t size;      // Real size, may be larger than usersize.
1808   size_t pagesize;  // page size of area
1809   vmembk_t* next;
1810 
1811   bool contains_addr(char* p) const {
1812     return p >= addr && p < (addr + size);
1813   }
1814 
1815   bool contains_range(char* p, size_t s) const {
1816     return contains_addr(p) && contains_addr(p + s - 1);
1817   }
1818 
1819   void print_on(outputStream* os) const {
1820     os->print("[" PTR_FORMAT " - " PTR_FORMAT "] (" UINTX_FORMAT
1821       " bytes, %d %s pages), %s",
1822       addr, addr + size - 1, size, size / pagesize, describe_pagesize(pagesize),
1823       (type == VMEM_SHMATED ? "shmat" : "mmap")
1824     );
1825   }
1826 
1827   // Check that range is a sub range of memory block (or equal to memory block);
1828   // also check that range is fully page aligned to the page size if the block.
1829   void assert_is_valid_subrange(char* p, size_t s) const {
1830     if (!contains_range(p, s)) {
1831       trcVerbose("[" PTR_FORMAT " - " PTR_FORMAT "] is not a sub "
1832               "range of [" PTR_FORMAT " - " PTR_FORMAT "].",
1833               p, p + s, addr, addr + size);
1834       guarantee0(false);
1835     }
1836     if (!is_aligned_to(p, pagesize) || !is_aligned_to(p + s, pagesize)) {
1837       trcVerbose("range [" PTR_FORMAT " - " PTR_FORMAT "] is not"
1838               " aligned to pagesize (%lu)", p, p + s, (unsigned long) pagesize);
1839       guarantee0(false);
1840     }
1841   }
1842 };
1843 
1844 static struct {
1845   vmembk_t* first;
1846   MiscUtils::CritSect cs;
1847 } vmem;
1848 
1849 static void vmembk_add(char* addr, size_t size, size_t pagesize, int type) {
1850   vmembk_t* p = (vmembk_t*) ::malloc(sizeof(vmembk_t));
1851   assert0(p);
1852   if (p) {
1853     MiscUtils::AutoCritSect lck(&vmem.cs);
1854     p->addr = addr; p->size = size;
1855     p->pagesize = pagesize;
1856     p->type = type;
1857     p->next = vmem.first;
1858     vmem.first = p;
1859   }
1860 }
1861 
1862 static vmembk_t* vmembk_find(char* addr) {
1863   MiscUtils::AutoCritSect lck(&vmem.cs);
1864   for (vmembk_t* p = vmem.first; p; p = p->next) {
1865     if (p->addr <= addr && (p->addr + p->size) > addr) {
1866       return p;
1867     }
1868   }
1869   return NULL;
1870 }
1871 
1872 static void vmembk_remove(vmembk_t* p0) {
1873   MiscUtils::AutoCritSect lck(&vmem.cs);
1874   assert0(p0);
1875   assert0(vmem.first); // List should not be empty.
1876   for (vmembk_t** pp = &(vmem.first); *pp; pp = &((*pp)->next)) {
1877     if (*pp == p0) {
1878       *pp = p0->next;
1879       ::free(p0);
1880       return;
1881     }
1882   }
1883   assert0(false); // Not found?
1884 }
1885 
1886 static void vmembk_print_on(outputStream* os) {
1887   MiscUtils::AutoCritSect lck(&vmem.cs);
1888   for (vmembk_t* vmi = vmem.first; vmi; vmi = vmi->next) {
1889     vmi->print_on(os);
1890     os->cr();
1891   }
1892 }
1893 
1894 // Reserve and attach a section of System V memory.
1895 // If <requested_addr> is not NULL, function will attempt to attach the memory at the given
1896 // address. Failing that, it will attach the memory anywhere.
1897 // If <requested_addr> is NULL, function will attach the memory anywhere.
1898 //
1899 // <alignment_hint> is being ignored by this function. It is very probable however that the
1900 // alignment requirements are met anyway, because shmat() attaches at 256M boundaries.
1901 // Should this be not enogh, we can put more work into it.
1902 static char* reserve_shmated_memory (
1903   size_t bytes,
1904   char* requested_addr,
1905   size_t alignment_hint) {
1906 
1907   trcVerbose("reserve_shmated_memory " UINTX_FORMAT " bytes, wishaddress "
1908     PTR_FORMAT ", alignment_hint " UINTX_FORMAT "...",
1909     bytes, requested_addr, alignment_hint);
1910 
1911   // Either give me wish address or wish alignment but not both.
1912   assert0(!(requested_addr != NULL && alignment_hint != 0));
1913 
1914   // We must prevent anyone from attaching too close to the
1915   // BRK because that may cause malloc OOM.
1916   if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
1917     trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
1918       "Will attach anywhere.", requested_addr);
1919     // Act like the OS refused to attach there.
1920     requested_addr = NULL;
1921   }
1922 
1923   // For old AS/400's (V5R4 and older) we should not even be here - System V shared memory is not
1924   // really supported (max size 4GB), so reserve_mmapped_memory should have been used instead.
1925   if (os::Aix::on_pase_V5R4_or_older()) {
1926     ShouldNotReachHere();
1927   }
1928 
1929   // Align size of shm up to 64K to avoid errors if we later try to change the page size.
1930   const size_t size = align_size_up(bytes, 64*K);
1931 
1932   // Reserve the shared segment.
1933   int shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | S_IRUSR | S_IWUSR);
1934   if (shmid == -1) {
1935     trcVerbose("shmget(.., " UINTX_FORMAT ", ..) failed (errno: %d).", size, errno);
1936     return NULL;
1937   }
1938 
1939   // Important note:
1940   // It is very important that we, upon leaving this function, do not leave a shm segment alive.
1941   // We must right after attaching it remove it from the system. System V shm segments are global and
1942   // survive the process.
1943   // So, from here on: Do not assert, do not return, until we have called shmctl(IPC_RMID) (A).
1944 
1945   struct shmid_ds shmbuf;
1946   memset(&shmbuf, 0, sizeof(shmbuf));
1947   shmbuf.shm_pagesize = 64*K;
1948   if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) != 0) {
1949     trcVerbose("Failed to set page size (need " UINTX_FORMAT " 64K pages) - shmctl failed with %d.",
1950                size / (64*K), errno);
1951     // I want to know if this ever happens.
1952     assert(false, "failed to set page size for shmat");
1953   }
1954 
1955   // Now attach the shared segment.
1956   // Note that I attach with SHM_RND - which means that the requested address is rounded down, if
1957   // needed, to the next lowest segment boundary. Otherwise the attach would fail if the address
1958   // were not a segment boundary.
1959   char* const addr = (char*) shmat(shmid, requested_addr, SHM_RND);
1960   const int errno_shmat = errno;
1961 
1962   // (A) Right after shmat and before handing shmat errors delete the shm segment.
1963   if (::shmctl(shmid, IPC_RMID, NULL) == -1) {
1964     trcVerbose("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);
1965     assert(false, "failed to remove shared memory segment!");
1966   }
1967 
1968   // Handle shmat error. If we failed to attach, just return.
1969   if (addr == (char*)-1) {
1970     trcVerbose("Failed to attach segment at " PTR_FORMAT " (%d).", requested_addr, errno_shmat);
1971     return NULL;
1972   }
1973 
1974   // Just for info: query the real page size. In case setting the page size did not
1975   // work (see above), the system may have given us something other then 4K (LDR_CNTRL).
1976   const size_t real_pagesize = os::Aix::query_pagesize(addr);
1977   if (real_pagesize != shmbuf.shm_pagesize) {
1978     trcVerbose("pagesize is, surprisingly, %h.", real_pagesize);
1979   }
1980 
1981   if (addr) {
1982     trcVerbose("shm-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes, " UINTX_FORMAT " %s pages)",
1983       addr, addr + size - 1, size, size/real_pagesize, describe_pagesize(real_pagesize));
1984   } else {
1985     if (requested_addr != NULL) {
1986       trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at with address " PTR_FORMAT ".", size, requested_addr);
1987     } else {
1988       trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at any address.", size);
1989     }
1990   }
1991 
1992   // book-keeping
1993   vmembk_add(addr, size, real_pagesize, VMEM_SHMATED);
1994   assert0(is_aligned_to(addr, os::vm_page_size()));
1995 
1996   return addr;
1997 }
1998 
1999 static bool release_shmated_memory(char* addr, size_t size) {
2000 
2001   trcVerbose("release_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2002     addr, addr + size - 1);
2003 
2004   bool rc = false;
2005 
2006   // TODO: is there a way to verify shm size without doing bookkeeping?
2007   if (::shmdt(addr) != 0) {
2008     trcVerbose("error (%d).", errno);
2009   } else {
2010     trcVerbose("ok.");
2011     rc = true;
2012   }
2013   return rc;
2014 }
2015 
2016 static bool uncommit_shmated_memory(char* addr, size_t size) {
2017   trcVerbose("uncommit_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2018     addr, addr + size - 1);
2019 
2020   const bool rc = my_disclaim64(addr, size);
2021 
2022   if (!rc) {
2023     trcVerbose("my_disclaim64(" PTR_FORMAT ", " UINTX_FORMAT ") failed.\n", addr, size);
2024     return false;
2025   }
2026   return true;
2027 }
2028 
2029 ////////////////////////////////  mmap-based routines /////////////////////////////////
2030 
2031 // Reserve memory via mmap.
2032 // If <requested_addr> is given, an attempt is made to attach at the given address.
2033 // Failing that, memory is allocated at any address.
2034 // If <alignment_hint> is given and <requested_addr> is NULL, an attempt is made to
2035 // allocate at an address aligned with the given alignment. Failing that, memory
2036 // is aligned anywhere.
2037 static char* reserve_mmaped_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2038   trcVerbose("reserve_mmaped_memory " UINTX_FORMAT " bytes, wishaddress " PTR_FORMAT ", "
2039     "alignment_hint " UINTX_FORMAT "...",
2040     bytes, requested_addr, alignment_hint);
2041 
2042   // If a wish address is given, but not aligned to 4K page boundary, mmap will fail.
2043   if (requested_addr && !is_aligned_to(requested_addr, os::vm_page_size()) != 0) {
2044     trcVerbose("Wish address " PTR_FORMAT " not aligned to page boundary.", requested_addr);
2045     return NULL;
2046   }
2047 
2048   // We must prevent anyone from attaching too close to the
2049   // BRK because that may cause malloc OOM.
2050   if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
2051     trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
2052       "Will attach anywhere.", requested_addr);
2053     // Act like the OS refused to attach there.
2054     requested_addr = NULL;
2055   }
2056 
2057   // Specify one or the other but not both.
2058   assert0(!(requested_addr != NULL && alignment_hint > 0));
2059 
2060   // In 64K mode, we claim the global page size (os::vm_page_size())
2061   // is 64K. This is one of the few points where that illusion may
2062   // break, because mmap() will always return memory aligned to 4K. So
2063   // we must ensure we only ever return memory aligned to 64k.
2064   if (alignment_hint) {
2065     alignment_hint = lcm(alignment_hint, os::vm_page_size());
2066   } else {
2067     alignment_hint = os::vm_page_size();
2068   }
2069 
2070   // Size shall always be a multiple of os::vm_page_size (esp. in 64K mode).
2071   const size_t size = align_size_up(bytes, os::vm_page_size());
2072 
2073   // alignment: Allocate memory large enough to include an aligned range of the right size and
2074   // cut off the leading and trailing waste pages.
2075   assert0(alignment_hint != 0 && is_aligned_to(alignment_hint, os::vm_page_size())); // see above
2076   const size_t extra_size = size + alignment_hint;
2077 
2078   // Note: MAP_SHARED (instead of MAP_PRIVATE) needed to be able to
2079   // later use msync(MS_INVALIDATE) (see os::uncommit_memory).
2080   int flags = MAP_ANONYMOUS | MAP_SHARED;
2081 
2082   // MAP_FIXED is needed to enforce requested_addr - manpage is vague about what
2083   // it means if wishaddress is given but MAP_FIXED is not set.
2084   //
2085   // Important! Behaviour differs depending on whether SPEC1170 mode is active or not.
2086   // SPEC1170 mode active: behaviour like POSIX, MAP_FIXED will clobber existing mappings.
2087   // SPEC1170 mode not active: behaviour, unlike POSIX, is that no existing mappings will
2088   // get clobbered.
2089   if (requested_addr != NULL) {
2090     if (!os::Aix::xpg_sus_mode()) {  // not SPEC1170 Behaviour
2091       flags |= MAP_FIXED;
2092     }
2093   }
2094 
2095   char* addr = (char*)::mmap(requested_addr, extra_size,
2096       PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0);
2097 
2098   if (addr == MAP_FAILED) {
2099     trcVerbose("mmap(" PTR_FORMAT ", " UINTX_FORMAT ", ..) failed (%d)", requested_addr, size, errno);
2100     return NULL;
2101   }
2102 
2103   // Handle alignment.
2104   char* const addr_aligned = (char *)align_ptr_up(addr, alignment_hint);
2105   const size_t waste_pre = addr_aligned - addr;
2106   char* const addr_aligned_end = addr_aligned + size;
2107   const size_t waste_post = extra_size - waste_pre - size;
2108   if (waste_pre > 0) {
2109     ::munmap(addr, waste_pre);
2110   }
2111   if (waste_post > 0) {
2112     ::munmap(addr_aligned_end, waste_post);
2113   }
2114   addr = addr_aligned;
2115 
2116   if (addr) {
2117     trcVerbose("mmap-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes)",
2118       addr, addr + bytes, bytes);
2119   } else {
2120     if (requested_addr != NULL) {
2121       trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at wish address " PTR_FORMAT ".", bytes, requested_addr);
2122     } else {
2123       trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at any address.", bytes);
2124     }
2125   }
2126 
2127   // bookkeeping
2128   vmembk_add(addr, size, 4*K, VMEM_MAPPED);
2129 
2130   // Test alignment, see above.
2131   assert0(is_aligned_to(addr, os::vm_page_size()));
2132 
2133   return addr;
2134 }
2135 
2136 static bool release_mmaped_memory(char* addr, size_t size) {
2137   assert0(is_aligned_to(addr, os::vm_page_size()));
2138   assert0(is_aligned_to(size, os::vm_page_size()));
2139 
2140   trcVerbose("release_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2141     addr, addr + size - 1);
2142   bool rc = false;
2143 
2144   if (::munmap(addr, size) != 0) {
2145     trcVerbose("failed (%d)\n", errno);
2146     rc = false;
2147   } else {
2148     trcVerbose("ok.");
2149     rc = true;
2150   }
2151 
2152   return rc;
2153 }
2154 
2155 static bool uncommit_mmaped_memory(char* addr, size_t size) {
2156 
2157   assert0(is_aligned_to(addr, os::vm_page_size()));
2158   assert0(is_aligned_to(size, os::vm_page_size()));
2159 
2160   trcVerbose("uncommit_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2161     addr, addr + size - 1);
2162   bool rc = false;
2163 
2164   // Uncommit mmap memory with msync MS_INVALIDATE.
2165   if (::msync(addr, size, MS_INVALIDATE) != 0) {
2166     trcVerbose("failed (%d)\n", errno);
2167     rc = false;
2168   } else {
2169     trcVerbose("ok.");
2170     rc = true;
2171   }
2172 
2173   return rc;
2174 }
2175 
2176 int os::vm_page_size() {
2177   // Seems redundant as all get out.
2178   assert(os::Aix::page_size() != -1, "must call os::init");
2179   return os::Aix::page_size();
2180 }
2181 
2182 // Aix allocates memory by pages.
2183 int os::vm_allocation_granularity() {
2184   assert(os::Aix::page_size() != -1, "must call os::init");
2185   return os::Aix::page_size();
2186 }
2187 
2188 #ifdef PRODUCT
2189 static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
2190                                     int err) {
2191   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2192           ", %d) failed; error='%s' (errno=%d)", addr, size, exec,
2193           os::errno_name(err), err);
2194 }
2195 #endif
2196 
2197 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
2198                                   const char* mesg) {
2199   assert(mesg != NULL, "mesg must be specified");
2200   if (!pd_commit_memory(addr, size, exec)) {
2201     // Add extra info in product mode for vm_exit_out_of_memory():
2202     PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
2203     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
2204   }
2205 }
2206 
2207 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
2208 
2209   assert(is_aligned_to(addr, os::vm_page_size()),
2210     "addr " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")",
2211     p2i(addr), os::vm_page_size());
2212   assert(is_aligned_to(size, os::vm_page_size()),
2213     "size " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")",
2214     size, os::vm_page_size());
2215 
2216   vmembk_t* const vmi = vmembk_find(addr);
2217   guarantee0(vmi);
2218   vmi->assert_is_valid_subrange(addr, size);
2219 
2220   trcVerbose("commit_memory [" PTR_FORMAT " - " PTR_FORMAT "].", addr, addr + size - 1);
2221 
2222   if (UseExplicitCommit) {
2223     // AIX commits memory on touch. So, touch all pages to be committed.
2224     for (char* p = addr; p < (addr + size); p += 4*K) {
2225       *p = '\0';
2226     }
2227   }
2228 
2229   return true;
2230 }
2231 
2232 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) {
2233   return pd_commit_memory(addr, size, exec);
2234 }
2235 
2236 void os::pd_commit_memory_or_exit(char* addr, size_t size,
2237                                   size_t alignment_hint, bool exec,
2238                                   const char* mesg) {
2239   // Alignment_hint is ignored on this OS.
2240   pd_commit_memory_or_exit(addr, size, exec, mesg);
2241 }
2242 
2243 bool os::pd_uncommit_memory(char* addr, size_t size) {
2244   assert(is_aligned_to(addr, os::vm_page_size()),
2245     "addr " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")",
2246     p2i(addr), os::vm_page_size());
2247   assert(is_aligned_to(size, os::vm_page_size()),
2248     "size " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")",
2249     size, os::vm_page_size());
2250 
2251   // Dynamically do different things for mmap/shmat.
2252   const vmembk_t* const vmi = vmembk_find(addr);
2253   guarantee0(vmi);
2254   vmi->assert_is_valid_subrange(addr, size);
2255 
2256   if (vmi->type == VMEM_SHMATED) {
2257     return uncommit_shmated_memory(addr, size);
2258   } else {
2259     return uncommit_mmaped_memory(addr, size);
2260   }
2261 }
2262 
2263 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
2264   // Do not call this; no need to commit stack pages on AIX.
2265   ShouldNotReachHere();
2266   return true;
2267 }
2268 
2269 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2270   // Do not call this; no need to commit stack pages on AIX.
2271   ShouldNotReachHere();
2272   return true;
2273 }
2274 
2275 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2276 }
2277 
2278 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
2279 }
2280 
2281 void os::numa_make_global(char *addr, size_t bytes) {
2282 }
2283 
2284 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2285 }
2286 
2287 bool os::numa_topology_changed() {
2288   return false;
2289 }
2290 
2291 size_t os::numa_get_groups_num() {
2292   return 1;
2293 }
2294 
2295 int os::numa_get_group_id() {
2296   return 0;
2297 }
2298 
2299 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2300   if (size > 0) {
2301     ids[0] = 0;
2302     return 1;
2303   }
2304   return 0;
2305 }
2306 
2307 bool os::get_page_info(char *start, page_info* info) {
2308   return false;
2309 }
2310 
2311 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2312   return end;
2313 }
2314 
2315 // Reserves and attaches a shared memory segment.
2316 // Will assert if a wish address is given and could not be obtained.
2317 char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2318 
2319   // All other Unices do a mmap(MAP_FIXED) if the addr is given,
2320   // thereby clobbering old mappings at that place. That is probably
2321   // not intended, never used and almost certainly an error were it
2322   // ever be used this way (to try attaching at a specified address
2323   // without clobbering old mappings an alternate API exists,
2324   // os::attempt_reserve_memory_at()).
2325   // Instead of mimicking the dangerous coding of the other platforms, here I
2326   // just ignore the request address (release) or assert(debug).
2327   assert0(requested_addr == NULL);
2328 
2329   // Always round to os::vm_page_size(), which may be larger than 4K.
2330   bytes = align_size_up(bytes, os::vm_page_size());
2331   const size_t alignment_hint0 =
2332     alignment_hint ? align_size_up(alignment_hint, os::vm_page_size()) : 0;
2333 
2334   // In 4K mode always use mmap.
2335   // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted.
2336   if (os::vm_page_size() == 4*K) {
2337     return reserve_mmaped_memory(bytes, requested_addr, alignment_hint);
2338   } else {
2339     if (bytes >= Use64KPagesThreshold) {
2340       return reserve_shmated_memory(bytes, requested_addr, alignment_hint);
2341     } else {
2342       return reserve_mmaped_memory(bytes, requested_addr, alignment_hint);
2343     }
2344   }
2345 }
2346 
2347 bool os::pd_release_memory(char* addr, size_t size) {
2348 
2349   // Dynamically do different things for mmap/shmat.
2350   vmembk_t* const vmi = vmembk_find(addr);
2351   guarantee0(vmi);
2352 
2353   // Always round to os::vm_page_size(), which may be larger than 4K.
2354   size = align_size_up(size, os::vm_page_size());
2355   addr = (char *)align_ptr_up(addr, os::vm_page_size());
2356 
2357   bool rc = false;
2358   bool remove_bookkeeping = false;
2359   if (vmi->type == VMEM_SHMATED) {
2360     // For shmatted memory, we do:
2361     // - If user wants to release the whole range, release the memory (shmdt).
2362     // - If user only wants to release a partial range, uncommit (disclaim) that
2363     //   range. That way, at least, we do not use memory anymore (bust still page
2364     //   table space).
2365     vmi->assert_is_valid_subrange(addr, size);
2366     if (addr == vmi->addr && size == vmi->size) {
2367       rc = release_shmated_memory(addr, size);
2368       remove_bookkeeping = true;
2369     } else {
2370       rc = uncommit_shmated_memory(addr, size);
2371     }
2372   } else {
2373     // User may unmap partial regions but region has to be fully contained.
2374 #ifdef ASSERT
2375     vmi->assert_is_valid_subrange(addr, size);
2376 #endif
2377     rc = release_mmaped_memory(addr, size);
2378     remove_bookkeeping = true;
2379   }
2380 
2381   // update bookkeeping
2382   if (rc && remove_bookkeeping) {
2383     vmembk_remove(vmi);
2384   }
2385 
2386   return rc;
2387 }
2388 
2389 static bool checked_mprotect(char* addr, size_t size, int prot) {
2390 
2391   // Little problem here: if SPEC1170 behaviour is off, mprotect() on AIX will
2392   // not tell me if protection failed when trying to protect an un-protectable range.
2393   //
2394   // This means if the memory was allocated using shmget/shmat, protection wont work
2395   // but mprotect will still return 0:
2396   //
2397   // See http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/mprotect.htm
2398 
2399   bool rc = ::mprotect(addr, size, prot) == 0 ? true : false;
2400 
2401   if (!rc) {
2402     const char* const s_errno = os::errno_name(errno);
2403     warning("mprotect(" PTR_FORMAT "-" PTR_FORMAT ", 0x%X) failed (%s).", addr, addr + size, prot, s_errno);
2404     return false;
2405   }
2406 
2407   // mprotect success check
2408   //
2409   // Mprotect said it changed the protection but can I believe it?
2410   //
2411   // To be sure I need to check the protection afterwards. Try to
2412   // read from protected memory and check whether that causes a segfault.
2413   //
2414   if (!os::Aix::xpg_sus_mode()) {
2415 
2416     if (CanUseSafeFetch32()) {
2417 
2418       const bool read_protected =
2419         (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&
2420          SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;
2421 
2422       if (prot & PROT_READ) {
2423         rc = !read_protected;
2424       } else {
2425         rc = read_protected;
2426       }
2427 
2428       if (!rc) {
2429         if (os::Aix::on_pase()) {
2430           // There is an issue on older PASE systems where mprotect() will return success but the
2431           // memory will not be protected.
2432           // This has nothing to do with the problem of using mproect() on SPEC1170 incompatible
2433           // machines; we only see it rarely, when using mprotect() to protect the guard page of
2434           // a stack. It is an OS error.
2435           //
2436           // A valid strategy is just to try again. This usually works. :-/
2437 
2438           ::usleep(1000);
2439           if (::mprotect(addr, size, prot) == 0) {
2440             const bool read_protected_2 =
2441               (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&
2442               SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;
2443             rc = true;
2444           }
2445         }
2446       }
2447     }
2448   }
2449 
2450   assert(rc == true, "mprotect failed.");
2451 
2452   return rc;
2453 }
2454 
2455 // Set protections specified
2456 bool os::protect_memory(char* addr, size_t size, ProtType prot, bool is_committed) {
2457   unsigned int p = 0;
2458   switch (prot) {
2459   case MEM_PROT_NONE: p = PROT_NONE; break;
2460   case MEM_PROT_READ: p = PROT_READ; break;
2461   case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;
2462   case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
2463   default:
2464     ShouldNotReachHere();
2465   }
2466   // is_committed is unused.
2467   return checked_mprotect(addr, size, p);
2468 }
2469 
2470 bool os::guard_memory(char* addr, size_t size) {
2471   return checked_mprotect(addr, size, PROT_NONE);
2472 }
2473 
2474 bool os::unguard_memory(char* addr, size_t size) {
2475   return checked_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC);
2476 }
2477 
2478 // Large page support
2479 
2480 static size_t _large_page_size = 0;
2481 
2482 // Enable large page support if OS allows that.
2483 void os::large_page_init() {
2484   return; // Nothing to do. See query_multipage_support and friends.
2485 }
2486 
2487 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
2488   // reserve_memory_special() is used to allocate large paged memory. On AIX, we implement
2489   // 64k paged memory reservation using the normal memory allocation paths (os::reserve_memory()),
2490   // so this is not needed.
2491   assert(false, "should not be called on AIX");
2492   return NULL;
2493 }
2494 
2495 bool os::release_memory_special(char* base, size_t bytes) {
2496   // Detaching the SHM segment will also delete it, see reserve_memory_special().
2497   Unimplemented();
2498   return false;
2499 }
2500 
2501 size_t os::large_page_size() {
2502   return _large_page_size;
2503 }
2504 
2505 bool os::can_commit_large_page_memory() {
2506   // Does not matter, we do not support huge pages.
2507   return false;
2508 }
2509 
2510 bool os::can_execute_large_page_memory() {
2511   // Does not matter, we do not support huge pages.
2512   return false;
2513 }
2514 
2515 // Reserve memory at an arbitrary address, only if that area is
2516 // available (and not reserved for something else).
2517 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2518   char* addr = NULL;
2519 
2520   // Always round to os::vm_page_size(), which may be larger than 4K.
2521   bytes = align_size_up(bytes, os::vm_page_size());
2522 
2523   // In 4K mode always use mmap.
2524   // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted.
2525   if (os::vm_page_size() == 4*K) {
2526     return reserve_mmaped_memory(bytes, requested_addr, 0);
2527   } else {
2528     if (bytes >= Use64KPagesThreshold) {
2529       return reserve_shmated_memory(bytes, requested_addr, 0);
2530     } else {
2531       return reserve_mmaped_memory(bytes, requested_addr, 0);
2532     }
2533   }
2534 
2535   return addr;
2536 }
2537 
2538 size_t os::read(int fd, void *buf, unsigned int nBytes) {
2539   return ::read(fd, buf, nBytes);
2540 }
2541 
2542 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
2543   return ::pread(fd, buf, nBytes, offset);
2544 }
2545 
2546 void os::naked_short_sleep(jlong ms) {
2547   struct timespec req;
2548 
2549   assert(ms < 1000, "Un-interruptable sleep, short time use only");
2550   req.tv_sec = 0;
2551   if (ms > 0) {
2552     req.tv_nsec = (ms % 1000) * 1000000;
2553   }
2554   else {
2555     req.tv_nsec = 1;
2556   }
2557 
2558   nanosleep(&req, NULL);
2559 
2560   return;
2561 }
2562 
2563 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
2564 void os::infinite_sleep() {
2565   while (true) {    // sleep forever ...
2566     ::sleep(100);   // ... 100 seconds at a time
2567   }
2568 }
2569 
2570 // Used to convert frequent JVM_Yield() to nops
2571 bool os::dont_yield() {
2572   return DontYieldALot;
2573 }
2574 
2575 void os::naked_yield() {
2576   sched_yield();
2577 }
2578 
2579 ////////////////////////////////////////////////////////////////////////////////
2580 // thread priority support
2581 
2582 // From AIX manpage to pthread_setschedparam
2583 // (see: http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?
2584 //    topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_setschedparam.htm):
2585 //
2586 // "If schedpolicy is SCHED_OTHER, then sched_priority must be in the
2587 // range from 40 to 80, where 40 is the least favored priority and 80
2588 // is the most favored."
2589 //
2590 // (Actually, I doubt this even has an impact on AIX, as we do kernel
2591 // scheduling there; however, this still leaves iSeries.)
2592 //
2593 // We use the same values for AIX and PASE.
2594 int os::java_to_os_priority[CriticalPriority + 1] = {
2595   54,             // 0 Entry should never be used
2596 
2597   55,             // 1 MinPriority
2598   55,             // 2
2599   56,             // 3
2600 
2601   56,             // 4
2602   57,             // 5 NormPriority
2603   57,             // 6
2604 
2605   58,             // 7
2606   58,             // 8
2607   59,             // 9 NearMaxPriority
2608 
2609   60,             // 10 MaxPriority
2610 
2611   60              // 11 CriticalPriority
2612 };
2613 
2614 OSReturn os::set_native_priority(Thread* thread, int newpri) {
2615   if (!UseThreadPriorities) return OS_OK;
2616   pthread_t thr = thread->osthread()->pthread_id();
2617   int policy = SCHED_OTHER;
2618   struct sched_param param;
2619   param.sched_priority = newpri;
2620   int ret = pthread_setschedparam(thr, policy, &param);
2621 
2622   if (ret != 0) {
2623     trcVerbose("Could not change priority for thread %d to %d (error %d, %s)",
2624         (int)thr, newpri, ret, os::errno_name(ret));
2625   }
2626   return (ret == 0) ? OS_OK : OS_ERR;
2627 }
2628 
2629 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
2630   if (!UseThreadPriorities) {
2631     *priority_ptr = java_to_os_priority[NormPriority];
2632     return OS_OK;
2633   }
2634   pthread_t thr = thread->osthread()->pthread_id();
2635   int policy = SCHED_OTHER;
2636   struct sched_param param;
2637   int ret = pthread_getschedparam(thr, &policy, &param);
2638   *priority_ptr = param.sched_priority;
2639 
2640   return (ret == 0) ? OS_OK : OS_ERR;
2641 }
2642 
2643 // Hint to the underlying OS that a task switch would not be good.
2644 // Void return because it's a hint and can fail.
2645 void os::hint_no_preempt() {}
2646 
2647 ////////////////////////////////////////////////////////////////////////////////
2648 // suspend/resume support
2649 
2650 //  the low-level signal-based suspend/resume support is a remnant from the
2651 //  old VM-suspension that used to be for java-suspension, safepoints etc,
2652 //  within hotspot. Now there is a single use-case for this:
2653 //    - calling get_thread_pc() on the VMThread by the flat-profiler task
2654 //      that runs in the watcher thread.
2655 //  The remaining code is greatly simplified from the more general suspension
2656 //  code that used to be used.
2657 //
2658 //  The protocol is quite simple:
2659 //  - suspend:
2660 //      - sends a signal to the target thread
2661 //      - polls the suspend state of the osthread using a yield loop
2662 //      - target thread signal handler (SR_handler) sets suspend state
2663 //        and blocks in sigsuspend until continued
2664 //  - resume:
2665 //      - sets target osthread state to continue
2666 //      - sends signal to end the sigsuspend loop in the SR_handler
2667 //
2668 //  Note that the SR_lock plays no role in this suspend/resume protocol,
2669 //  but is checked for NULL in SR_handler as a thread termination indicator.
2670 //
2671 
2672 static void resume_clear_context(OSThread *osthread) {
2673   osthread->set_ucontext(NULL);
2674   osthread->set_siginfo(NULL);
2675 }
2676 
2677 static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
2678   osthread->set_ucontext(context);
2679   osthread->set_siginfo(siginfo);
2680 }
2681 
2682 //
2683 // Handler function invoked when a thread's execution is suspended or
2684 // resumed. We have to be careful that only async-safe functions are
2685 // called here (Note: most pthread functions are not async safe and
2686 // should be avoided.)
2687 //
2688 // Note: sigwait() is a more natural fit than sigsuspend() from an
2689 // interface point of view, but sigwait() prevents the signal hander
2690 // from being run. libpthread would get very confused by not having
2691 // its signal handlers run and prevents sigwait()'s use with the
2692 // mutex granting granting signal.
2693 //
2694 // Currently only ever called on the VMThread and JavaThreads (PC sampling).
2695 //
2696 static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) {
2697   // Save and restore errno to avoid confusing native code with EINTR
2698   // after sigsuspend.
2699   int old_errno = errno;
2700 
2701   Thread* thread = Thread::current_or_null_safe();
2702   assert(thread != NULL, "Missing current thread in SR_handler");
2703 
2704   // On some systems we have seen signal delivery get "stuck" until the signal
2705   // mask is changed as part of thread termination. Check that the current thread
2706   // has not already terminated (via SR_lock()) - else the following assertion
2707   // will fail because the thread is no longer a JavaThread as the ~JavaThread
2708   // destructor has completed.
2709 
2710   if (thread->SR_lock() == NULL) {
2711     return;
2712   }
2713 
2714   assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread");
2715 
2716   OSThread* osthread = thread->osthread();
2717 
2718   os::SuspendResume::State current = osthread->sr.state();
2719   if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
2720     suspend_save_context(osthread, siginfo, context);
2721 
2722     // attempt to switch the state, we assume we had a SUSPEND_REQUEST
2723     os::SuspendResume::State state = osthread->sr.suspended();
2724     if (state == os::SuspendResume::SR_SUSPENDED) {
2725       sigset_t suspend_set;  // signals for sigsuspend()
2726 
2727       // get current set of blocked signals and unblock resume signal
2728       pthread_sigmask(SIG_BLOCK, NULL, &suspend_set);
2729       sigdelset(&suspend_set, SR_signum);
2730 
2731       // wait here until we are resumed
2732       while (1) {
2733         sigsuspend(&suspend_set);
2734 
2735         os::SuspendResume::State result = osthread->sr.running();
2736         if (result == os::SuspendResume::SR_RUNNING) {
2737           break;
2738         }
2739       }
2740 
2741     } else if (state == os::SuspendResume::SR_RUNNING) {
2742       // request was cancelled, continue
2743     } else {
2744       ShouldNotReachHere();
2745     }
2746 
2747     resume_clear_context(osthread);
2748   } else if (current == os::SuspendResume::SR_RUNNING) {
2749     // request was cancelled, continue
2750   } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
2751     // ignore
2752   } else {
2753     ShouldNotReachHere();
2754   }
2755 
2756   errno = old_errno;
2757 }
2758 
2759 static int SR_initialize() {
2760   struct sigaction act;
2761   char *s;
2762   // Get signal number to use for suspend/resume
2763   if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
2764     int sig = ::strtol(s, 0, 10);
2765     if (sig > MAX2(SIGSEGV, SIGBUS) &&  // See 4355769.
2766         sig < NSIG) {                   // Must be legal signal and fit into sigflags[].
2767       SR_signum = sig;
2768     } else {
2769       warning("You set _JAVA_SR_SIGNUM=%d. It must be in range [%d, %d]. Using %d instead.",
2770               sig, MAX2(SIGSEGV, SIGBUS)+1, NSIG-1, SR_signum);
2771     }
2772   }
2773 
2774   assert(SR_signum > SIGSEGV && SR_signum > SIGBUS,
2775         "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
2776 
2777   sigemptyset(&SR_sigset);
2778   sigaddset(&SR_sigset, SR_signum);
2779 
2780   // Set up signal handler for suspend/resume.
2781   act.sa_flags = SA_RESTART|SA_SIGINFO;
2782   act.sa_handler = (void (*)(int)) SR_handler;
2783 
2784   // SR_signum is blocked by default.
2785   pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask);
2786 
2787   if (sigaction(SR_signum, &act, 0) == -1) {
2788     return -1;
2789   }
2790 
2791   // Save signal flag
2792   os::Aix::set_our_sigflags(SR_signum, act.sa_flags);
2793   return 0;
2794 }
2795 
2796 static int SR_finalize() {
2797   return 0;
2798 }
2799 
2800 static int sr_notify(OSThread* osthread) {
2801   int status = pthread_kill(osthread->pthread_id(), SR_signum);
2802   assert_status(status == 0, status, "pthread_kill");
2803   return status;
2804 }
2805 
2806 // "Randomly" selected value for how long we want to spin
2807 // before bailing out on suspending a thread, also how often
2808 // we send a signal to a thread we want to resume
2809 static const int RANDOMLY_LARGE_INTEGER = 1000000;
2810 static const int RANDOMLY_LARGE_INTEGER2 = 100;
2811 
2812 // returns true on success and false on error - really an error is fatal
2813 // but this seems the normal response to library errors
2814 static bool do_suspend(OSThread* osthread) {
2815   assert(osthread->sr.is_running(), "thread should be running");
2816   // mark as suspended and send signal
2817 
2818   if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
2819     // failed to switch, state wasn't running?
2820     ShouldNotReachHere();
2821     return false;
2822   }
2823 
2824   if (sr_notify(osthread) != 0) {
2825     // try to cancel, switch to running
2826 
2827     os::SuspendResume::State result = osthread->sr.cancel_suspend();
2828     if (result == os::SuspendResume::SR_RUNNING) {
2829       // cancelled
2830       return false;
2831     } else if (result == os::SuspendResume::SR_SUSPENDED) {
2832       // somehow managed to suspend
2833       return true;
2834     } else {
2835       ShouldNotReachHere();
2836       return false;
2837     }
2838   }
2839 
2840   // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED
2841 
2842   for (int n = 0; !osthread->sr.is_suspended(); n++) {
2843     for (int i = 0; i < RANDOMLY_LARGE_INTEGER2 && !osthread->sr.is_suspended(); i++) {
2844       os::naked_yield();
2845     }
2846 
2847     // timeout, try to cancel the request
2848     if (n >= RANDOMLY_LARGE_INTEGER) {
2849       os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
2850       if (cancelled == os::SuspendResume::SR_RUNNING) {
2851         return false;
2852       } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
2853         return true;
2854       } else {
2855         ShouldNotReachHere();
2856         return false;
2857       }
2858     }
2859   }
2860 
2861   guarantee(osthread->sr.is_suspended(), "Must be suspended");
2862   return true;
2863 }
2864 
2865 static void do_resume(OSThread* osthread) {
2866   //assert(osthread->sr.is_suspended(), "thread should be suspended");
2867 
2868   if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
2869     // failed to switch to WAKEUP_REQUEST
2870     ShouldNotReachHere();
2871     return;
2872   }
2873 
2874   while (!osthread->sr.is_running()) {
2875     if (sr_notify(osthread) == 0) {
2876       for (int n = 0; n < RANDOMLY_LARGE_INTEGER && !osthread->sr.is_running(); n++) {
2877         for (int i = 0; i < 100 && !osthread->sr.is_running(); i++) {
2878           os::naked_yield();
2879         }
2880       }
2881     } else {
2882       ShouldNotReachHere();
2883     }
2884   }
2885 
2886   guarantee(osthread->sr.is_running(), "Must be running!");
2887 }
2888 
2889 ///////////////////////////////////////////////////////////////////////////////////
2890 // signal handling (except suspend/resume)
2891 
2892 // This routine may be used by user applications as a "hook" to catch signals.
2893 // The user-defined signal handler must pass unrecognized signals to this
2894 // routine, and if it returns true (non-zero), then the signal handler must
2895 // return immediately. If the flag "abort_if_unrecognized" is true, then this
2896 // routine will never retun false (zero), but instead will execute a VM panic
2897 // routine kill the process.
2898 //
2899 // If this routine returns false, it is OK to call it again. This allows
2900 // the user-defined signal handler to perform checks either before or after
2901 // the VM performs its own checks. Naturally, the user code would be making
2902 // a serious error if it tried to handle an exception (such as a null check
2903 // or breakpoint) that the VM was generating for its own correct operation.
2904 //
2905 // This routine may recognize any of the following kinds of signals:
2906 //   SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1.
2907 // It should be consulted by handlers for any of those signals.
2908 //
2909 // The caller of this routine must pass in the three arguments supplied
2910 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
2911 // field of the structure passed to sigaction(). This routine assumes that
2912 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
2913 //
2914 // Note that the VM will print warnings if it detects conflicting signal
2915 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
2916 //
2917 extern "C" JNIEXPORT int
2918 JVM_handle_aix_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized);
2919 
2920 // Set thread signal mask (for some reason on AIX sigthreadmask() seems
2921 // to be the thing to call; documentation is not terribly clear about whether
2922 // pthread_sigmask also works, and if it does, whether it does the same.
2923 bool set_thread_signal_mask(int how, const sigset_t* set, sigset_t* oset) {
2924   const int rc = ::pthread_sigmask(how, set, oset);
2925   // return value semantics differ slightly for error case:
2926   // pthread_sigmask returns error number, sigthreadmask -1 and sets global errno
2927   // (so, pthread_sigmask is more theadsafe for error handling)
2928   // But success is always 0.
2929   return rc == 0 ? true : false;
2930 }
2931 
2932 // Function to unblock all signals which are, according
2933 // to POSIX, typical program error signals. If they happen while being blocked,
2934 // they typically will bring down the process immediately.
2935 bool unblock_program_error_signals() {
2936   sigset_t set;
2937   ::sigemptyset(&set);
2938   ::sigaddset(&set, SIGILL);
2939   ::sigaddset(&set, SIGBUS);
2940   ::sigaddset(&set, SIGFPE);
2941   ::sigaddset(&set, SIGSEGV);
2942   return set_thread_signal_mask(SIG_UNBLOCK, &set, NULL);
2943 }
2944 
2945 // Renamed from 'signalHandler' to avoid collision with other shared libs.
2946 void javaSignalHandler(int sig, siginfo_t* info, void* uc) {
2947   assert(info != NULL && uc != NULL, "it must be old kernel");
2948 
2949   // Never leave program error signals blocked;
2950   // on all our platforms they would bring down the process immediately when
2951   // getting raised while being blocked.
2952   unblock_program_error_signals();
2953 
2954   int orig_errno = errno;  // Preserve errno value over signal handler.
2955   JVM_handle_aix_signal(sig, info, uc, true);
2956   errno = orig_errno;
2957 }
2958 
2959 // This boolean allows users to forward their own non-matching signals
2960 // to JVM_handle_aix_signal, harmlessly.
2961 bool os::Aix::signal_handlers_are_installed = false;
2962 
2963 // For signal-chaining
2964 struct sigaction sigact[NSIG];
2965 sigset_t sigs;
2966 bool os::Aix::libjsig_is_loaded = false;
2967 typedef struct sigaction *(*get_signal_t)(int);
2968 get_signal_t os::Aix::get_signal_action = NULL;
2969 
2970 struct sigaction* os::Aix::get_chained_signal_action(int sig) {
2971   struct sigaction *actp = NULL;
2972 
2973   if (libjsig_is_loaded) {
2974     // Retrieve the old signal handler from libjsig
2975     actp = (*get_signal_action)(sig);
2976   }
2977   if (actp == NULL) {
2978     // Retrieve the preinstalled signal handler from jvm
2979     actp = get_preinstalled_handler(sig);
2980   }
2981 
2982   return actp;
2983 }
2984 
2985 static bool call_chained_handler(struct sigaction *actp, int sig,
2986                                  siginfo_t *siginfo, void *context) {
2987   // Call the old signal handler
2988   if (actp->sa_handler == SIG_DFL) {
2989     // It's more reasonable to let jvm treat it as an unexpected exception
2990     // instead of taking the default action.
2991     return false;
2992   } else if (actp->sa_handler != SIG_IGN) {
2993     if ((actp->sa_flags & SA_NODEFER) == 0) {
2994       // automaticlly block the signal
2995       sigaddset(&(actp->sa_mask), sig);
2996     }
2997 
2998     sa_handler_t hand = NULL;
2999     sa_sigaction_t sa = NULL;
3000     bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
3001     // retrieve the chained handler
3002     if (siginfo_flag_set) {
3003       sa = actp->sa_sigaction;
3004     } else {
3005       hand = actp->sa_handler;
3006     }
3007 
3008     if ((actp->sa_flags & SA_RESETHAND) != 0) {
3009       actp->sa_handler = SIG_DFL;
3010     }
3011 
3012     // try to honor the signal mask
3013     sigset_t oset;
3014     pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset);
3015 
3016     // call into the chained handler
3017     if (siginfo_flag_set) {
3018       (*sa)(sig, siginfo, context);
3019     } else {
3020       (*hand)(sig);
3021     }
3022 
3023     // restore the signal mask
3024     pthread_sigmask(SIG_SETMASK, &oset, 0);
3025   }
3026   // Tell jvm's signal handler the signal is taken care of.
3027   return true;
3028 }
3029 
3030 bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) {
3031   bool chained = false;
3032   // signal-chaining
3033   if (UseSignalChaining) {
3034     struct sigaction *actp = get_chained_signal_action(sig);
3035     if (actp != NULL) {
3036       chained = call_chained_handler(actp, sig, siginfo, context);
3037     }
3038   }
3039   return chained;
3040 }
3041 
3042 struct sigaction* os::Aix::get_preinstalled_handler(int sig) {
3043   if (sigismember(&sigs, sig)) {
3044     return &sigact[sig];
3045   }
3046   return NULL;
3047 }
3048 
3049 void os::Aix::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
3050   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3051   sigact[sig] = oldAct;
3052   sigaddset(&sigs, sig);
3053 }
3054 
3055 // for diagnostic
3056 int sigflags[NSIG];
3057 
3058 int os::Aix::get_our_sigflags(int sig) {
3059   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3060   return sigflags[sig];
3061 }
3062 
3063 void os::Aix::set_our_sigflags(int sig, int flags) {
3064   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3065   if (sig > 0 && sig < NSIG) {
3066     sigflags[sig] = flags;
3067   }
3068 }
3069 
3070 void os::Aix::set_signal_handler(int sig, bool set_installed) {
3071   // Check for overwrite.
3072   struct sigaction oldAct;
3073   sigaction(sig, (struct sigaction*)NULL, &oldAct);
3074 
3075   void* oldhand = oldAct.sa_sigaction
3076     ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3077     : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3078   if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
3079       oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
3080       oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) {
3081     if (AllowUserSignalHandlers || !set_installed) {
3082       // Do not overwrite; user takes responsibility to forward to us.
3083       return;
3084     } else if (UseSignalChaining) {
3085       // save the old handler in jvm
3086       save_preinstalled_handler(sig, oldAct);
3087       // libjsig also interposes the sigaction() call below and saves the
3088       // old sigaction on it own.
3089     } else {
3090       fatal("Encountered unexpected pre-existing sigaction handler "
3091             "%#lx for signal %d.", (long)oldhand, sig);
3092     }
3093   }
3094 
3095   struct sigaction sigAct;
3096   sigfillset(&(sigAct.sa_mask));
3097   if (!set_installed) {
3098     sigAct.sa_handler = SIG_DFL;
3099     sigAct.sa_flags = SA_RESTART;
3100   } else {
3101     sigAct.sa_sigaction = javaSignalHandler;
3102     sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
3103   }
3104   // Save flags, which are set by ours
3105   assert(sig > 0 && sig < NSIG, "vm signal out of expected range");
3106   sigflags[sig] = sigAct.sa_flags;
3107 
3108   int ret = sigaction(sig, &sigAct, &oldAct);
3109   assert(ret == 0, "check");
3110 
3111   void* oldhand2 = oldAct.sa_sigaction
3112                  ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3113                  : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3114   assert(oldhand2 == oldhand, "no concurrent signal handler installation");
3115 }
3116 
3117 // install signal handlers for signals that HotSpot needs to
3118 // handle in order to support Java-level exception handling.
3119 void os::Aix::install_signal_handlers() {
3120   if (!signal_handlers_are_installed) {
3121     signal_handlers_are_installed = true;
3122 
3123     // signal-chaining
3124     typedef void (*signal_setting_t)();
3125     signal_setting_t begin_signal_setting = NULL;
3126     signal_setting_t end_signal_setting = NULL;
3127     begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3128                              dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
3129     if (begin_signal_setting != NULL) {
3130       end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3131                              dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
3132       get_signal_action = CAST_TO_FN_PTR(get_signal_t,
3133                             dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
3134       libjsig_is_loaded = true;
3135       assert(UseSignalChaining, "should enable signal-chaining");
3136     }
3137     if (libjsig_is_loaded) {
3138       // Tell libjsig jvm is setting signal handlers.
3139       (*begin_signal_setting)();
3140     }
3141 
3142     ::sigemptyset(&sigs);
3143     set_signal_handler(SIGSEGV, true);
3144     set_signal_handler(SIGPIPE, true);
3145     set_signal_handler(SIGBUS, true);
3146     set_signal_handler(SIGILL, true);
3147     set_signal_handler(SIGFPE, true);
3148     set_signal_handler(SIGTRAP, true);
3149     set_signal_handler(SIGXFSZ, true);
3150     set_signal_handler(SIGDANGER, true);
3151 
3152     if (libjsig_is_loaded) {
3153       // Tell libjsig jvm finishes setting signal handlers.
3154       (*end_signal_setting)();
3155     }
3156 
3157     // We don't activate signal checker if libjsig is in place, we trust ourselves
3158     // and if UserSignalHandler is installed all bets are off.
3159     // Log that signal checking is off only if -verbose:jni is specified.
3160     if (CheckJNICalls) {
3161       if (libjsig_is_loaded) {
3162         tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
3163         check_signals = false;
3164       }
3165       if (AllowUserSignalHandlers) {
3166         tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
3167         check_signals = false;
3168       }
3169       // Need to initialize check_signal_done.
3170       ::sigemptyset(&check_signal_done);
3171     }
3172   }
3173 }
3174 
3175 static const char* get_signal_handler_name(address handler,
3176                                            char* buf, int buflen) {
3177   int offset;
3178   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
3179   if (found) {
3180     // skip directory names
3181     const char *p1, *p2;
3182     p1 = buf;
3183     size_t len = strlen(os::file_separator());
3184     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
3185     // The way os::dll_address_to_library_name is implemented on Aix
3186     // right now, it always returns -1 for the offset which is not
3187     // terribly informative.
3188     // Will fix that. For now, omit the offset.
3189     jio_snprintf(buf, buflen, "%s", p1);
3190   } else {
3191     jio_snprintf(buf, buflen, PTR_FORMAT, handler);
3192   }
3193   return buf;
3194 }
3195 
3196 static void print_signal_handler(outputStream* st, int sig,
3197                                  char* buf, size_t buflen) {
3198   struct sigaction sa;
3199   sigaction(sig, NULL, &sa);
3200 
3201   st->print("%s: ", os::exception_name(sig, buf, buflen));
3202 
3203   address handler = (sa.sa_flags & SA_SIGINFO)
3204     ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
3205     : CAST_FROM_FN_PTR(address, sa.sa_handler);
3206 
3207   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
3208     st->print("SIG_DFL");
3209   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
3210     st->print("SIG_IGN");
3211   } else {
3212     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
3213   }
3214 
3215   // Print readable mask.
3216   st->print(", sa_mask[0]=");
3217   os::Posix::print_signal_set_short(st, &sa.sa_mask);
3218 
3219   address rh = VMError::get_resetted_sighandler(sig);
3220   // May be, handler was resetted by VMError?
3221   if (rh != NULL) {
3222     handler = rh;
3223     sa.sa_flags = VMError::get_resetted_sigflags(sig);
3224   }
3225 
3226   // Print textual representation of sa_flags.
3227   st->print(", sa_flags=");
3228   os::Posix::print_sa_flags(st, sa.sa_flags);
3229 
3230   // Check: is it our handler?
3231   if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler) ||
3232       handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
3233     // It is our signal handler.
3234     // Check for flags, reset system-used one!
3235     if ((int)sa.sa_flags != os::Aix::get_our_sigflags(sig)) {
3236       st->print(", flags was changed from " PTR32_FORMAT ", consider using jsig library",
3237                 os::Aix::get_our_sigflags(sig));
3238     }
3239   }
3240   st->cr();
3241 }
3242 
3243 #define DO_SIGNAL_CHECK(sig) \
3244   if (!sigismember(&check_signal_done, sig)) \
3245     os::Aix::check_signal_handler(sig)
3246 
3247 // This method is a periodic task to check for misbehaving JNI applications
3248 // under CheckJNI, we can add any periodic checks here
3249 
3250 void os::run_periodic_checks() {
3251 
3252   if (check_signals == false) return;
3253 
3254   // SEGV and BUS if overridden could potentially prevent
3255   // generation of hs*.log in the event of a crash, debugging
3256   // such a case can be very challenging, so we absolutely
3257   // check the following for a good measure:
3258   DO_SIGNAL_CHECK(SIGSEGV);
3259   DO_SIGNAL_CHECK(SIGILL);
3260   DO_SIGNAL_CHECK(SIGFPE);
3261   DO_SIGNAL_CHECK(SIGBUS);
3262   DO_SIGNAL_CHECK(SIGPIPE);
3263   DO_SIGNAL_CHECK(SIGXFSZ);
3264   if (UseSIGTRAP) {
3265     DO_SIGNAL_CHECK(SIGTRAP);
3266   }
3267   DO_SIGNAL_CHECK(SIGDANGER);
3268 
3269   // ReduceSignalUsage allows the user to override these handlers
3270   // see comments at the very top and jvm_solaris.h
3271   if (!ReduceSignalUsage) {
3272     DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
3273     DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
3274     DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
3275     DO_SIGNAL_CHECK(BREAK_SIGNAL);
3276   }
3277 
3278   DO_SIGNAL_CHECK(SR_signum);
3279 }
3280 
3281 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
3282 
3283 static os_sigaction_t os_sigaction = NULL;
3284 
3285 void os::Aix::check_signal_handler(int sig) {
3286   char buf[O_BUFLEN];
3287   address jvmHandler = NULL;
3288 
3289   struct sigaction act;
3290   if (os_sigaction == NULL) {
3291     // only trust the default sigaction, in case it has been interposed
3292     os_sigaction = CAST_TO_FN_PTR(os_sigaction_t, dlsym(RTLD_DEFAULT, "sigaction"));
3293     if (os_sigaction == NULL) return;
3294   }
3295 
3296   os_sigaction(sig, (struct sigaction*)NULL, &act);
3297 
3298   address thisHandler = (act.sa_flags & SA_SIGINFO)
3299     ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
3300     : CAST_FROM_FN_PTR(address, act.sa_handler);
3301 
3302   switch(sig) {
3303   case SIGSEGV:
3304   case SIGBUS:
3305   case SIGFPE:
3306   case SIGPIPE:
3307   case SIGILL:
3308   case SIGXFSZ:
3309     jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler);
3310     break;
3311 
3312   case SHUTDOWN1_SIGNAL:
3313   case SHUTDOWN2_SIGNAL:
3314   case SHUTDOWN3_SIGNAL:
3315   case BREAK_SIGNAL:
3316     jvmHandler = (address)user_handler();
3317     break;
3318 
3319   default:
3320     if (sig == SR_signum) {
3321       jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler);
3322     } else {
3323       return;
3324     }
3325     break;
3326   }
3327 
3328   if (thisHandler != jvmHandler) {
3329     tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
3330     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
3331     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
3332     // No need to check this sig any longer
3333     sigaddset(&check_signal_done, sig);
3334     // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN
3335     if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) {
3336       tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell",
3337                     exception_name(sig, buf, O_BUFLEN));
3338     }
3339   } else if (os::Aix::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Aix::get_our_sigflags(sig)) {
3340     tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
3341     tty->print("expected:");
3342     os::Posix::print_sa_flags(tty, os::Aix::get_our_sigflags(sig));
3343     tty->cr();
3344     tty->print("  found:");
3345     os::Posix::print_sa_flags(tty, act.sa_flags);
3346     tty->cr();
3347     // No need to check this sig any longer
3348     sigaddset(&check_signal_done, sig);
3349   }
3350 
3351   // Dump all the signal
3352   if (sigismember(&check_signal_done, sig)) {
3353     print_signal_handlers(tty, buf, O_BUFLEN);
3354   }
3355 }
3356 
3357 // To install functions for atexit system call
3358 extern "C" {
3359   static void perfMemory_exit_helper() {
3360     perfMemory_exit();
3361   }
3362 }
3363 
3364 // This is called _before_ the most of global arguments have been parsed.
3365 void os::init(void) {
3366   // This is basic, we want to know if that ever changes.
3367   // (Shared memory boundary is supposed to be a 256M aligned.)
3368   assert(SHMLBA == ((uint64_t)0x10000000ULL)/*256M*/, "unexpected");
3369 
3370   // Record process break at startup.
3371   g_brk_at_startup = (address) ::sbrk(0);
3372   assert(g_brk_at_startup != (address) -1, "sbrk failed");
3373 
3374   // First off, we need to know whether we run on AIX or PASE, and
3375   // the OS level we run on.
3376   os::Aix::initialize_os_info();
3377 
3378   // Scan environment (SPEC1170 behaviour, etc).
3379   os::Aix::scan_environment();
3380 
3381   // Probe multipage support.
3382   query_multipage_support();
3383 
3384   // Act like we only have one page size by eliminating corner cases which
3385   // we did not support very well anyway.
3386   // We have two input conditions:
3387   // 1) Data segment page size. This is controlled by linker setting (datapsize) on the
3388   //    launcher, and/or by LDR_CNTRL environment variable. The latter overrules the linker
3389   //    setting.
3390   //    Data segment page size is important for us because it defines the thread stack page
3391   //    size, which is needed for guard page handling, stack banging etc.
3392   // 2) The ability to allocate 64k pages dynamically. If this is a given, java heap can
3393   //    and should be allocated with 64k pages.
3394   //
3395   // So, we do the following:
3396   // LDR_CNTRL    can_use_64K_pages_dynamically       what we do                      remarks
3397   // 4K           no                                  4K                              old systems (aix 5.2, as/400 v5r4) or new systems with AME activated
3398   // 4k           yes                                 64k (treat 4k stacks as 64k)    different loader than java and standard settings
3399   // 64k          no              --- AIX 5.2 ? ---
3400   // 64k          yes                                 64k                             new systems and standard java loader (we set datapsize=64k when linking)
3401 
3402   // We explicitly leave no option to change page size, because only upgrading would work,
3403   // not downgrading (if stack page size is 64k you cannot pretend its 4k).
3404 
3405   if (g_multipage_support.datapsize == 4*K) {
3406     // datapsize = 4K. Data segment, thread stacks are 4K paged.
3407     if (g_multipage_support.can_use_64K_pages) {
3408       // .. but we are able to use 64K pages dynamically.
3409       // This would be typical for java launchers which are not linked
3410       // with datapsize=64K (like, any other launcher but our own).
3411       //
3412       // In this case it would be smart to allocate the java heap with 64K
3413       // to get the performance benefit, and to fake 64k pages for the
3414       // data segment (when dealing with thread stacks).
3415       //
3416       // However, leave a possibility to downgrade to 4K, using
3417       // -XX:-Use64KPages.
3418       if (Use64KPages) {
3419         trcVerbose("64K page mode (faked for data segment)");
3420         Aix::_page_size = 64*K;
3421       } else {
3422         trcVerbose("4K page mode (Use64KPages=off)");
3423         Aix::_page_size = 4*K;
3424       }
3425     } else {
3426       // .. and not able to allocate 64k pages dynamically. Here, just
3427       // fall back to 4K paged mode and use mmap for everything.
3428       trcVerbose("4K page mode");
3429       Aix::_page_size = 4*K;
3430       FLAG_SET_ERGO(bool, Use64KPages, false);
3431     }
3432   } else {
3433     // datapsize = 64k. Data segment, thread stacks are 64k paged.
3434     // This normally means that we can allocate 64k pages dynamically.
3435     // (There is one special case where this may be false: EXTSHM=on.
3436     // but we decided to not support that mode).
3437     assert0(g_multipage_support.can_use_64K_pages);
3438     Aix::_page_size = 64*K;
3439     trcVerbose("64K page mode");
3440     FLAG_SET_ERGO(bool, Use64KPages, true);
3441   }
3442 
3443   // For now UseLargePages is just ignored.
3444   FLAG_SET_ERGO(bool, UseLargePages, false);
3445   _page_sizes[0] = 0;
3446 
3447   // debug trace
3448   trcVerbose("os::vm_page_size %s", describe_pagesize(os::vm_page_size()));
3449 
3450   // Next, we need to initialize libo4 and libperfstat libraries.
3451   if (os::Aix::on_pase()) {
3452     os::Aix::initialize_libo4();
3453   } else {
3454     os::Aix::initialize_libperfstat();
3455   }
3456 
3457   // Reset the perfstat information provided by ODM.
3458   if (os::Aix::on_aix()) {
3459     libperfstat::perfstat_reset();
3460   }
3461 
3462   // Now initialze basic system properties. Note that for some of the values we
3463   // need libperfstat etc.
3464   os::Aix::initialize_system_info();
3465 
3466   clock_tics_per_sec = sysconf(_SC_CLK_TCK);
3467 
3468   init_random(1234567);
3469 
3470   ThreadCritical::initialize();
3471 
3472   // Main_thread points to the aboriginal thread.
3473   Aix::_main_thread = pthread_self();
3474 
3475   initial_time_count = os::elapsed_counter();
3476 }
3477 
3478 // This is called _after_ the global arguments have been parsed.
3479 jint os::init_2(void) {
3480 
3481   if (os::Aix::on_pase()) {
3482     trcVerbose("Running on PASE.");
3483   } else {
3484     trcVerbose("Running on AIX (not PASE).");
3485   }
3486 
3487   trcVerbose("processor count: %d", os::_processor_count);
3488   trcVerbose("physical memory: %lu", Aix::_physical_memory);
3489 
3490   // Initially build up the loaded dll map.
3491   LoadedLibraries::reload();
3492   if (Verbose) {
3493     trcVerbose("Loaded Libraries: ");
3494     LoadedLibraries::print(tty);
3495   }
3496 
3497   const int page_size = Aix::page_size();
3498   const int map_size = page_size;
3499 
3500   address map_address = (address) MAP_FAILED;
3501   const int prot  = PROT_READ;
3502   const int flags = MAP_PRIVATE|MAP_ANONYMOUS;
3503 
3504   // Use optimized addresses for the polling page,
3505   // e.g. map it to a special 32-bit address.
3506   if (OptimizePollingPageLocation) {
3507     // architecture-specific list of address wishes:
3508     address address_wishes[] = {
3509       // AIX: addresses lower than 0x30000000 don't seem to work on AIX.
3510       // PPC64: all address wishes are non-negative 32 bit values where
3511       // the lower 16 bits are all zero. we can load these addresses
3512       // with a single ppc_lis instruction.
3513       (address) 0x30000000, (address) 0x31000000,
3514       (address) 0x32000000, (address) 0x33000000,
3515       (address) 0x40000000, (address) 0x41000000,
3516       (address) 0x42000000, (address) 0x43000000,
3517       (address) 0x50000000, (address) 0x51000000,
3518       (address) 0x52000000, (address) 0x53000000,
3519       (address) 0x60000000, (address) 0x61000000,
3520       (address) 0x62000000, (address) 0x63000000
3521     };
3522     int address_wishes_length = sizeof(address_wishes)/sizeof(address);
3523 
3524     // iterate over the list of address wishes:
3525     for (int i=0; i<address_wishes_length; i++) {
3526       // Try to map with current address wish.
3527       // AIX: AIX needs MAP_FIXED if we provide an address and mmap will
3528       // fail if the address is already mapped.
3529       map_address = (address) ::mmap(address_wishes[i] - (ssize_t)page_size,
3530                                      map_size, prot,
3531                                      flags | MAP_FIXED,
3532                                      -1, 0);
3533       trcVerbose("SafePoint Polling  Page address: %p (wish) => %p",
3534                    address_wishes[i], map_address + (ssize_t)page_size);
3535 
3536       if (map_address + (ssize_t)page_size == address_wishes[i]) {
3537         // Map succeeded and map_address is at wished address, exit loop.
3538         break;
3539       }
3540 
3541       if (map_address != (address) MAP_FAILED) {
3542         // Map succeeded, but polling_page is not at wished address, unmap and continue.
3543         ::munmap(map_address, map_size);
3544         map_address = (address) MAP_FAILED;
3545       }
3546       // Map failed, continue loop.
3547     }
3548   } // end OptimizePollingPageLocation
3549 
3550   if (map_address == (address) MAP_FAILED) {
3551     map_address = (address) ::mmap(NULL, map_size, prot, flags, -1, 0);
3552   }
3553   guarantee(map_address != MAP_FAILED, "os::init_2: failed to allocate polling page");
3554   os::set_polling_page(map_address);
3555 
3556   if (!UseMembar) {
3557     address mem_serialize_page = (address) ::mmap(NULL, Aix::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
3558     guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
3559     os::set_memory_serialize_page(mem_serialize_page);
3560 
3561     trcVerbose("Memory Serialize  Page address: %p - %p, size %IX (%IB)",
3562         mem_serialize_page, mem_serialize_page + Aix::page_size(),
3563         Aix::page_size(), Aix::page_size());
3564   }
3565 
3566   // initialize suspend/resume support - must do this before signal_sets_init()
3567   if (SR_initialize() != 0) {
3568     perror("SR_initialize failed");
3569     return JNI_ERR;
3570   }
3571 
3572   Aix::signal_sets_init();
3573   Aix::install_signal_handlers();
3574 
3575   // Check and sets minimum stack sizes against command line options
3576   if (Posix::set_minimum_stack_sizes() == JNI_ERR) {
3577     return JNI_ERR;
3578   }
3579 
3580   if (UseNUMA) {
3581     UseNUMA = false;
3582     warning("NUMA optimizations are not available on this OS.");
3583   }
3584 
3585   if (MaxFDLimit) {
3586     // Set the number of file descriptors to max. print out error
3587     // if getrlimit/setrlimit fails but continue regardless.
3588     struct rlimit nbr_files;
3589     int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
3590     if (status != 0) {
3591       log_info(os)("os::init_2 getrlimit failed: %s", os::strerror(errno));
3592     } else {
3593       nbr_files.rlim_cur = nbr_files.rlim_max;
3594       status = setrlimit(RLIMIT_NOFILE, &nbr_files);
3595       if (status != 0) {
3596         log_info(os)("os::init_2 setrlimit failed: %s", os::strerror(errno));
3597       }
3598     }
3599   }
3600 
3601   if (PerfAllowAtExitRegistration) {
3602     // Only register atexit functions if PerfAllowAtExitRegistration is set.
3603     // At exit functions can be delayed until process exit time, which
3604     // can be problematic for embedded VM situations. Embedded VMs should
3605     // call DestroyJavaVM() to assure that VM resources are released.
3606 
3607     // Note: perfMemory_exit_helper atexit function may be removed in
3608     // the future if the appropriate cleanup code can be added to the
3609     // VM_Exit VMOperation's doit method.
3610     if (atexit(perfMemory_exit_helper) != 0) {
3611       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3612     }
3613   }
3614 
3615   return JNI_OK;
3616 }
3617 
3618 // Mark the polling page as unreadable
3619 void os::make_polling_page_unreadable(void) {
3620   if (!guard_memory((char*)_polling_page, Aix::page_size())) {
3621     fatal("Could not disable polling page");
3622   }
3623 };
3624 
3625 // Mark the polling page as readable
3626 void os::make_polling_page_readable(void) {
3627   // Changed according to os_linux.cpp.
3628   if (!checked_mprotect((char *)_polling_page, Aix::page_size(), PROT_READ)) {
3629     fatal("Could not enable polling page at " PTR_FORMAT, _polling_page);
3630   }
3631 };
3632 
3633 int os::active_processor_count() {
3634   int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
3635   assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
3636   return online_cpus;
3637 }
3638 
3639 void os::set_native_thread_name(const char *name) {
3640   // Not yet implemented.
3641   return;
3642 }
3643 
3644 bool os::distribute_processes(uint length, uint* distribution) {
3645   // Not yet implemented.
3646   return false;
3647 }
3648 
3649 bool os::bind_to_processor(uint processor_id) {
3650   // Not yet implemented.
3651   return false;
3652 }
3653 
3654 void os::SuspendedThreadTask::internal_do_task() {
3655   if (do_suspend(_thread->osthread())) {
3656     SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext());
3657     do_task(context);
3658     do_resume(_thread->osthread());
3659   }
3660 }
3661 
3662 class PcFetcher : public os::SuspendedThreadTask {
3663 public:
3664   PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
3665   ExtendedPC result();
3666 protected:
3667   void do_task(const os::SuspendedThreadTaskContext& context);
3668 private:
3669   ExtendedPC _epc;
3670 };
3671 
3672 ExtendedPC PcFetcher::result() {
3673   guarantee(is_done(), "task is not done yet.");
3674   return _epc;
3675 }
3676 
3677 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
3678   Thread* thread = context.thread();
3679   OSThread* osthread = thread->osthread();
3680   if (osthread->ucontext() != NULL) {
3681     _epc = os::Aix::ucontext_get_pc((const ucontext_t *) context.ucontext());
3682   } else {
3683     // NULL context is unexpected, double-check this is the VMThread.
3684     guarantee(thread->is_VM_thread(), "can only be called for VMThread");
3685   }
3686 }
3687 
3688 // Suspends the target using the signal mechanism and then grabs the PC before
3689 // resuming the target. Used by the flat-profiler only
3690 ExtendedPC os::get_thread_pc(Thread* thread) {
3691   // Make sure that it is called by the watcher for the VMThread.
3692   assert(Thread::current()->is_Watcher_thread(), "Must be watcher");
3693   assert(thread->is_VM_thread(), "Can only be called for VMThread");
3694 
3695   PcFetcher fetcher(thread);
3696   fetcher.run();
3697   return fetcher.result();
3698 }
3699 
3700 ////////////////////////////////////////////////////////////////////////////////
3701 // debug support
3702 
3703 bool os::find(address addr, outputStream* st) {
3704 
3705   st->print(PTR_FORMAT ": ", addr);
3706 
3707   loaded_module_t lm;
3708   if (LoadedLibraries::find_for_text_address(addr, &lm) != NULL ||
3709       LoadedLibraries::find_for_data_address(addr, &lm) != NULL) {
3710     st->print_cr("%s", lm.path);
3711     return true;
3712   }
3713 
3714   return false;
3715 }
3716 
3717 ////////////////////////////////////////////////////////////////////////////////
3718 // misc
3719 
3720 // This does not do anything on Aix. This is basically a hook for being
3721 // able to use structured exception handling (thread-local exception filters)
3722 // on, e.g., Win32.
3723 void
3724 os::os_exception_wrapper(java_call_t f, JavaValue* value, const methodHandle& method,
3725                          JavaCallArguments* args, Thread* thread) {
3726   f(value, method, args, thread);
3727 }
3728 
3729 void os::print_statistics() {
3730 }
3731 
3732 bool os::message_box(const char* title, const char* message) {
3733   int i;
3734   fdStream err(defaultStream::error_fd());
3735   for (i = 0; i < 78; i++) err.print_raw("=");
3736   err.cr();
3737   err.print_raw_cr(title);
3738   for (i = 0; i < 78; i++) err.print_raw("-");
3739   err.cr();
3740   err.print_raw_cr(message);
3741   for (i = 0; i < 78; i++) err.print_raw("=");
3742   err.cr();
3743 
3744   char buf[16];
3745   // Prevent process from exiting upon "read error" without consuming all CPU
3746   while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
3747 
3748   return buf[0] == 'y' || buf[0] == 'Y';
3749 }
3750 
3751 int os::stat(const char *path, struct stat *sbuf) {
3752   char pathbuf[MAX_PATH];
3753   if (strlen(path) > MAX_PATH - 1) {
3754     errno = ENAMETOOLONG;
3755     return -1;
3756   }
3757   os::native_path(strcpy(pathbuf, path));
3758   return ::stat(pathbuf, sbuf);
3759 }
3760 
3761 // Is a (classpath) directory empty?
3762 bool os::dir_is_empty(const char* path) {
3763   DIR *dir = NULL;
3764   struct dirent *ptr;
3765 
3766   dir = opendir(path);
3767   if (dir == NULL) return true;
3768 
3769   /* Scan the directory */
3770   bool result = true;
3771   char buf[sizeof(struct dirent) + MAX_PATH];
3772   while (result && (ptr = ::readdir(dir)) != NULL) {
3773     if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
3774       result = false;
3775     }
3776   }
3777   closedir(dir);
3778   return result;
3779 }
3780 
3781 // This code originates from JDK's sysOpen and open64_w
3782 // from src/solaris/hpi/src/system_md.c
3783 
3784 int os::open(const char *path, int oflag, int mode) {
3785 
3786   if (strlen(path) > MAX_PATH - 1) {
3787     errno = ENAMETOOLONG;
3788     return -1;
3789   }
3790   int fd;
3791 
3792   fd = ::open64(path, oflag, mode);
3793   if (fd == -1) return -1;
3794 
3795   // If the open succeeded, the file might still be a directory.
3796   {
3797     struct stat64 buf64;
3798     int ret = ::fstat64(fd, &buf64);
3799     int st_mode = buf64.st_mode;
3800 
3801     if (ret != -1) {
3802       if ((st_mode & S_IFMT) == S_IFDIR) {
3803         errno = EISDIR;
3804         ::close(fd);
3805         return -1;
3806       }
3807     } else {
3808       ::close(fd);
3809       return -1;
3810     }
3811   }
3812 
3813   // All file descriptors that are opened in the JVM and not
3814   // specifically destined for a subprocess should have the
3815   // close-on-exec flag set. If we don't set it, then careless 3rd
3816   // party native code might fork and exec without closing all
3817   // appropriate file descriptors (e.g. as we do in closeDescriptors in
3818   // UNIXProcess.c), and this in turn might:
3819   //
3820   // - cause end-of-file to fail to be detected on some file
3821   //   descriptors, resulting in mysterious hangs, or
3822   //
3823   // - might cause an fopen in the subprocess to fail on a system
3824   //   suffering from bug 1085341.
3825   //
3826   // (Yes, the default setting of the close-on-exec flag is a Unix
3827   // design flaw.)
3828   //
3829   // See:
3830   // 1085341: 32-bit stdio routines should support file descriptors >255
3831   // 4843136: (process) pipe file descriptor from Runtime.exec not being closed
3832   // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
3833 #ifdef FD_CLOEXEC
3834   {
3835     int flags = ::fcntl(fd, F_GETFD);
3836     if (flags != -1)
3837       ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
3838   }
3839 #endif
3840 
3841   return fd;
3842 }
3843 
3844 // create binary file, rewriting existing file if required
3845 int os::create_binary_file(const char* path, bool rewrite_existing) {
3846   int oflags = O_WRONLY | O_CREAT;
3847   if (!rewrite_existing) {
3848     oflags |= O_EXCL;
3849   }
3850   return ::open64(path, oflags, S_IREAD | S_IWRITE);
3851 }
3852 
3853 // return current position of file pointer
3854 jlong os::current_file_offset(int fd) {
3855   return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
3856 }
3857 
3858 // move file pointer to the specified offset
3859 jlong os::seek_to_file_offset(int fd, jlong offset) {
3860   return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
3861 }
3862 
3863 // This code originates from JDK's sysAvailable
3864 // from src/solaris/hpi/src/native_threads/src/sys_api_td.c
3865 
3866 int os::available(int fd, jlong *bytes) {
3867   jlong cur, end;
3868   int mode;
3869   struct stat64 buf64;
3870 
3871   if (::fstat64(fd, &buf64) >= 0) {
3872     mode = buf64.st_mode;
3873     if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
3874       int n;
3875       if (::ioctl(fd, FIONREAD, &n) >= 0) {
3876         *bytes = n;
3877         return 1;
3878       }
3879     }
3880   }
3881   if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
3882     return 0;
3883   } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
3884     return 0;
3885   } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
3886     return 0;
3887   }
3888   *bytes = end - cur;
3889   return 1;
3890 }
3891 
3892 // Map a block of memory.
3893 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
3894                         char *addr, size_t bytes, bool read_only,
3895                         bool allow_exec) {
3896   int prot;
3897   int flags = MAP_PRIVATE;
3898 
3899   if (read_only) {
3900     prot = PROT_READ;
3901     flags = MAP_SHARED;
3902   } else {
3903     prot = PROT_READ | PROT_WRITE;
3904     flags = MAP_PRIVATE;
3905   }
3906 
3907   if (allow_exec) {
3908     prot |= PROT_EXEC;
3909   }
3910 
3911   if (addr != NULL) {
3912     flags |= MAP_FIXED;
3913   }
3914 
3915   // Allow anonymous mappings if 'fd' is -1.
3916   if (fd == -1) {
3917     flags |= MAP_ANONYMOUS;
3918   }
3919 
3920   char* mapped_address = (char*)::mmap(addr, (size_t)bytes, prot, flags,
3921                                      fd, file_offset);
3922   if (mapped_address == MAP_FAILED) {
3923     return NULL;
3924   }
3925   return mapped_address;
3926 }
3927 
3928 // Remap a block of memory.
3929 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
3930                           char *addr, size_t bytes, bool read_only,
3931                           bool allow_exec) {
3932   // same as map_memory() on this OS
3933   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
3934                         allow_exec);
3935 }
3936 
3937 // Unmap a block of memory.
3938 bool os::pd_unmap_memory(char* addr, size_t bytes) {
3939   return munmap(addr, bytes) == 0;
3940 }
3941 
3942 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3943 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3944 // of a thread.
3945 //
3946 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3947 // the fast estimate available on the platform.
3948 
3949 jlong os::current_thread_cpu_time() {
3950   // return user + sys since the cost is the same
3951   const jlong n = os::thread_cpu_time(Thread::current(), true /* user + sys */);
3952   assert(n >= 0, "negative CPU time");
3953   return n;
3954 }
3955 
3956 jlong os::thread_cpu_time(Thread* thread) {
3957   // consistent with what current_thread_cpu_time() returns
3958   const jlong n = os::thread_cpu_time(thread, true /* user + sys */);
3959   assert(n >= 0, "negative CPU time");
3960   return n;
3961 }
3962 
3963 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3964   const jlong n = os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3965   assert(n >= 0, "negative CPU time");
3966   return n;
3967 }
3968 
3969 static bool thread_cpu_time_unchecked(Thread* thread, jlong* p_sys_time, jlong* p_user_time) {
3970   bool error = false;
3971 
3972   jlong sys_time = 0;
3973   jlong user_time = 0;
3974 
3975   // Reimplemented using getthrds64().
3976   //
3977   // Works like this:
3978   // For the thread in question, get the kernel thread id. Then get the
3979   // kernel thread statistics using that id.
3980   //
3981   // This only works of course when no pthread scheduling is used,
3982   // i.e. there is a 1:1 relationship to kernel threads.
3983   // On AIX, see AIXTHREAD_SCOPE variable.
3984 
3985   pthread_t pthtid = thread->osthread()->pthread_id();
3986 
3987   // retrieve kernel thread id for the pthread:
3988   tid64_t tid = 0;
3989   struct __pthrdsinfo pinfo;
3990   // I just love those otherworldly IBM APIs which force me to hand down
3991   // dummy buffers for stuff I dont care for...
3992   char dummy[1];
3993   int dummy_size = sizeof(dummy);
3994   if (pthread_getthrds_np(&pthtid, PTHRDSINFO_QUERY_TID, &pinfo, sizeof(pinfo),
3995                           dummy, &dummy_size) == 0) {
3996     tid = pinfo.__pi_tid;
3997   } else {
3998     tty->print_cr("pthread_getthrds_np failed.");
3999     error = true;
4000   }
4001 
4002   // retrieve kernel timing info for that kernel thread
4003   if (!error) {
4004     struct thrdentry64 thrdentry;
4005     if (getthrds64(getpid(), &thrdentry, sizeof(thrdentry), &tid, 1) == 1) {
4006       sys_time = thrdentry.ti_ru.ru_stime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_stime.tv_usec * 1000LL;
4007       user_time = thrdentry.ti_ru.ru_utime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_utime.tv_usec * 1000LL;
4008     } else {
4009       tty->print_cr("pthread_getthrds_np failed.");
4010       error = true;
4011     }
4012   }
4013 
4014   if (p_sys_time) {
4015     *p_sys_time = sys_time;
4016   }
4017 
4018   if (p_user_time) {
4019     *p_user_time = user_time;
4020   }
4021 
4022   if (error) {
4023     return false;
4024   }
4025 
4026   return true;
4027 }
4028 
4029 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
4030   jlong sys_time;
4031   jlong user_time;
4032 
4033   if (!thread_cpu_time_unchecked(thread, &sys_time, &user_time)) {
4034     return -1;
4035   }
4036 
4037   return user_sys_cpu_time ? sys_time + user_time : user_time;
4038 }
4039 
4040 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4041   info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4042   info_ptr->may_skip_backward = false;     // elapsed time not wall time
4043   info_ptr->may_skip_forward = false;      // elapsed time not wall time
4044   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4045 }
4046 
4047 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4048   info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4049   info_ptr->may_skip_backward = false;     // elapsed time not wall time
4050   info_ptr->may_skip_forward = false;      // elapsed time not wall time
4051   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4052 }
4053 
4054 bool os::is_thread_cpu_time_supported() {
4055   return true;
4056 }
4057 
4058 // System loadavg support. Returns -1 if load average cannot be obtained.
4059 // For now just return the system wide load average (no processor sets).
4060 int os::loadavg(double values[], int nelem) {
4061 
4062   guarantee(nelem >= 0 && nelem <= 3, "argument error");
4063   guarantee(values, "argument error");
4064 
4065   if (os::Aix::on_pase()) {
4066 
4067     // AS/400 PASE: use libo4 porting library
4068     double v[3] = { 0.0, 0.0, 0.0 };
4069 
4070     if (libo4::get_load_avg(v, v + 1, v + 2)) {
4071       for (int i = 0; i < nelem; i ++) {
4072         values[i] = v[i];
4073       }
4074       return nelem;
4075     } else {
4076       return -1;
4077     }
4078 
4079   } else {
4080 
4081     // AIX: use libperfstat
4082     libperfstat::cpuinfo_t ci;
4083     if (libperfstat::get_cpuinfo(&ci)) {
4084       for (int i = 0; i < nelem; i++) {
4085         values[i] = ci.loadavg[i];
4086       }
4087     } else {
4088       return -1;
4089     }
4090     return nelem;
4091   }
4092 }
4093 
4094 void os::pause() {
4095   char filename[MAX_PATH];
4096   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4097     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4098   } else {
4099     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4100   }
4101 
4102   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4103   if (fd != -1) {
4104     struct stat buf;
4105     ::close(fd);
4106     while (::stat(filename, &buf) == 0) {
4107       (void)::poll(NULL, 0, 100);
4108     }
4109   } else {
4110     trcVerbose("Could not open pause file '%s', continuing immediately.", filename);
4111   }
4112 }
4113 
4114 bool os::Aix::is_primordial_thread() {
4115   if (pthread_self() == (pthread_t)1) {
4116     return true;
4117   } else {
4118     return false;
4119   }
4120 }
4121 
4122 // OS recognitions (PASE/AIX, OS level) call this before calling any
4123 // one of Aix::on_pase(), Aix::os_version() static
4124 void os::Aix::initialize_os_info() {
4125 
4126   assert(_on_pase == -1 && _os_version == 0, "already called.");
4127 
4128   struct utsname uts;
4129   memset(&uts, 0, sizeof(uts));
4130   strcpy(uts.sysname, "?");
4131   if (::uname(&uts) == -1) {
4132     trcVerbose("uname failed (%d)", errno);
4133     guarantee(0, "Could not determine whether we run on AIX or PASE");
4134   } else {
4135     trcVerbose("uname says: sysname \"%s\" version \"%s\" release \"%s\" "
4136                "node \"%s\" machine \"%s\"\n",
4137                uts.sysname, uts.version, uts.release, uts.nodename, uts.machine);
4138     const int major = atoi(uts.version);
4139     assert(major > 0, "invalid OS version");
4140     const int minor = atoi(uts.release);
4141     assert(minor > 0, "invalid OS release");
4142     _os_version = (major << 24) | (minor << 16);
4143     char ver_str[20] = {0};
4144     char *name_str = "unknown OS";
4145     if (strcmp(uts.sysname, "OS400") == 0) {
4146       // We run on AS/400 PASE. We do not support versions older than V5R4M0.
4147       _on_pase = 1;
4148       if (os_version_short() < 0x0504) {
4149         trcVerbose("OS/400 releases older than V5R4M0 not supported.");
4150         assert(false, "OS/400 release too old.");
4151       }
4152       name_str = "OS/400 (pase)";
4153       jio_snprintf(ver_str, sizeof(ver_str), "%u.%u", major, minor);
4154     } else if (strcmp(uts.sysname, "AIX") == 0) {
4155       // We run on AIX. We do not support versions older than AIX 5.3.
4156       _on_pase = 0;
4157       // Determine detailed AIX version: Version, Release, Modification, Fix Level.
4158       odmWrapper::determine_os_kernel_version(&_os_version);
4159       if (os_version_short() < 0x0503) {
4160         trcVerbose("AIX release older than AIX 5.3 not supported.");
4161         assert(false, "AIX release too old.");
4162       }
4163       name_str = "AIX";
4164       jio_snprintf(ver_str, sizeof(ver_str), "%u.%u.%u.%u",
4165                    major, minor, (_os_version >> 8) & 0xFF, _os_version & 0xFF);
4166     } else {
4167       assert(false, name_str);
4168     }
4169     trcVerbose("We run on %s %s", name_str, ver_str);
4170   }
4171 
4172   guarantee(_on_pase != -1 && _os_version, "Could not determine AIX/OS400 release");
4173 } // end: os::Aix::initialize_os_info()
4174 
4175 // Scan environment for important settings which might effect the VM.
4176 // Trace out settings. Warn about invalid settings and/or correct them.
4177 //
4178 // Must run after os::Aix::initialue_os_info().
4179 void os::Aix::scan_environment() {
4180 
4181   char* p;
4182   int rc;
4183 
4184   // Warn explicity if EXTSHM=ON is used. That switch changes how
4185   // System V shared memory behaves. One effect is that page size of
4186   // shared memory cannot be change dynamically, effectivly preventing
4187   // large pages from working.
4188   // This switch was needed on AIX 32bit, but on AIX 64bit the general
4189   // recommendation is (in OSS notes) to switch it off.
4190   p = ::getenv("EXTSHM");
4191   trcVerbose("EXTSHM=%s.", p ? p : "<unset>");
4192   if (p && strcasecmp(p, "ON") == 0) {
4193     _extshm = 1;
4194     trcVerbose("*** Unsupported mode! Please remove EXTSHM from your environment! ***");
4195     if (!AllowExtshm) {
4196       // We allow under certain conditions the user to continue. However, we want this
4197       // to be a fatal error by default. On certain AIX systems, leaving EXTSHM=ON means
4198       // that the VM is not able to allocate 64k pages for the heap.
4199       // We do not want to run with reduced performance.
4200       vm_exit_during_initialization("EXTSHM is ON. Please remove EXTSHM from your environment.");
4201     }
4202   } else {
4203     _extshm = 0;
4204   }
4205 
4206   // SPEC1170 behaviour: will change the behaviour of a number of POSIX APIs.
4207   // Not tested, not supported.
4208   //
4209   // Note that it might be worth the trouble to test and to require it, if only to
4210   // get useful return codes for mprotect.
4211   //
4212   // Note: Setting XPG_SUS_ENV in the process is too late. Must be set earlier (before
4213   // exec() ? before loading the libjvm ? ....)
4214   p = ::getenv("XPG_SUS_ENV");
4215   trcVerbose("XPG_SUS_ENV=%s.", p ? p : "<unset>");
4216   if (p && strcmp(p, "ON") == 0) {
4217     _xpg_sus_mode = 1;
4218     trcVerbose("Unsupported setting: XPG_SUS_ENV=ON");
4219     // This is not supported. Worst of all, it changes behaviour of mmap MAP_FIXED to
4220     // clobber address ranges. If we ever want to support that, we have to do some
4221     // testing first.
4222     guarantee(false, "XPG_SUS_ENV=ON not supported");
4223   } else {
4224     _xpg_sus_mode = 0;
4225   }
4226 
4227   if (os::Aix::on_pase()) {
4228     p = ::getenv("QIBM_MULTI_THREADED");
4229     trcVerbose("QIBM_MULTI_THREADED=%s.", p ? p : "<unset>");
4230   }
4231 
4232   p = ::getenv("LDR_CNTRL");
4233   trcVerbose("LDR_CNTRL=%s.", p ? p : "<unset>");
4234   if (os::Aix::on_pase() && os::Aix::os_version_short() == 0x0701) {
4235     if (p && ::strstr(p, "TEXTPSIZE")) {
4236       trcVerbose("*** WARNING - LDR_CNTRL contains TEXTPSIZE. "
4237         "you may experience hangs or crashes on OS/400 V7R1.");
4238     }
4239   }
4240 
4241   p = ::getenv("AIXTHREAD_GUARDPAGES");
4242   trcVerbose("AIXTHREAD_GUARDPAGES=%s.", p ? p : "<unset>");
4243 
4244 } // end: os::Aix::scan_environment()
4245 
4246 // PASE: initialize the libo4 library (PASE porting library).
4247 void os::Aix::initialize_libo4() {
4248   guarantee(os::Aix::on_pase(), "OS/400 only.");
4249   if (!libo4::init()) {
4250     trcVerbose("libo4 initialization failed.");
4251     assert(false, "libo4 initialization failed");
4252   } else {
4253     trcVerbose("libo4 initialized.");
4254   }
4255 }
4256 
4257 // AIX: initialize the libperfstat library.
4258 void os::Aix::initialize_libperfstat() {
4259   assert(os::Aix::on_aix(), "AIX only");
4260   if (!libperfstat::init()) {
4261     trcVerbose("libperfstat initialization failed.");
4262     assert(false, "libperfstat initialization failed");
4263   } else {
4264     trcVerbose("libperfstat initialized.");
4265   }
4266 }
4267 
4268 /////////////////////////////////////////////////////////////////////////////
4269 // thread stack
4270 
4271 // Function to query the current stack size using pthread_getthrds_np.
4272 static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size) {
4273   // This only works when invoked on a pthread. As we agreed not to use
4274   // primordial threads anyway, I assert here.
4275   guarantee(!os::Aix::is_primordial_thread(), "not allowed on the primordial thread");
4276 
4277   // Information about this api can be found (a) in the pthread.h header and
4278   // (b) in http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_getthrds_np.htm
4279   //
4280   // The use of this API to find out the current stack is kind of undefined.
4281   // But after a lot of tries and asking IBM about it, I concluded that it is safe
4282   // enough for cases where I let the pthread library create its stacks. For cases
4283   // where I create an own stack and pass this to pthread_create, it seems not to
4284   // work (the returned stack size in that case is 0).
4285 
4286   pthread_t tid = pthread_self();
4287   struct __pthrdsinfo pinfo;
4288   char dummy[1]; // Just needed to satisfy pthread_getthrds_np.
4289   int dummy_size = sizeof(dummy);
4290 
4291   memset(&pinfo, 0, sizeof(pinfo));
4292 
4293   const int rc = pthread_getthrds_np(&tid, PTHRDSINFO_QUERY_ALL, &pinfo,
4294                                      sizeof(pinfo), dummy, &dummy_size);
4295 
4296   if (rc != 0) {
4297     assert0(false);
4298     trcVerbose("pthread_getthrds_np failed (%d)", rc);
4299     return false;
4300   }
4301   guarantee0(pinfo.__pi_stackend);
4302 
4303   // The following may happen when invoking pthread_getthrds_np on a pthread
4304   // running on a user provided stack (when handing down a stack to pthread
4305   // create, see pthread_attr_setstackaddr).
4306   // Not sure what to do then.
4307 
4308   guarantee0(pinfo.__pi_stacksize);
4309 
4310   // Note: we get three values from pthread_getthrds_np:
4311   //       __pi_stackaddr, __pi_stacksize, __pi_stackend
4312   //
4313   // high addr    ---------------------
4314   //
4315   //    |         pthread internal data, like ~2K
4316   //    |
4317   //    |         ---------------------   __pi_stackend   (usually not page aligned, (xxxxF890))
4318   //    |
4319   //    |
4320   //    |
4321   //    |
4322   //    |
4323   //    |
4324   //    |          ---------------------   (__pi_stackend - __pi_stacksize)
4325   //    |
4326   //    |          padding to align the following AIX guard pages, if enabled.
4327   //    |
4328   //    V          ---------------------   __pi_stackaddr
4329   //
4330   // low addr      AIX guard pages, if enabled (AIXTHREAD_GUARDPAGES > 0)
4331   //
4332 
4333   address stack_base = (address)(pinfo.__pi_stackend);
4334   address stack_low_addr = (address)align_ptr_up(pinfo.__pi_stackaddr,
4335     os::vm_page_size());
4336   size_t stack_size = stack_base - stack_low_addr;
4337 
4338   if (p_stack_base) {
4339     *p_stack_base = stack_base;
4340   }
4341 
4342   if (p_stack_size) {
4343     *p_stack_size = stack_size;
4344   }
4345 
4346   return true;
4347 }
4348 
4349 // Get the current stack base from the OS (actually, the pthread library).
4350 address os::current_stack_base() {
4351   address p;
4352   query_stack_dimensions(&p, 0);
4353   return p;
4354 }
4355 
4356 // Get the current stack size from the OS (actually, the pthread library).
4357 size_t os::current_stack_size() {
4358   size_t s;
4359   query_stack_dimensions(0, &s);
4360   return s;
4361 }
4362 
4363 // Refer to the comments in os_solaris.cpp park-unpark.
4364 
4365 // utility to compute the abstime argument to timedwait:
4366 // millis is the relative timeout time
4367 // abstime will be the absolute timeout time
4368 // TODO: replace compute_abstime() with unpackTime()
4369 
4370 static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
4371   if (millis < 0) millis = 0;
4372   struct timeval now;
4373   int status = gettimeofday(&now, NULL);
4374   assert(status == 0, "gettimeofday");
4375   jlong seconds = millis / 1000;
4376   millis %= 1000;
4377   if (seconds > 50000000) { // see man cond_timedwait(3T)
4378     seconds = 50000000;
4379   }
4380   abstime->tv_sec = now.tv_sec  + seconds;
4381   long       usec = now.tv_usec + millis * 1000;
4382   if (usec >= 1000000) {
4383     abstime->tv_sec += 1;
4384     usec -= 1000000;
4385   }
4386   abstime->tv_nsec = usec * 1000;
4387   return abstime;
4388 }
4389 
4390 // Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
4391 // Conceptually TryPark() should be equivalent to park(0).
4392 
4393 int os::PlatformEvent::TryPark() {
4394   for (;;) {
4395     const int v = _Event;
4396     guarantee ((v == 0) || (v == 1), "invariant");
4397     if (Atomic::cmpxchg (0, &_Event, v) == v) return v;
4398   }
4399 }
4400 
4401 void os::PlatformEvent::park() {       // AKA "down()"
4402   // Invariant: Only the thread associated with the Event/PlatformEvent
4403   // may call park().
4404   // TODO: assert that _Assoc != NULL or _Assoc == Self
4405   int v;
4406   for (;;) {
4407     v = _Event;
4408     if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4409   }
4410   guarantee (v >= 0, "invariant");
4411   if (v == 0) {
4412     // Do this the hard way by blocking ...
4413     int status = pthread_mutex_lock(_mutex);
4414     assert_status(status == 0, status, "mutex_lock");
4415     guarantee (_nParked == 0, "invariant");
4416     ++ _nParked;
4417     while (_Event < 0) {
4418       status = pthread_cond_wait(_cond, _mutex);
4419       assert_status(status == 0 || status == ETIMEDOUT, status, "cond_timedwait");
4420     }
4421     -- _nParked;
4422 
4423     // In theory we could move the ST of 0 into _Event past the unlock(),
4424     // but then we'd need a MEMBAR after the ST.
4425     _Event = 0;
4426     status = pthread_mutex_unlock(_mutex);
4427     assert_status(status == 0, status, "mutex_unlock");
4428   }
4429   guarantee (_Event >= 0, "invariant");
4430 }
4431 
4432 int os::PlatformEvent::park(jlong millis) {
4433   guarantee (_nParked == 0, "invariant");
4434 
4435   int v;
4436   for (;;) {
4437     v = _Event;
4438     if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4439   }
4440   guarantee (v >= 0, "invariant");
4441   if (v != 0) return OS_OK;
4442 
4443   // We do this the hard way, by blocking the thread.
4444   // Consider enforcing a minimum timeout value.
4445   struct timespec abst;
4446   compute_abstime(&abst, millis);
4447 
4448   int ret = OS_TIMEOUT;
4449   int status = pthread_mutex_lock(_mutex);
4450   assert_status(status == 0, status, "mutex_lock");
4451   guarantee (_nParked == 0, "invariant");
4452   ++_nParked;
4453 
4454   // Object.wait(timo) will return because of
4455   // (a) notification
4456   // (b) timeout
4457   // (c) thread.interrupt
4458   //
4459   // Thread.interrupt and object.notify{All} both call Event::set.
4460   // That is, we treat thread.interrupt as a special case of notification.
4461   // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
4462   // We assume all ETIME returns are valid.
4463   //
4464   // TODO: properly differentiate simultaneous notify+interrupt.
4465   // In that case, we should propagate the notify to another waiter.
4466 
4467   while (_Event < 0) {
4468     status = pthread_cond_timedwait(_cond, _mutex, &abst);
4469     assert_status(status == 0 || status == ETIMEDOUT,
4470                   status, "cond_timedwait");
4471     if (!FilterSpuriousWakeups) break;         // previous semantics
4472     if (status == ETIMEDOUT) break;
4473     // We consume and ignore EINTR and spurious wakeups.
4474   }
4475   --_nParked;
4476   if (_Event >= 0) {
4477      ret = OS_OK;
4478   }
4479   _Event = 0;
4480   status = pthread_mutex_unlock(_mutex);
4481   assert_status(status == 0, status, "mutex_unlock");
4482   assert (_nParked == 0, "invariant");
4483   return ret;
4484 }
4485 
4486 void os::PlatformEvent::unpark() {
4487   int v, AnyWaiters;
4488   for (;;) {
4489     v = _Event;
4490     if (v > 0) {
4491       // The LD of _Event could have reordered or be satisfied
4492       // by a read-aside from this processor's write buffer.
4493       // To avoid problems execute a barrier and then
4494       // ratify the value.
4495       OrderAccess::fence();
4496       if (_Event == v) return;
4497       continue;
4498     }
4499     if (Atomic::cmpxchg (v+1, &_Event, v) == v) break;
4500   }
4501   if (v < 0) {
4502     // Wait for the thread associated with the event to vacate
4503     int status = pthread_mutex_lock(_mutex);
4504     assert_status(status == 0, status, "mutex_lock");
4505     AnyWaiters = _nParked;
4506 
4507     if (AnyWaiters != 0) {
4508       // We intentional signal *after* dropping the lock
4509       // to avoid a common class of futile wakeups.
4510       status = pthread_cond_signal(_cond);
4511       assert_status(status == 0, status, "cond_signal");
4512     }
4513     // Mutex should be locked for pthread_cond_signal(_cond).
4514     status = pthread_mutex_unlock(_mutex);
4515     assert_status(status == 0, status, "mutex_unlock");
4516   }
4517 
4518   // Note that we signal() _after dropping the lock for "immortal" Events.
4519   // This is safe and avoids a common class of futile wakeups. In rare
4520   // circumstances this can cause a thread to return prematurely from
4521   // cond_{timed}wait() but the spurious wakeup is benign and the victim will
4522   // simply re-test the condition and re-park itself.
4523 }
4524 
4525 
4526 // JSR166
4527 // -------------------------------------------------------
4528 
4529 //
4530 // The solaris and linux implementations of park/unpark are fairly
4531 // conservative for now, but can be improved. They currently use a
4532 // mutex/condvar pair, plus a a count.
4533 // Park decrements count if > 0, else does a condvar wait. Unpark
4534 // sets count to 1 and signals condvar. Only one thread ever waits
4535 // on the condvar. Contention seen when trying to park implies that someone
4536 // is unparking you, so don't wait. And spurious returns are fine, so there
4537 // is no need to track notifications.
4538 //
4539 
4540 #define MAX_SECS 100000000
4541 //
4542 // This code is common to linux and solaris and will be moved to a
4543 // common place in dolphin.
4544 //
4545 // The passed in time value is either a relative time in nanoseconds
4546 // or an absolute time in milliseconds. Either way it has to be unpacked
4547 // into suitable seconds and nanoseconds components and stored in the
4548 // given timespec structure.
4549 // Given time is a 64-bit value and the time_t used in the timespec is only
4550 // a signed-32-bit value (except on 64-bit Linux) we have to watch for
4551 // overflow if times way in the future are given. Further on Solaris versions
4552 // prior to 10 there is a restriction (see cond_timedwait) that the specified
4553 // number of seconds, in abstime, is less than current_time + 100,000,000.
4554 // As it will be 28 years before "now + 100000000" will overflow we can
4555 // ignore overflow and just impose a hard-limit on seconds using the value
4556 // of "now + 100,000,000". This places a limit on the timeout of about 3.17
4557 // years from "now".
4558 //
4559 
4560 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
4561   assert (time > 0, "convertTime");
4562 
4563   struct timeval now;
4564   int status = gettimeofday(&now, NULL);
4565   assert(status == 0, "gettimeofday");
4566 
4567   time_t max_secs = now.tv_sec + MAX_SECS;
4568 
4569   if (isAbsolute) {
4570     jlong secs = time / 1000;
4571     if (secs > max_secs) {
4572       absTime->tv_sec = max_secs;
4573     }
4574     else {
4575       absTime->tv_sec = secs;
4576     }
4577     absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
4578   }
4579   else {
4580     jlong secs = time / NANOSECS_PER_SEC;
4581     if (secs >= MAX_SECS) {
4582       absTime->tv_sec = max_secs;
4583       absTime->tv_nsec = 0;
4584     }
4585     else {
4586       absTime->tv_sec = now.tv_sec + secs;
4587       absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
4588       if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
4589         absTime->tv_nsec -= NANOSECS_PER_SEC;
4590         ++absTime->tv_sec; // note: this must be <= max_secs
4591       }
4592     }
4593   }
4594   assert(absTime->tv_sec >= 0, "tv_sec < 0");
4595   assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
4596   assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
4597   assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
4598 }
4599 
4600 void Parker::park(bool isAbsolute, jlong time) {
4601   // Optional fast-path check:
4602   // Return immediately if a permit is available.
4603   if (_counter > 0) {
4604     _counter = 0;
4605     OrderAccess::fence();
4606     return;
4607   }
4608 
4609   Thread* thread = Thread::current();
4610   assert(thread->is_Java_thread(), "Must be JavaThread");
4611   JavaThread *jt = (JavaThread *)thread;
4612 
4613   // Optional optimization -- avoid state transitions if there's an interrupt pending.
4614   // Check interrupt before trying to wait
4615   if (Thread::is_interrupted(thread, false)) {
4616     return;
4617   }
4618 
4619   // Next, demultiplex/decode time arguments
4620   timespec absTime;
4621   if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
4622     return;
4623   }
4624   if (time > 0) {
4625     unpackTime(&absTime, isAbsolute, time);
4626   }
4627 
4628   // Enter safepoint region
4629   // Beware of deadlocks such as 6317397.
4630   // The per-thread Parker:: mutex is a classic leaf-lock.
4631   // In particular a thread must never block on the Threads_lock while
4632   // holding the Parker:: mutex. If safepoints are pending both the
4633   // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
4634   ThreadBlockInVM tbivm(jt);
4635 
4636   // Don't wait if cannot get lock since interference arises from
4637   // unblocking. Also. check interrupt before trying wait
4638   if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
4639     return;
4640   }
4641 
4642   int status;
4643   if (_counter > 0) { // no wait needed
4644     _counter = 0;
4645     status = pthread_mutex_unlock(_mutex);
4646     assert (status == 0, "invariant");
4647     OrderAccess::fence();
4648     return;
4649   }
4650 
4651 #ifdef ASSERT
4652   // Don't catch signals while blocked; let the running threads have the signals.
4653   // (This allows a debugger to break into the running thread.)
4654   sigset_t oldsigs;
4655   sigset_t* allowdebug_blocked = os::Aix::allowdebug_blocked_signals();
4656   pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
4657 #endif
4658 
4659   OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4660   jt->set_suspend_equivalent();
4661   // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
4662 
4663   if (time == 0) {
4664     status = pthread_cond_wait (_cond, _mutex);
4665   } else {
4666     status = pthread_cond_timedwait (_cond, _mutex, &absTime);
4667   }
4668   assert_status(status == 0 || status == EINTR ||
4669                 status == ETIME || status == ETIMEDOUT,
4670                 status, "cond_timedwait");
4671 
4672 #ifdef ASSERT
4673   pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
4674 #endif
4675 
4676   _counter = 0;
4677   status = pthread_mutex_unlock(_mutex);
4678   assert_status(status == 0, status, "invariant");
4679   // If externally suspended while waiting, re-suspend
4680   if (jt->handle_special_suspend_equivalent_condition()) {
4681     jt->java_suspend_self();
4682   }
4683 
4684   OrderAccess::fence();
4685 }
4686 
4687 void Parker::unpark() {
4688   int s, status;
4689   status = pthread_mutex_lock(_mutex);
4690   assert (status == 0, "invariant");
4691   s = _counter;
4692   _counter = 1;
4693   if (s < 1) {
4694     status = pthread_mutex_unlock(_mutex);
4695     assert (status == 0, "invariant");
4696     status = pthread_cond_signal (_cond);
4697     assert (status == 0, "invariant");
4698   } else {
4699     pthread_mutex_unlock(_mutex);
4700     assert (status == 0, "invariant");
4701   }
4702 }
4703 
4704 extern char** environ;
4705 
4706 // Run the specified command in a separate process. Return its exit value,
4707 // or -1 on failure (e.g. can't fork a new process).
4708 // Unlike system(), this function can be called from signal handler. It
4709 // doesn't block SIGINT et al.
4710 int os::fork_and_exec(char* cmd) {
4711   char * argv[4] = {"sh", "-c", cmd, NULL};
4712 
4713   pid_t pid = fork();
4714 
4715   if (pid < 0) {
4716     // fork failed
4717     return -1;
4718 
4719   } else if (pid == 0) {
4720     // child process
4721 
4722     // Try to be consistent with system(), which uses "/usr/bin/sh" on AIX.
4723     execve("/usr/bin/sh", argv, environ);
4724 
4725     // execve failed
4726     _exit(-1);
4727 
4728   } else {
4729     // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
4730     // care about the actual exit code, for now.
4731 
4732     int status;
4733 
4734     // Wait for the child process to exit. This returns immediately if
4735     // the child has already exited. */
4736     while (waitpid(pid, &status, 0) < 0) {
4737       switch (errno) {
4738         case ECHILD: return 0;
4739         case EINTR: break;
4740         default: return -1;
4741       }
4742     }
4743 
4744     if (WIFEXITED(status)) {
4745       // The child exited normally; get its exit code.
4746       return WEXITSTATUS(status);
4747     } else if (WIFSIGNALED(status)) {
4748       // The child exited because of a signal.
4749       // The best value to return is 0x80 + signal number,
4750       // because that is what all Unix shells do, and because
4751       // it allows callers to distinguish between process exit and
4752       // process death by signal.
4753       return 0x80 + WTERMSIG(status);
4754     } else {
4755       // Unknown exit code; pass it through.
4756       return status;
4757     }
4758   }
4759   return -1;
4760 }
4761 
4762 // is_headless_jre()
4763 //
4764 // Test for the existence of xawt/libmawt.so or libawt_xawt.so
4765 // in order to report if we are running in a headless jre.
4766 //
4767 // Since JDK8 xawt/libmawt.so is moved into the same directory
4768 // as libawt.so, and renamed libawt_xawt.so
4769 bool os::is_headless_jre() {
4770   struct stat statbuf;
4771   char buf[MAXPATHLEN];
4772   char libmawtpath[MAXPATHLEN];
4773   const char *xawtstr = "/xawt/libmawt.so";
4774   const char *new_xawtstr = "/libawt_xawt.so";
4775 
4776   char *p;
4777 
4778   // Get path to libjvm.so
4779   os::jvm_path(buf, sizeof(buf));
4780 
4781   // Get rid of libjvm.so
4782   p = strrchr(buf, '/');
4783   if (p == NULL) return false;
4784   else *p = '\0';
4785 
4786   // Get rid of client or server
4787   p = strrchr(buf, '/');
4788   if (p == NULL) return false;
4789   else *p = '\0';
4790 
4791   // check xawt/libmawt.so
4792   strcpy(libmawtpath, buf);
4793   strcat(libmawtpath, xawtstr);
4794   if (::stat(libmawtpath, &statbuf) == 0) return false;
4795 
4796   // check libawt_xawt.so
4797   strcpy(libmawtpath, buf);
4798   strcat(libmawtpath, new_xawtstr);
4799   if (::stat(libmawtpath, &statbuf) == 0) return false;
4800 
4801   return true;
4802 }
4803 
4804 // Get the default path to the core file
4805 // Returns the length of the string
4806 int os::get_core_path(char* buffer, size_t bufferSize) {
4807   const char* p = get_current_directory(buffer, bufferSize);
4808 
4809   if (p == NULL) {
4810     assert(p != NULL, "failed to get current directory");
4811     return 0;
4812   }
4813 
4814   jio_snprintf(buffer, bufferSize, "%s/core or core.%d",
4815                                                p, current_process_id());
4816 
4817   return strlen(buffer);
4818 }
4819 
4820 #ifndef PRODUCT
4821 void TestReserveMemorySpecial_test() {
4822   // No tests available for this platform
4823 }
4824 #endif
4825 
4826 bool os::start_debugging(char *buf, int buflen) {
4827   int len = (int)strlen(buf);
4828   char *p = &buf[len];
4829 
4830   jio_snprintf(p, buflen -len,
4831                  "\n\n"
4832                  "Do you want to debug the problem?\n\n"
4833                  "To debug, run 'dbx -a %d'; then switch to thread tid " INTX_FORMAT ", k-tid " INTX_FORMAT "\n"
4834                  "Enter 'yes' to launch dbx automatically (PATH must include dbx)\n"
4835                  "Otherwise, press RETURN to abort...",
4836                  os::current_process_id(),
4837                  os::current_thread_id(), thread_self());
4838 
4839   bool yes = os::message_box("Unexpected Error", buf);
4840 
4841   if (yes) {
4842     // yes, user asked VM to launch debugger
4843     jio_snprintf(buf, buflen, "dbx -a %d", os::current_process_id());
4844 
4845     os::fork_and_exec(buf);
4846     yes = false;
4847   }
4848   return yes;
4849 }
4850 
4851 static inline time_t get_mtime(const char* filename) {
4852   struct stat st;
4853   int ret = os::stat(filename, &st);
4854   assert(ret == 0, "failed to stat() file '%s': %s", filename, strerror(errno));
4855   return st.st_mtime;
4856 }
4857 
4858 int os::compare_file_modified_times(const char* file1, const char* file2) {
4859   time_t t1 = get_mtime(file1);
4860   time_t t2 = get_mtime(file2);
4861   return t1 - t2;
4862 }
--- EOF ---