/*

 * Copyright (c) 1997, 2019, 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.

 *

 */

// no precompiled headers

#include "jvm.h"

#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 "compiler/disassembler.hpp"

#include "interpreter/interpreter.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "memory/universe.hpp"

#include "oops/oop.inline.hpp"

#include "os_share_solaris.hpp"

#include "os_solaris.inline.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm_misc.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/extendedPC.hpp"

#include "runtime/globals.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/orderAccess.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 "semaphore_posix.hpp"

#include "services/attachListener.hpp"

#include "services/memTracker.hpp"

#include "services/runtimeService.hpp"

#include "utilities/align.hpp"

#include "utilities/decoder.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/events.hpp"

#include "utilities/growableArray.hpp"

#include "utilities/macros.hpp"

#include "utilities/vmError.hpp"

// put OS-includes here

# include <dlfcn.h>

# include <errno.h>

# include <exception>

# include <link.h>

# include <poll.h>

# include <pthread.h>

# include <setjmp.h>

# include <signal.h>

# include <stdio.h>

# include <alloca.h>

# include <sys/filio.h>

# include <sys/ipc.h>

# include <sys/lwp.h>

# include <sys/machelf.h>     // for elf Sym structure used by dladdr1

# include <sys/mman.h>

# include <sys/processor.h>

# include <sys/procset.h>

# include <sys/pset.h>

# include <sys/resource.h>

# include <sys/shm.h>

# include <sys/socket.h>

# include <sys/stat.h>

# include <sys/systeminfo.h>

# include <sys/time.h>

# include <sys/times.h>

# include <sys/types.h>

# include <sys/wait.h>

# include <sys/utsname.h>

# include <thread.h>

# include <unistd.h>

# include <sys/priocntl.h>

# include <sys/rtpriocntl.h>

# include <sys/tspriocntl.h>

# include <sys/iapriocntl.h>

# include <sys/fxpriocntl.h>

# include <sys/loadavg.h>

# include <string.h>

# include <stdio.h>

# define _STRUCTURED_PROC 1  //  this gets us the new structured proc interfaces of 5.6 & later

# include <sys/procfs.h>     //  see comment in <sys/procfs.h>

#define MAX_PATH (2 * K)

// for timer info max values which include all bits

#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

// Here are some liblgrp types from sys/lgrp_user.h to be able to

// compile on older systems without this header file.

#ifndef MADV_ACCESS_LWP

  #define  MADV_ACCESS_LWP   7       /* next LWP to access heavily */

#endif

#ifndef MADV_ACCESS_MANY

  #define  MADV_ACCESS_MANY  8       /* many processes to access heavily */

#endif

#ifndef LGRP_RSRC_CPU

  #define LGRP_RSRC_CPU      0       /* CPU resources */

#endif

#ifndef LGRP_RSRC_MEM

  #define LGRP_RSRC_MEM      1       /* memory resources */

#endif

// Values for ThreadPriorityPolicy == 1

int prio_policy1[CriticalPriority+1] = {

  -99999,  0, 16,  32,  48,  64,

          80, 96, 112, 124, 127, 127 };

// System parameters used internally

static clock_t clock_tics_per_sec = 100;

// Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+)

static bool enabled_extended_FILE_stdio = false;

// For diagnostics to print a message once. see run_periodic_checks

static bool check_addr0_done = false;

static sigset_t check_signal_done;

static bool check_signals = true;

address os::Solaris::handler_start;  // start pc of thr_sighndlrinfo

address os::Solaris::handler_end;    // end pc of thr_sighndlrinfo

address os::Solaris::_main_stack_base = NULL;  // 4352906 workaround

os::Solaris::pthread_setname_np_func_t os::Solaris::_pthread_setname_np = NULL;

// "default" initializers for missing libc APIs

extern "C" {

  static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }

  static int lwp_mutex_destroy(mutex_t *mx)                 { return 0; }

  static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }

  static int lwp_cond_destroy(cond_t *cv)                   { return 0; }

}

// "default" initializers for pthread-based synchronization

extern "C" {

  static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }

  static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }

}

static void unpackTime(timespec* absTime, bool isAbsolute, jlong time);

static inline size_t adjust_stack_size(address base, size_t size) {

  if ((ssize_t)size < 0) {

    // 4759953: Compensate for ridiculous stack size.

    size = max_intx;

  }

  if (size > (size_t)base) {

    // 4812466: Make sure size doesn't allow the stack to wrap the address space.

    size = (size_t)base;

  }

  return size;

}

