Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.

  * Copyright 2012, 2013 SAP AG. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 // According to the AIX OS doc #pragma alloca must be used

 // with C++ compiler before referencing the function alloca()

 #pragma alloca

 // no precompiled headers

 #include "classfile/classLoader.hpp"

 #include "classfile/systemDictionary.hpp"

 #include "classfile/vmSymbols.hpp"

 #include "code/icBuffer.hpp"

 #include "code/vtableStubs.hpp"

 #include "compiler/compileBroker.hpp"

 #include "interpreter/interpreter.hpp"

 #include "jvm_aix.h"

 #include "libperfstat_aix.hpp"

 #include "loadlib_aix.hpp"

 #include "memory/allocation.inline.hpp"

 #include "memory/filemap.hpp"

 #include "mutex_aix.inline.hpp"

 #include "oops/oop.inline.hpp"

 #include "os_share_aix.hpp"

 #include "porting_aix.hpp"

 #include "prims/jniFastGetField.hpp"

 #include "prims/jvm.h"

 #include "prims/jvm_misc.hpp"

 #include "runtime/arguments.hpp"

 #include "runtime/extendedPC.hpp"

 #include "runtime/globals.hpp"

 #include "runtime/interfaceSupport.hpp"

 #include "runtime/java.hpp"

 #include "runtime/javaCalls.hpp"

 #include "runtime/mutexLocker.hpp"

 #include "runtime/objectMonitor.hpp"

 #include "runtime/osThread.hpp"

 #include "runtime/perfMemory.hpp"

 #include "runtime/sharedRuntime.hpp"

 #include "runtime/statSampler.hpp"

 #include "runtime/stubRoutines.hpp"

 #include "runtime/threadCritical.hpp"

 #include "runtime/timer.hpp"

 #include "services/attachListener.hpp"

 #include "services/runtimeService.hpp"

 #include "thread_aix.inline.hpp"

 #include "utilities/decoder.hpp"

 #include "utilities/defaultStream.hpp"

 #include "utilities/events.hpp"

 #include "utilities/growableArray.hpp"

 #include "utilities/vmError.hpp"

 #ifdef TARGET_ARCH_ppc

 # include "assembler_ppc.inline.hpp"

 # include "nativeInst_ppc.hpp"

 #endif

 #ifdef COMPILER1

 #include "c1/c1_Runtime1.hpp"

 #endif

 #ifdef COMPILER2

 #include "opto/runtime.hpp"

 #endif

 // put OS-includes here (sorted alphabetically)

 #include <errno.h>

 #include <fcntl.h>

 #include <inttypes.h>

 #include <poll.h>

 #include <procinfo.h>

 #include <pthread.h>

 #include <pwd.h>

 #include <semaphore.h>

 #include <signal.h>

 #include <stdint.h>

 #include <stdio.h>

 #include <string.h>

 #include <unistd.h>

 #include <sys/ioctl.h>

 #include <sys/ipc.h>

 #include <sys/mman.h>

 #include <sys/resource.h>

 #include <sys/select.h>

 #include <sys/shm.h>

 #include <sys/socket.h>

 #include <sys/stat.h>

 #include <sys/sysinfo.h>

 #include <sys/systemcfg.h>

 #include <sys/time.h>

 #include <sys/times.h>

 #include <sys/types.h>

 #include <sys/utsname.h>

 #include <sys/vminfo.h>

 #include <sys/wait.h>

 // Add missing declarations (should be in procinfo.h but isn't until AIX 6.1).

 #if !defined(_AIXVERSION_610)

 extern "C" {

   int getthrds64(pid_t ProcessIdentifier,

                  struct thrdentry64* ThreadBuffer,

                  int ThreadSize,

                  tid64_t* IndexPointer,

                  int Count);

 }

 #endif

 // Excerpts from systemcfg.h definitions newer than AIX 5.3

 #ifndef PV_7

 # define PV_7 0x200000          // Power PC 7

 # define PV_7_Compat 0x208000   // Power PC 7

 #endif

 #define MAX_PATH (2 * K)

 // for timer info max values which include all bits

 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

 // for multipage initialization error analysis (in 'g_multipage_error')

 #define ERROR_MP_OS_TOO_OLD                          100

 #define ERROR_MP_EXTSHM_ACTIVE                       101

 #define ERROR_MP_VMGETINFO_FAILED                    102

 #define ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K 103

 // the semantics in this file are thus that codeptr_t is a *real code ptr*

 // This means that any function taking codeptr_t as arguments will assume

 // a real codeptr and won't handle function descriptors (eg getFuncName),

 // whereas functions taking address as args will deal with function

 // descriptors (eg os::dll_address_to_library_name)

 typedef unsigned int* codeptr_t;

 // typedefs for stackslots, stack pointers, pointers to op codes

 typedef unsigned long stackslot_t;

 typedef stackslot_t* stackptr_t;

 // query dimensions of the stack of the calling thread

 static void query_stack_dimensions(address* p_stack_base, size_t* p_stack_size);

 // function to check a given stack pointer against given stack limits

 inline bool is_valid_stackpointer(stackptr_t sp, stackptr_t stack_base, size_t stack_size) {

   if (((uintptr_t)sp) & 0x7) {

     return false;

   }

   if (sp > stack_base) {

     return false;

   }

   if (sp < (stackptr_t) ((address)stack_base - stack_size)) {

     return false;

   }

   return true;

 }

 // returns true if function is a valid codepointer

 inline bool is_valid_codepointer(codeptr_t p) {

   if (!p) {

     return false;

   }

   if (((uintptr_t)p) & 0x3) {

     return false;

   }

   if (LoadedLibraries::find_for_text_address((address)p) == NULL) {

     return false;

   }

   return true;

 }

 // macro to check a given stack pointer against given stack limits and to die if test fails

 #define CHECK_STACK_PTR(sp, stack_base, stack_size) { \

     guarantee(is_valid_stackpointer((stackptr_t)(sp), (stackptr_t)(stack_base), stack_size), "Stack Pointer Invalid"); \

 }

 // macro to check the current stack pointer against given stacklimits

 #define CHECK_CURRENT_STACK_PTR(stack_base, stack_size) { \

   address sp; \

   sp = os::current_stack_pointer(); \

   CHECK_STACK_PTR(sp, stack_base, stack_size); \

 }

 ////////////////////////////////////////////////////////////////////////////////

 // global variables (for a description see os_aix.hpp)

 julong    os::Aix::_physical_memory = 0;

 pthread_t os::Aix::_main_thread = ((pthread_t)0);

 int       os::Aix::_page_size = -1;

 int       os::Aix::_on_pase = -1;

 int       os::Aix::_os_version = -1;

 int       os::Aix::_stack_page_size = -1;

 size_t    os::Aix::_shm_default_page_size = -1;

 int       os::Aix::_can_use_64K_pages = -1;

 int       os::Aix::_can_use_16M_pages = -1;

 int       os::Aix::_xpg_sus_mode = -1;

 int       os::Aix::_extshm = -1;

 int       os::Aix::_logical_cpus = -1;

 ////////////////////////////////////////////////////////////////////////////////

 // local variables

 static int      g_multipage_error  = -1;   // error analysis for multipage initialization

 static jlong    initial_time_count = 0;

 static int      clock_tics_per_sec = 100;

 static sigset_t check_signal_done;         // For diagnostics to print a message once (see run_periodic_checks)

 static bool     check_signals      = true;

 static pid_t    _initial_pid       = 0;

 static int      SR_signum          = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769)

 static sigset_t SR_sigset;

 static pthread_mutex_t dl_mutex;           // Used to protect dlsym() calls */

 julong os::available_memory() {

   return Aix::available_memory();

 }

 julong os::Aix::available_memory() {

   Unimplemented();

   return 0;

 }

 julong os::physical_memory() {

   return Aix::physical_memory();

 }

 ////////////////////////////////////////////////////////////////////////////////

 // environment support

 bool os::getenv(const char* name, char* buf, int len) {

   const char* val = ::getenv(name);

   if (val != NULL && strlen(val) < (size_t)len) {

     strcpy(buf, val);

     return true;

   }

   if (len > 0) buf[0] = 0;  // return a null string

   return false;

 }

 // Return true if user is running as root.

 bool os::have_special_privileges() {

   static bool init = false;

   static bool privileges = false;

   if (!init) {

     privileges = (getuid() != geteuid()) || (getgid() != getegid());

     init = true;

   }

   return privileges;

 }

 // Helper function, emulates disclaim64 using multiple 32bit disclaims

 // because we cannot use disclaim64() on AS/400 and old AIX releases.

 static bool my_disclaim64(char* addr, size_t size) {

   if (size == 0) {

     return true;

   }

   // Maximum size 32bit disclaim() accepts. (Theoretically 4GB, but I just do not trust that.)

   const unsigned int maxDisclaimSize = 0x80000000;

   const unsigned int numFullDisclaimsNeeded = (size / maxDisclaimSize);

   const unsigned int lastDisclaimSize = (size % maxDisclaimSize);

   char* p = addr;

   for (int i = 0; i < numFullDisclaimsNeeded; i ++) {

     if (::disclaim(p, maxDisclaimSize, DISCLAIM_ZEROMEM) != 0) {

       //if (Verbose)

       fprintf(stderr, "Cannot disclaim %p - %p (errno %d)\n", p, p + maxDisclaimSize, errno);

       return false;

     }

     p += maxDisclaimSize;

   }

   if (lastDisclaimSize > 0) {

     if (::disclaim(p, lastDisclaimSize, DISCLAIM_ZEROMEM) != 0) {

       //if (Verbose)

         fprintf(stderr, "Cannot disclaim %p - %p (errno %d)\n", p, p + lastDisclaimSize, errno);

       return false;

     }

   }

   return true;

 }

 // Cpu architecture string

 #if defined(PPC32)

 static char cpu_arch[] = "ppc";

 #elif defined(PPC64)

 static char cpu_arch[] = "ppc64";

 #else

 #error Add appropriate cpu_arch setting

 #endif

 // Given an address, returns the size of the page backing that address.

 size_t os::Aix::query_pagesize(void* addr) {

   vm_page_info pi;

   pi.addr = (uint64_t)addr;

   if (::vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) {

     return pi.pagesize;

   } else {

     fprintf(stderr, "vmgetinfo failed to retrieve page size for address %p (errno %d).\n", addr, errno);

     assert(false, "vmgetinfo failed to retrieve page size");

     return SIZE_4K;

   }

 }

 // Returns the kernel thread id of the currently running thread.

 pid_t os::Aix::gettid() {

   return (pid_t) thread_self();

 }

 void os::Aix::initialize_system_info() {

   // get the number of online(logical) cpus instead of configured

   os::_processor_count = sysconf(_SC_NPROCESSORS_ONLN);

   assert(_processor_count > 0, "_processor_count must be > 0");

   // retrieve total physical storage

   os::Aix::meminfo_t mi;

   if (!os::Aix::get_meminfo(&mi)) {

     fprintf(stderr, "os::Aix::get_meminfo failed.\n"); fflush(stderr);

     assert(false, "os::Aix::get_meminfo failed.");

   }

   _physical_memory = (julong) mi.real_total;

 }

 // Helper function for tracing page sizes.

 static const char* describe_pagesize(size_t pagesize) {

   switch (pagesize) {

     case SIZE_4K : return "4K";

     case SIZE_64K: return "64K";

     case SIZE_16M: return "16M";

     case SIZE_16G: return "16G";

     default:

       assert(false, "surprise");

       return "??";

   }

 }

 // Retrieve information about multipage size support. Will initialize

 // Aix::_page_size, Aix::_stack_page_size, Aix::_can_use_64K_pages,

 // Aix::_can_use_16M_pages.

 // Must be called before calling os::large_page_init().

 void os::Aix::query_multipage_support() {

   guarantee(_page_size == -1 &&

             _stack_page_size == -1 &&

             _can_use_64K_pages == -1 &&

             _can_use_16M_pages == -1 &&

             g_multipage_error == -1,

             "do not call twice");

   _page_size = ::sysconf(_SC_PAGESIZE);

   // This really would surprise me.

   assert(_page_size == SIZE_4K, "surprise!");

   // query default data page size (default page size for C-Heap, pthread stacks and .bss).

   // Default data page size is influenced either by linker options (-bdatapsize)

   // or by environment variable LDR_CNTRL (suboption DATAPSIZE). If none is given,

   // default should be 4K.

   size_t data_page_size = SIZE_4K;

   {

     void* p = ::malloc(SIZE_16M);

     data_page_size = os::Aix::query_pagesize(p);

     ::free(p);

   }

   // query default shm page size (LDR_CNTRL SHMPSIZE)

   {

     const int shmid = ::shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR | S_IWUSR);

     guarantee(shmid != -1, "shmget failed");

     void* p = ::shmat(shmid, NULL, 0);

     ::shmctl(shmid, IPC_RMID, NULL);

     guarantee(p != (void*) -1, "shmat failed");

     _shm_default_page_size = os::Aix::query_pagesize(p);

     ::shmdt(p);

   }

   // before querying the stack page size, make sure we are not running as primordial

   // thread (because primordial thread's stack may have different page size than

   // pthread thread stacks). Running a VM on the primordial thread won't work for a

   // number of reasons so we may just as well guarantee it here

   guarantee(!os::Aix::is_primordial_thread(), "Must not be called for primordial thread");

   // query stack page size

   {

     int dummy = 0;

     _stack_page_size = os::Aix::query_pagesize(&dummy);

     // everything else would surprise me and should be looked into

     guarantee(_stack_page_size == SIZE_4K || _stack_page_size == SIZE_64K, "Wrong page size");

     // also, just for completeness: pthread stacks are allocated from C heap, so

     // stack page size should be the same as data page size

     guarantee(_stack_page_size == data_page_size, "stack page size should be the same as data page size");

   }

   // EXTSHM is bad: among other things, it prevents setting pagesize dynamically

   // for system V shm.

   if (Aix::extshm()) {

     if (Verbose) {

       fprintf(stderr, "EXTSHM is active - will disable large page support.\n"

                       "Please make sure EXTSHM is OFF for large page support.\n");

     }

     g_multipage_error = ERROR_MP_EXTSHM_ACTIVE;

     _can_use_64K_pages = _can_use_16M_pages = 0;

     goto query_multipage_support_end;

   }

   // now check which page sizes the OS claims it supports, and of those, which actually can be used.

   {

     const int MAX_PAGE_SIZES = 4;

     psize_t sizes[MAX_PAGE_SIZES];

     const int num_psizes = ::vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES);

     if (num_psizes == -1) {

       if (Verbose) {

         fprintf(stderr, "vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)\n", errno);

         fprintf(stderr, "disabling multipage support.\n");

       }

       g_multipage_error = ERROR_MP_VMGETINFO_FAILED;

       _can_use_64K_pages = _can_use_16M_pages = 0;

       goto query_multipage_support_end;

     }

     guarantee(num_psizes > 0, "vmgetinfo(.., VMINFO_GETPSIZES, ...) failed.");

     assert(num_psizes <= MAX_PAGE_SIZES, "Surprise! more than 4 page sizes?");

     if (Verbose) {

       fprintf(stderr, "vmgetinfo(.., VMINFO_GETPSIZES, ...) returns %d supported page sizes: ", num_psizes);

       for (int i = 0; i < num_psizes; i ++) {

         fprintf(stderr, " %s ", describe_pagesize(sizes[i]));

       }

       fprintf(stderr, " .\n");

     }

     // Can we use 64K, 16M pages?

     _can_use_64K_pages = 0;

     _can_use_16M_pages = 0;

     for (int i = 0; i < num_psizes; i ++) {

       if (sizes[i] == SIZE_64K) {

         _can_use_64K_pages = 1;

       } else if (sizes[i] == SIZE_16M) {

         _can_use_16M_pages = 1;

       }

     }

     if (!_can_use_64K_pages) {

       g_multipage_error = ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K;

     }

     // Double-check for 16M pages: Even if AIX claims to be able to use 16M pages,

     // there must be an actual 16M page pool, and we must run with enough rights.

     if (_can_use_16M_pages) {

       const int shmid = ::shmget(IPC_PRIVATE, SIZE_16M, IPC_CREAT | S_IRUSR | S_IWUSR);

       guarantee(shmid != -1, "shmget failed");

       struct shmid_ds shm_buf = { 0 };

       shm_buf.shm_pagesize = SIZE_16M;

       const bool can_set_pagesize = ::shmctl(shmid, SHM_PAGESIZE, &shm_buf) == 0 ? true : false;

       const int en = errno;

       ::shmctl(shmid, IPC_RMID, NULL);

       if (!can_set_pagesize) {

         if (Verbose) {

           fprintf(stderr, "Failed to allocate even one misely 16M page. shmctl failed with %d (%s).\n"

                           "Will deactivate 16M support.\n", en, strerror(en));

         }

         _can_use_16M_pages = 0;

       }

     }

   } // end: check which pages can be used for shared memory

 query_multipage_support_end:

   guarantee(_page_size != -1 &&

             _stack_page_size != -1 &&

             _can_use_64K_pages != -1 &&

             _can_use_16M_pages != -1, "Page sizes not properly initialized");

   if (_can_use_64K_pages) {

     g_multipage_error = 0;

   }

   if (Verbose) {

     fprintf(stderr, "Data page size (C-Heap, bss, etc): %s\n", describe_pagesize(data_page_size));

     fprintf(stderr, "Thread stack page size (pthread): %s\n", describe_pagesize(_stack_page_size));

     fprintf(stderr, "Default shared memory page size: %s\n", describe_pagesize(_shm_default_page_size));

     fprintf(stderr, "Can use 64K pages dynamically with shared meory: %s\n", (_can_use_64K_pages ? "yes" :"no"));

     fprintf(stderr, "Can use 16M pages dynamically with shared memory: %s\n", (_can_use_16M_pages ? "yes" :"no"));

     fprintf(stderr, "Multipage error details: %d\n", g_multipage_error);

   }

 } // end os::Aix::query_multipage_support()

 // The code for this method was initially derived from the version in os_linux.cpp

 void os::init_system_properties_values() {

   // The next few definitions allow the code to be verbatim:

 #define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal)

 #define DEFAULT_LIBPATH "/usr/lib:/lib"

 #define EXTENSIONS_DIR  "/lib/ext"

 #define ENDORSED_DIR    "/lib/endorsed"

   // sysclasspath, java_home, dll_dir

   char *home_path;

   char *dll_path;

   char *pslash;

   char buf[MAXPATHLEN];

   os::jvm_path(buf, sizeof(buf));

   // Found the full path to libjvm.so.

   // Now cut the path to <java_home>/jre if we can.

   *(strrchr(buf, '/')) = '\0'; // get rid of /libjvm.so

   pslash = strrchr(buf, '/');

   if (pslash != NULL) {

     *pslash = '\0';            // get rid of /{client|server|hotspot}

   }

   dll_path = malloc(strlen(buf) + 1);

   strcpy(dll_path, buf);

   Arguments::set_dll_dir(dll_path);

   if (pslash != NULL) {

     pslash = strrchr(buf, '/');

     if (pslash != NULL) {

       *pslash = '\0';          // get rid of /<arch>

       pslash = strrchr(buf, '/');

       if (pslash != NULL) {

         *pslash = '\0';        // get rid of /lib

       }

     }

   }

   home_path = malloc(strlen(buf) + 1);

   strcpy(home_path, buf);

   Arguments::set_java_home(home_path);

   if (!set_boot_path('/', ':')) return;

   // Where to look for native libraries

   // On Aix we get the user setting of LIBPATH

   // Eventually, all the library path setting will be done here.

   char *ld_library_path;

   // Construct the invariant part of ld_library_path.

   ld_library_path = (char *) malloc(sizeof(DEFAULT_LIBPATH));

   sprintf(ld_library_path, DEFAULT_LIBPATH);

   // Get the user setting of LIBPATH, and prepended it.

   char *v = ::getenv("LIBPATH");

   if (v == NULL) {

     v = "";

   }

   char *t = ld_library_path;

   // That's +1 for the colon and +1 for the trailing '\0'

   ld_library_path = (char *) malloc(strlen(v) + 1 + strlen(t) + 1);

   sprintf(ld_library_path, "%s:%s", v, t);

   Arguments::set_library_path(ld_library_path);

   // Extensions directories

   char* cbuf = malloc(strlen(Arguments::get_java_home()) + sizeof(EXTENSIONS_DIR));

   sprintf(cbuf, "%s" EXTENSIONS_DIR, Arguments::get_java_home());

   Arguments::set_ext_dirs(cbuf);

   // Endorsed standards default directory.

   cbuf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR));

   sprintf(cbuf, "%s" ENDORSED_DIR, Arguments::get_java_home());

   Arguments::set_endorsed_dirs(cbuf);

 #undef malloc

 #undef DEFAULT_LIBPATH

 #undef EXTENSIONS_DIR

 #undef ENDORSED_DIR

 }

 ////////////////////////////////////////////////////////////////////////////////

 // breakpoint support

 void os::breakpoint() {

   BREAKPOINT;

 }

 extern "C" void breakpoint() {

   // use debugger to set breakpoint here

 }

 ////////////////////////////////////////////////////////////////////////////////

 // signal support

 debug_only(static bool signal_sets_initialized = false);

 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;

 bool os::Aix::is_sig_ignored(int sig) {

   struct sigaction oact;

   sigaction(sig, (struct sigaction*)NULL, &oact);

   void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)

     : CAST_FROM_FN_PTR(void*, oact.sa_handler);

   if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))

     return true;

   else

     return false;

 }

 void os::Aix::signal_sets_init() {

   // Should also have an assertion stating we are still single-threaded.

   assert(!signal_sets_initialized, "Already initialized");

   // Fill in signals that are necessarily unblocked for all threads in

   // the VM. Currently, we unblock the following signals:

   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden

   //                         by -Xrs (=ReduceSignalUsage));

   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all

   // other threads. The "ReduceSignalUsage" boolean tells us not to alter

   // the dispositions or masks wrt these signals.

   // Programs embedding the VM that want to use the above signals for their

   // own purposes must, at this time, use the "-Xrs" option to prevent

   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.

   // (See bug 4345157, and other related bugs).

   // In reality, though, unblocking these signals is really a nop, since

   // these signals are not blocked by default.

   sigemptyset(&unblocked_sigs);

   sigemptyset(&allowdebug_blocked_sigs);

   sigaddset(&unblocked_sigs, SIGILL);

   sigaddset(&unblocked_sigs, SIGSEGV);

   sigaddset(&unblocked_sigs, SIGBUS);

   sigaddset(&unblocked_sigs, SIGFPE);

   sigaddset(&unblocked_sigs, SIGTRAP);

   sigaddset(&unblocked_sigs, SIGDANGER);

   sigaddset(&unblocked_sigs, SR_signum);

   if (!ReduceSignalUsage) {

    if (!os::Aix::is_sig_ignored(SHUTDOWN1_SIGNAL)) {

      sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);

      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);

    }

    if (!os::Aix::is_sig_ignored(SHUTDOWN2_SIGNAL)) {

      sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);

      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);

    }

    if (!os::Aix::is_sig_ignored(SHUTDOWN3_SIGNAL)) {

      sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);

      sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);

    }

   }

   // Fill in signals that are blocked by all but the VM thread.

   sigemptyset(&vm_sigs);

   if (!ReduceSignalUsage)

     sigaddset(&vm_sigs, BREAK_SIGNAL);

   debug_only(signal_sets_initialized = true);

 }

 // These are signals that are unblocked while a thread is running Java.

 // (For some reason, they get blocked by default.)

 sigset_t* os::Aix::unblocked_signals() {

   assert(signal_sets_initialized, "Not initialized");

   return &unblocked_sigs;

 }

 // These are the signals that are blocked while a (non-VM) thread is

 // running Java. Only the VM thread handles these signals.

 sigset_t* os::Aix::vm_signals() {

   assert(signal_sets_initialized, "Not initialized");

   return &vm_sigs;

 }

 // These are signals that are blocked during cond_wait to allow debugger in

 sigset_t* os::Aix::allowdebug_blocked_signals() {

   assert(signal_sets_initialized, "Not initialized");

   return &allowdebug_blocked_sigs;

 }

 void os::Aix::hotspot_sigmask(Thread* thread) {

   //Save caller's signal mask before setting VM signal mask

   sigset_t caller_sigmask;

   pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);

   OSThread* osthread = thread->osthread();

   osthread->set_caller_sigmask(caller_sigmask);

   pthread_sigmask(SIG_UNBLOCK, os::Aix::unblocked_signals(), NULL);

   if (!ReduceSignalUsage) {

     if (thread->is_VM_thread()) {

       // Only the VM thread handles BREAK_SIGNAL ...

       pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);

     } else {

       // ... all other threads block BREAK_SIGNAL

       pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);

     }

   }

 }

 // retrieve memory information.

 // Returns false if something went wrong;

 // content of pmi undefined in this case.

 bool os::Aix::get_meminfo(meminfo_t* pmi) {

   assert(pmi, "get_meminfo: invalid parameter");

   memset(pmi, 0, sizeof(meminfo_t));

   if (os::Aix::on_pase()) {

     Unimplemented();

     return false;

   } else {

     // On AIX, I use the (dynamically loaded) perfstat library to retrieve memory statistics

     // See:

     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp

     //        ?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_memtot.htm

     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp

     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm

     perfstat_memory_total_t psmt;

     memset (&psmt, '\0', sizeof(psmt));

     const int rc = libperfstat::perfstat_memory_total(NULL, &psmt, sizeof(psmt), 1);

     if (rc == -1) {

       fprintf(stderr, "perfstat_memory_total() failed (errno=%d)\n", errno);

       assert(0, "perfstat_memory_total() failed");

       return false;

     }

     assert(rc == 1, "perfstat_memory_total() - weird return code");

     // excerpt from

     // http://publib.boulder.ibm.com/infocenter/systems/index.jsp

     //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm

     // The fields of perfstat_memory_total_t:

     // u_longlong_t virt_total         Total virtual memory (in 4 KB pages).

     // u_longlong_t real_total         Total real memory (in 4 KB pages).

     // u_longlong_t real_free          Free real memory (in 4 KB pages).

     // u_longlong_t pgsp_total         Total paging space (in 4 KB pages).

     // u_longlong_t pgsp_free          Free paging space (in 4 KB pages).

     pmi->virt_total = psmt.virt_total * 4096;

     pmi->real_total = psmt.real_total * 4096;

     pmi->real_free = psmt.real_free * 4096;

     pmi->pgsp_total = psmt.pgsp_total * 4096;

     pmi->pgsp_free = psmt.pgsp_free * 4096;

     return true;

   }

 } // end os::Aix::get_meminfo

 // Retrieve global cpu information.

 // Returns false if something went wrong;

 // the content of pci is undefined in this case.

 bool os::Aix::get_cpuinfo(cpuinfo_t* pci) {

   assert(pci, "get_cpuinfo: invalid parameter");

   memset(pci, 0, sizeof(cpuinfo_t));

   perfstat_cpu_total_t psct;

   memset (&psct, '\0', sizeof(psct));

   if (-1 == libperfstat::perfstat_cpu_total(NULL, &psct, sizeof(perfstat_cpu_total_t), 1)) {

     fprintf(stderr, "perfstat_cpu_total() failed (errno=%d)\n", errno);

     assert(0, "perfstat_cpu_total() failed");

     return false;

   }

   // global cpu information

   strcpy (pci->description, psct.description);

   pci->processorHZ = psct.processorHZ;

   pci->ncpus = psct.ncpus;

   os::Aix::_logical_cpus = psct.ncpus;

   for (int i = 0; i < 3; i++) {

     pci->loadavg[i] = (double) psct.loadavg[i] / (1 << SBITS);

   }

   // get the processor version from _system_configuration

   switch (_system_configuration.version) {

   case PV_7:

     strcpy(pci->version, "Power PC 7");

     break;

   case PV_6_1:

     strcpy(pci->version, "Power PC 6 DD1.x");

     break;

   case PV_6:

     strcpy(pci->version, "Power PC 6");

     break;

   case PV_5:

     strcpy(pci->version, "Power PC 5");

     break;

   case PV_5_2:

     strcpy(pci->version, "Power PC 5_2");

     break;

   case PV_5_3:

     strcpy(pci->version, "Power PC 5_3");

     break;

   case PV_5_Compat:

     strcpy(pci->version, "PV_5_Compat");

     break;

   case PV_6_Compat:

     strcpy(pci->version, "PV_6_Compat");

     break;

   case PV_7_Compat:

     strcpy(pci->version, "PV_7_Compat");

     break;

   default:

     strcpy(pci->version, "unknown");

   }

   return true;

 } //end os::Aix::get_cpuinfo

 //////////////////////////////////////////////////////////////////////////////

 // detecting pthread library

 void os::Aix::libpthread_init() {

   return;

 }

 //////////////////////////////////////////////////////////////////////////////

 // create new thread

 // Thread start routine for all newly created threads

 static void *java_start(Thread *thread) {

   // find out my own stack dimensions

   {

     // actually, this should do exactly the same as thread->record_stack_base_and_size...

     address base = 0;

     size_t size = 0;

     query_stack_dimensions(&base, &size);

     thread->set_stack_base(base);

     thread->set_stack_size(size);

   }

   // Do some sanity checks.

   CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());

   // Try to randomize the cache line index of hot stack frames.

   // This helps when threads of the same stack traces evict each other's

   // cache lines. The threads can be either from the same JVM instance, or

   // from different JVM instances. The benefit is especially true for

   // processors with hyperthreading technology.

   static int counter = 0;

   int pid = os::current_process_id();

   alloca(((pid ^ counter++) & 7) * 128);

   ThreadLocalStorage::set_thread(thread);

   OSThread* osthread = thread->osthread();

   // thread_id is kernel thread id (similar to Solaris LWP id)

   osthread->set_thread_id(os::Aix::gettid());

   // initialize signal mask for this thread

   os::Aix::hotspot_sigmask(thread);

   // initialize floating point control register

   os::Aix::init_thread_fpu_state();

   assert(osthread->get_state() == RUNNABLE, "invalid os thread state");

   // call one more level start routine

   thread->run();

   return 0;

 }

 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {

   // We want the whole function to be synchronized.

   ThreadCritical cs;

   assert(thread->osthread() == NULL, "caller responsible");

   // Allocate the OSThread object

   OSThread* osthread = new OSThread(NULL, NULL);

   if (osthread == NULL) {

     return false;

   }

   // set the correct thread state

   osthread->set_thread_type(thr_type);

   // Initial state is ALLOCATED but not INITIALIZED

   osthread->set_state(ALLOCATED);

   thread->set_osthread(osthread);

   // init thread attributes

   pthread_attr_t attr;

   pthread_attr_init(&attr);

   guarantee(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0, "???");

   // Make sure we run in 1:1 kernel-user-thread mode.

   if (os::Aix::on_aix()) {

     guarantee(pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0, "???");

     guarantee(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0, "???");

   } // end: aix

   // Start in suspended state, and in os::thread_start, wake the thread up.

   guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???");

   // calculate stack size if it's not specified by caller

   if (os::Aix::supports_variable_stack_size()) {

     if (stack_size == 0) {

       stack_size = os::Aix::default_stack_size(thr_type);

       switch (thr_type) {

       case os::java_thread:

         // Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.

         assert(JavaThread::stack_size_at_create() > 0, "this should be set");

         stack_size = JavaThread::stack_size_at_create();

         break;

       case os::compiler_thread:

         if (CompilerThreadStackSize > 0) {

           stack_size = (size_t)(CompilerThreadStackSize * K);

           break;

         } // else fall through:

           // use VMThreadStackSize if CompilerThreadStackSize is not defined

       case os::vm_thread:

       case os::pgc_thread:

       case os::cgc_thread:

       case os::watcher_thread:

         if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);

         break;

       }

     }

     stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);

     pthread_attr_setstacksize(&attr, stack_size);

   } //else let thread_create() pick the default value (96 K on AIX)

   pthread_t tid;

   int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

   pthread_attr_destroy(&attr);

   if (ret != 0) {

     if (PrintMiscellaneous && (Verbose || WizardMode)) {

       perror("pthread_create()");

     }

     // Need to clean up stuff we've allocated so far

     thread->set_osthread(NULL);

     delete osthread;

     return false;

   }

   // Store pthread info into the OSThread

   osthread->set_pthread_id(tid);

   return true;

 }

 /////////////////////////////////////////////////////////////////////////////

 // attach existing thread

 // bootstrap the main thread

 bool os::create_main_thread(JavaThread* thread) {

   assert(os::Aix::_main_thread == pthread_self(), "should be called inside main thread");

   return create_attached_thread(thread);

 }

 bool os::create_attached_thread(JavaThread* thread) {

 #ifdef ASSERT

     thread->verify_not_published();

 #endif

   // Allocate the OSThread object

   OSThread* osthread = new OSThread(NULL, NULL);

   if (osthread == NULL) {

     return false;

   }

   // Store pthread info into the OSThread

   osthread->set_thread_id(os::Aix::gettid());

   osthread->set_pthread_id(::pthread_self());

   // initialize floating point control register

   os::Aix::init_thread_fpu_state();

   // some sanity checks

   CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());

   // Initial thread state is RUNNABLE

   osthread->set_state(RUNNABLE);

   thread->set_osthread(osthread);

   if (UseNUMA) {

     int lgrp_id = os::numa_get_group_id();

     if (lgrp_id != -1) {

       thread->set_lgrp_id(lgrp_id);

     }

   }

   // initialize signal mask for this thread

   // and save the caller's signal mask

   os::Aix::hotspot_sigmask(thread);

   return true;

 }

 void os::pd_start_thread(Thread* thread) {

   int status = pthread_continue_np(thread->osthread()->pthread_id());

   assert(status == 0, "thr_continue failed");

 }

 // Free OS resources related to the OSThread

 void os::free_thread(OSThread* osthread) {

   assert(osthread != NULL, "osthread not set");

   if (Thread::current()->osthread() == osthread) {

     // Restore caller's signal mask

     sigset_t sigmask = osthread->caller_sigmask();

     pthread_sigmask(SIG_SETMASK, &sigmask, NULL);

    }

   delete osthread;

 }

 //////////////////////////////////////////////////////////////////////////////

 // thread local storage

 int os::allocate_thread_local_storage() {

   pthread_key_t key;

   int rslt = pthread_key_create(&key, NULL);

   assert(rslt == 0, "cannot allocate thread local storage");

   return (int)key;

 }

 // Note: This is currently not used by VM, as we don't destroy TLS key

 // on VM exit.

 void os::free_thread_local_storage(int index) {

   int rslt = pthread_key_delete((pthread_key_t)index);

   assert(rslt == 0, "invalid index");

 }

 void os::thread_local_storage_at_put(int index, void* value) {

   int rslt = pthread_setspecific((pthread_key_t)index, value);

   assert(rslt == 0, "pthread_setspecific failed");

 }

 extern "C" Thread* get_thread() {

   return ThreadLocalStorage::thread();

 }

 ////////////////////////////////////////////////////////////////////////////////

 // time support

 // Time since start-up in seconds to a fine granularity.

 // Used by VMSelfDestructTimer and the MemProfiler.

 double os::elapsedTime() {

   return (double)(os::elapsed_counter()) * 0.000001;

 }

 jlong os::elapsed_counter() {

   timeval time;

   int status = gettimeofday(&time, NULL);

   return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;

 }

 jlong os::elapsed_frequency() {

   return (1000 * 1000);

 }

 // For now, we say that linux does not support vtime. I have no idea

 // whether it can actually be made to (DLD, 9/13/05).

 bool os::supports_vtime() { return false; }

 bool os::enable_vtime()   { return false; }

 bool os::vtime_enabled()  { return false; }

 double os::elapsedVTime() {

   // better than nothing, but not much

   return elapsedTime();

 }

 jlong os::javaTimeMillis() {

   timeval time;

   int status = gettimeofday(&time, NULL);

   assert(status != -1, "aix error at gettimeofday()");

   return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000);

 }

 // We need to manually declare mread_real_time,

 // because IBM didn't provide a prototype in time.h.

 // (they probably only ever tested in C, not C++)

 extern "C"

 int mread_real_time(timebasestruct_t *t, size_t size_of_timebasestruct_t);

 jlong os::javaTimeNanos() {

   if (os::Aix::on_pase()) {

     Unimplemented();

     return 0;

   }

   else {

     // On AIX use the precision of processors real time clock

     // or time base registers.

     timebasestruct_t time;

     int rc;

     // If the CPU has a time register, it will be used and

     // we have to convert to real time first. After convertion we have following data:

     // time.tb_high [seconds since 00:00:00 UTC on 1.1.1970]

     // time.tb_low  [nanoseconds after the last full second above]

     // We better use mread_real_time here instead of read_real_time

     // to ensure that we will get a monotonic increasing time.

     if (mread_real_time(&time, TIMEBASE_SZ) != RTC_POWER) {

       rc = time_base_to_time(&time, TIMEBASE_SZ);

       assert(rc != -1, "aix error at time_base_to_time()");

     }

     return jlong(time.tb_high) * (1000 * 1000 * 1000) + jlong(time.tb_low);

   }

 }

 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {

   {

     // gettimeofday - based on time in seconds since the Epoch thus does not wrap

     info_ptr->max_value = ALL_64_BITS;

     // gettimeofday is a real time clock so it skips

     info_ptr->may_skip_backward = true;

     info_ptr->may_skip_forward = true;

   }

   info_ptr->kind = JVMTI_TIMER_ELAPSED;    // elapsed not CPU time

 }

 // Return the real, user, and system times in seconds from an

 // arbitrary fixed point in the past.

 bool os::getTimesSecs(double* process_real_time,

                       double* process_user_time,

                       double* process_system_time) {

   Unimplemented();

   return false;

 }

 char * os::local_time_string(char *buf, size_t buflen) {

   struct tm t;

   time_t long_time;

   time(&long_time);

   localtime_r(&long_time, &t);

   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",

                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,

                t.tm_hour, t.tm_min, t.tm_sec);

   return buf;

 }

 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {

   return localtime_r(clock, res);

 }

 ////////////////////////////////////////////////////////////////////////////////

 // runtime exit support

 // Note: os::shutdown() might be called very early during initialization, or

 // called from signal handler. Before adding something to os::shutdown(), make

 // sure it is async-safe and can handle partially initialized VM.

 void os::shutdown() {

   // allow PerfMemory to attempt cleanup of any persistent resources

   perfMemory_exit();

   // needs to remove object in file system

   AttachListener::abort();

   // flush buffered output, finish log files

   ostream_abort();

   // Check for abort hook

   abort_hook_t abort_hook = Arguments::abort_hook();

   if (abort_hook != NULL) {

     abort_hook();

   }

 }

 // Note: os::abort() might be called very early during initialization, or

 // called from signal handler. Before adding something to os::abort(), make

 // sure it is async-safe and can handle partially initialized VM.

 void os::abort(bool dump_core) {

   os::shutdown();

   if (dump_core) {

 #ifndef PRODUCT

     fdStream out(defaultStream::output_fd());

     out.print_raw("Current thread is ");

     char buf[16];

     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());

     out.print_raw_cr(buf);

     out.print_raw_cr("Dumping core ...");

 #endif

     ::abort(); // dump core

   }

   ::exit(1);

 }

 // Die immediately, no exit hook, no abort hook, no cleanup.

 void os::die() {

   ::abort();

 }

 // Unused on Aix for now.

 void os::set_error_file(const char *logfile) {}

 // This method is a copy of JDK's sysGetLastErrorString

 // from src/solaris/hpi/src/system_md.c

 size_t os::lasterror(char *buf, size_t len) {

   if (errno == 0)  return 0;

   const char *s = ::strerror(errno);

   size_t n = ::strlen(s);

   if (n >= len) {

     n = len - 1;

   }

   ::strncpy(buf, s, n);

   buf[n] = '\0';

   return n;

 }

 intx os::current_thread_id() { return (intx)pthread_self(); }

 int os::current_process_id() {

   // This implementation returns a unique pid, the pid of the

   // launcher thread that starts the vm 'process'.

   // Under POSIX, getpid() returns the same pid as the

   // launcher thread rather than a unique pid per thread.

   // Use gettid() if you want the old pre NPTL behaviour.

   // if you are looking for the result of a call to getpid() that

   // returns a unique pid for the calling thread, then look at the

   // OSThread::thread_id() method in osThread_linux.hpp file

   return (int)(_initial_pid ? _initial_pid : getpid());

 }

 // DLL functions

 const char* os::dll_file_extension() { return ".so"; }

 // This must be hard coded because it's the system's temporary

 // directory not the java application's temp directory, ala java.io.tmpdir.

 const char* os::get_temp_directory() { return "/tmp"; }

 static bool file_exists(const char* filename) {

   struct stat statbuf;

   if (filename == NULL || strlen(filename) == 0) {

     return false;

   }

   return os::stat(filename, &statbuf) == 0;

 }

 bool os::dll_build_name(char* buffer, size_t buflen,

                         const char* pname, const char* fname) {

   bool retval = false;

   // Copied from libhpi

   const size_t pnamelen = pname ? strlen(pname) : 0;

   // Return error on buffer overflow.

   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {

     *buffer = '\0';

     return retval;

   }

   if (pnamelen == 0) {

     snprintf(buffer, buflen, "lib%s.so", fname);

     retval = true;

   } else if (strchr(pname, *os::path_separator()) != NULL) {

     int n;

     char** pelements = split_path(pname, &n);

     for (int i = 0; i < n; i++) {

       // Really shouldn't be NULL, but check can't hurt

       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {

         continue; // skip the empty path values

       }

       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);

       if (file_exists(buffer)) {

         retval = true;

         break;

       }

     }

     // release the storage

     for (int i = 0; i < n; i++) {

       if (pelements[i] != NULL) {

         FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);

       }

     }

     if (pelements != NULL) {

       FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);

     }

   } else {

     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);

     retval = true;

   }

   return retval;

 }

 // Check if addr is inside libjvm.so.

 bool os::address_is_in_vm(address addr) {

   // Input could be a real pc or a function pointer literal. The latter

   // would be a function descriptor residing in the data segment of a module.

   const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(addr);

   if (lib) {

     if (strcmp(lib->get_shortname(), "libjvm.so") == 0) {

       return true;

     } else {

       return false;

     }

   } else {

     lib = LoadedLibraries::find_for_data_address(addr);

     if (lib) {

       if (strcmp(lib->get_shortname(), "libjvm.so") == 0) {

         return true;

       } else {

         return false;

       }

     } else {

       return false;

     }

   }

 }

 // Resolve an AIX function descriptor literal to a code pointer.

 // If the input is a valid code pointer to a text segment of a loaded module,

 //   it is returned unchanged.

 // If the input is a valid AIX function descriptor, it is resolved to the

 //   code entry point.

 // If the input is neither a valid function descriptor nor a valid code pointer,

 //   NULL is returned.

 static address resolve_function_descriptor_to_code_pointer(address p) {

   const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(p);

   if (lib) {

     // its a real code pointer

     return p;

   } else {

     lib = LoadedLibraries::find_for_data_address(p);

     if (lib) {

       // pointer to data segment, potential function descriptor

       address code_entry = (address)(((FunctionDescriptor*)p)->entry());

       if (LoadedLibraries::find_for_text_address(code_entry)) {

         // Its a function descriptor

         return code_entry;

       }

     }

   }

   return NULL;

 }

 bool os::dll_address_to_function_name(address addr, char *buf,

                                       int buflen, int *offset) {

   if (offset) {

     *offset = -1;

   }

   if (buf) {

     buf[0] = '\0';

   }

   // Resolve function ptr literals first.

   addr = resolve_function_descriptor_to_code_pointer(addr);

   if (!addr) {

     return false;

   }

   // Go through Decoder::decode to call getFuncName which reads the name from the traceback table.

   return Decoder::decode(addr, buf, buflen, offset);

 }

 static int getModuleName(codeptr_t pc,                    // [in] program counter

                          char* p_name, size_t namelen,    // [out] optional: function name

                          char* p_errmsg, size_t errmsglen // [out] optional: user provided buffer for error messages

                          ) {

   // initialize output parameters

   if (p_name && namelen > 0) {

     *p_name = '\0';

   }

   if (p_errmsg && errmsglen > 0) {

     *p_errmsg = '\0';

   }

   const LoadedLibraryModule* const lib = LoadedLibraries::find_for_text_address((address)pc);

   if (lib) {

     if (p_name && namelen > 0) {

       sprintf(p_name, "%.*s", namelen, lib->get_shortname());

     }

     return 0;

   }

   if (Verbose) {

     fprintf(stderr, "pc outside any module");

   }

   return -1;

 }

 bool os::dll_address_to_library_name(address addr, char* buf,

                                      int buflen, int* offset) {

   if (offset) {

     *offset = -1;

   }

   if (buf) {

       buf[0] = '\0';

   }

   // Resolve function ptr literals first.

   addr = resolve_function_descriptor_to_code_pointer(addr);

   if (!addr) {

     return false;

   }

   if (::getModuleName((codeptr_t) addr, buf, buflen, 0, 0) == 0) {

     return true;

   }

   return false;

 }

 // Loads .dll/.so and in case of error it checks if .dll/.so was built

 // for the same architecture as Hotspot is running on

 void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {

   if (ebuf && ebuflen > 0) {

     ebuf[0] = '\0';

     ebuf[ebuflen - 1] = '\0';

   }

   if (!filename || strlen(filename) == 0) {

     ::strncpy(ebuf, "dll_load: empty filename specified", ebuflen - 1);

     return NULL;

   }

   // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants.

   void * result= ::dlopen(filename, RTLD_LAZY);

   if (result != NULL) {

     // Reload dll cache. Don't do this in signal handling.

     LoadedLibraries::reload();

     return result;

   } else {

     // error analysis when dlopen fails

     const char* const error_report = ::dlerror();

     if (error_report && ebuf && ebuflen > 0) {

       snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s",

                filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report);

     }

   }

   return NULL;

 }

 // Glibc-2.0 libdl is not MT safe. If you are building with any glibc,

 // chances are you might want to run the generated bits against glibc-2.0

 // libdl.so, so always use locking for any version of glibc.

 void* os::dll_lookup(void* handle, const char* name) {

   pthread_mutex_lock(&dl_mutex);

   void* res = dlsym(handle, name);

   pthread_mutex_unlock(&dl_mutex);

   return res;

 }

 void os::print_dll_info(outputStream *st) {

   st->print_cr("Dynamic libraries:");

   LoadedLibraries::print(st);

 }

 void os::print_os_info(outputStream* st) {

   st->print("OS:");

   st->print("uname:");

   struct utsname name;

   uname(&name);

   st->print(name.sysname); st->print(" ");

   st->print(name.nodename); st->print(" ");

   st->print(name.release); st->print(" ");

   st->print(name.version); st->print(" ");

   st->print(name.machine);

   st->cr();

   // rlimit

   st->print("rlimit:");

   struct rlimit rlim;

   st->print(" STACK ");

   getrlimit(RLIMIT_STACK, &rlim);

   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

   else st->print("%uk", rlim.rlim_cur >> 10);

   st->print(", CORE ");

   getrlimit(RLIMIT_CORE, &rlim);

   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

   else st->print("%uk", rlim.rlim_cur >> 10);

   st->print(", NPROC ");

   st->print("%d", sysconf(_SC_CHILD_MAX));

   st->print(", NOFILE ");

   getrlimit(RLIMIT_NOFILE, &rlim);

   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

   else st->print("%d", rlim.rlim_cur);

   st->print(", AS ");

   getrlimit(RLIMIT_AS, &rlim);

   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

   else st->print("%uk", rlim.rlim_cur >> 10);

   // Print limits on DATA, because it limits the C-heap.

   st->print(", DATA ");

   getrlimit(RLIMIT_DATA, &rlim);

   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

   else st->print("%uk", rlim.rlim_cur >> 10);

   st->cr();

   // load average

   st->print("load average:");

   double loadavg[3] = {-1.L, -1.L, -1.L};

   os::loadavg(loadavg, 3);

   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);

   st->cr();

 }

 void os::print_memory_info(outputStream* st) {

   st->print_cr("Memory:");

   st->print_cr("  default page size: %s", describe_pagesize(os::vm_page_size()));

   st->print_cr("  default stack page size: %s", describe_pagesize(os::vm_page_size()));

   st->print_cr("  default shm page size: %s", describe_pagesize(os::Aix::shm_default_page_size()));

   st->print_cr("  can use 64K pages dynamically: %s", (os::Aix::can_use_64K_pages() ? "yes" :"no"));

   st->print_cr("  can use 16M pages dynamically: %s", (os::Aix::can_use_16M_pages() ? "yes" :"no"));

   if (g_multipage_error != 0) {

     st->print_cr("  multipage error: %d", g_multipage_error);

   }

   // print out LDR_CNTRL because it affects the default page sizes

   const char* const ldr_cntrl = ::getenv("LDR_CNTRL");

   st->print_cr("  LDR_CNTRL=%s.", ldr_cntrl ? ldr_cntrl : "<unset>");

   const char* const extshm = ::getenv("EXTSHM");

   st->print_cr("  EXTSHM=%s.", extshm ? extshm : "<unset>");

   // Call os::Aix::get_meminfo() to retrieve memory statistics.

   os::Aix::meminfo_t mi;

   if (os::Aix::get_meminfo(&mi)) {

     char buffer[256];

     if (os::Aix::on_aix()) {

       jio_snprintf(buffer, sizeof(buffer),

                    "  physical total : %llu\n"

                    "  physical free  : %llu\n"

                    "  swap total     : %llu\n"

                    "  swap free      : %llu\n",

                    mi.real_total,

                    mi.real_free,

                    mi.pgsp_total,

                    mi.pgsp_free);

     } else {

       Unimplemented();

     }

     st->print_raw(buffer);

   } else {

     st->print_cr("  (no more information available)");

   }

 }

 void os::pd_print_cpu_info(outputStream* st) {

   // cpu

   st->print("CPU:");

   st->print("total %d", os::processor_count());

   // It's not safe to query number of active processors after crash

   // st->print("(active %d)", os::active_processor_count());

   st->print(" %s", VM_Version::cpu_features());

   st->cr();

 }

 void os::print_siginfo(outputStream* st, void* siginfo) {

   // Use common posix version.

   os::Posix::print_siginfo_brief(st, (const siginfo_t*) siginfo);

   st->cr();

 }

 static void print_signal_handler(outputStream* st, int sig,

                                  char* buf, size_t buflen);

 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {

   st->print_cr("Signal Handlers:");

   print_signal_handler(st, SIGSEGV, buf, buflen);

   print_signal_handler(st, SIGBUS , buf, buflen);

   print_signal_handler(st, SIGFPE , buf, buflen);

   print_signal_handler(st, SIGPIPE, buf, buflen);

   print_signal_handler(st, SIGXFSZ, buf, buflen);

   print_signal_handler(st, SIGILL , buf, buflen);

   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);

   print_signal_handler(st, SR_signum, buf, buflen);

   print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);

   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);

   print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);

   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);

   print_signal_handler(st, SIGTRAP, buf, buflen);

   print_signal_handler(st, SIGDANGER, buf, buflen);

 }

 static char saved_jvm_path[MAXPATHLEN] = {0};

 // Find the full path to the current module, libjvm.so or libjvm_g.so

 void os::jvm_path(char *buf, jint buflen) {

   // Error checking.

   if (buflen < MAXPATHLEN) {

     assert(false, "must use a large-enough buffer");

     buf[0] = '\0';

     return;

   }

   // Lazy resolve the path to current module.

   if (saved_jvm_path[0] != 0) {

     strcpy(buf, saved_jvm_path);

     return;

   }

   Dl_info dlinfo;

   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);

   assert(ret != 0, "cannot locate libjvm");

   char* rp = realpath((char *)dlinfo.dli_fname, buf);

   assert(rp != NULL, "error in realpath(): maybe the 'path' argument is too long?");

   strcpy(saved_jvm_path, buf);

 }

 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {

   // no prefix required, not even "_"

 }

 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {

   // no suffix required

 }

 ////////////////////////////////////////////////////////////////////////////////

 // sun.misc.Signal support

 static volatile jint sigint_count = 0;

 static void

 UserHandler(int sig, void *siginfo, void *context) {

   // 4511530 - sem_post is serialized and handled by the manager thread. When

   // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We

   // don't want to flood the manager thread with sem_post requests.

   if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)

     return;

   // Ctrl-C is pressed during error reporting, likely because the error

   // handler fails to abort. Let VM die immediately.

   if (sig == SIGINT && is_error_reported()) {

     os::die();

   }

   os::signal_notify(sig);

 }

 void* os::user_handler() {

   return CAST_FROM_FN_PTR(void*, UserHandler);

 }

 extern "C" {

   typedef void (*sa_handler_t)(int);

   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);

 }

 void* os::signal(int signal_number, void* handler) {

   struct sigaction sigAct, oldSigAct;

   sigfillset(&(sigAct.sa_mask));

   // Do not block out synchronous signals in the signal handler.

   // Blocking synchronous signals only makes sense if you can really

   // be sure that those signals won't happen during signal handling,

   // when the blocking applies.  Normal signal handlers are lean and

   // do not cause signals. But our signal handlers tend to be "risky"

   // - secondary SIGSEGV, SIGILL, SIGBUS' may and do happen.

   // On AIX, PASE there was a case where a SIGSEGV happened, followed

   // by a SIGILL, which was blocked due to the signal mask. The process

   // just hung forever. Better to crash from a secondary signal than to hang.

   sigdelset(&(sigAct.sa_mask), SIGSEGV);

   sigdelset(&(sigAct.sa_mask), SIGBUS);

   sigdelset(&(sigAct.sa_mask), SIGILL);

   sigdelset(&(sigAct.sa_mask), SIGFPE);

   sigdelset(&(sigAct.sa_mask), SIGTRAP);

   sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;

   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);

   if (sigaction(signal_number, &sigAct, &oldSigAct)) {

     // -1 means registration failed

     return (void *)-1;

   }

   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);

 }

 void os::signal_raise(int signal_number) {

   ::raise(signal_number);

 }

 //

 // The following code is moved from os.cpp for making this

 // code platform specific, which it is by its very nature.

 //

 // Will be modified when max signal is changed to be dynamic

 int os::sigexitnum_pd() {

   return NSIG;

 }

 // a counter for each possible signal value

 static volatile jint pending_signals[NSIG+1] = { 0 };

 // Linux(POSIX) specific hand shaking semaphore.

 static sem_t sig_sem;

 void os::signal_init_pd() {

   // Initialize signal structures

   ::memset((void*)pending_signals, 0, sizeof(pending_signals));

   // Initialize signal semaphore

   int rc = ::sem_init(&sig_sem, 0, 0);

   guarantee(rc != -1, "sem_init failed");

 }

 void os::signal_notify(int sig) {

   Atomic::inc(&pending_signals[sig]);

   ::sem_post(&sig_sem);

 }

 static int check_pending_signals(bool wait) {

   Atomic::store(0, &sigint_count);

   for (;;) {

     for (int i = 0; i < NSIG + 1; i++) {

       jint n = pending_signals[i];

       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {

         return i;

       }

     }

     if (!wait) {

       return -1;

     }

     JavaThread *thread = JavaThread::current();

     ThreadBlockInVM tbivm(thread);

     bool threadIsSuspended;

     do {

       thread->set_suspend_equivalent();

       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

       ::sem_wait(&sig_sem);

       // were we externally suspended while we were waiting?

       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();

       if (threadIsSuspended) {

         //

         // The semaphore has been incremented, but while we were waiting

         // another thread suspended us. We don't want to continue running

         // while suspended because that would surprise the thread that

         // suspended us.

         //

         ::sem_post(&sig_sem);

         thread->java_suspend_self();

       }

     } while (threadIsSuspended);

   }

 }

 int os::signal_lookup() {

   return check_pending_signals(false);

 }

 int os::signal_wait() {

   return check_pending_signals(true);

 }

 ////////////////////////////////////////////////////////////////////////////////

 // Virtual Memory

 // AddrRange describes an immutable address range

 //

 // This is a helper class for the 'shared memory bookkeeping' below.

 class AddrRange {

   friend class ShmBkBlock;

   char* _start;

   size_t _size;

 public:

   AddrRange(char* start, size_t size)

     : _start(start), _size(size)

   {}

   AddrRange(const AddrRange& r)

     : _start(r.start()), _size(r.size())

   {}

   char* start() const { return _start; }

   size_t size() const { return _size; }

   char* end() const { return _start + _size; }

   bool is_empty() const { return _size == 0 ? true : false; }

   static AddrRange empty_range() { return AddrRange(NULL, 0); }

   bool contains(const char* p) const {

     return start() <= p && end() > p;

   }

   bool contains(const AddrRange& range) const {

     return start() <= range.start() && end() >= range.end();

   }

   bool intersects(const AddrRange& range) const {

     return (range.start() <= start() && range.end() > start()) ||

            (range.start() < end() && range.end() >= end()) ||

            contains(range);

   }

   bool is_same_range(const AddrRange& range) const {

     return start() == range.start() && size() == range.size();

   }

   // return the closest inside range consisting of whole pages

   AddrRange find_closest_aligned_range(size_t pagesize) const {

     if (pagesize == 0 || is_empty()) {

       return empty_range();

     }

     char* const from = (char*)align_size_up((intptr_t)_start, pagesize);

     char* const to = (char*)align_size_down((intptr_t)end(), pagesize);

     if (from > to) {

       return empty_range();

     }

     return AddrRange(from, to - from);

   }

 };

 ////////////////////////////////////////////////////////////////////////////

 // shared memory bookkeeping

 //

 // the os::reserve_memory() API and friends hand out different kind of memory, depending

 // on need and circumstances. Memory may be allocated with mmap() or with shmget/shmat.

 //

 // But these memory types have to be treated differently. For example, to uncommit

 // mmap-based memory, msync(MS_INVALIDATE) is needed, to uncommit shmat-based memory,

 // disclaim64() is needed.

 //

 // Therefore we need to keep track of the allocated memory segments and their

 // properties.

 // ShmBkBlock: base class for all blocks in the shared memory bookkeeping

 class ShmBkBlock {

   ShmBkBlock* _next;

 protected:

   AddrRange _range;

   const size_t _pagesize;

   const bool _pinned;

 public:

   ShmBkBlock(AddrRange range, size_t pagesize, bool pinned)

     : _range(range), _pagesize(pagesize), _pinned(pinned) , _next(NULL) {

     assert(_pagesize == SIZE_4K || _pagesize == SIZE_64K || _pagesize == SIZE_16M, "invalid page size");

     assert(!_range.is_empty(), "invalid range");

   }

   virtual void print(outputStream* st) const {

     st->print("0x%p ... 0x%p (%llu) - %d %s pages - %s",

               _range.start(), _range.end(), _range.size(),

               _range.size() / _pagesize, describe_pagesize(_pagesize),

               _pinned ? "pinned" : "");

   }

   enum Type { MMAP, SHMAT };

   virtual Type getType() = 0;

   char* base() const { return _range.start(); }

   size_t size() const { return _range.size(); }

   void setAddrRange(AddrRange range) {

     _range = range;

   }

   bool containsAddress(const char* p) const {

     return _range.contains(p);

   }

   bool containsRange(const char* p, size_t size) const {

     return _range.contains(AddrRange((char*)p, size));

   }

   bool isSameRange(const char* p, size_t size) const {

     return _range.is_same_range(AddrRange((char*)p, size));

   }

   virtual bool disclaim(char* p, size_t size) = 0;

   virtual bool release() = 0;

   // blocks live in a list.

   ShmBkBlock* next() const { return _next; }

   void set_next(ShmBkBlock* blk) { _next = blk; }

 }; // end: ShmBkBlock

 // ShmBkMappedBlock: describes an block allocated with mmap()

 class ShmBkMappedBlock : public ShmBkBlock {

 public:

   ShmBkMappedBlock(AddrRange range)

     : ShmBkBlock(range, SIZE_4K, false) {} // mmap: always 4K, never pinned

   void print(outputStream* st) const {

     ShmBkBlock::print(st);

     st->print_cr(" - mmap'ed");

   }

   Type getType() {

     return MMAP;

   }

   bool disclaim(char* p, size_t size) {

     AddrRange r(p, size);

     guarantee(_range.contains(r), "invalid disclaim");

     // only disclaim whole ranges.

     const AddrRange r2 = r.find_closest_aligned_range(_pagesize);

     if (r2.is_empty()) {

       return true;

     }

     const int rc = ::msync(r2.start(), r2.size(), MS_INVALIDATE);

     if (rc != 0) {

       warning("msync(0x%p, %llu, MS_INVALIDATE) failed (%d)\n", r2.start(), r2.size(), errno);

     }

     return rc == 0 ? true : false;

   }

   bool release() {

     // mmap'ed blocks are released using munmap

     if (::munmap(_range.start(), _range.size()) != 0) {

       warning("munmap(0x%p, %llu) failed (%d)\n", _range.start(), _range.size(), errno);

       return false;

     }

     return true;

   }

 }; // end: ShmBkMappedBlock

 // ShmBkShmatedBlock: describes an block allocated with shmget/shmat()

 class ShmBkShmatedBlock : public ShmBkBlock {

 public:

   ShmBkShmatedBlock(AddrRange range, size_t pagesize, bool pinned)

     : ShmBkBlock(range, pagesize, pinned) {}

   void print(outputStream* st) const {

     ShmBkBlock::print(st);

     st->print_cr(" - shmat'ed");

   }

   Type getType() {

     return SHMAT;

   }

   bool disclaim(char* p, size_t size) {

     AddrRange r(p, size);

     if (_pinned) {

       return true;

     }

     // shmat'ed blocks are disclaimed using disclaim64

     guarantee(_range.contains(r), "invalid disclaim");

     // only disclaim whole ranges.

     const AddrRange r2 = r.find_closest_aligned_range(_pagesize);

     if (r2.is_empty()) {

       return true;

     }

     const bool rc = my_disclaim64(r2.start(), r2.size());

     if (Verbose && !rc) {

       warning("failed to disclaim shm %p-%p\n", r2.start(), r2.end());

     }

     return rc;

   }

   bool release() {

     bool rc = false;

     if (::shmdt(_range.start()) != 0) {

       warning("shmdt(0x%p) failed (%d)\n", _range.start(), errno);

     } else {

       rc = true;

     }

     return rc;

   }

 }; // end: ShmBkShmatedBlock

 static ShmBkBlock* g_shmbk_list = NULL;

 static volatile jint g_shmbk_table_lock = 0;

 // keep some usage statistics

 static struct {

   int nodes;    // number of nodes in list

   size_t bytes; // reserved - not committed - bytes.

   int reserves; // how often reserve was called

   int lookups;  // how often a lookup was made

 } g_shmbk_stats = { 0, 0, 0, 0 };

 // add information about a shared memory segment to the bookkeeping

 static void shmbk_register(ShmBkBlock* p_block) {

   guarantee(p_block, "logic error");

   p_block->set_next(g_shmbk_list);

   g_shmbk_list = p_block;

   g_shmbk_stats.reserves ++;

   g_shmbk_stats.bytes += p_block->size();

   g_shmbk_stats.nodes ++;

 }

 // remove information about a shared memory segment by its starting address

 static void shmbk_unregister(ShmBkBlock* p_block) {

   ShmBkBlock* p = g_shmbk_list;

   ShmBkBlock* prev = NULL;

   while (p) {

     if (p == p_block) {

       if (prev) {

         prev->set_next(p->next());

       } else {

         g_shmbk_list = p->next();

       }

       g_shmbk_stats.nodes --;

       g_shmbk_stats.bytes -= p->size();

       return;

     }

     prev = p;

     p = p->next();

   }

   assert(false, "should not happen");

 }

 // given a pointer, return shared memory bookkeeping record for the segment it points into

 // using the returned block info must happen under lock protection

 static ShmBkBlock* shmbk_find_by_containing_address(const char* addr) {

   g_shmbk_stats.lookups ++;

   ShmBkBlock* p = g_shmbk_list;

   while (p) {

     if (p->containsAddress(addr)) {

       return p;

     }

     p = p->next();

   }

   return NULL;

 }

 // dump all information about all memory segments allocated with os::reserve_memory()

 void shmbk_dump_info() {

   tty->print_cr("-- shared mem bookkeeping (alive: %d segments, %llu bytes, "

     "total reserves: %d total lookups: %d)",

     g_shmbk_stats.nodes, g_shmbk_stats.bytes, g_shmbk_stats.reserves, g_shmbk_stats.lookups);

   const ShmBkBlock* p = g_shmbk_list;

   int i = 0;

   while (p) {

     p->print(tty);

     p = p->next();

     i ++;

   }

 }

 #define LOCK_SHMBK     { ThreadCritical _LOCK_SHMBK;

 #define UNLOCK_SHMBK   }

 // End: shared memory bookkeeping

 ////////////////////////////////////////////////////////////////////////////////////////////////////

 int os::vm_page_size() {

   // Seems redundant as all get out

   assert(os::Aix::page_size() != -1, "must call os::init");

   return os::Aix::page_size();

 }

 // Aix allocates memory by pages.

 int os::vm_allocation_granularity() {

   assert(os::Aix::page_size() != -1, "must call os::init");

   return os::Aix::page_size();

 }

 int os::Aix::commit_memory_impl(char* addr, size_t size, bool exec) {

   // Commit is a noop. There is no explicit commit

   // needed on AIX. Memory is committed when touched.

   //

   // Debug : check address range for validity

 #ifdef ASSERT

   LOCK_SHMBK

     ShmBkBlock* const block = shmbk_find_by_containing_address(addr);

     if (!block) {

       fprintf(stderr, "invalid pointer: " INTPTR_FORMAT "\n", addr);

       shmbk_dump_info();

       assert(false, "invalid pointer");

       return false;

     } else if (!block->containsRange(addr, size)) {

       fprintf(stderr, "invalid range: " INTPTR_FORMAT " .. " INTPTR_FORMAT "\n", addr, addr + size);

       shmbk_dump_info();

       assert(false, "invalid range");

       return false;

     }

   UNLOCK_SHMBK

 #endif // ASSERT

   return 0;

 }

 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {

   return os::Aix::commit_memory_impl(addr, size, exec) == 0;

 }

 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,

                                   const char* mesg) {

   assert(mesg != NULL, "mesg must be specified");

   os::Aix::commit_memory_impl(addr, size, exec);

 }

 int os::Aix::commit_memory_impl(char* addr, size_t size,

                                 size_t alignment_hint, bool exec) {

   return os::Aix::commit_memory_impl(addr, size, exec);

 }

 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,

                           bool exec) {

   return os::Aix::commit_memory_impl(addr, size, alignment_hint, exec) == 0;

 }

 void os::pd_commit_memory_or_exit(char* addr, size_t size,

                                   size_t alignment_hint, bool exec,

                                   const char* mesg) {

   os::Aix::commit_memory_impl(addr, size, alignment_hint, exec);

 }

 bool os::pd_uncommit_memory(char* addr, size_t size) {

   // Delegate to ShmBkBlock class which knows how to uncommit its memory.

   bool rc = false;

   LOCK_SHMBK

     ShmBkBlock* const block = shmbk_find_by_containing_address(addr);

     if (!block) {

       fprintf(stderr, "invalid pointer: 0x%p.\n", addr);

       shmbk_dump_info();

       assert(false, "invalid pointer");

       return false;

     } else if (!block->containsRange(addr, size)) {

       fprintf(stderr, "invalid range: 0x%p .. 0x%p.\n", addr, addr + size);

       shmbk_dump_info();

       assert(false, "invalid range");

       return false;

     }

     rc = block->disclaim(addr, size);

   UNLOCK_SHMBK

   if (Verbose && !rc) {

     warning("failed to disclaim 0x%p .. 0x%p (0x%llX bytes).", addr, addr + size, size);

   }

   return rc;

 }

 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {

   return os::guard_memory(addr, size);

 }

 bool os::remove_stack_guard_pages(char* addr, size_t size) {

   return os::unguard_memory(addr, size);

 }

 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {

 }

 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {

 }

 void os::numa_make_global(char *addr, size_t bytes) {

 }

 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {

 }

 bool os::numa_topology_changed() {

   return false;

 }

 size_t os::numa_get_groups_num() {

   return 1;

 }

 int os::numa_get_group_id() {

   return 0;

 }

 size_t os::numa_get_leaf_groups(int *ids, size_t size) {

   if (size > 0) {

     ids[0] = 0;

     return 1;

   }

   return 0;

 }

 bool os::get_page_info(char *start, page_info* info) {

   return false;

 }

 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {

   return end;

 }

 // Flags for reserve_shmatted_memory:

 #define RESSHM_WISHADDR_OR_FAIL                     1

 #define RESSHM_TRY_16M_PAGES                        2

 #define RESSHM_16M_PAGES_OR_FAIL                    4

 // Result of reserve_shmatted_memory:

 struct shmatted_memory_info_t {

   char* addr;

   size_t pagesize;

   bool pinned;

 };

 // Reserve a section of shmatted memory.

 // params:

 // bytes [in]: size of memory, in bytes

 // requested_addr [in]: wish address.

 //                      NULL = no wish.

 //                      If RESSHM_WISHADDR_OR_FAIL is set in flags and wish address cannot

 //                      be obtained, function will fail. Otherwise wish address is treated as hint and

 //                      another pointer is returned.

 // flags [in]:          some flags. Valid flags are:

 //                      RESSHM_WISHADDR_OR_FAIL - fail if wish address is given and cannot be obtained.

 //                      RESSHM_TRY_16M_PAGES - try to allocate from 16M page pool

 //                          (requires UseLargePages and Use16MPages)

 //                      RESSHM_16M_PAGES_OR_FAIL - if you cannot allocate from 16M page pool, fail.

 //                          Otherwise any other page size will do.

 // p_info [out] :       holds information about the created shared memory segment.

 static bool reserve_shmatted_memory(size_t bytes, char* requested_addr, int flags, shmatted_memory_info_t* p_info) {

   assert(p_info, "parameter error");

   // init output struct.

   p_info->addr = NULL;

   // neither should we be here for EXTSHM=ON.

   if (os::Aix::extshm()) {

     ShouldNotReachHere();

   }

   // extract flags. sanity checks.

   const bool wishaddr_or_fail =

     flags & RESSHM_WISHADDR_OR_FAIL;

   const bool try_16M_pages =

     flags & RESSHM_TRY_16M_PAGES;

   const bool f16M_pages_or_fail =

     flags & RESSHM_16M_PAGES_OR_FAIL;

   // first check: if a wish address is given and it is mandatory, but not aligned to segment boundary,

   // shmat will fail anyway, so save some cycles by failing right away

   if (requested_addr && ((uintptr_t)requested_addr % SIZE_256M == 0)) {

     if (wishaddr_or_fail) {

       return false;

     } else {

       requested_addr = NULL;

     }

   }

   char* addr = NULL;

   // Align size of shm up to the largest possible page size, to avoid errors later on when we try to change

   // pagesize dynamically.

   const size_t size = align_size_up(bytes, SIZE_16M);

   // reserve the shared segment

   int shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | S_IRUSR | S_IWUSR);

   if (shmid == -1) {

     warning("shmget(.., %lld, ..) failed (errno: %d).", size, errno);

     return false;

   }

   // Important note:

   // It is very important that we, upon leaving this function, do not leave a shm segment alive.

   // We must right after attaching it remove it from the system. System V shm segments are global and

   // survive the process.

   // So, from here on: Do not assert. Do not return. Always do a "goto cleanup_shm".

   // try forcing the page size

   size_t pagesize = -1; // unknown so far

   if (UseLargePages) {

     struct shmid_ds shmbuf;

     memset(&shmbuf, 0, sizeof(shmbuf));

     // First, try to take from 16M page pool if...

     if (os::Aix::can_use_16M_pages()  // we can ...

         && Use16MPages                // we are not explicitly forbidden to do so (-XX:-Use16MPages)..

         && try_16M_pages) {           // caller wants us to.

       shmbuf.shm_pagesize = SIZE_16M;

       if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) == 0) {

         pagesize = SIZE_16M;

       } else {

         warning("Failed to allocate %d 16M pages. 16M page pool might be exhausted. (shmctl failed with %d)",

                 size / SIZE_16M, errno);

         if (f16M_pages_or_fail) {

           goto cleanup_shm;

         }

       }

     }

     // Nothing yet? Try setting 64K pages. Note that I never saw this fail, but in theory it might,

     // because the 64K page pool may also be exhausted.

     if (pagesize == -1) {

       shmbuf.shm_pagesize = SIZE_64K;

       if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) == 0) {

         pagesize = SIZE_64K;

       } else {

         warning("Failed to allocate %d 64K pages. (shmctl failed with %d)",

                 size / SIZE_64K, errno);

         // here I give up. leave page_size -1 - later, after attaching, we will query the

         // real page size of the attached memory. (in theory, it may be something different

         // from 4K if LDR_CNTRL SHM_PSIZE is set)

       }

     }

   }

   // sanity point

   assert(pagesize == -1 || pagesize == SIZE_16M || pagesize == SIZE_64K, "wrong page size");

   // Now attach the shared segment.

   addr = (char*) shmat(shmid, requested_addr, 0);

   if (addr == (char*)-1) {

     // How to handle attach failure:

     // If it failed for a specific wish address, tolerate this: in that case, if wish address was

     // mandatory, fail, if not, retry anywhere.

     // If it failed for any other reason, treat that as fatal error.

     addr = NULL;

     if (requested_addr) {

       if (wishaddr_or_fail) {

         goto cleanup_shm;

       } else {

         addr = (char*) shmat(shmid, NULL, 0);

         if (addr == (char*)-1) { // fatal

           addr = NULL;

           warning("shmat failed (errno: %d)", errno);

           goto cleanup_shm;

         }

       }

     } else { // fatal

       addr = NULL;

       warning("shmat failed (errno: %d)", errno);

       goto cleanup_shm;

     }

   }

   // sanity point

   assert(addr && addr != (char*) -1, "wrong address");

   // after successful Attach remove the segment - right away.

   if (::shmctl(shmid, IPC_RMID, NULL) == -1) {

     warning("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);

     guarantee(false, "failed to remove shared memory segment!");

   }

   shmid = -1;

   // query the real page size. In case setting the page size did not work (see above), the system

   // may have given us something other then 4K (LDR_CNTRL)

   {

     const size_t real_pagesize = os::Aix::query_pagesize(addr);

     if (pagesize != -1) {

       assert(pagesize == real_pagesize, "unexpected pagesize after shmat");

     } else {

       pagesize = real_pagesize;

     }

   }

   // Now register the reserved block with internal book keeping.

   LOCK_SHMBK

     const bool pinned = pagesize >= SIZE_16M ? true : false;

     ShmBkShmatedBlock* const p_block = new ShmBkShmatedBlock(AddrRange(addr, size), pagesize, pinned);

     assert(p_block, "");

     shmbk_register(p_block);

   UNLOCK_SHMBK

 cleanup_shm:

   // if we have not done so yet, remove the shared memory segment. This is very important.

   if (shmid != -1) {

     if (::shmctl(shmid, IPC_RMID, NULL) == -1) {

       warning("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);

       guarantee(false, "failed to remove shared memory segment!");

     }

     shmid = -1;

   }

   // trace

   if (Verbose && !addr) {

     if (requested_addr != NULL) {

       warning("failed to shm-allocate 0x%llX bytes at with address 0x%p.", size, requested_addr);

     } else {

       warning("failed to shm-allocate 0x%llX bytes at any address.", size);

     }

   }

   // hand info to caller

   if (addr) {

     p_info->addr = addr;

     p_info->pagesize = pagesize;

     p_info->pinned = pagesize == SIZE_16M ? true : false;

   }

   // sanity test:

   if (requested_addr && addr && wishaddr_or_fail) {

     guarantee(addr == requested_addr, "shmat error");

   }

   // just one more test to really make sure we have no dangling shm segments.

   guarantee(shmid == -1, "dangling shm segments");

   return addr ? true : false;

 } // end: reserve_shmatted_memory

 // Reserve memory using mmap. Behaves the same as reserve_shmatted_memory():

 // will return NULL in case of an error.

 static char* reserve_mmaped_memory(size_t bytes, char* requested_addr) {

   // if a wish address is given, but not aligned to 4K page boundary, mmap will fail.

   if (requested_addr && ((uintptr_t)requested_addr % os::vm_page_size() != 0)) {

     warning("Wish address 0x%p not aligned to page boundary.", requested_addr);

     return NULL;

   }

   const size_t size = align_size_up(bytes, SIZE_4K);

   // Note: MAP_SHARED (instead of MAP_PRIVATE) needed to be able to

   // msync(MS_INVALIDATE) (see os::uncommit_memory)

   int flags = MAP_ANONYMOUS | MAP_SHARED;

   // MAP_FIXED is needed to enforce requested_addr - manpage is vague about what

   // it means if wishaddress is given but MAP_FIXED is not set.

   //

   // Note however that this changes semantics in SPEC1170 mode insofar as MAP_FIXED

   // clobbers the address range, which is probably not what the caller wants. That's

   // why I assert here (again) that the SPEC1170 compat mode is off.

   // If we want to be able to run under SPEC1170, we have to do some porting and

   // testing.

   if (requested_addr != NULL) {

     assert(!os::Aix::xpg_sus_mode(), "SPEC1170 mode not allowed.");

     flags |= MAP_FIXED;

   }

   char* addr = (char*)::mmap(requested_addr, size, PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0);

   if (addr == MAP_FAILED) {

     // attach failed: tolerate for specific wish addresses. Not being able to attach

     // anywhere is a fatal error.

     if (requested_addr == NULL) {

       // It's ok to fail here if the machine has not enough memory.

       warning("mmap(NULL, 0x%llX, ..) failed (%d)", size, errno);

     }

     addr = NULL;

     goto cleanup_mmap;

   }

   // If we did request a specific address and that address was not available, fail.

   if (addr && requested_addr) {

     guarantee(addr == requested_addr, "unexpected");

   }

   // register this mmap'ed segment with book keeping

   LOCK_SHMBK

     ShmBkMappedBlock* const p_block = new ShmBkMappedBlock(AddrRange(addr, size));

     assert(p_block, "");

     shmbk_register(p_block);

   UNLOCK_SHMBK

 cleanup_mmap:

   if (addr) {

     if (Verbose) {

       fprintf(stderr, "mmap-allocated 0x%p .. 0x%p (0x%llX bytes)\n", addr, addr + bytes, bytes);

     }

   }

   else {

     if (requested_addr != NULL) {

       warning("failed to mmap-allocate 0x%llX bytes at wish address 0x%p.", bytes, requested_addr);

     } else {

       warning("failed to mmap-allocate 0x%llX bytes at any address.", bytes);

     }

   }

   return addr;

 } // end: reserve_mmaped_memory

 // Reserves and attaches a shared memory segment.

 // Will assert if a wish address is given and could not be obtained.

 char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {

   return os::attempt_reserve_memory_at(bytes, requested_addr);

 }

 bool os::pd_release_memory(char* addr, size_t size) {

   // delegate to ShmBkBlock class which knows how to uncommit its memory.

   bool rc = false;

   LOCK_SHMBK

     ShmBkBlock* const block = shmbk_find_by_containing_address(addr);

     if (!block) {

       fprintf(stderr, "invalid pointer: 0x%p.\n", addr);

       shmbk_dump_info();

       assert(false, "invalid pointer");

       return false;

     }

     else if (!block->isSameRange(addr, size)) {

       if (block->getType() == ShmBkBlock::MMAP) {

         // Release only the same range or a the beginning or the end of a range.

         if (block->base() == addr && size < block->size()) {

           ShmBkMappedBlock* const b = new ShmBkMappedBlock(AddrRange(block->base() + size, block->size() - size));

           assert(b, "");

           shmbk_register(b);

           block->setAddrRange(AddrRange(addr, size));

         }

         else if (addr > block->base() && addr + size == block->base() + block->size()) {

           ShmBkMappedBlock* const b = new ShmBkMappedBlock(AddrRange(block->base(), block->size() - size));

           assert(b, "");

           shmbk_register(b);

           block->setAddrRange(AddrRange(addr, size));

         }

         else {

           fprintf(stderr, "invalid mmap range: 0x%p .. 0x%p.\n", addr, addr + size);

           shmbk_dump_info();

           assert(false, "invalid mmap range");

           return false;

         }

       }

       else {

         // Release only the same range. No partial release allowed.

         // Soften the requirement a bit, because the user may think he owns a smaller size

         // than the block is due to alignment etc.

         if (block->base() != addr || block->size() < size) {

           fprintf(stderr, "invalid shmget range: 0x%p .. 0x%p.\n", addr, addr + size);

           shmbk_dump_info();

           assert(false, "invalid shmget range");

           return false;

         }

       }

     }

     rc = block->release();

     assert(rc, "release failed");

     // remove block from bookkeeping

     shmbk_unregister(block);

     delete block;

   UNLOCK_SHMBK

   if (!rc) {

     warning("failed to released %lu bytes at 0x%p", size, addr);

   }

   return rc;

 }

 static bool checked_mprotect(char* addr, size_t size, int prot) {

   // Little problem here: if SPEC1170 behaviour is off, mprotect() on AIX will

   // not tell me if protection failed when trying to protect an un-protectable range.

   //

   // This means if the memory was allocated using shmget/shmat, protection wont work

   // but mprotect will still return 0:

   //

   // See http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/mprotect.htm

   bool rc = ::mprotect(addr, size, prot) == 0 ? true : false;

   if (!rc) {

     const char* const s_errno = strerror(errno);

     warning("mprotect(" PTR_FORMAT "-" PTR_FORMAT ", 0x%X) failed (%s).", addr, addr + size, prot, s_errno);

     return false;

   }

   // mprotect success check

   //

   // Mprotect said it changed the protection but can I believe it?

   //

   // To be sure I need to check the protection afterwards. Try to

   // read from protected memory and check whether that causes a segfault.

   //

   if (!os::Aix::xpg_sus_mode()) {

     if (StubRoutines::SafeFetch32_stub()) {

       const bool read_protected =

         (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&

          SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;

       if (prot & PROT_READ) {

         rc = !read_protected;

       } else {

         rc = read_protected;

       }

     }

   }

   if (!rc) {

     assert(false, "mprotect failed.");

   }