/*

 * 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 "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_bsd.h"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "mutex_bsd.inline.hpp"

#include "oops/oop.inline.hpp"

#include "os_share_bsd.hpp"

#include "prims/jniFastGetField.hpp"

#include "prims/jvm.h"

#include "prims/jvm_misc.hpp"

#include "runtime/arguments.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/osThread.hpp"

#include "runtime/perfMemory.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/statSampler.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "services/attachListener.hpp"

#include "services/runtimeService.hpp"

#include "thread_bsd.inline.hpp"

#include "utilities/decoder.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/events.hpp"

#include "utilities/growableArray.hpp"

#include "utilities/vmError.hpp"

#ifdef TARGET_ARCH_x86

# include "assembler_x86.inline.hpp"

# include "nativeInst_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "assembler_sparc.inline.hpp"

# include "nativeInst_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "assembler_zero.inline.hpp"

# include "nativeInst_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "assembler_arm.inline.hpp"

# include "nativeInst_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "assembler_ppc.inline.hpp"

# include "nativeInst_ppc.hpp"

#endif

#ifdef COMPILER1

#include "c1/c1_Runtime1.hpp"

#endif

#ifdef COMPILER2

#include "opto/runtime.hpp"

#endif

// 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 <semaphore.h>

# include <fcntl.h>

# include <string.h>

#ifdef _ALLBSD_SOURCE

# include <sys/param.h>

# include <sys/sysctl.h>

#else

# include <syscall.h>

# include <sys/sysinfo.h>

# include <gnu/libc-version.h>

#endif

# include <sys/ipc.h>

# include <sys/shm.h>

#ifndef __APPLE__

# include <link.h>

#endif

# include <stdint.h>

# include <inttypes.h>

# include <sys/ioctl.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;

#ifndef _ALLBSD_SOURCE

address   os::Bsd::_initial_thread_stack_bottom = NULL;

uintptr_t os::Bsd::_initial_thread_stack_size   = 0;

#endif

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

#ifndef _ALLBSD_SOURCE

int (*os::Bsd::_pthread_getcpuclockid)(pthread_t, clockid_t *) = NULL;

Mutex* os::Bsd::_createThread_lock = NULL;

#endif

pthread_t os::Bsd::_main_thread;

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

#ifndef _ALLBSD_SOURCE

bool os::Bsd::_is_floating_stack = false;

bool os::Bsd::_is_NPTL = false;

bool os::Bsd::_supports_fast_thread_cpu_time = false;

const char * os::Bsd::_glibc_version = NULL;

const char * os::Bsd::_libpthread_version = NULL;

#endif

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

static int SR_finalize();

julong os::available_memory() {

  return Bsd::available_memory();

}

julong os::Bsd::available_memory() {

#ifdef _ALLBSD_SOURCE

  // XXXBSD: this is just a stopgap implementation

  return physical_memory() >> 2;

#else

  // values in struct sysinfo are "unsigned long"

  struct sysinfo si;

  sysinfo(&si);

  return (julong)si.freeram * si.mem_unit;

#endif

}

julong os::physical_memory() {

  return Bsd::physical_memory();

}

julong os::allocatable_physical_memory(julong size) {

#ifdef _LP64

  return size;

#else

  julong result = MIN2(size, (julong)3800*M);

   if (!is_allocatable(result)) {

     // See comments under solaris for alignment considerations

     julong reasonable_size = (julong)2*G - 2 * os::vm_page_size();

     result =  MIN2(size, reasonable_size);

   }

   return result;

#endif // _LP64

}

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

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

}

#ifndef _ALLBSD_SOURCE

#ifndef SYS_gettid

// i386: 224, ia64: 1105, amd64: 186, sparc 143

#ifdef __ia64__

#define SYS_gettid 1105

#elif __i386__

#define SYS_gettid 224

#elif __amd64__

#define SYS_gettid 186

#elif __sparc__

#define SYS_gettid 143

#else

#error define gettid for the arch

#endif

#endif

#endif

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

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

#ifndef _ALLBSD_SOURCE

// pid_t gettid()

//

// Returns the kernel thread id of the currently running thread. Kernel

// thread id is used to access /proc.

//

// (Note that getpid() on BsdThreads returns kernel thread id too; but

// on NPTL, it returns the same pid for all threads, as required by POSIX.)

//

pid_t os::Bsd::gettid() {

  int rslt = syscall(SYS_gettid);

  if (rslt == -1) {

     // old kernel, no NPTL support

     return getpid();

  } else {

     return (pid_t)rslt;

  }

}

// Most versions of bsd have a bug where the number of processors are

// determined by looking at the /proc file system.  In a chroot environment,

// the system call returns 1.  This causes the VM to act as if it is

// a single processor and elide locking (see is_MP() call).

static bool unsafe_chroot_detected = false;

static const char *unstable_chroot_error = "/proc file system not found.\n"

                     "Java may be unstable running multithreaded in a chroot "

                     "environment on Bsd when /proc filesystem is not mounted.";

#endif

#ifdef _ALLBSD_SOURCE

void os::Bsd::initialize_system_info() {

  int mib[2];

  size_t len;

  int cpu_val;

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

       set_processor_count(cpu_val);

  }

  else {

       set_processor_count(1);   // fallback

  }

  /* get physical memory via hw.usermem sysctl (hw.usermem is used

   * instead of hw.physmem because we need size of allocatable memory

   */

  mib[0] = CTL_HW;

  mib[1] = HW_USERMEM;

  len = sizeof(mem_val);

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

       _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

}

