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