/*

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

#include "os_linux.inline.hpp"

#include "os_posix.inline.hpp"

#include "os_share_linux.hpp"

#include "osContainer_linux.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/init.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/threadSMR.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/elfFile.hpp"

#include "utilities/growableArray.hpp"

#include "utilities/macros.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 <endian.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 <pwd.h>

# include <poll.h>

# include <fcntl.h>

# include <string.h>

# include <syscall.h>

# include <sys/sysinfo.h>

# include <gnu/libc-version.h>

# include <sys/ipc.h>

# include <sys/shm.h>

# include <link.h>

# include <stdint.h>

# include <inttypes.h>

# include <sys/ioctl.h>

#ifndef _GNU_SOURCE

  #define _GNU_SOURCE

  #include <sched.h>

  #undef _GNU_SOURCE

#else

  #include <sched.h>

#endif

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

#define MAX_PATH    (2 * K)

#define MAX_SECS 100000000

// for timer info max values which include all bits

#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

enum CoredumpFilterBit {

  FILE_BACKED_PVT_BIT = 1 << 2,

  FILE_BACKED_SHARED_BIT = 1 << 3,

  LARGEPAGES_BIT = 1 << 6,

  DAX_SHARED_BIT = 1 << 8

};

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

// global variables

julong os::Linux::_physical_memory = 0;

address   os::Linux::_initial_thread_stack_bottom = NULL;

uintptr_t os::Linux::_initial_thread_stack_size   = 0;

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

int (*os::Linux::_pthread_setname_np)(pthread_t, const char*) = NULL;

pthread_t os::Linux::_main_thread;

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

bool os::Linux::_supports_fast_thread_cpu_time = false;

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

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

static jlong initial_time_count=0;

static int clock_tics_per_sec = 100;

// If the VM might have been created on the primordial thread, we need to resolve the

// primordial thread stack bounds and check if the current thread might be the

// primordial thread in places. If we know that the primordial thread is never used,

// such as when the VM was created by one of the standard java launchers, we can

// avoid this

static bool suppress_primordial_thread_resolution = false;

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

static sigset_t check_signal_done;

static bool check_signals = true;

// 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 Linux::available_memory();

}

julong os::Linux::available_memory() {

  // values in struct sysinfo are "unsigned long"

  struct sysinfo si;

  julong avail_mem;

  if (OSContainer::is_containerized()) {

    jlong mem_limit, mem_usage;

    if ((mem_limit = OSContainer::memory_limit_in_bytes()) < 1) {

      log_debug(os, container)("container memory limit %s: " JLONG_FORMAT ", using host value",

                             mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit);

    }

    if (mem_limit > 0 && (mem_usage = OSContainer::memory_usage_in_bytes()) < 1) {

      log_debug(os, container)("container memory usage failed: " JLONG_FORMAT ", using host value", mem_usage);

    }

    if (mem_limit > 0 && mem_usage > 0 ) {

      avail_mem = mem_limit > mem_usage ? (julong)mem_limit - (julong)mem_usage : 0;

      log_trace(os)("available container memory: " JULONG_FORMAT, avail_mem);

      return avail_mem;

    }

  }

  sysinfo(&si);

  avail_mem = (julong)si.freeram * si.mem_unit;

  log_trace(os)("available memory: " JULONG_FORMAT, avail_mem);

  return avail_mem;

}

julong os::physical_memory() {

  jlong phys_mem = 0;

  if (OSContainer::is_containerized()) {

    jlong mem_limit;

    if ((mem_limit = OSContainer::memory_limit_in_bytes()) > 0) {

      log_trace(os)("total container memory: " JLONG_FORMAT, mem_limit);

      return mem_limit;

    }

    log_debug(os, container)("container memory limit %s: " JLONG_FORMAT ", using host value",

                            mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit);

  }

  phys_mem = Linux::physical_memory();

  log_trace(os)("total system memory: " JLONG_FORMAT, phys_mem);

  return phys_mem;

}

static uint64_t initial_total_ticks = 0;

static uint64_t initial_steal_ticks = 0;

static bool     has_initial_tick_info = false;

static void next_line(FILE *f) {

  int c;

  do {

    c = fgetc(f);

  } while (c != '\n' && c != EOF);

}

bool os::Linux::get_tick_information(CPUPerfTicks* pticks, int which_logical_cpu) {

  FILE*         fh;

  uint64_t      userTicks, niceTicks, systemTicks, idleTicks;

  // since at least kernel 2.6 : iowait: time waiting for I/O to complete

  // irq: time  servicing interrupts; softirq: time servicing softirqs

  uint64_t      iowTicks = 0, irqTicks = 0, sirqTicks= 0;

  // steal (since kernel 2.6.11): time spent in other OS when running in a virtualized environment

  uint64_t      stealTicks = 0;

  // guest (since kernel 2.6.24): time spent running a virtual CPU for guest OS under the

  // control of the Linux kernel

  uint64_t      guestNiceTicks = 0;

  int           logical_cpu = -1;

  const int     required_tickinfo_count = (which_logical_cpu == -1) ? 4 : 5;

  int           n;

  memset(pticks, 0, sizeof(CPUPerfTicks));

  if ((fh = fopen("/proc/stat", "r")) == NULL) {

    return false;

  }

  if (which_logical_cpu == -1) {

    n = fscanf(fh, "cpu " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "

            UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "

            UINT64_FORMAT " " UINT64_FORMAT " ",

            &userTicks, &niceTicks, &systemTicks, &idleTicks,

            &iowTicks, &irqTicks, &sirqTicks,

            &stealTicks, &guestNiceTicks);

  } else {

    // Move to next line

    next_line(fh);

    // find the line for requested cpu faster to just iterate linefeeds?

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

      next_line(fh);

    }

    n = fscanf(fh, "cpu%u " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "

               UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " " UINT64_FORMAT " "

               UINT64_FORMAT " " UINT64_FORMAT " ",

               &logical_cpu, &userTicks, &niceTicks,

               &systemTicks, &idleTicks, &iowTicks, &irqTicks, &sirqTicks,

               &stealTicks, &guestNiceTicks);

  }

  fclose(fh);

  if (n < required_tickinfo_count || logical_cpu != which_logical_cpu) {

    return false;

  }

  pticks->used       = userTicks + niceTicks;

  pticks->usedKernel = systemTicks + irqTicks + sirqTicks;

  pticks->total      = userTicks + niceTicks + systemTicks + idleTicks +

                       iowTicks + irqTicks + sirqTicks + stealTicks + guestNiceTicks;

  if (n > required_tickinfo_count + 3) {

    pticks->steal = stealTicks;

    pticks->has_steal_ticks = true;

  } else {

    pticks->steal = 0;

    pticks->has_steal_ticks = false;

  }

  return true;

}

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

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

  #ifdef __ia64__

    #define SYS_gettid 1105

  #else

    #ifdef __i386__

      #define SYS_gettid 224

    #else

      #ifdef __amd64__

        #define SYS_gettid 186

      #else

        #ifdef __sparc__

          #define SYS_gettid 143

        #else

          #error define gettid for the arch

        #endif

      #endif

    #endif

  #endif

#endif

// pid_t gettid()

//

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

// thread id is used to access /proc.

pid_t os::Linux::gettid() {

  int rslt = syscall(SYS_gettid);

  assert(rslt != -1, "must be."); // old linuxthreads implementation?

  return (pid_t)rslt;

}

// Most versions of linux 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.

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 Linux when /proc filesystem is not mounted.";

void os::Linux::initialize_system_info() {

  set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

  if (processor_count() == 1) {

    pid_t pid = os::Linux::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, "linux error");

}

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>/lib/{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 OVERRIDE_LIBPATH

  #if defined(AMD64) || (defined(_LP64) && defined(SPARC)) || defined(PPC64) || defined(S390)

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

  #else

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

  #endif

#else

  #define DEFAULT_LIBPATH OVERRIDE_LIBPATH

#endif

// Base path of extensions installed on the system.

#define SYS_EXT_DIR     "/usr/java/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 =

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

    pslash = strrchr(buf, '/');

    if (pslash != NULL) {

      *pslash = '\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.

  //

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

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

  // on legacy Linux 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 = NEW_C_HEAP_ARRAY(char,

                                             strlen(v) + 1 +

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

                                             mtInternal);

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

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

#undef DEFAULT_LIBPATH

#undef SYS_EXT_DIR

#undef EXTENSIONS_DIR

}