/*

 * Copyright (c) 1999, 2015, Oracle and/or its affiliates. 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_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>

// If RUSAGE_THREAD for getrusage() has not been defined, do it here. The code calling

// getrusage() is prepared to handle the associated failure.

#ifndef RUSAGE_THREAD

#define RUSAGE_THREAD   (1)               /* only the calling thread */

#endif

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

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

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

#ifndef PV_8

#define PV_8 0x300000          /* Power PC 8 */

#define PV_8_Compat 0x308000   /* Power PC 8 */

#endif

#define trcVerbose(fmt, ...) { /* PPC port */  \

  if (Verbose) { \

    fprintf(stderr, fmt, ##__VA_ARGS__); \

    fputc('\n', stderr); fflush(stderr); \

  } \

}

#define trc(fmt, ...)        /* PPC port */

#define ERRBYE(s) { \

    trcVerbose(s); \

    return -1; \

}

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

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

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

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

  }

}

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

            "do not call twice");

  // This really would surprise me.

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

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

  // default should be 4K.

  {

  {

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

    ::shmdt(p);

  }

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

  {

    int dummy = 0;

    goto query_multipage_support_end;

  }

  {

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

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