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