/*

* Copyright (c) 1999, 2021, 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/vmSymbols.hpp"

#include "code/icBuffer.hpp"

#include "code/vtableStubs.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/disassembler.hpp"

#include "interpreter/interpreter.hpp"

#include "jvmtifiles/jvmti.h"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.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/globals.hpp"

#include "runtime/globals_extension.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/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 "signals_posix.hpp"

#include "semaphore_posix.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/powerOfTwo.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 <pwd.h>

# include <poll.h>

# include <fcntl.h>

# include <string.h>

# include <syscall.h>

# include <sys/sysinfo.h>

# include <sys/ipc.h>

# include <sys/shm.h>

# include <link.h>

# include <stdint.h>

# include <inttypes.h>

# include <sys/ioctl.h>

# include <linux/elf-em.h>

#ifdef __GLIBC__

# include <malloc.h>

#endif

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

#ifdef MUSL_LIBC

// dlvsym is not a part of POSIX

// and musl libc doesn't implement it.

static void *dlvsym(void *handle,

const char *symbol,

const char *version) {

// load the latest version of symbol

return dlsym(handle, symbol);

}

#endif

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::_libc_version = NULL;

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

size_t os::Linux::_default_large_page_size = 0;

#ifdef __GLIBC__

os::Linux::mallinfo_func_t os::Linux::_mallinfo = NULL;

os::Linux::mallinfo2_func_t os::Linux::_mallinfo2 = NULL;

#endif // __GLIBC__

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;

// utility functions

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;

}

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

#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

}

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

// breakpoint support

void os::breakpoint() {

BREAKPOINT;

}

extern "C" void breakpoint() {

// use debugger to set breakpoint here

}

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

// detecting pthread library

void os::Linux::libpthread_init() {

// Save glibc and pthread version strings.

#if !defined(_CS_GNU_LIBC_VERSION) || \

!defined(_CS_GNU_LIBPTHREAD_VERSION)

#error "glibc too old (< 2.3.2)"

#endif

#ifdef MUSL_LIBC

// confstr() from musl libc returns EINVAL for

// _CS_GNU_LIBC_VERSION and _CS_GNU_LIBPTHREAD_VERSION

os::Linux::set_libc_version("musl - unknown");

os::Linux::set_libpthread_version("musl - unknown");

#else

size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);

assert(n > 0, "cannot retrieve glibc version");

char *str = (char *)malloc(n, mtInternal);

confstr(_CS_GNU_LIBC_VERSION, str, n);

os::Linux::set_libc_version(str);

n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);

assert(n > 0, "cannot retrieve pthread version");

str = (char *)malloc(n, mtInternal);

confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);

os::Linux::set_libpthread_version(str);

#endif

}

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

// thread stack expansion

// os::Linux::manually_expand_stack() takes care of expanding the thread

// stack. Note that this is normally not needed: pthread stacks allocate

// thread stack using mmap() without MAP_NORESERVE, so the stack is already

// committed. Therefore it is not necessary to expand the stack manually.

//

// Manually expanding the stack was historically needed on LinuxThreads

// thread stacks, which were allocated with mmap(MAP_GROWSDOWN). Nowadays

// it is kept to deal with very rare corner cases:

//

// For one, user may run the VM on an own implementation of threads

// whose stacks are - like the old LinuxThreads - implemented using

// mmap(MAP_GROWSDOWN).

//

// Also, this coding may be needed if the VM is running on the primordial

// thread. Normally we avoid running on the primordial thread; however,

// user may still invoke the VM on the primordial thread.

//

// The following historical comment describes the details about running

// on a thread stack allocated with mmap(MAP_GROWSDOWN):

// Force Linux kernel to expand current thread stack. If "bottom" is close

// to the stack guard, caller should block all signals.

//

// MAP_GROWSDOWN:

// A special mmap() flag that is used to implement thread stacks. It tells

// kernel that the memory region should extend downwards when needed. This

// allows early versions of LinuxThreads to only mmap the first few pages

// when creating a new thread. Linux kernel will automatically expand thread

// stack as needed (on page faults).

//

// However, because the memory region of a MAP_GROWSDOWN stack can grow on

// demand, if a page fault happens outside an already mapped MAP_GROWSDOWN

// region, it's hard to tell if the fault is due to a legitimate stack

// access or because of reading/writing non-exist memory (e.g. buffer

// overrun). As a rule, if the fault happens below current stack pointer,

// Linux kernel does not expand stack, instead a SIGSEGV is sent to the

// application (see Linux kernel fault.c).

//

// This Linux feature can cause SIGSEGV when VM bangs thread stack for

// stack overflow detection.

//

// Newer version of LinuxThreads (since glibc-2.2, or, RH-7.x) and NPTL do

// not use MAP_GROWSDOWN.

//

// To get around the problem and allow stack banging on Linux, we need to

// manually expand thread stack after receiving the SIGSEGV.

//

// There are two ways to expand thread stack to address "bottom", we used

// both of them in JVM before 1.5:

// 1. adjust stack pointer first so that it is below "bottom", and then

// touch "bottom"

// 2. mmap() the page in question

//

// Now alternate signal stack is gone, it's harder to use 2. For instance,

// if current sp is already near the lower end of page 101, and we need to

// call mmap() to map page 100, it is possible that part of the mmap() frame

// will be placed in page 100. When page 100 is mapped, it is zero-filled.

// That will destroy the mmap() frame and cause VM to crash.

//

// The following code works by adjusting sp first, then accessing the "bottom"

// page to force a page fault. Linux kernel will then automatically expand the

// stack mapping.

//

// _expand_stack_to() assumes its frame size is less than page size, which

// should always be true if the function is not inlined.

static void NOINLINE _expand_stack_to(address bottom) {

address sp;

size_t size;

volatile char *p;

// Adjust bottom to point to the largest address within the same page, it

// gives us a one-page buffer if alloca() allocates slightly more memory.

bottom = (address)align_down((uintptr_t)bottom, os::Linux::page_size());

bottom += os::Linux::page_size() - 1;

// sp might be slightly above current stack pointer; if that's the case, we

// will alloca() a little more space than necessary, which is OK. Don't use

// os::current_stack_pointer(), as its result can be slightly below current

// stack pointer, causing us to not alloca enough to reach "bottom".

sp = (address)&sp;

if (sp > bottom) {

size = sp - bottom;

p = (volatile char *)alloca(size);

assert(p != NULL && p <= (volatile char *)bottom, "alloca problem?");

p[0] = '\0';

}

}

void os::Linux::expand_stack_to(address bottom) {

_expand_stack_to(bottom);

}

bool os::Linux::manually_expand_stack(JavaThread * t, address addr) {

assert(t!=NULL, "just checking");

assert(t->osthread()->expanding_stack(), "expand should be set");

if (t->is_in_usable_stack(addr)) {

sigset_t mask_all, old_sigset;

sigfillset(&mask_all);

pthread_sigmask(SIG_SETMASK, &mask_all, &old_sigset);

_expand_stack_to(addr);

pthread_sigmask(SIG_SETMASK, &old_sigset, NULL);

return true;

}

return false;

}

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

// create new thread

// Thread start routine for all newly created threads

static void *thread_native_entry(Thread *thread) {

thread->record_stack_base_and_size();

#ifndef __GLIBC__

// Try to randomize the cache line index of hot stack frames.

// This helps when threads of the same stack traces evict each other's

// cache lines. The threads can be either from the same JVM instance, or

// from different JVM instances. The benefit is especially true for

// processors with hyperthreading technology.

// This code is not needed anymore in glibc because it has MULTI_PAGE_ALIASING

// and we did not see any degradation in performance without `alloca()`.

static int counter = 0;

int pid = os::current_process_id();

int random = ((pid ^ counter++) & 7) * 128;

void *stackmem = alloca(random != 0 ? random : 1); // ensure we allocate > 0

// Ensure the alloca result is used in a way that prevents the compiler from eliding it.

*(char *)stackmem = 1;

#endif

thread->initialize_thread_current();

OSThread* osthread = thread->osthread();

Monitor* sync = osthread->startThread_lock();

osthread->set_thread_id(os::current_thread_id());

if (UseNUMA) {

int lgrp_id = os::numa_get_group_id();

if (lgrp_id != -1) {

thread->set_lgrp_id(lgrp_id);

}

}

// initialize signal mask for this thread

PosixSignals::hotspot_sigmask(thread);

// initialize floating point control register

os::Linux::init_thread_fpu_state();

// handshaking with parent thread

{

MutexLocker ml(sync, Mutex::_no_safepoint_check_flag);

// notify parent thread

osthread->set_state(INITIALIZED);

sync->notify_all();

// wait until os::start_thread()

while (osthread->get_state() == INITIALIZED) {

sync->wait_without_safepoint_check();

}

}

log_info(os, thread)("Thread is alive (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ").",

os::current_thread_id(), (uintx) pthread_self());

assert(osthread->pthread_id() != 0, "pthread_id was not set as expected");

// call one more level start routine

thread->call_run();

// Note: at this point the thread object may already have deleted itself.

// Prevent dereferencing it from here on out.

thread = NULL;

log_info(os, thread)("Thread finished (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ").",

os::current_thread_id(), (uintx) pthread_self());

return 0;

}

// On Linux, glibc places static TLS blocks (for __thread variables) on

// the thread stack. This decreases the stack size actually available

// to threads.

//

// For large static TLS sizes, this may cause threads to malfunction due

// to insufficient stack space. This is a well-known issue in glibc:

// http://sourceware.org/bugzilla/show_bug.cgi?id=11787.

//

// As a workaround, we call a private but assumed-stable glibc function,

// __pthread_get_minstack() to obtain the minstack size and derive the

// static TLS size from it. We then increase the user requested stack

// size by this TLS size.

//

// Due to compatibility concerns, this size adjustment is opt-in and

// controlled via AdjustStackSizeForTLS.

typedef size_t (*GetMinStack)(const pthread_attr_t *attr);

GetMinStack _get_minstack_func = NULL;

static void get_minstack_init() {

_get_minstack_func =

(GetMinStack)dlsym(RTLD_DEFAULT, "__pthread_get_minstack");

log_info(os, thread)("Lookup of __pthread_get_minstack %s",

_get_minstack_func == NULL ? "failed" : "succeeded");

}

// Returns the size of the static TLS area glibc puts on thread stacks.

// The value is cached on first use, which occurs when the first thread

// is created during VM initialization.

static size_t get_static_tls_area_size(const pthread_attr_t *attr) {

size_t tls_size = 0;

if (_get_minstack_func != NULL) {

// Obtain the pthread minstack size by calling __pthread_get_minstack.

size_t minstack_size = _get_minstack_func(attr);

// Remove non-TLS area size included in minstack size returned

// by __pthread_get_minstack() to get the static TLS size.

// In glibc before 2.27, minstack size includes guard_size.

// In glibc 2.27 and later, guard_size is automatically added

// to the stack size by pthread_create and is no longer included

// in minstack size. In both cases, the guard_size is taken into

// account, so there is no need to adjust the result for that.

//

// Although __pthread_get_minstack() is a private glibc function,

// it is expected to have a stable behavior across future glibc

// versions while glibc still allocates the static TLS blocks off

// the stack. Following is glibc 2.28 __pthread_get_minstack():

//

// size_t

// __pthread_get_minstack (const pthread_attr_t *attr)

// {

// return GLRO(dl_pagesize) + __static_tls_size + PTHREAD_STACK_MIN;

// }

//

//

// The following 'minstack_size > os::vm_page_size() + PTHREAD_STACK_MIN'

// if check is done for precaution.

if (minstack_size > (size_t)os::vm_page_size() + PTHREAD_STACK_MIN) {

tls_size = minstack_size - os::vm_page_size() - PTHREAD_STACK_MIN;

}

}

log_info(os, thread)("Stack size adjustment for TLS is " SIZE_FORMAT,

tls_size);

return tls_size;

}

bool os::create_thread(Thread* thread, ThreadType thr_type,

size_t req_stack_size) {

assert(thread->osthread() == NULL, "caller responsible");

// Allocate the OSThread object

OSThread* osthread = new OSThread(NULL, NULL);

if (osthread == NULL) {

return false;

}

// set the correct thread state

osthread->set_thread_type(thr_type);

// Initial state is ALLOCATED but not INITIALIZED

osthread->set_state(ALLOCATED);

thread->set_osthread(osthread);

// init thread attributes

pthread_attr_t attr;

pthread_attr_init(&attr);

pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

// Calculate stack size if it's not specified by caller.

size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);

// In glibc versions prior to 2.7 the guard size mechanism

// is not implemented properly. The posix standard requires adding

// the size of the guard pages to the stack size, instead Linux

// takes the space out of 'stacksize'. Thus we adapt the requested

// stack_size by the size of the guard pages to mimick proper

// behaviour. However, be careful not to end up with a size

// of zero due to overflow. Don't add the guard page in that case.

size_t guard_size = os::Linux::default_guard_size(thr_type);

// Configure glibc guard page. Must happen before calling

// get_static_tls_area_size(), which uses the guard_size.

pthread_attr_setguardsize(&attr, guard_size);

size_t stack_adjust_size = 0;

if (AdjustStackSizeForTLS) {

// Adjust the stack_size for on-stack TLS - see get_static_tls_area_size().

stack_adjust_size += get_static_tls_area_size(&attr);

} else {

stack_adjust_size += guard_size;

}

stack_adjust_size = align_up(stack_adjust_size, os::vm_page_size());

if (stack_size <= SIZE_MAX - stack_adjust_size) {

stack_size += stack_adjust_size;

}

assert(is_aligned(stack_size, os::vm_page_size()), "stack_size not aligned");

int status = pthread_attr_setstacksize(&attr, stack_size);

if (status != 0) {

// pthread_attr_setstacksize() function can fail

// if the stack size exceeds a system-imposed limit.

assert_status(status == EINVAL, status, "pthread_attr_setstacksize");

log_warning(os, thread)("The %sthread stack size specified is invalid: " SIZE_FORMAT "k",

(thr_type == compiler_thread) ? "compiler " : ((thr_type == java_thread) ? "" : "VM "),

stack_size / K);

thread->set_osthread(NULL);

delete osthread;

return false;

}

ThreadState state;

{

ResourceMark rm;

pthread_t tid;

int ret = 0;

int limit = 3;

do {

ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);

} while (ret == EAGAIN && limit-- > 0);

char buf[64];

if (ret == 0) {

log_info(os, thread)("Thread \"%s\" started (pthread id: " UINTX_FORMAT ", attributes: %s). ",

thread->name(), (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));

} else {

log_warning(os, thread)("Failed to start thread \"%s\" - pthread_create failed (%s) for attributes: %s.",

thread->name(), os::errno_name(ret), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr));

// Log some OS information which might explain why creating the thread failed.

log_info(os, thread)("Number of threads approx. running in the VM: %d", Threads::number_of_threads());

LogStream st(Log(os, thread)::info());

os::Posix::print_rlimit_info(&st);

os::print_memory_info(&st);

os::Linux::print_proc_sys_info(&st);

os::Linux::print_container_info(&st);

}

pthread_attr_destroy(&attr);

if (ret != 0) {

// Need to clean up stuff we've allocated so far

thread->set_osthread(NULL);

delete osthread;

return false;

}

// Store pthread info into the OSThread

osthread->set_pthread_id(tid);

// Wait until child thread is either initialized or aborted

{

Monitor* sync_with_child = osthread->startThread_lock();

MutexLocker ml(sync_with_child, Mutex::_no_safepoint_check_flag);

while ((state = osthread->get_state()) == ALLOCATED) {

sync_with_child->wait_without_safepoint_check();

}

}

}

// The thread is returned suspended (in state INITIALIZED),

// and is started higher up in the call chain

assert(state == INITIALIZED, "race condition");

return true;

}

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

// attach existing thread

// bootstrap the main thread

bool os::create_main_thread(JavaThread* thread) {

assert(os::Linux::_main_thread == pthread_self(), "should be called inside main thread");

return create_attached_thread(thread);

}

bool os::create_attached_thread(JavaThread* thread) {

#ifdef ASSERT

thread->verify_not_published();

#endif

// Allocate the OSThread object

OSThread* osthread = new OSThread(NULL, NULL);

if (osthread == NULL) {

return false;

}

// Store pthread info into the OSThread

osthread->set_thread_id(os::Linux::gettid());

osthread->set_pthread_id(::pthread_self());

// initialize floating point control register

os::Linux::init_thread_fpu_state();

// Initial thread state is RUNNABLE

osthread->set_state(RUNNABLE);

thread->set_osthread(osthread);

if (UseNUMA) {

int lgrp_id = os::numa_get_group_id();

if (lgrp_id != -1) {

thread->set_lgrp_id(lgrp_id);

}

}

if (os::is_primordial_thread()) {

// If current thread is primordial thread, its stack is mapped on demand,

// see notes about MAP_GROWSDOWN. Here we try to force kernel to map

// the entire stack region to avoid SEGV in stack banging.

// It is also useful to get around the heap-stack-gap problem on SuSE

// kernel (see 4821821 for details). We first expand stack to the top

// of yellow zone, then enable stack yellow zone (order is significant,

// enabling yellow zone first will crash JVM on SuSE Linux), so there

// is no gap between the last two virtual memory regions.

StackOverflow* overflow_state = thread->stack_overflow_state();

address addr = overflow_state->stack_reserved_zone_base();

assert(addr != NULL, "initialization problem?");

assert(overflow_state->stack_available(addr) > 0, "stack guard should not be enabled");

osthread->set_expanding_stack();

os::Linux::manually_expand_stack(thread, addr);

osthread->clear_expanding_stack();

}

// initialize signal mask for this thread

// and save the caller's signal mask

PosixSignals::hotspot_sigmask(thread);

log_info(os, thread)("Thread attached (tid: " UINTX_FORMAT ", pthread id: " UINTX_FORMAT ").",

os::current_thread_id(), (uintx) pthread_self());

return true;

}

void os::pd_start_thread(Thread* thread) {

OSThread * osthread = thread->osthread();

assert(osthread->get_state() != INITIALIZED, "just checking");

Monitor* sync_with_child = osthread->startThread_lock();

MutexLocker ml(sync_with_child, Mutex::_no_safepoint_check_flag);

sync_with_child->notify();

}

// Free Linux resources related to the OSThread

void os::free_thread(OSThread* osthread) {

assert(osthread != NULL, "osthread not set");

// We are told to free resources of the argument thread,

// but we can only really operate on the current thread.

assert(Thread::current()->osthread() == osthread,

"os::free_thread but not current thread");

#ifdef ASSERT

sigset_t current;

sigemptyset(&current);

pthread_sigmask(SIG_SETMASK, NULL, &current);

assert(!sigismember(&current, PosixSignals::SR_signum), "SR signal should not be blocked!");

#endif

// Restore caller's signal mask

sigset_t sigmask = osthread->caller_sigmask();

pthread_sigmask(SIG_SETMASK, &sigmask, NULL);