/*

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

 * Copyright 2012, 2014 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/atomic.inline.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/orderAccess.inline.hpp"

#include "runtime/osThread.hpp"

#include "runtime/perfMemory.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/statSampler.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "services/attachListener.hpp"

#include "services/runtimeService.hpp"

#include "utilities/decoder.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/events.hpp"

#include "utilities/growableArray.hpp"

#include "utilities/vmError.hpp"

// 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() {

  os::Aix::meminfo_t mi;

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

    return mi.real_free;

  } else {

    return 0xFFFFFFFFFFFFFFFFLL;

  }

}

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);

    guarantee(p != NULL, "malloc failed");

    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() {

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

#define EXTENSIONS_DIR  "/lib/ext"

#define ENDORSED_DIR    "/lib/endorsed"

  // Buffer that fits several sprintfs.

  // Note that the space for the trailing null is provided

  // by the nulls included by the sizeof operator.

  const size_t bufsize =

    MAX3((size_t)MAXPATHLEN,  // For dll_dir & friends.

         (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR), // extensions dir

         (size_t)MAXPATHLEN + sizeof(ENDORSED_DIR)); // endorsed dir

  char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);

  // sysclasspath, java_home, dll_dir

  {

    char *pslash;