/* * Copyright (c) 1999, 2025, 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. * */ #include "classfile/vmSymbols.hpp" #include "code/vtableStubs.hpp" #include "compiler/compileBroker.hpp" #include "compiler/disassembler.hpp" #include "interpreter/interpreter.hpp" #include "jvm.h" #include "jvmtifiles/jvmti.h" #include "logging/log.hpp" #include "logging/logStream.hpp" #include "memory/allocation.inline.hpp" #include "nmt/memTracker.hpp" #include "oops/oop.inline.hpp" #include "os_bsd.inline.hpp" #include "os_posix.inline.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/java.hpp" #include "runtime/javaCalls.hpp" #include "runtime/javaThread.hpp" #include "runtime/mutexLocker.hpp" #include "runtime/objectMonitor.hpp" #include "runtime/osInfo.hpp" #include "runtime/osThread.hpp" #include "runtime/perfMemory.hpp" #include "runtime/semaphore.hpp" #include "runtime/sharedRuntime.hpp" #include "runtime/stubRoutines.hpp" #include "runtime/threads.hpp" #include "runtime/timer.hpp" #include "services/attachListener.hpp" #include "services/runtimeService.hpp" #include "signals_posix.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" #if INCLUDE_JFR #include "jfr/jfrEvents.hpp" #include "jfr/support/jfrNativeLibraryLoadEvent.hpp" #endif // put OS-includes here # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include #if defined(__FreeBSD__) || defined(__NetBSD__) #include #endif #ifdef __APPLE__ #include #include #endif #ifndef MAP_ANONYMOUS #define MAP_ANONYMOUS MAP_ANON #endif #define MAX_PATH (2 * K) //////////////////////////////////////////////////////////////////////////////// // 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; #endif pthread_t os::Bsd::_main_thread; #if defined(__APPLE__) && defined(__x86_64__) static const int processor_id_unassigned = -1; static const int processor_id_assigning = -2; static const int processor_id_map_size = 256; static volatile int processor_id_map[processor_id_map_size]; static volatile int processor_id_next = 0; #endif //////////////////////////////////////////////////////////////////////////////// // utility functions julong os::available_memory() { return Bsd::available_memory(); } julong os::free_memory() { return Bsd::available_memory(); } // Available here means free. Note that this number is of no much use. As an estimate // for future memory pressure it is far too conservative, since MacOS will use a lot // of unused memory for caches, and return it willingly in case of needs. 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) { // free_count is just a lowerbound, other page categories can be freed too and make memory available available = (vmstat.free_count + vmstat.inactive_count + vmstat.purgeable_count) * os::vm_page_size(); } #endif return available; } // for more info see : // https://man.openbsd.org/sysctl.2 void os::Bsd::print_uptime_info(outputStream* st) { struct timeval boottime; size_t len = sizeof(boottime); int mib[2]; mib[0] = CTL_KERN; mib[1] = KERN_BOOTTIME; if (sysctl(mib, 2, &boottime, &len, nullptr, 0) >= 0) { time_t bootsec = boottime.tv_sec; time_t currsec = time(nullptr); os::print_dhm(st, "OS uptime:", (long) difftime(currsec, bootsec)); } } jlong os::total_swap_space() { #if defined(__APPLE__) struct xsw_usage vmusage; size_t size = sizeof(vmusage); if (sysctlbyname("vm.swapusage", &vmusage, &size, nullptr, 0) != 0) { return -1; } return (jlong)vmusage.xsu_total; #else return -1; #endif } jlong os::free_swap_space() { #if defined(__APPLE__) struct xsw_usage vmusage; size_t size = sizeof(vmusage); if (sysctlbyname("vm.swapusage", &vmusage, &size, nullptr, 0) != 0) { return -1; } return (jlong)vmusage.xsu_avail; #else return -1; #endif } julong os::physical_memory() { return Bsd::physical_memory(); } size_t os::rss() { size_t rss = 0; #ifdef __APPLE__ mach_task_basic_info info; mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT; kern_return_t ret = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &count); if (ret == KERN_SUCCESS) { rss = info.resident_size; } #endif // __APPLE__ return rss; } // Cpu architecture string #if defined(ZERO) static char cpu_arch[] = ZERO_LIBARCH; #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(AARCH64) static char cpu_arch[] = "aarch64"; #elif defined(PPC32) static char cpu_arch[] = "ppc"; #else #error Add appropriate cpu_arch setting #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, nullptr, 0) != -1 && cpu_val >= 1) { assert(len == sizeof(cpu_val), "unexpected data size"); set_processor_count(cpu_val); } else { set_processor_count(1); // fallback } #if defined(__APPLE__) && defined(__x86_64__) // initialize processor id map for (int i = 0; i < processor_id_map_size; i++) { processor_id_map[i] = processor_id_unassigned; } #endif // 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, nullptr, 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 == nullptr) || (*home_dir == '\0')) { struct passwd *passwd_info = getpwuid(geteuid()); if (passwd_info != nullptr) { 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: // /jre/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/, // then we append a fake suffix "hotspot/libjvm.so" to this path so // it looks like libjvm.so is installed there // /jre/lib//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 #ifndef OVERRIDE_LIBPATH #define DEFAULT_LIBPATH "/lib:/usr/lib" #else #define DEFAULT_LIBPATH OVERRIDE_LIBPATH #endif #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 snprintfs. // 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 /jre if we can. *(strrchr(buf, '/')) = '\0'; // Get rid of /libjvm.so. pslash = strrchr(buf, '/'); if (pslash != nullptr) { *pslash = '\0'; // Get rid of /{client|server|hotspot}. } Arguments::set_dll_dir(buf); if (pslash != nullptr) { pslash = strrchr(buf, '/'); if (pslash != nullptr) { *pslash = '\0'; // Get rid of /. pslash = strrchr(buf, '/'); if (pslash != nullptr) { *pslash = '\0'; // Get rid of /lib. } } } Arguments::set_java_home(buf); if (!set_boot_path('/', ':')) { vm_exit_during_initialization("Failed setting boot class path.", nullptr); } } // 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 accommodate 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 == nullptr) { v = ""; v_colon = ""; } // That's +1 for the colon and +1 for the trailing '\0'. const size_t ld_library_path_size = strlen(v) + 1 + sizeof(SYS_EXT_DIR) + sizeof("/lib/") + strlen(cpu_arch) + sizeof(DEFAULT_LIBPATH) + 1; char *ld_library_path = NEW_C_HEAP_ARRAY(char, ld_library_path_size, mtInternal); os::snprintf_checked(ld_library_path, ld_library_path_size, "%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. os::snprintf_checked(buf, bufsize, "%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 snprintfs. // 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 = 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 /jre if we can. *(strrchr(buf, '/')) = '\0'; // Get rid of /libjvm.so. pslash = strrchr(buf, '/'); if (pslash != nullptr) { *pslash = '\0'; // Get rid of /{client|server|hotspot}. } if (is_vm_statically_linked()) { strcat(buf, "/lib"); } Arguments::set_dll_dir(buf); if (pslash != nullptr) { pslash = strrchr(buf, '/'); if (pslash != nullptr) { *pslash = '\0'; // Get rid of /lib. } } Arguments::set_java_home(buf); if (!set_boot_path('/', ':')) { vm_exit_during_initialization("Failed setting boot class path.", nullptr); } } // 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 accommodate 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 == nullptr) { l = ""; l_colon = ""; } const char *v = ::getenv("DYLD_LIBRARY_PATH"); const char *v_colon = ":"; if (v == nullptr) { 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. const size_t ld_library_path_size = strlen(v) + 1 + strlen(l) + 1 + system_ext_size + 3; char *ld_library_path = NEW_C_HEAP_ARRAY(char, ld_library_path_size, mtInternal); os::snprintf_checked(ld_library_path, ld_library_path_size, "%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. // // Note that the space for the colon and the trailing null are provided // by the nulls included by the sizeof operator (so actually one byte more // than necessary is allocated). os::snprintf_checked(buf, bufsize, "%s" SYS_EXTENSIONS_DIR ":%s" EXTENSIONS_DIR ":" SYS_EXTENSIONS_DIRS, user_home_dir, Arguments::get_java_home()); Arguments::set_ext_dirs(buf); FREE_C_HEAP_ARRAY(char, buf); #undef SYS_EXTENSIONS_DIR #undef SYS_EXTENSIONS_DIRS #endif // __APPLE__ #undef SYS_EXT_DIR #undef EXTENSIONS_DIR } ////////////////////////////////////////////////////////////////////////////// // create new thread #ifdef __APPLE__ // library handle for calling objc_registerThreadWithCollector() // without static linking to the libobjc library #define OBJC_LIB "/usr/lib/libobjc.dylib" #define OBJC_GCREGISTER "objc_registerThreadWithCollector" typedef void (*objc_registerThreadWithCollector_t)(); extern "C" objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction; objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction = nullptr; #endif // Thread start routine for all newly created threads static void *thread_native_entry(Thread *thread) { thread->record_stack_base_and_size(); thread->initialize_thread_current(); OSThread* osthread = thread->osthread(); Monitor* sync = osthread->startThread_lock(); osthread->set_thread_id(os::Bsd::gettid()); #ifdef __APPLE__ // Store unique OS X thread id used by SA osthread->set_unique_thread_id(); #endif // initialize signal mask for this thread PosixSignals::hotspot_sigmask(thread); // initialize floating point control register os::Bsd::init_thread_fpu_state(); #ifdef __APPLE__ // register thread with objc gc if (objc_registerThreadWithCollectorFunction != nullptr) { objc_registerThreadWithCollectorFunction(); } #endif // 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: %zu, pthread id: %zu).", os::current_thread_id(), (uintx) pthread_self()); // 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 = nullptr; log_info(os, thread)("Thread finished (tid: %zu, pthread id: %zu).", os::current_thread_id(), (uintx) pthread_self()); return 0; } bool os::create_thread(Thread* thread, ThreadType thr_type, size_t req_stack_size) { assert(thread->osthread() == nullptr, "caller responsible"); // Allocate the OSThread object OSThread* osthread = new (std::nothrow) OSThread(); if (osthread == nullptr) { return false; } // Initial state is ALLOCATED but not INITIALIZED osthread->set_state(ALLOCATED); thread->set_osthread(osthread); // init thread attributes pthread_attr_t attr; int rslt = pthread_attr_init(&attr); if (rslt != 0) { thread->set_osthread(nullptr); delete osthread; return false; } 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); int status = pthread_attr_setstacksize(&attr, stack_size); assert_status(status == 0, status, "pthread_attr_setstacksize"); ThreadState state; { ResourceMark rm; pthread_t tid; int ret = 0; int trials_remaining = 4; useconds_t next_delay = 1000; while (true) { ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread); if (ret != EAGAIN) { break; } if (--trials_remaining <= 0) { break; } log_debug(os, thread)("Failed to start native thread (%s), retrying after %dus.", os::errno_name(ret), next_delay); ::usleep(next_delay); next_delay *= 2; } char buf[64]; if (ret == 0) { log_info(os, thread)("Thread \"%s\" started (pthread id: %zu, 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); } pthread_attr_destroy(&attr); if (ret != 0) { // Need to clean up stuff we've allocated so far thread->set_osthread(nullptr); 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::Bsd::_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 (std::nothrow) OSThread(); if (osthread == nullptr) { return false; } osthread->set_thread_id(os::Bsd::gettid()); #ifdef __APPLE__ // Store unique OS X thread id used by SA osthread->set_unique_thread_id(); #endif // Store pthread info into the OSThread osthread->set_pthread_id(::pthread_self()); // initialize floating point control register os::Bsd::init_thread_fpu_state(); // Initial thread state is RUNNABLE osthread->set_state(RUNNABLE); thread->set_osthread(osthread); // initialize signal mask for this thread // and save the caller's signal mask PosixSignals::hotspot_sigmask(thread); log_info(os, thread)("Thread attached (tid: %zu, pthread id: %zu" ", stack: " PTR_FORMAT " - " PTR_FORMAT " (%zuK) ).", os::current_thread_id(), (uintx) pthread_self(), p2i(thread->stack_base()), p2i(thread->stack_end()), thread->stack_size() / K); 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 Bsd resources related to the OSThread void os::free_thread(OSThread* osthread) { assert(osthread != nullptr, "osthread not set"); // We are told to free resources of the argument thread, but we can only really operate // on the current thread. The current thread may be already detached at this point. assert(Thread::current_or_null() == nullptr || Thread::current()->osthread() == osthread, "os::free_thread but not current thread"); // Restore caller's signal mask sigset_t sigmask = osthread->caller_sigmask(); pthread_sigmask(SIG_SETMASK, &sigmask, nullptr); delete osthread; } //////////////////////////////////////////////////////////////////////////////// // time support double os::elapsedVTime() { // better than nothing, but not much return elapsedTime(); } #ifdef __APPLE__ void os::Bsd::clock_init() { mach_timebase_info(&_timebase_info); } #else void os::Bsd::clock_init() { // Nothing to do } #endif #ifdef __APPLE__ jlong os::javaTimeNanos() { const uint64_t tm = mach_absolute_time(); const uint64_t now = (tm * Bsd::_timebase_info.numer) / Bsd::_timebase_info.denom; const uint64_t prev = Bsd::_max_abstime; if (now <= prev) { return prev; // same or retrograde time; } const uint64_t obsv = Atomic::cmpxchg(&Bsd::_max_abstime, prev, now); assert(obsv >= prev, "invariant"); // Monotonicity // If the CAS succeeded then we're done and return "now". // If the CAS failed and the observed value "obsv" is >= now then // we should return "obsv". If the CAS failed and now > obsv > prv then // some other thread raced this thread and installed a new value, in which case // we could either (a) retry the entire operation, (b) retry trying to install now // or (c) just return obsv. We use (c). No loop is required although in some cases // we might discard a higher "now" value in deference to a slightly lower but freshly // installed obsv value. That's entirely benign -- it admits no new orderings compared // to (a) or (b) -- and greatly reduces coherence traffic. // We might also condition (c) on the magnitude of the delta between obsv and now. // Avoiding excessive CAS operations to hot RW locations is critical. // See https://blogs.oracle.com/dave/entry/cas_and_cache_trivia_invalidate return (prev == obsv) ? now : obsv; } void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { info_ptr->max_value = all_bits_jlong; info_ptr->may_skip_backward = false; // not subject to resetting or drifting info_ptr->may_skip_forward = false; // not subject to resetting or drifting info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time } #endif // __APPLE__ // Information of current thread in variety of formats pid_t os::Bsd::gettid() { int retval = -1; #ifdef __APPLE__ // XNU kernel mach_port_t port = mach_thread_self(); guarantee(MACH_PORT_VALID(port), "just checking"); mach_port_deallocate(mach_task_self(), port); return (pid_t)port; #else #ifdef __FreeBSD__ retval = syscall(SYS_thr_self); #else #ifdef __OpenBSD__ retval = syscall(SYS_getthrid); #else #ifdef __NetBSD__ retval = (pid_t) syscall(SYS__lwp_self); #endif #endif #endif #endif if (retval == -1) { return getpid(); } } intx os::current_thread_id() { #ifdef __APPLE__ return (intx)os::Bsd::gettid(); #else return (intx)::pthread_self(); #endif } int os::current_process_id() { return (int)(getpid()); } // DLL functions static int local_dladdr(const void* addr, Dl_info* info) { #ifdef __APPLE__ if (addr == (void*)-1) { // dladdr() in macOS12/Monterey returns success for -1, but that addr // value should not be allowed to work to avoid confusion. return 0; } #endif return dladdr(addr, info); } // This must be hard coded because it's the system's temporary // directory not the java application's temp directory, ala java.io.tmpdir. #ifdef __APPLE__ // macosx has a secure per-user temporary directory char temp_path_storage[PATH_MAX]; const char* os::get_temp_directory() { static char *temp_path = nullptr; if (temp_path == nullptr) { int pathSize = confstr(_CS_DARWIN_USER_TEMP_DIR, temp_path_storage, PATH_MAX); if (pathSize == 0 || pathSize > PATH_MAX) { strlcpy(temp_path_storage, "/tmp/", sizeof(temp_path_storage)); } temp_path = temp_path_storage; } return temp_path; } #else // __APPLE__ const char* os::get_temp_directory() { return "/tmp"; } #endif // __APPLE__ // check if addr is inside libjvm.so bool os::address_is_in_vm(address addr) { static address libjvm_base_addr; Dl_info dlinfo; if (libjvm_base_addr == nullptr) { if (dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo) != 0) { libjvm_base_addr = (address)dlinfo.dli_fbase; } assert(libjvm_base_addr !=nullptr, "Cannot obtain base address for libjvm"); } if (dladdr((void *)addr, &dlinfo) != 0) { if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true; } return false; } void os::prepare_native_symbols() { } bool os::dll_address_to_function_name(address addr, char *buf, int buflen, int *offset, bool demangle) { // buf is not optional, but offset is optional assert(buf != nullptr, "sanity check"); Dl_info dlinfo; if (local_dladdr((void*)addr, &dlinfo) != 0) { // see if we have a matching symbol if (dlinfo.dli_saddr != nullptr && dlinfo.dli_sname != nullptr) { if (!(demangle && Decoder::demangle(dlinfo.dli_sname, buf, buflen))) { jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname); } if (offset != nullptr) *offset = addr - (address)dlinfo.dli_saddr; return true; } #ifndef __APPLE__ // The 6-parameter Decoder::decode() function is not implemented on macOS. // The Mach-O binary format does not contain a "list of files" with address // ranges like ELF. That makes sense since Mach-O can contain binaries for // than one instruction set so there can be more than one address range for // each "file". // no matching symbol so try for just file info if (dlinfo.dli_fname != nullptr && dlinfo.dli_fbase != nullptr) { if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase), buf, buflen, offset, dlinfo.dli_fname, demangle)) { return true; } } #else // __APPLE__ #define MACH_MAXSYMLEN 256 char localbuf[MACH_MAXSYMLEN]; // Handle non-dynamic manually: if (dlinfo.dli_fbase != nullptr && Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset, dlinfo.dli_fbase)) { if (!(demangle && Decoder::demangle(localbuf, buf, buflen))) { jio_snprintf(buf, buflen, "%s", localbuf); } return true; } #undef MACH_MAXSYMLEN #endif // __APPLE__ } buf[0] = '\0'; if (offset != nullptr) *offset = -1; return false; } bool os::dll_address_to_library_name(address addr, char* buf, int buflen, int* offset) { // buf is not optional, but offset is optional assert(buf != nullptr, "sanity check"); Dl_info dlinfo; if (local_dladdr((void*)addr, &dlinfo) != 0) { if (dlinfo.dli_fname != nullptr) { jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname); } if (dlinfo.dli_fbase != nullptr && offset != nullptr) { *offset = addr - (address)dlinfo.dli_fbase; } return true; } buf[0] = '\0'; if (offset) *offset = -1; return false; } // Loads .dll/.so and // in case of error it checks if .dll/.so was built for the // same architecture as Hotspot is running on void *os::Bsd::dlopen_helper(const char *filename, int mode, char *ebuf, int ebuflen) { #ifndef IA32 bool ieee_handling = IEEE_subnormal_handling_OK(); if (!ieee_handling) { Events::log_dll_message(nullptr, "IEEE subnormal handling check failed before loading %s", filename); log_info(os)("IEEE subnormal handling check failed before loading %s", filename); if (CheckJNICalls) { tty->print_cr("WARNING: IEEE subnormal handling check failed before loading %s", filename); Thread* current = Thread::current(); if (current->is_Java_thread()) { JavaThread::cast(current)->print_jni_stack(); } } } // Save and restore the floating-point environment around dlopen(). // There are known cases where global library initialization sets // FPU flags that affect computation accuracy, for example, enabling // Flush-To-Zero and Denormals-Are-Zero. Do not let those libraries // break Java arithmetic. Unfortunately, this might affect libraries // that might depend on these FPU features for performance and/or // numerical "accuracy", but we need to protect Java semantics first // and foremost. See JDK-8295159. // This workaround is ineffective on IA32 systems because the MXCSR // register (which controls flush-to-zero mode) is not stored in the // legacy fenv. fenv_t default_fenv; int rtn = fegetenv(&default_fenv); assert(rtn == 0, "fegetenv must succeed"); #endif // IA32 void* result; JFR_ONLY(NativeLibraryLoadEvent load_event(filename, &result);) result = ::dlopen(filename, RTLD_LAZY); if (result == nullptr) { const char* error_report = ::dlerror(); if (error_report == nullptr) { error_report = "dlerror returned no error description"; } if (ebuf != nullptr && ebuflen > 0) { ::strncpy(ebuf, error_report, ebuflen-1); ebuf[ebuflen-1]='\0'; } Events::log_dll_message(nullptr, "Loading shared library %s failed, %s", filename, error_report); log_info(os)("shared library load of %s failed, %s", filename, error_report); JFR_ONLY(load_event.set_error_msg(error_report);) } else { Events::log_dll_message(nullptr, "Loaded shared library %s", filename); log_info(os)("shared library load of %s was successful", filename); #ifndef IA32 if (! IEEE_subnormal_handling_OK()) { // We just dlopen()ed a library that mangled the floating-point // flags. Silently fix things now. JFR_ONLY(load_event.set_fp_env_correction_attempt(true);) int rtn = fesetenv(&default_fenv); assert(rtn == 0, "fesetenv must succeed"); if (IEEE_subnormal_handling_OK()) { Events::log_dll_message(nullptr, "IEEE subnormal handling had to be corrected after loading %s", filename); log_info(os)("IEEE subnormal handling had to be corrected after loading %s", filename); JFR_ONLY(load_event.set_fp_env_correction_success(true);) } else { Events::log_dll_message(nullptr, "IEEE subnormal handling could not be corrected after loading %s", filename); log_info(os)("IEEE subnormal handling could not be corrected after loading %s", filename); if (CheckJNICalls) { tty->print_cr("WARNING: IEEE subnormal handling could not be corrected after loading %s", filename); Thread* current = Thread::current(); if (current->is_Java_thread()) { JavaThread::cast(current)->print_jni_stack(); } } assert(false, "fesetenv didn't work"); } } #endif // IA32 } return result; } #ifdef __APPLE__ void * os::dll_load(const char *filename, char *ebuf, int ebuflen) { if (is_vm_statically_linked()) { return os::get_default_process_handle(); } log_info(os)("attempting shared library load of %s", filename); return os::Bsd::dlopen_helper(filename, RTLD_LAZY, ebuf, ebuflen); } #else void * os::dll_load(const char *filename, char *ebuf, int ebuflen) { if (is_vm_statically_linked()) { return os::get_default_process_handle(); } log_info(os)("attempting shared library load of %s", filename); void* result; result = os::Bsd::dlopen_helper(filename, RTLD_LAZY, ebuf, ebuflen); if (result != nullptr) { return result; } Events::log_dll_message(nullptr, "Loading shared library %s failed, %s", filename, error_report); log_info(os)("shared library load of %s failed, %s", filename, error_report); int diag_msg_max_length=ebuflen-strlen(ebuf); char* diag_msg_buf=ebuf+strlen(ebuf); if (diag_msg_max_length==0) { // No more space in ebuf for additional diagnostics message return nullptr; } int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK); if (file_descriptor < 0) { // Can't open library, report dlerror() message return nullptr; } Elf32_Ehdr elf_head; bool failed_to_read_elf_head= (sizeof(elf_head)!= (::read(file_descriptor, &elf_head,sizeof(elf_head)))); ::close(file_descriptor); if (failed_to_read_elf_head) { // file i/o error - report dlerror() msg return nullptr; } typedef struct { Elf32_Half code; // Actual value as defined in elf.h Elf32_Half compat_class; // Compatibility of archs at VM's sense char elf_class; // 32 or 64 bit char endianess; // MSB or LSB char* name; // String representation } arch_t; #ifndef EM_486 #define EM_486 6 /* Intel 80486 */ #endif #ifndef EM_MIPS_RS3_LE #define EM_MIPS_RS3_LE 10 /* MIPS */ #endif #ifndef EM_PPC64 #define EM_PPC64 21 /* PowerPC64 */ #endif #ifndef EM_S390 #define EM_S390 22 /* IBM System/390 */ #endif #ifndef EM_IA_64 #define EM_IA_64 50 /* HP/Intel IA-64 */ #endif #ifndef EM_X86_64 #define EM_X86_64 62 /* AMD x86-64 */ #endif static const arch_t arch_array[]={ {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"}, {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"}, {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"}, {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"}, {EM_ARM, EM_ARM, ELFCLASS32, ELFDATA2LSB, (char*)"ARM"}, {EM_S390, EM_S390, ELFCLASSNONE, ELFDATA2MSB, (char*)"IBM System/390"}, {EM_ALPHA, EM_ALPHA, ELFCLASS64, ELFDATA2LSB, (char*)"Alpha"}, {EM_MIPS_RS3_LE, EM_MIPS_RS3_LE, ELFCLASS32, ELFDATA2LSB, (char*)"MIPSel"}, {EM_MIPS, EM_MIPS, ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"}, {EM_PARISC, EM_PARISC, ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"}, {EM_68K, EM_68K, ELFCLASS32, ELFDATA2MSB, (char*)"M68k"} }; #if (defined IA32) static Elf32_Half running_arch_code=EM_386; #elif (defined AMD64) static Elf32_Half running_arch_code=EM_X86_64; #elif (defined __powerpc64__) static Elf32_Half running_arch_code=EM_PPC64; #elif (defined __powerpc__) static Elf32_Half running_arch_code=EM_PPC; #elif (defined ARM) static Elf32_Half running_arch_code=EM_ARM; #elif (defined S390) static Elf32_Half running_arch_code=EM_S390; #elif (defined ALPHA) static Elf32_Half running_arch_code=EM_ALPHA; #elif (defined MIPSEL) static Elf32_Half running_arch_code=EM_MIPS_RS3_LE; #elif (defined PARISC) static Elf32_Half running_arch_code=EM_PARISC; #elif (defined MIPS) static Elf32_Half running_arch_code=EM_MIPS; #elif (defined M68K) static Elf32_Half running_arch_code=EM_68K; #else #error Method os::dll_load requires that one of following is defined:\ IA32, AMD64, __powerpc__, ARM, S390, ALPHA, MIPS, MIPSEL, PARISC, M68K #endif // Identify compatibility class for VM's architecture and library's architecture // Obtain string descriptions for architectures arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], nullptr}; int running_arch_index=-1; for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) { if (running_arch_code == arch_array[i].code) { running_arch_index = i; } if (lib_arch.code == arch_array[i].code) { lib_arch.compat_class = arch_array[i].compat_class; lib_arch.name = arch_array[i].name; } } assert(running_arch_index != -1, "Didn't find running architecture code (running_arch_code) in arch_array"); if (running_arch_index == -1) { // Even though running architecture detection failed // we may still continue with reporting dlerror() message return nullptr; } if (lib_arch.endianess != arch_array[running_arch_index].endianess) { ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)"); return nullptr; } #ifndef S390 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) { ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)"); return nullptr; } #endif // !S390 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) { if (lib_arch.name!=nullptr) { ::snprintf(diag_msg_buf, diag_msg_max_length-1, " (Possible cause: can't load %s-bit .so on a %s-bit platform)", lib_arch.name, arch_array[running_arch_index].name); } else { ::snprintf(diag_msg_buf, diag_msg_max_length-1, " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)", lib_arch.code, arch_array[running_arch_index].name); } } return nullptr; } #endif // !__APPLE__ static int _print_dll_info_cb(const char * name, address base_address, address top_address, void * param) { outputStream * out = (outputStream *) param; out->print_cr(INTPTR_FORMAT " \t%s", (intptr_t)base_address, name); return 0; } void os::print_dll_info(outputStream *st) { st->print_cr("Dynamic libraries:"); if (get_loaded_modules_info(_print_dll_info_cb, (void *)st)) { st->print_cr("Error: Cannot print dynamic libraries."); } } int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) { #ifdef RTLD_DI_LINKMAP Dl_info dli; void *handle; Link_map *map; Link_map *p; if (dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli) == 0 || dli.dli_fname == nullptr) { return 1; } handle = dlopen(dli.dli_fname, RTLD_LAZY); if (handle == nullptr) { return 1; } dlinfo(handle, RTLD_DI_LINKMAP, &map); if (map == nullptr) { dlclose(handle); return 1; } while (map->l_prev != nullptr) map = map->l_prev; while (map != nullptr) { // Value for top_address is returned as 0 since we don't have any information about module size if (callback(map->l_name, (address)map->l_addr, (address)0, param)) { dlclose(handle); return 1; } map = map->l_next; } dlclose(handle); #elif defined(__APPLE__) for (uint32_t i = 1; i < _dyld_image_count(); i++) { // Value for top_address is returned as 0 since we don't have any information about module size if (callback(_dyld_get_image_name(i), (address)_dyld_get_image_header(i), (address)0, param)) { return 1; } } return 0; #else return 1; #endif } void os::get_summary_os_info(char* buf, size_t buflen) { // These buffers are small because we want this to be brief // and not use a lot of stack while generating the hs_err file. char os[100]; size_t size = sizeof(os); int mib_kern[] = { CTL_KERN, KERN_OSTYPE }; if (sysctl(mib_kern, 2, os, &size, nullptr, 0) < 0) { #ifdef __APPLE__ strncpy(os, "Darwin", sizeof(os)); #elif __OpenBSD__ strncpy(os, "OpenBSD", sizeof(os)); #else strncpy(os, "BSD", sizeof(os)); #endif } char release[100]; size = sizeof(release); int mib_release[] = { CTL_KERN, KERN_OSRELEASE }; if (sysctl(mib_release, 2, release, &size, nullptr, 0) < 0) { // if error, leave blank strncpy(release, "", sizeof(release)); } #ifdef __APPLE__ char osproductversion[100]; size_t sz = sizeof(osproductversion); int ret = sysctlbyname("kern.osproductversion", osproductversion, &sz, nullptr, 0); if (ret == 0) { char build[100]; size = sizeof(build); int mib_build[] = { CTL_KERN, KERN_OSVERSION }; if (sysctl(mib_build, 2, build, &size, nullptr, 0) < 0) { snprintf(buf, buflen, "%s %s, macOS %s", os, release, osproductversion); } else { snprintf(buf, buflen, "%s %s, macOS %s (%s)", os, release, osproductversion, build); } } else #endif snprintf(buf, buflen, "%s %s", os, release); } void os::print_os_info_brief(outputStream* st) { os::Posix::print_uname_info(st); } void os::print_os_info(outputStream* st) { st->print_cr("OS:"); os::Posix::print_uname_info(st); os::Bsd::print_uptime_info(st); os::Posix::print_rlimit_info(st); os::Posix::print_load_average(st); VM_Version::print_platform_virtualization_info(st); } #ifdef __APPLE__ static void print_sysctl_info_string(const char* sysctlkey, outputStream* st, char* buf, size_t size) { if (sysctlbyname(sysctlkey, buf, &size, nullptr, 0) >= 0) { st->print_cr("%s:%s", sysctlkey, buf); } } static void print_sysctl_info_uint64(const char* sysctlkey, outputStream* st) { uint64_t val; size_t size=sizeof(uint64_t); if (sysctlbyname(sysctlkey, &val, &size, nullptr, 0) >= 0) { st->print_cr("%s:%llu", sysctlkey, val); } } #endif void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) { #ifdef __APPLE__ print_sysctl_info_string("machdep.cpu.brand_string", st, buf, buflen); print_sysctl_info_uint64("hw.cpufrequency", st); print_sysctl_info_uint64("hw.cpufrequency_min", st); print_sysctl_info_uint64("hw.cpufrequency_max", st); print_sysctl_info_uint64("hw.cachelinesize", st); print_sysctl_info_uint64("hw.l1icachesize", st); print_sysctl_info_uint64("hw.l1dcachesize", st); print_sysctl_info_uint64("hw.l2cachesize", st); print_sysctl_info_uint64("hw.l3cachesize", st); #endif } void os::get_summary_cpu_info(char* buf, size_t buflen) { unsigned int mhz; size_t size = sizeof(mhz); int mib[] = { CTL_HW, HW_CPU_FREQ }; if (sysctl(mib, 2, &mhz, &size, nullptr, 0) < 0) { mhz = 1; // looks like an error but can be divided by } else { mhz /= 1000000; // reported in millions } char model[100]; size = sizeof(model); int mib_model[] = { CTL_HW, HW_MODEL }; if (sysctl(mib_model, 2, model, &size, nullptr, 0) < 0) { strncpy(model, cpu_arch, sizeof(model)); } char machine[100]; size = sizeof(machine); int mib_machine[] = { CTL_HW, HW_MACHINE }; if (sysctl(mib_machine, 2, machine, &size, nullptr, 0) < 0) { strncpy(machine, "", sizeof(machine)); } #if defined(__APPLE__) && !defined(ZERO) if (VM_Version::is_cpu_emulated()) { snprintf(buf, buflen, "\"%s\" %s (EMULATED) %d MHz", model, machine, mhz); } else { NOT_AARCH64(snprintf(buf, buflen, "\"%s\" %s %d MHz", model, machine, mhz)); // aarch64 CPU doesn't report its speed AARCH64_ONLY(snprintf(buf, buflen, "\"%s\" %s", model, machine)); } #else snprintf(buf, buflen, "\"%s\" %s %d MHz", model, machine, mhz); #endif } void os::print_memory_info(outputStream* st) { xsw_usage swap_usage; size_t size = sizeof(swap_usage); st->print("Memory:"); st->print(" %zuk page", os::vm_page_size()>>10); st->print(", physical " UINT64_FORMAT "k", os::physical_memory() >> 10); st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10); if((sysctlbyname("vm.swapusage", &swap_usage, &size, nullptr, 0) == 0) || (errno == ENOMEM)) { if (size >= offset_of(xsw_usage, xsu_used)) { st->print(", swap " UINT64_FORMAT "k", ((julong) swap_usage.xsu_total) >> 10); st->print("(" UINT64_FORMAT "k free)", ((julong) swap_usage.xsu_avail) >> 10); } } st->cr(); } //////////////////////////////////////////////////////////////////////////////// // Virtual Memory static void warn_fail_commit_memory(char* addr, size_t size, bool exec, int err) { warning("INFO: os::commit_memory(" INTPTR_FORMAT ", %zu" ", %d) failed; error='%s' (errno=%d)", (intptr_t)addr, size, exec, os::errno_name(err), err); } // NOTE: Bsd kernel does not really reserve the pages for us. // All it does is to check if there are enough free pages // left at the time of mmap(). This could be a potential // problem. bool os::pd_commit_memory(char* addr, size_t size, bool exec) { int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; #if defined(__OpenBSD__) // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD Events::log_memprotect(nullptr, "Protecting memory [" INTPTR_FORMAT "," INTPTR_FORMAT "] with protection modes %x", p2i(addr), p2i(addr+size), prot); if (::mprotect(addr, size, prot) == 0) { return true; } else { ErrnoPreserver ep; log_trace(os, map)("mprotect failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); } #elif defined(__APPLE__) if (exec) { // Do not replace MAP_JIT mappings, see JDK-8234930 if (::mprotect(addr, size, prot) == 0) { return true; } else { ErrnoPreserver ep; log_trace(os, map)("mprotect failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); } } else { uintptr_t res = (uintptr_t) ::mmap(addr, size, prot, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); if (res != (uintptr_t) MAP_FAILED) { return true; } else { ErrnoPreserver ep; log_trace(os, map)("mmap failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); } } #else uintptr_t res = (uintptr_t) ::mmap(addr, size, prot, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0); if (res != (uintptr_t) MAP_FAILED) { return true; } else { ErrnoPreserver ep; log_trace(os, map)("mmap failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); } #endif // Warn about any commit errors we see in non-product builds just // in case mmap() doesn't work as described on the man page. NOT_PRODUCT(warn_fail_commit_memory(addr, size, exec, errno);) return false; } bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) { // alignment_hint is ignored on this OS return pd_commit_memory(addr, size, exec); } void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec, const char* mesg) { assert(mesg != nullptr, "mesg must be specified"); if (!pd_commit_memory(addr, size, exec)) { // add extra info in product mode for vm_exit_out_of_memory(): PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);) vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg); } } void os::pd_commit_memory_or_exit(char* addr, size_t size, size_t alignment_hint, bool exec, const char* mesg) { // alignment_hint is ignored on this OS pd_commit_memory_or_exit(addr, size, exec, mesg); } void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } void os::pd_disclaim_memory(char *addr, size_t bytes) { ::madvise(addr, bytes, MADV_DONTNEED); } size_t os::pd_pretouch_memory(void* first, void* last, size_t page_size) { return page_size; } void os::numa_make_global(char *addr, size_t bytes) { } void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { } bool os::numa_topology_changed() { return false; } size_t os::numa_get_groups_num() { return 1; } int os::numa_get_group_id() { return 0; } size_t os::numa_get_leaf_groups(uint *ids, size_t size) { if (size > 0) { ids[0] = 0; return 1; } return 0; } int os::numa_get_group_id_for_address(const void* address) { return 0; } bool os::numa_get_group_ids_for_range(const void** addresses, int* lgrp_ids, size_t count) { return false; } bool os::pd_uncommit_memory(char* addr, size_t size, bool exec) { #if defined(__OpenBSD__) // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD Events::log_memprotect(nullptr, "Protecting memory [" INTPTR_FORMAT "," INTPTR_FORMAT "] with PROT_NONE", p2i(addr), p2i(addr+size)); if (::mprotect(addr, size, PROT_NONE) == 0) { return true; } else { ErrnoPreserver ep; log_trace(os, map)("mprotect failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); return false; } #elif defined(__APPLE__) if (exec) { if (::madvise(addr, size, MADV_FREE) != 0) { ErrnoPreserver ep; log_trace(os, map)("madvise failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); return false; } if (::mprotect(addr, size, PROT_NONE) == 0) { return true; } else { ErrnoPreserver ep; log_trace(os, map)("mprotect failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); return false; } } else { uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE, MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0); if (res == (uintptr_t) MAP_FAILED) { ErrnoPreserver ep; log_trace(os, map)("mmap failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); return false; } return true; } #else uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE, MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0); if (res == (uintptr_t) MAP_FAILED) { ErrnoPreserver ep; log_trace(os, map)("mmap failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); return false; } return true; #endif } bool os::pd_create_stack_guard_pages(char* addr, size_t size) { return os::commit_memory(addr, size, !ExecMem); } // If this is a growable mapping, remove the guard pages entirely by // munmap()ping them. If not, just call uncommit_memory(). bool os::remove_stack_guard_pages(char* addr, size_t size) { return os::uncommit_memory(addr, size); } // 'requested_addr' is only treated as a hint, the return value may or // may not start from the requested address. Unlike Bsd mmap(), this // function returns null to indicate failure. static char* anon_mmap(char* requested_addr, size_t bytes, bool exec) { // MAP_FIXED is intentionally left out, to leave existing mappings intact. const int flags = MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS MACOS_ONLY(| (exec ? MAP_JIT : 0)); // Map reserved/uncommitted pages PROT_NONE so we fail early if we // touch an uncommitted page. Otherwise, the read/write might // succeed if we have enough swap space to back the physical page. char* addr = (char*)::mmap(requested_addr, bytes, PROT_NONE, flags, -1, 0); if (addr == MAP_FAILED) { ErrnoPreserver ep; log_trace(os, map)("mmap failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(requested_addr, bytes), os::strerror(ep.saved_errno())); return nullptr; } return addr; } static int anon_munmap(char * addr, size_t size) { if (::munmap(addr, size) == 0) { return 1; } else { ErrnoPreserver ep; log_trace(os, map)("munmap failed: " RANGEFMT " errno=(%s)", RANGEFMTARGS(addr, size), os::strerror(ep.saved_errno())); return 0; } } char* os::pd_reserve_memory(size_t bytes, bool exec) { return anon_mmap(nullptr /* addr */, bytes, exec); } bool os::pd_release_memory(char* addr, size_t size) { return anon_munmap(addr, size); } static bool bsd_mprotect(char* addr, size_t size, int prot) { // Bsd wants the mprotect address argument to be page aligned. char* bottom = (char*)align_down((intptr_t)addr, os::vm_page_size()); // According to SUSv3, mprotect() should only be used with mappings // established by mmap(), and mmap() always maps whole pages. Unaligned // 'addr' likely indicates problem in the VM (e.g. trying to change // protection of malloc'ed or statically allocated memory). Check the // caller if you hit this assert. assert(addr == bottom, "sanity check"); size = align_up(pointer_delta(addr, bottom, 1) + size, os::vm_page_size()); Events::log_memprotect(nullptr, "Protecting memory [" INTPTR_FORMAT "," INTPTR_FORMAT "] with protection modes %x", p2i(bottom), p2i(bottom+size), prot); return ::mprotect(bottom, size, prot) == 0; } // Set protections specified bool os::protect_memory(char* addr, size_t bytes, ProtType prot, bool is_committed) { unsigned int p = 0; switch (prot) { case MEM_PROT_NONE: p = PROT_NONE; break; case MEM_PROT_READ: p = PROT_READ; break; case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break; case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break; default: ShouldNotReachHere(); } // is_committed is unused. return bsd_mprotect(addr, bytes, p); } bool os::guard_memory(char* addr, size_t size) { return bsd_mprotect(addr, size, PROT_NONE); } bool os::unguard_memory(char* addr, size_t size) { return bsd_mprotect(addr, size, PROT_READ|PROT_WRITE); } bool os::Bsd::hugetlbfs_sanity_check(bool warn, size_t page_size) { return false; } // Large page support static size_t _large_page_size = 0; void os::large_page_init() { } char* os::pd_reserve_memory_special(size_t bytes, size_t alignment, size_t page_size, char* req_addr, bool exec) { fatal("os::reserve_memory_special should not be called on BSD."); return nullptr; } bool os::pd_release_memory_special(char* base, size_t bytes) { fatal("os::release_memory_special should not be called on BSD."); return false; } size_t os::large_page_size() { return _large_page_size; } bool os::can_commit_large_page_memory() { // Does not matter, we do not support huge pages. return false; } char* os::pd_attempt_map_memory_to_file_at(char* requested_addr, size_t bytes, int file_desc) { assert(file_desc >= 0, "file_desc is not valid"); char* result = pd_attempt_reserve_memory_at(requested_addr, bytes, !ExecMem); if (result != nullptr) { if (replace_existing_mapping_with_file_mapping(result, bytes, file_desc) == nullptr) { vm_exit_during_initialization(err_msg("Error in mapping Java heap at the given filesystem directory")); } } return result; } // Reserve memory at an arbitrary address, only if that area is // available (and not reserved for something else). char* os::pd_attempt_reserve_memory_at(char* requested_addr, size_t bytes, bool exec) { // Assert only that the size is a multiple of the page size, since // that's all that mmap requires, and since that's all we really know // about at this low abstraction level. If we need higher alignment, // we can either pass an alignment to this method or verify alignment // in one of the methods further up the call chain. See bug 5044738. assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block"); // Bsd mmap allows caller to pass an address as hint; give it a try first, // if kernel honors the hint then we can return immediately. char * addr = anon_mmap(requested_addr, bytes, exec); if (addr == requested_addr) { return requested_addr; } if (addr != nullptr) { // mmap() is successful but it fails to reserve at the requested address anon_munmap(addr, bytes); } return nullptr; } size_t os::vm_min_address() { #ifdef __APPLE__ // On MacOS, the lowest 4G are denied to the application (see "PAGEZERO" resp. // -pagezero_size linker option). return 4 * G; #else assert(is_aligned(_vm_min_address_default, os::vm_allocation_granularity()), "Sanity"); return _vm_min_address_default; #endif } //////////////////////////////////////////////////////////////////////////////// // thread priority support // Note: Normal Bsd applications are run with SCHED_OTHER policy. SCHED_OTHER // only supports dynamic priority, static priority must be zero. For real-time // applications, Bsd supports SCHED_RR which allows static priority (1-99). // However, for large multi-threaded applications, SCHED_RR is not only slower // than SCHED_OTHER, but also very unstable (my volano tests hang hard 4 out // of 5 runs - Sep 2005). // // The following code actually changes the niceness of kernel-thread/LWP. It // has an assumption that setpriority() only modifies one kernel-thread/LWP, // not the entire user process, and user level threads are 1:1 mapped to kernel // threads. It has always been the case, but could change in the future. For // this reason, the code should not be used as default (ThreadPriorityPolicy=0). // It is only used when ThreadPriorityPolicy=1 and may require system level permission // (e.g., root privilege or CAP_SYS_NICE capability). #if !defined(__APPLE__) int os::java_to_os_priority[CriticalPriority + 1] = { 19, // 0 Entry should never be used 0, // 1 MinPriority 3, // 2 6, // 3 10, // 4 15, // 5 NormPriority 18, // 6 21, // 7 25, // 8 28, // 9 NearMaxPriority 31, // 10 MaxPriority 31 // 11 CriticalPriority }; #else // Using Mach high-level priority assignments int os::java_to_os_priority[CriticalPriority + 1] = { 0, // 0 Entry should never be used (MINPRI_USER) 27, // 1 MinPriority 28, // 2 29, // 3 30, // 4 31, // 5 NormPriority (BASEPRI_DEFAULT) 32, // 6 33, // 7 34, // 8 35, // 9 NearMaxPriority 36, // 10 MaxPriority 36 // 11 CriticalPriority }; #endif static int prio_init() { if (ThreadPriorityPolicy == 1) { if (geteuid() != 0) { if (!FLAG_IS_DEFAULT(ThreadPriorityPolicy) && !FLAG_IS_JIMAGE_RESOURCE(ThreadPriorityPolicy)) { warning("-XX:ThreadPriorityPolicy=1 may require system level permission, " \ "e.g., being the root user. If the necessary permission is not " \ "possessed, changes to priority will be silently ignored."); } } } if (UseCriticalJavaThreadPriority) { os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority]; } return 0; } OSReturn os::set_native_priority(Thread* thread, int newpri) { if (!UseThreadPriorities || ThreadPriorityPolicy == 0) return OS_OK; #ifdef __OpenBSD__ // OpenBSD pthread_setprio starves low priority threads return OS_OK; #elif defined(__FreeBSD__) int ret = pthread_setprio(thread->osthread()->pthread_id(), newpri); return (ret == 0) ? OS_OK : OS_ERR; #elif defined(__APPLE__) || defined(__NetBSD__) struct sched_param sp; int policy; if (pthread_getschedparam(thread->osthread()->pthread_id(), &policy, &sp) != 0) { return OS_ERR; } sp.sched_priority = newpri; if (pthread_setschedparam(thread->osthread()->pthread_id(), policy, &sp) != 0) { return OS_ERR; } return OS_OK; #else int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri); return (ret == 0) ? OS_OK : OS_ERR; #endif } OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) { if (!UseThreadPriorities || ThreadPriorityPolicy == 0) { *priority_ptr = java_to_os_priority[NormPriority]; return OS_OK; } errno = 0; #if defined(__OpenBSD__) || defined(__FreeBSD__) *priority_ptr = pthread_getprio(thread->osthread()->pthread_id()); #elif defined(__APPLE__) || defined(__NetBSD__) int policy; struct sched_param sp; int res = pthread_getschedparam(thread->osthread()->pthread_id(), &policy, &sp); if (res != 0) { *priority_ptr = -1; return OS_ERR; } else { *priority_ptr = sp.sched_priority; return OS_OK; } #else *priority_ptr = getpriority(PRIO_PROCESS, thread->osthread()->thread_id()); #endif return (*priority_ptr != -1 || errno == 0 ? OS_OK : OS_ERR); } extern void report_error(char* file_name, int line_no, char* title, char* format, ...); // this is called _before_ the most of global arguments have been parsed void os::init(void) { char dummy; // used to get a guess on initial stack address size_t page_size = (size_t)getpagesize(); OSInfo::set_vm_page_size(page_size); OSInfo::set_vm_allocation_granularity(page_size); if (os::vm_page_size() == 0) { fatal("os_bsd.cpp: os::init: getpagesize() failed (%s)", os::strerror(errno)); } _page_sizes.add(os::vm_page_size()); Bsd::initialize_system_info(); // _main_thread points to the thread that created/loaded the JVM. Bsd::_main_thread = pthread_self(); Bsd::clock_init(); os::Posix::init(); } // To install functions for atexit system call extern "C" { static void perfMemory_exit_helper() { perfMemory_exit(); } } // this is called _after_ the global arguments have been parsed jint os::init_2(void) { // This could be set after os::Posix::init() but all platforms // have to set it the same so we have to mirror Solaris. DEBUG_ONLY(os::set_mutex_init_done();) os::Posix::init_2(); if (PosixSignals::init() == JNI_ERR) { return JNI_ERR; } // Check and sets minimum stack sizes against command line options if (set_minimum_stack_sizes() == JNI_ERR) { return JNI_ERR; } // Not supported. FLAG_SET_ERGO(UseNUMA, false); FLAG_SET_ERGO(UseNUMAInterleaving, false); if (MaxFDLimit) { // set the number of file descriptors to max. print out error // if getrlimit/setrlimit fails but continue regardless. struct rlimit nbr_files; int status = getrlimit(RLIMIT_NOFILE, &nbr_files); if (status != 0) { log_info(os)("os::init_2 getrlimit failed: %s", os::strerror(errno)); } else { rlim_t rlim_original = nbr_files.rlim_cur; // On macOS according to setrlimit(2), OPEN_MAX must be used instead // of RLIM_INFINITY, but testing on macOS >= 10.6, reveals that // we can, in fact, use even RLIM_INFINITY. // However, we need to limit the value to 0x100000 (which is the max value // allowed on Linux) so that any existing code that iterates over all allowed // file descriptors, finishes in a reasonable time, without appearing // to hang. nbr_files.rlim_cur = MIN(0x100000, nbr_files.rlim_max); status = setrlimit(RLIMIT_NOFILE, &nbr_files); if (status != 0) { // If that fails then try lowering the limit to either OPEN_MAX // (which is safe) or the original limit, whichever was greater. nbr_files.rlim_cur = MAX(OPEN_MAX, rlim_original); status = setrlimit(RLIMIT_NOFILE, &nbr_files); } if (status != 0) { log_info(os)("os::init_2 setrlimit failed: %s", os::strerror(errno)); } } } // at-exit methods are called in the reverse order of their registration. // atexit functions are called on return from main or as a result of a // call to exit(3C). There can be only 32 of these functions registered // and atexit() does not set errno. if (PerfAllowAtExitRegistration) { // only register atexit functions if PerfAllowAtExitRegistration is set. // atexit functions can be delayed until process exit time, which // can be problematic for embedded VM situations. Embedded VMs should // call DestroyJavaVM() to assure that VM resources are released. // note: perfMemory_exit_helper atexit function may be removed in // the future if the appropriate cleanup code can be added to the // VM_Exit VMOperation's doit method. if (atexit(perfMemory_exit_helper) != 0) { warning("os::init_2 atexit(perfMemory_exit_helper) failed"); } } // initialize thread priority policy prio_init(); #ifdef __APPLE__ // dynamically link to objective c gc registration void *handleLibObjc = dlopen(OBJC_LIB, RTLD_LAZY); if (handleLibObjc != nullptr) { objc_registerThreadWithCollectorFunction = (objc_registerThreadWithCollector_t) dlsym(handleLibObjc, OBJC_GCREGISTER); } #endif return JNI_OK; } 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; } return _processor_count; } uint os::processor_id() { #if defined(__APPLE__) && defined(__x86_64__) // Get the initial APIC id and return the associated processor id. The initial APIC // id is limited to 8-bits, which means we can have at most 256 unique APIC ids. If // the system has more processors (or the initial APIC ids are discontiguous) the // APIC id will be truncated and more than one processor will potentially share the // same processor id. This is not optimal, but unlikely to happen in practice. Should // this become a real problem we could switch to using x2APIC ids, which are 32-bit // wide. However, note that x2APIC is Intel-specific, and the wider number space // would require a more complicated mapping approach. uint eax = 0x1; uint ebx; uint ecx = 0; uint edx; __asm__ ("cpuid\n\t" : "+a" (eax), "+b" (ebx), "+c" (ecx), "+d" (edx) : ); uint apic_id = (ebx >> 24) & (processor_id_map_size - 1); int processor_id = Atomic::load(&processor_id_map[apic_id]); while (processor_id < 0) { // Assign processor id to APIC id processor_id = Atomic::cmpxchg(&processor_id_map[apic_id], processor_id_unassigned, processor_id_assigning); if (processor_id == processor_id_unassigned) { processor_id = Atomic::fetch_then_add(&processor_id_next, 1) % os::processor_count(); Atomic::store(&processor_id_map[apic_id], processor_id); } } assert(processor_id >= 0 && processor_id < os::processor_count(), "invalid processor id"); return (uint)processor_id; #else // defined(__APPLE__) && defined(__x86_64__) // Return 0 until we find a good way to get the current processor id on // the platform. Returning 0 is safe, since there is always at least one // processor, but might not be optimal for performance in some cases. return 0; #endif } void os::set_native_thread_name(const char *name) { #if defined(__APPLE__) && MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_5 // This is only supported in Snow Leopard and beyond if (name != nullptr) { // Add a "Java: " prefix to the name char buf[MAXTHREADNAMESIZE]; snprintf(buf, sizeof(buf), "Java: %s", name); pthread_setname_np(buf); } #endif } //////////////////////////////////////////////////////////////////////////////// // debug support bool os::find(address addr, outputStream* st) { Dl_info dlinfo; memset(&dlinfo, 0, sizeof(dlinfo)); if (dladdr(addr, &dlinfo) != 0) { st->print(INTPTR_FORMAT ": ", (intptr_t)addr); if (dlinfo.dli_sname != nullptr && dlinfo.dli_saddr != nullptr) { st->print("%s+%#x", dlinfo.dli_sname, (uint)((uintptr_t)addr - (uintptr_t)dlinfo.dli_saddr)); } else if (dlinfo.dli_fbase != nullptr) { st->print("", (uint)((uintptr_t)addr - (uintptr_t)dlinfo.dli_fbase)); } else { st->print(""); } if (dlinfo.dli_fname != nullptr) { st->print(" in %s", dlinfo.dli_fname); } if (dlinfo.dli_fbase != nullptr) { st->print(" at " INTPTR_FORMAT, (intptr_t)dlinfo.dli_fbase); } st->cr(); if (Verbose) { // decode some bytes around the PC address begin = clamp_address_in_page(addr-40, addr, os::vm_page_size()); address end = clamp_address_in_page(addr+40, addr, os::vm_page_size()); address lowest = (address) dlinfo.dli_sname; if (!lowest) lowest = (address) dlinfo.dli_fbase; if (begin < lowest) begin = lowest; Dl_info dlinfo2; if (dladdr(end, &dlinfo2) != 0 && dlinfo2.dli_saddr != dlinfo.dli_saddr && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) { end = (address) dlinfo2.dli_saddr; } Disassembler::decode(begin, end, st); } return true; } return false; } //////////////////////////////////////////////////////////////////////////////// // misc // This does not do anything on Bsd. This is basically a hook for being // able to use structured exception handling (thread-local exception filters) // on, e.g., Win32. void os::os_exception_wrapper(java_call_t f, JavaValue* value, const methodHandle& method, JavaCallArguments* args, JavaThread* thread) { f(value, method, args, thread); } static inline struct timespec get_mtime(const char* filename) { struct stat st; int ret = os::stat(filename, &st); assert(ret == 0, "failed to stat() file '%s': %s", filename, os::strerror(errno)); #ifdef __APPLE__ return st.st_mtimespec; #else return st.st_mtim; #endif } int os::compare_file_modified_times(const char* file1, const char* file2) { struct timespec filetime1 = get_mtime(file1); struct timespec filetime2 = get_mtime(file2); int diff = primitive_compare(filetime1.tv_sec, filetime2.tv_sec); if (diff == 0) { diff = primitive_compare(filetime1.tv_nsec, filetime2.tv_nsec); } return diff; } // This code originates from JDK's sysOpen and open64_w // from src/solaris/hpi/src/system_md.c int os::open(const char *path, int oflag, int mode) { if (strlen(path) > MAX_PATH - 1) { errno = ENAMETOOLONG; return -1; } // All file descriptors that are opened in the JVM and not // specifically destined for a subprocess should have the // close-on-exec flag set. If we don't set it, then careless 3rd // party native code might fork and exec without closing all // appropriate file descriptors (e.g. as we do in closeDescriptors in // UNIXProcess.c), and this in turn might: // // - cause end-of-file to fail to be detected on some file // descriptors, resulting in mysterious hangs, or // // - might cause an fopen in the subprocess to fail on a system // suffering from bug 1085341. // // (Yes, the default setting of the close-on-exec flag is a Unix // design flaw) // // See: // 1085341: 32-bit stdio routines should support file descriptors >255 // 4843136: (process) pipe file descriptor from Runtime.exec not being closed // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9 // int fd = ::open(path, oflag | O_CLOEXEC, mode); if (fd == -1) return -1; // If the open succeeded, the file might still be a directory { struct stat buf; int ret = ::fstat(fd, &buf); int st_mode = buf.st_mode; if (ret != -1) { if ((st_mode & S_IFMT) == S_IFDIR) { errno = EISDIR; ::close(fd); return -1; } } else { ::close(fd); return -1; } } return fd; } // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) // are used by JVM M&M and JVMTI to get user+sys or user CPU time // of a thread. // // current_thread_cpu_time() and thread_cpu_time(Thread*) returns // the fast estimate available on the platform. jlong os::current_thread_cpu_time() { #ifdef __APPLE__ return os::thread_cpu_time(Thread::current(), true /* user + sys */); #else Unimplemented(); return 0; #endif } jlong os::thread_cpu_time(Thread* thread) { #ifdef __APPLE__ return os::thread_cpu_time(thread, true /* user + sys */); #else Unimplemented(); return 0; #endif } jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { #ifdef __APPLE__ return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); #else Unimplemented(); return 0; #endif } jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) { #ifdef __APPLE__ struct thread_basic_info tinfo; mach_msg_type_number_t tcount = THREAD_INFO_MAX; kern_return_t kr; thread_t mach_thread; mach_thread = thread->osthread()->thread_id(); kr = thread_info(mach_thread, THREAD_BASIC_INFO, (thread_info_t)&tinfo, &tcount); if (kr != KERN_SUCCESS) { return -1; } if (user_sys_cpu_time) { jlong nanos; nanos = ((jlong) tinfo.system_time.seconds + tinfo.user_time.seconds) * (jlong)1000000000; nanos += ((jlong) tinfo.system_time.microseconds + (jlong) tinfo.user_time.microseconds) * (jlong)1000; return nanos; } else { return ((jlong)tinfo.user_time.seconds * 1000000000) + ((jlong)tinfo.user_time.microseconds * (jlong)1000); } #else Unimplemented(); return 0; #endif } void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { info_ptr->max_value = all_bits_jlong; // will not wrap in less than 64 bits info_ptr->may_skip_backward = false; // elapsed time not wall time info_ptr->may_skip_forward = false; // elapsed time not wall time info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned } void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { info_ptr->max_value = all_bits_jlong; // will not wrap in less than 64 bits info_ptr->may_skip_backward = false; // elapsed time not wall time info_ptr->may_skip_forward = false; // elapsed time not wall time info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned } bool os::is_thread_cpu_time_supported() { #ifdef __APPLE__ return true; #else return false; #endif } // System loadavg support. Returns -1 if load average cannot be obtained. // Bsd doesn't yet have a (official) notion of processor sets, // so just return the system wide load average. int os::loadavg(double loadavg[], int nelem) { return ::getloadavg(loadavg, nelem); } // Get the kern.corefile setting, or otherwise the default path to the core file // Returns the length of the string int os::get_core_path(char* buffer, size_t bufferSize) { int n = 0; #ifdef __APPLE__ char coreinfo[MAX_PATH]; size_t sz = sizeof(coreinfo); int ret = sysctlbyname("kern.corefile", coreinfo, &sz, nullptr, 0); if (ret == 0) { char *pid_pos = strstr(coreinfo, "%P"); // skip over the "%P" to preserve any optional custom user pattern const char* tail = (pid_pos != nullptr) ? (pid_pos + 2) : ""; if (pid_pos != nullptr) { *pid_pos = '\0'; n = jio_snprintf(buffer, bufferSize, "%s%d%s", coreinfo, os::current_process_id(), tail); } else { n = jio_snprintf(buffer, bufferSize, "%s", coreinfo); } } else #endif { n = jio_snprintf(buffer, bufferSize, "/cores/core.%d", os::current_process_id()); } // Truncate if theoretical string was longer than bufferSize n = MIN2(n, (int)bufferSize); return n; } bool os::supports_map_sync() { return false; } bool os::start_debugging(char *buf, int buflen) { int len = (int)strlen(buf); char *p = &buf[len]; jio_snprintf(p, buflen-len, "\n\n" "Do you want to debug the problem?\n\n" "To debug, run 'gdb /proc/%d/exe %d'; then switch to thread %zd (" INTPTR_FORMAT ")\n" "Enter 'yes' to launch gdb automatically (PATH must include gdb)\n" "Otherwise, press RETURN to abort...", os::current_process_id(), os::current_process_id(), os::current_thread_id(), os::current_thread_id()); bool yes = os::message_box("Unexpected Error", buf); if (yes) { // yes, user asked VM to launch debugger jio_snprintf(buf, sizeof(buf), "gdb /proc/%d/exe %d", os::current_process_id(), os::current_process_id()); os::fork_and_exec(buf); yes = false; } return yes; } void os::print_memory_mappings(char* addr, size_t bytes, outputStream* st) {} #if INCLUDE_JFR void os::jfr_report_memory_info() { #ifdef __APPLE__ mach_task_basic_info info; mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT; kern_return_t ret = task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info, &count); if (ret == KERN_SUCCESS) { // Send the RSS JFR event EventResidentSetSize event; event.set_size(info.resident_size); // We've seen that resident_size_max sometimes trails resident_size with one page. // Make sure we always report size <= peak event.set_peak(MAX2(info.resident_size_max, info.resident_size)); event.commit(); } else { // Log a warning static bool first_warning = true; if (first_warning) { log_warning(jfr)("Error fetching RSS values: task_info failed"); first_warning = false; } } #endif // __APPLE__ } #endif // INCLUDE_JFR bool os::pd_dll_unload(void* libhandle, char* ebuf, int ebuflen) { if (ebuf && ebuflen > 0) { ebuf[0] = '\0'; ebuf[ebuflen - 1] = '\0'; } bool res = (0 == ::dlclose(libhandle)); if (!res) { // error analysis when dlopen fails const char* error_report = ::dlerror(); if (error_report == nullptr) { error_report = "dlerror returned no error description"; } if (ebuf != nullptr && ebuflen > 0) { snprintf(ebuf, ebuflen - 1, "%s", error_report); } } return res; } // end: os::pd_dll_unload()