#else

void os::Bsd::initialize_system_info() {

  set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

  if (processor_count() == 1) {

    pid_t pid = os::Bsd::gettid();

    char fname[32];

    jio_snprintf(fname, sizeof(fname), "/proc/%d", pid);

    FILE *fp = fopen(fname, "r");

    if (fp == NULL) {

      unsafe_chroot_detected = true;

    } else {

      fclose(fp);

    }

  }

  _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);

  assert(processor_count() > 0, "bsd error");

}

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

//  char arch[12];

//  sysinfo(SI_ARCHITECTURE, arch, sizeof(arch));

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

  //

  // Obtain the JAVA_HOME value from the location of libjvm[_g].so.

  // This library should be located at:

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

  //

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

  // assume libjvm[_g].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[_g].so" to this path so

  // it looks like libjvm[_g].so is installed there

  // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so.

  //

  // Otherwise exit.

  //

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

  // code needs to be changed accordingly.

  // The next few definitions allow the code to be verbatim:

#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))

#define getenv(n) ::getenv(n)

/*

 * 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

#define EXTENSIONS_DIR  "/lib/ext"

#define ENDORSED_DIR    "/lib/endorsed"

#define REG_DIR         "/usr/java/packages"

#ifdef __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

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

            sizeof(SYS_EXTENSIONS_DIRS);

#endif

  {

    /* sysclasspath, java_home, dll_dir */

    {

        char *home_path;

        char *dll_path;

        char *pslash;

        char buf[MAXPATHLEN];

        os::jvm_path(buf, sizeof(buf));

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

        dll_path = malloc(strlen(buf) + 1);

        if (dll_path == NULL)

            return;

        strcpy(dll_path, buf);

        Arguments::set_dll_dir(dll_path);

        if (pslash != NULL) {

            pslash = strrchr(buf, '/');

            if (pslash != NULL) {

                *pslash = '\0';       /* get rid of /<arch> (/lib on macosx) */

#ifndef __APPLE__

                pslash = strrchr(buf, '/');

                if (pslash != NULL)

                    *pslash = '\0';   /* get rid of /lib */

#endif

            }

        }

        home_path = malloc(strlen(buf) + 1);

        if (home_path == NULL)

            return;

        strcpy(home_path, buf);

        Arguments::set_java_home(home_path);

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

            return;

    }

    /*

     * 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.

     */