static inline stack_t get_stack_info() {

  stack_t st;

  int retval = thr_stksegment(&st);

  st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);

  assert(retval == 0, "incorrect return value from thr_stksegment");

  assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");

  assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");

  return st;

}

static void _handle_uncaught_cxx_exception() {

  VMError::report_and_die("An uncaught C++ exception");

}

bool os::is_primordial_thread(void) {

  int r = thr_main();

  guarantee(r == 0 || r == 1, "CR6501650 or CR6493689");

  return r == 1;

}

address os::current_stack_base() {

  bool _is_primordial_thread = is_primordial_thread();

  // Workaround 4352906, avoid calls to thr_stksegment by

  // thr_main after the first one (it looks like we trash

  // some data, causing the value for ss_sp to be incorrect).

  if (!_is_primordial_thread || os::Solaris::_main_stack_base == NULL) {

    stack_t st = get_stack_info();

    if (_is_primordial_thread) {

      // cache initial value of stack base

      os::Solaris::_main_stack_base = (address)st.ss_sp;

    }

    return (address)st.ss_sp;

  } else {

    guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");

    return os::Solaris::_main_stack_base;

  }

}

size_t os::current_stack_size() {

  size_t size;

  if (!is_primordial_thread()) {

    size = get_stack_info().ss_size;

  } else {

    struct rlimit limits;

    getrlimit(RLIMIT_STACK, &limits);

    size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);

  }

  // base may not be page aligned

  address base = current_stack_base();

  address bottom = align_up(base - size, os::vm_page_size());;

  return (size_t)(base - bottom);

}

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

  return localtime_r(clock, res);

}

void os::Solaris::try_enable_extended_io() {

  typedef int (*enable_extended_FILE_stdio_t)(int, int);

  if (!UseExtendedFileIO) {

    return;

  }

  enable_extended_FILE_stdio_t enabler =

    (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,

                                         "enable_extended_FILE_stdio");

  if (enabler) {

    enabler(-1, -1);

  }

}

jint os::Solaris::_os_thread_limit = 0;

volatile jint os::Solaris::_os_thread_count = 0;

julong os::available_memory() {

  return Solaris::available_memory();

}

julong os::Solaris::available_memory() {

  return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();

}

julong os::Solaris::_physical_memory = 0;

julong os::physical_memory() {

  return Solaris::physical_memory();

}

static hrtime_t first_hrtime = 0;

static const hrtime_t hrtime_hz = 1000*1000*1000;

static volatile hrtime_t max_hrtime = 0;

void os::Solaris::initialize_system_info() {

  set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

  _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) *

                                     (julong)sysconf(_SC_PAGESIZE);

}

uint os::processor_id() {

  const processorid_t id = ::getcpuid();

  assert(id >= 0 && id < _processor_count, "Invalid processor id");

  return (uint)id;

}

int os::active_processor_count() {

  // User has overridden the number of active processors

  if (ActiveProcessorCount > 0) {

    log_trace(os)("active_processor_count: "

                  "active processor count set by user : %d",

                  ActiveProcessorCount);

    return ActiveProcessorCount;

  }

  int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);

  pid_t pid = getpid();

  psetid_t pset = PS_NONE;

  // Are we running in a processor set or is there any processor set around?

  if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {

    uint_t pset_cpus;

    // Query the number of cpus available to us.

    if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {

      assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");

      return pset_cpus;

    }

  }

  // Otherwise return number of online cpus

  return online_cpus;

}

void os::set_native_thread_name(const char *name) {

  if (Solaris::_pthread_setname_np != NULL) {

    // Only the first 31 bytes of 'name' are processed by pthread_setname_np

    // but we explicitly copy into a size-limited buffer to avoid any

    // possible overflow.

    char buf[32];

    snprintf(buf, sizeof(buf), "%s", name);

    buf[sizeof(buf) - 1] = '\0';

    Solaris::_pthread_setname_np(pthread_self(), buf);

  }

}

bool os::bind_to_processor(uint processor_id) {

  // We assume that a processorid_t can be stored in a uint.

  assert(sizeof(uint) == sizeof(processorid_t),

         "can't convert uint to processorid_t");

  int bind_result =

    processor_bind(P_LWPID,                       // bind LWP.

                   P_MYID,                        // bind current LWP.

                   (processorid_t) processor_id,  // id.

                   NULL);                         // don't return old binding.

  return (bind_result == 0);

}

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

}

