/*

 * Copyright (c) 1999, 2018, 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 "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "oops/oop.inline.hpp"

#include "os_bsd.inline.hpp"

#include "os_share_bsd.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/semaphore.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/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/vmError.hpp"

// put OS-includes here

# include <sys/types.h>

# include <sys/mman.h>

# include <sys/stat.h>

# include <sys/select.h>

# include <pthread.h>

# include <signal.h>

# include <errno.h>

# include <dlfcn.h>

# include <stdio.h>

# include <unistd.h>

# include <sys/resource.h>

# include <pthread.h>

# include <sys/stat.h>

# include <sys/time.h>

# include <sys/times.h>

# include <sys/utsname.h>

# include <sys/socket.h>

# include <sys/wait.h>

# include <time.h>

# include <pwd.h>

# include <poll.h>

# include <fcntl.h>

# include <string.h>

# include <sys/param.h>

# include <sys/sysctl.h>

# include <sys/ipc.h>

# include <sys/shm.h>

#ifndef __APPLE__

# include <link.h>

#endif

# include <stdint.h>

# include <inttypes.h>

# include <sys/ioctl.h>

# include <sys/syscall.h>

#if defined(__FreeBSD__) || defined(__NetBSD__)

  #include <elf.h>

#endif

#ifdef __APPLE__

  #include <mach/mach.h> // semaphore_* API

  #include <mach-o/dyld.h>

  #include <sys/proc_info.h>

  #include <objc/objc-auto.h>

#endif

#ifndef MAP_ANONYMOUS

  #define MAP_ANONYMOUS MAP_ANON

#endif

#define MAX_PATH    (2 * K)

// for timer info max values which include all bits

#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

#define LARGEPAGES_BIT (1 << 6)

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

// global variables

julong os::Bsd::_physical_memory = 0;

#ifdef __APPLE__

mach_timebase_info_data_t os::Bsd::_timebase_info = {0, 0};

volatile uint64_t         os::Bsd::_max_abstime   = 0;

#else

int (*os::Bsd::_clock_gettime)(clockid_t, struct timespec *) = NULL;

#endif

pthread_t os::Bsd::_main_thread;

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

static jlong initial_time_count=0;

static int clock_tics_per_sec = 100;

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

static sigset_t check_signal_done;

static bool check_signals = true;

static pid_t _initial_pid = 0;

// Signal number used to suspend/resume a thread

// do not use any signal number less than SIGSEGV, see 4355769

static int SR_signum = SIGUSR2;

sigset_t SR_sigset;

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

// utility functions

static int SR_initialize();

julong os::available_memory() {

  return Bsd::available_memory();

}

// available here means free

julong os::Bsd::available_memory() {

  uint64_t available = physical_memory() >> 2;

#ifdef __APPLE__

  mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;

  vm_statistics64_data_t vmstat;

  kern_return_t kerr = host_statistics64(mach_host_self(), HOST_VM_INFO64,

                                         (host_info64_t)&vmstat, &count);

  assert(kerr == KERN_SUCCESS,

         "host_statistics64 failed - check mach_host_self() and count");

  if (kerr == KERN_SUCCESS) {

    available = vmstat.free_count * os::vm_page_size();

  }

#endif

  return available;

}

julong os::physical_memory() {

  return Bsd::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;

}

// Cpu architecture string

#if   defined(ZERO)

static char cpu_arch[] = ZERO_LIBARCH;

#elif defined(IA64)

static char cpu_arch[] = "ia64";

#elif defined(IA32)

static char cpu_arch[] = "i386";

#elif defined(AMD64)

static char cpu_arch[] = "amd64";

#elif defined(ARM)

static char cpu_arch[] = "arm";

#elif defined(PPC32)

static char cpu_arch[] = "ppc";

#elif defined(SPARC)

  #ifdef _LP64

static char cpu_arch[] = "sparcv9";

  #else

static char cpu_arch[] = "sparc";

  #endif

#else

  #error Add appropriate cpu_arch setting

#endif

// Compiler variant

#ifdef COMPILER2

  #define COMPILER_VARIANT "server"

#else

  #define COMPILER_VARIANT "client"

#endif

void os::Bsd::initialize_system_info() {

  int mib[2];

  size_t len;

  int cpu_val;

  julong mem_val;

  // get processors count via hw.ncpus sysctl

  mib[0] = CTL_HW;

  mib[1] = HW_NCPU;

  len = sizeof(cpu_val);

  if (sysctl(mib, 2, &cpu_val, &len, NULL, 0) != -1 && cpu_val >= 1) {

    assert(len == sizeof(cpu_val), "unexpected data size");

    set_processor_count(cpu_val);

  } else {

    set_processor_count(1);   // fallback

  }

  // get physical memory via hw.memsize sysctl (hw.memsize is used

  // since it returns a 64 bit value)

  mib[0] = CTL_HW;

#if defined (HW_MEMSIZE) // Apple

  mib[1] = HW_MEMSIZE;

#elif defined(HW_PHYSMEM) // Most of BSD

  mib[1] = HW_PHYSMEM;

#elif defined(HW_REALMEM) // Old FreeBSD

  mib[1] = HW_REALMEM;

#else

  #error No ways to get physmem

#endif

  len = sizeof(mem_val);

  if (sysctl(mib, 2, &mem_val, &len, NULL, 0) != -1) {

    assert(len == sizeof(mem_val), "unexpected data size");

    _physical_memory = mem_val;

  } else {

    _physical_memory = 256 * 1024 * 1024;       // fallback (XXXBSD?)

  }

#ifdef __OpenBSD__

  {

    // limit _physical_memory memory view on OpenBSD since

    // datasize rlimit restricts us anyway.

    struct rlimit limits;

    getrlimit(RLIMIT_DATA, &limits);

    _physical_memory = MIN2(_physical_memory, (julong)limits.rlim_cur);

  }

#endif

}

#ifdef __APPLE__

static const char *get_home() {

  const char *home_dir = ::getenv("HOME");

  if ((home_dir == NULL) || (*home_dir == '\0')) {

    struct passwd *passwd_info = getpwuid(geteuid());

    if (passwd_info != NULL) {

      home_dir = passwd_info->pw_dir;

    }

  }

  return home_dir;

}

#endif

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.

  // See ld(1):

  //      The linker uses the following search paths to locate required

  //      shared libraries:

  //        1: ...

  //        ...

  //        7: The default directories, normally /lib and /usr/lib.

#ifndef DEFAULT_LIBPATH

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

#endif

// Base path of extensions installed on the system.

#define SYS_EXT_DIR     "/usr/java/packages"

#define EXTENSIONS_DIR  "/lib/ext"

#ifndef __APPLE__

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

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

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

  char *buf = (char *)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 /<arch>.

        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.

  //

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

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

  // on legacy Bsd 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/java/packages is added here.

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

  {

    // Get the user setting of LD_LIBRARY_PATH, and prepended it. It

    // should always exist (until the legacy problem cited above is

    // addressed).

    const char *v = ::getenv("LD_LIBRARY_PATH");

    const char *v_colon = ":";

    if (v == NULL) { v = ""; v_colon = ""; }

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

    char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char,

                                                     strlen(v) + 1 +

                                                     sizeof(SYS_EXT_DIR) + sizeof("/lib/") + strlen(cpu_arch) + sizeof(DEFAULT_LIBPATH) + 1,

                                                     mtInternal);

    sprintf(ld_library_path, "%s%s" SYS_EXT_DIR "/lib/%s:" DEFAULT_LIBPATH, v, v_colon, cpu_arch);

    Arguments::set_library_path(ld_library_path);

    FREE_C_HEAP_ARRAY(char, ld_library_path);

  }

  // Extensions directories.

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

  Arguments::set_ext_dirs(buf);

  FREE_C_HEAP_ARRAY(char, buf);

#else // __APPLE__

  #define SYS_EXTENSIONS_DIR   "/Library/Java/Extensions"

  #define SYS_EXTENSIONS_DIRS  SYS_EXTENSIONS_DIR ":/Network" SYS_EXTENSIONS_DIR ":/System" SYS_EXTENSIONS_DIR ":/usr/lib/java"

  const char *user_home_dir = get_home();

  // The null in SYS_EXTENSIONS_DIRS counts for the size of the colon after user_home_dir.

  size_t system_ext_size = strlen(user_home_dir) + sizeof(SYS_EXTENSIONS_DIR) +

    sizeof(SYS_EXTENSIONS_DIRS);

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

    MAX2((size_t)MAXPATHLEN,  // for dll_dir & friends.

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

  char *buf = (char *)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}.

    }

#ifdef STATIC_BUILD

    strcat(buf, "/lib");

#endif

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

    set_boot_path('/', ':');

  }

  // Where to look for native libraries.

  //

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

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

  // on legacy Bsd 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/java/packages is added here.

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

  {

    // Get the user setting of LD_LIBRARY_PATH, and prepended it. It

    // should always exist (until the legacy problem cited above is

    // addressed).

    // Prepend the default path with the JAVA_LIBRARY_PATH so that the app launcher code

    // can specify a directory inside an app wrapper

    const char *l = ::getenv("JAVA_LIBRARY_PATH");

    const char *l_colon = ":";

    if (l == NULL) { l = ""; l_colon = ""; }

    const char *v = ::getenv("DYLD_LIBRARY_PATH");

    const char *v_colon = ":";

    if (v == NULL) { v = ""; v_colon = ""; }

    // Apple's Java6 has "." at the beginning of java.library.path.

    // OpenJDK on Windows has "." at the end of java.library.path.

    // OpenJDK on Linux and Solaris don't have "." in java.library.path

    // at all. To ease the transition from Apple's Java6 to OpenJDK7,

    // "." is appended to the end of java.library.path. Yes, this

    // could cause a change in behavior, but Apple's Java6 behavior

    // can be achieved by putting "." at the beginning of the

    // JAVA_LIBRARY_PATH environment variable.

    char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char,

                                                     strlen(v) + 1 + strlen(l) + 1 +

                                                     system_ext_size + 3,

                                                     mtInternal);

    sprintf(ld_library_path, "%s%s%s%s%s" SYS_EXTENSIONS_DIR ":" SYS_EXTENSIONS_DIRS ":.",

            v, v_colon, l, l_colon, user_home_dir);

    Arguments::set_library_path(ld_library_path);

    FREE_C_HEAP_ARRAY(char, ld_library_path);

  }

  // Extensions directories.

  //