/*

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

 * Copyright 2012, 2015 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 "libo4.hpp"

#include "libperfstat_aix.hpp"

#include "loadlib_aix.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "misc_aix.hpp"

#include "mutex_aix.inline.hpp"

#include "oops/oop.inline.hpp"

#include "os_aix.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/os.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 "runtime/vm_version.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>

// Missing prototypes for various system APIs.

extern "C"

int mread_real_time(timebasestruct_t *t, size_t size_of_timebasestruct_t);

#if !defined(_AIXVERSION_610)

extern "C" int getthrds64(pid_t, struct thrdentry64*, int, tid64_t*, int);

extern "C" int getprocs64(procentry64*, int, fdsinfo*, int, pid_t*, int);

extern "C" int getargs   (procsinfo*, int, char*, int);

#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 bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size);

static address resolve_function_descriptor_to_code_pointer(address p);

// 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(p, NULL) == 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); \

}

static void vmembk_print_on(outputStream* os);

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

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

// -1 = uninitialized, 0 if AIX, 1 if OS/400 pase

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

// -1 = uninitialized, otherwise os version in the form 0xMMmm - MM:major, mm:minor

//  E.g. 0x0601 for  AIX 6.1 or 0x0504 for OS/400 V5R4

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

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

// -1 = uninitialized, 0 - no, 1 - yes

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

// -1 = uninitialized, 0 - no, 1 - yes

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

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

// local variables

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 int      SR_signum          = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769)

static sigset_t SR_sigset;

// Process break recorded at startup.

static address g_brk_at_startup = NULL;

// This describes the state of multipage support of the underlying

// OS. Note that this is of no interest to the outsize world and

// therefore should not be defined in AIX class.

//

// AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The

// latter two (16M "large" resp. 16G "huge" pages) require special

// setup and are normally not available.

//

// AIX supports multiple page sizes per process, for:

//  - Stack (of the primordial thread, so not relevant for us)

//  - Data - data, bss, heap, for us also pthread stacks

//  - Text - text code

//  - shared memory

//

// Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...)

// and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...).

//

// For shared memory, page size can be set dynamically via

// shmctl(). Different shared memory regions can have different page

// sizes.

//

// More information can be found at AIBM info center:

//   http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm

//

static struct {

  size_t pagesize;            // sysconf _SC_PAGESIZE (4K)

  size_t datapsize;           // default data page size (LDR_CNTRL DATAPSIZE)

  size_t shmpsize;            // default shared memory page size (LDR_CNTRL SHMPSIZE)

  size_t pthr_stack_pagesize; // stack page size of pthread threads

  size_t textpsize;           // default text page size (LDR_CNTRL STACKPSIZE)

  bool can_use_64K_pages;     // True if we can alloc 64K pages dynamically with Sys V shm.

  bool can_use_16M_pages;     // True if we can alloc 16M pages dynamically with Sys V shm.

  int error;                  // Error describing if something went wrong at multipage init.

} g_multipage_support = {

  (size_t) -1,

  (size_t) -1,

  (size_t) -1,

  (size_t) -1,

  (size_t) -1,

  false, false,

  0

};

// We must not accidentally allocate memory close to the BRK - even if

// that would work - because then we prevent the BRK segment from

// growing which may result in a malloc OOM even though there is

// enough memory. The problem only arises if we shmat() or mmap() at

// a specific wish address, e.g. to place the heap in a

// compressed-oops-friendly way.

static bool is_close_to_brk(address a) {

  assert0(g_brk_at_startup != NULL);

  if (a >= g_brk_at_startup &&

      a < (g_brk_at_startup + MaxExpectedDataSegmentSize)) {

    return true;

  }

  return false;

}

julong os::available_memory() {

  return Aix::available_memory();

}

julong os::Aix::available_memory() {

  // Avoid expensive API call here, as returned value will always be null.

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

    return 0x0LL;

  }

  os::Aix::meminfo_t mi;

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

    return mi.real_free;

  } else {

    return ULONG_MAX;

  }

}

julong os::physical_memory() {

  return Aix::physical_memory();

}

// 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 = 0x40000000;

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

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

      trcVerbose("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

// Wrap the function "vmgetinfo" which is not available on older OS releases.

static int checked_vmgetinfo(void *out, int command, int arg) {

  if (os::Aix::on_pase() && os::Aix::os_version() < 0x0601) {

    guarantee(false, "cannot call vmgetinfo on AS/400 older than V6R1");

  }

  return ::vmgetinfo(out, command, arg);

}

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

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

  if (os::Aix::on_pase() && os::Aix::os_version() < 0x0601) {

    // AS/400 older than V6R1: no vmgetinfo here, default to 4K

    return SIZE_4K;

  }

  vm_page_info pi;

  pi.addr = (uint64_t)addr;

  if (checked_vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) {

    return pi.pagesize;

  } else {

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

    return SIZE_4K;

  }

}

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

    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 "??";

  }

}

// Probe OS for multipage support.

// Will fill the global g_multipage_support structure.

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

static void query_multipage_support() {

  guarantee(g_multipage_support.pagesize == -1,

            "do not call twice");

  g_multipage_support.pagesize = ::sysconf(_SC_PAGESIZE);

  // This really would surprise me.

  assert(g_multipage_support.pagesize == SIZE_4K, "surprise!");

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

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

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

  // default should be 4K.

  {

    void* p = ::malloc(SIZE_16M);

    g_multipage_support.datapsize = os::Aix::query_pagesize(p);

    ::free(p);

  }

  // Query default shm page size (LDR_CNTRL SHMPSIZE).

  // Note that this is pure curiosity. We do not rely on default page size but set

  // our own page size after allocated.

  {

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

    g_multipage_support.shmpsize = 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.

  guarantee0(!os::Aix::is_primordial_thread());

  // Query pthread stack page size. Should be the same as data page size because

  // pthread stacks are allocated from C-Heap.

  {

    int dummy = 0;

    g_multipage_support.pthr_stack_pagesize = os::Aix::query_pagesize(&dummy);

  }

  // Query default text page size (LDR_CNTRL TEXTPSIZE).

  {

    address any_function =

      resolve_function_descriptor_to_code_pointer((address)describe_pagesize);

    g_multipage_support.textpsize = os::Aix::query_pagesize(any_function);

  }

  // Now probe for support of 64K pages and 16M pages.

  // Before OS/400 V6R1, there is no support for pages other than 4K.

  if (os::Aix::on_pase_V5R4_or_older()) {

    trcVerbose("OS/400 < V6R1 - no large page support.");

    g_multipage_support.error = ERROR_MP_OS_TOO_OLD;

    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 = checked_vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES);

    if (num_psizes == -1) {

      trcVerbose("vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)", errno);

      trcVerbose("disabling multipage support.");

      g_multipage_support.error = ERROR_MP_VMGETINFO_FAILED;

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

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

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

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

    }

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

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

      const size_t pagesize = sizes[i];

      if (pagesize != SIZE_64K && pagesize != SIZE_16M) {

        continue;

      }

      bool can_use = false;

      trcVerbose("Probing support for %s pages...", describe_pagesize(pagesize));

      const int shmid = ::shmget(IPC_PRIVATE, pagesize,

        IPC_CREAT | S_IRUSR | S_IWUSR);

      guarantee0(shmid != -1); // Should always work.

      // Try to set pagesize.

      struct shmid_ds shm_buf = { 0 };

      shm_buf.shm_pagesize = pagesize;