void os::init_system_properties_values() {

  // The next steps are taken in the product version:

  //

  // Obtain the JAVA_HOME value from the location of libjvm.so.

  // This library should be located at:

  // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm.so.

  //

  // If "/jre/lib/" appears at the right place in the path, then we

  // assume libjvm.so is installed in a JDK and we use this path.

  //

  // Otherwise exit with message: "Could not create the Java virtual machine."

  //

  // The following extra steps are taken in the debugging version:

  //

  // If "/jre/lib/" does NOT appear at the right place in the path

  // instead of exit check for $JAVA_HOME environment variable.

  //

  // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,

  // then we append a fake suffix "hotspot/libjvm.so" to this path so

  // it looks like libjvm.so is installed there

  // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm.so.

  //

  // Otherwise exit.

  //

  // Important note: if the location of libjvm.so changes this

  // code needs to be changed accordingly.

// Base path of extensions installed on the system.

#define SYS_EXT_DIR     "/usr/jdk/packages"

#define EXTENSIONS_DIR  "/lib/ext"

  // Buffer that fits several sprintfs.

  // Note that the space for the colon and the trailing null are provided

  // by the nulls included by the sizeof operator.

  const size_t bufsize =

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

         sizeof(SYS_EXT_DIR) + sizeof("/lib/"), // invariant ld_library_path

         (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR) + sizeof(SYS_EXT_DIR) + sizeof(EXTENSIONS_DIR)); // extensions dir

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

  // sysclasspath, java_home, dll_dir

  {

    char *pslash;

    os::jvm_path(buf, bufsize);

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

    }

    Arguments::set_dll_dir(buf);

    if (pslash != NULL) {

      pslash = strrchr(buf, '/');

      if (pslash != NULL) {

        *pslash = '\0';        // Get rid of /lib.

      }

    }

    Arguments::set_java_home(buf);

    if (!set_boot_path('/', ':')) {

      vm_exit_during_initialization("Failed setting boot class path.", NULL);

    }

  }

  // Where to look for native libraries.

  {

    // Use dlinfo() to determine the correct java.library.path.

    //

    // If we're launched by the Java launcher, and the user

    // does not set java.library.path explicitly on the commandline,

    // the Java launcher sets LD_LIBRARY_PATH for us and unsets

    // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64.  In this case

    // dlinfo returns LD_LIBRARY_PATH + crle settings (including

    // /usr/lib), which is exactly what we want.

    //

    // If the user does set java.library.path, it completely

    // overwrites this setting, and always has.

    //

    // If we're not launched by the Java launcher, we may

    // get here with any/all of the LD_LIBRARY_PATH[_32|64]

    // settings.  Again, dlinfo does exactly what we want.

    Dl_serinfo     info_sz, *info = &info_sz;

    Dl_serpath     *path;

    char           *library_path;

    char           *common_path = buf;

    // Determine search path count and required buffer size.

    if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {

      FREE_C_HEAP_ARRAY(char, buf);

      vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());

    }

    // Allocate new buffer and initialize.

    info = (Dl_serinfo*)NEW_C_HEAP_ARRAY(char, info_sz.dls_size, mtInternal);

    info->dls_size = info_sz.dls_size;

    info->dls_cnt = info_sz.dls_cnt;

    // Obtain search path information.

    if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {

      FREE_C_HEAP_ARRAY(char, buf);

      FREE_C_HEAP_ARRAY(char, info);

      vm_exit_during_initialization("dlinfo SERINFO request", dlerror());

    }

    path = &info->dls_serpath[0];

    // Note: Due to a legacy implementation, most of the library path

    // is set in the launcher. This was to accomodate linking restrictions

    // on legacy Solaris implementations (which are no longer supported).

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

    //

    // However, to prevent the proliferation of improperly built native

    // libraries, the new path component /usr/jdk/packages is added here.

    // Construct the invariant part of ld_library_path.

    sprintf(common_path, SYS_EXT_DIR "/lib");

    // Struct size is more than sufficient for the path components obtained

    // through the dlinfo() call, so only add additional space for the path

    // components explicitly added here.

    size_t library_path_size = info->dls_size + strlen(common_path);

    library_path = NEW_C_HEAP_ARRAY(char, library_path_size, mtInternal);

    library_path[0] = '\0';

    // Construct the desired Java library path from the linker's library

    // search path.

    //

    // For compatibility, it is optimal that we insert the additional path

    // components specific to the Java VM after those components specified

    // in LD_LIBRARY_PATH (if any) but before those added by the ld.so

    // infrastructure.

    if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it.

      strcpy(library_path, common_path);

    } else {

      int inserted = 0;

      int i;

      for (i = 0; i < info->dls_cnt; i++, path++) {

        uint_t flags = path->dls_flags & LA_SER_MASK;