os_solaris.cpp revision 3826:6cb0d32b828b
117680Spst/* 239300Sfenner * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. 317680Spst * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 417680Spst * 517680Spst * This code is free software; you can redistribute it and/or modify it 617680Spst * under the terms of the GNU General Public License version 2 only, as 717680Spst * published by the Free Software Foundation. 817680Spst * 917680Spst * This code is distributed in the hope that it will be useful, but WITHOUT 1017680Spst * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1117680Spst * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1217680Spst * version 2 for more details (a copy is included in the LICENSE file that 1317680Spst * accompanied this code). 1417680Spst * 1517680Spst * You should have received a copy of the GNU General Public License version 1617680Spst * 2 along with this work; if not, write to the Free Software Foundation, 1717680Spst * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 1817680Spst * 1917680Spst * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2017680Spst * or visit www.oracle.com if you need additional information or have any 2117680Spst * questions. 2217680Spst * 2356896Sfenner */ 2456896Sfenner 2517680Spst// no precompiled headers 2617680Spst#include "classfile/classLoader.hpp" 27127675Sbms#include "classfile/systemDictionary.hpp" 28162021Ssam#include "classfile/vmSymbols.hpp" 2917680Spst#include "code/icBuffer.hpp" 3017680Spst#include "code/vtableStubs.hpp" 3156896Sfenner#include "compiler/compileBroker.hpp" 3256896Sfenner#include "interpreter/interpreter.hpp" 3356896Sfenner#include "jvm_solaris.h" 3456896Sfenner#include "memory/allocation.inline.hpp" 35127675Sbms#include "memory/filemap.hpp" 3617680Spst#include "mutex_solaris.inline.hpp" 37111729Sfenner#include "oops/oop.inline.hpp" 3875118Sfenner#include "os_share_solaris.hpp" 39111729Sfenner#include "prims/jniFastGetField.hpp" 40111729Sfenner#include "prims/jvm.h" 41111729Sfenner#include "prims/jvm_misc.hpp" 4275118Sfenner#include "runtime/arguments.hpp" 43111729Sfenner#include "runtime/extendedPC.hpp" 44146778Ssam#include "runtime/globals.hpp" 45146778Ssam#include "runtime/interfaceSupport.hpp" 46146778Ssam#include "runtime/java.hpp" 4756896Sfenner#include "runtime/javaCalls.hpp" 48146778Ssam#include "runtime/mutexLocker.hpp" 49147904Ssam#include "runtime/objectMonitor.hpp" 50147904Ssam#include "runtime/osThread.hpp" 51147904Ssam#include "runtime/perfMemory.hpp" 52147904Ssam#include "runtime/sharedRuntime.hpp" 53147904Ssam#include "runtime/statSampler.hpp" 54146778Ssam#include "runtime/stubRoutines.hpp" 55146778Ssam#include "runtime/threadCritical.hpp" 56146778Ssam#include "runtime/timer.hpp" 57147904Ssam#include "services/attachListener.hpp" 58147904Ssam#include "services/memTracker.hpp" 5917680Spst#include "services/runtimeService.hpp" 6017680Spst#include "thread_solaris.inline.hpp" 6117680Spst#include "utilities/decoder.hpp" 6217680Spst#include "utilities/defaultStream.hpp" 6317680Spst#include "utilities/events.hpp" 6417680Spst#include "utilities/growableArray.hpp" 6517680Spst#include "utilities/vmError.hpp" 6617680Spst#ifdef TARGET_ARCH_x86 6717680Spst# include "assembler_x86.inline.hpp" 6817680Spst# include "nativeInst_x86.hpp" 6939300Sfenner#endif 70147904Ssam#ifdef TARGET_ARCH_sparc 71147904Ssam# include "assembler_sparc.inline.hpp" 7217680Spst# include "nativeInst_sparc.hpp" 7317680Spst#endif 7417680Spst 75127675Sbms// put OS-includes here 76127675Sbms# include <dlfcn.h> 7717680Spst# include <errno.h> 7817680Spst# include <exception> 7917680Spst# include <link.h> 80147904Ssam# include <poll.h> 8117680Spst# include <pthread.h> 8217680Spst# include <pwd.h> 8317680Spst# include <schedctl.h> 8498527Sfenner# include <setjmp.h> 8517680Spst# include <signal.h> 8617680Spst# include <stdio.h> 8717680Spst# include <alloca.h> 8817680Spst# include <sys/filio.h> 8917680Spst# include <sys/ipc.h> 9017680Spst# include <sys/lwp.h> 9117680Spst# include <sys/machelf.h> // for elf Sym structure used by dladdr1 9217680Spst# include <sys/mman.h> 93127675Sbms# include <sys/processor.h> 9417680Spst# include <sys/procset.h> 95127675Sbms# include <sys/pset.h> 96127675Sbms# include <sys/resource.h> 97127675Sbms# include <sys/shm.h> 98127675Sbms# include <sys/socket.h> 99127675Sbms# include <sys/stat.h> 100127675Sbms# include <sys/systeminfo.h> 101127675Sbms# include <sys/time.h> 102127675Sbms# include <sys/times.h> 103127675Sbms# include <sys/types.h> 104127675Sbms# include <sys/wait.h> 105127675Sbms# include <sys/utsname.h> 106127675Sbms# include <thread.h> 107127675Sbms# include <unistd.h> 108127675Sbms# include <sys/priocntl.h> 109127675Sbms# include <sys/rtpriocntl.h> 110127675Sbms# include <sys/tspriocntl.h> 111127675Sbms# include <sys/iapriocntl.h> 112127675Sbms# include <sys/fxpriocntl.h> 113127675Sbms# include <sys/loadavg.h> 114127675Sbms# include <string.h> 115127675Sbms# include <stdio.h> 116127675Sbms 117127675Sbms# define _STRUCTURED_PROC 1 // this gets us the new structured proc interfaces of 5.6 & later 118127675Sbms# include <sys/procfs.h> // see comment in <sys/procfs.h> 119127675Sbms 120127675Sbms#define MAX_PATH (2 * K) 121146778Ssam 122146778Ssam// for timer info max values which include all bits 123127675Sbms#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF) 124127675Sbms 125127675Sbms#ifdef _GNU_SOURCE 126127675Sbms// See bug #6514594 127127675Sbmsextern "C" int madvise(caddr_t, size_t, int); 128127675Sbmsextern "C" int memcntl(caddr_t addr, size_t len, int cmd, caddr_t arg, 129127675Sbms int attr, int mask); 130127675Sbms#endif //_GNU_SOURCE 131127675Sbms 132127675Sbms/* 133146778Ssam MPSS Changes Start. 134127675Sbms The JVM binary needs to be built and run on pre-Solaris 9 13556896Sfenner systems, but the constants needed by MPSS are only in Solaris 9 13656896Sfenner header files. They are textually replicated here to allow 13756896Sfenner building on earlier systems. Once building on Solaris 8 is 13856896Sfenner no longer a requirement, these #defines can be replaced by ordinary 13956896Sfenner system .h inclusion. 14056896Sfenner 14156896Sfenner In earlier versions of the JDK and Solaris, we used ISM for large pages. 14256896Sfenner But ISM requires shared memory to achieve this and thus has many caveats. 14356896Sfenner MPSS is a fully transparent and is a cleaner way to get large pages. 14456896Sfenner Although we still require keeping ISM for backward compatiblitiy as well as 14517680Spst giving the opportunity to use large pages on older systems it is 14617680Spst recommended that MPSS be used for Solaris 9 and above. 14717680Spst 14817680Spst*/ 14998527Sfenner 15017680Spst#ifndef MC_HAT_ADVISE 15198527Sfenner 15217680Spststruct memcntl_mha { 15317680Spst uint_t mha_cmd; /* command(s) */ 15417680Spst uint_t mha_flags; 15517680Spst size_t mha_pagesize; 15617680Spst}; 15798527Sfenner#define MC_HAT_ADVISE 7 /* advise hat map size */ 15817680Spst#define MHA_MAPSIZE_VA 0x1 /* set preferred page size */ 15917680Spst#define MAP_ALIGN 0x200 /* addr specifies alignment */ 16017680Spst 16117680Spst#endif 16298527Sfenner// MPSS Changes End. 16317680Spst 16417680Spst 16517680Spst// Here are some liblgrp types from sys/lgrp_user.h to be able to 16617680Spst// compile on older systems without this header file. 16717680Spst 16817680Spst#ifndef MADV_ACCESS_LWP 16917680Spst# define MADV_ACCESS_LWP 7 /* next LWP to access heavily */ 17017680Spst#endif 17198527Sfenner#ifndef MADV_ACCESS_MANY 17217680Spst# define MADV_ACCESS_MANY 8 /* many processes to access heavily */ 17317680Spst#endif 17417680Spst 17517680Spst#ifndef LGRP_RSRC_CPU 17617680Spst# define LGRP_RSRC_CPU 0 /* CPU resources */ 17717680Spst#endif 17817680Spst#ifndef LGRP_RSRC_MEM 17917680Spst# define LGRP_RSRC_MEM 1 /* memory resources */ 180147904Ssam#endif 18117680Spst 18217680Spst// Some more macros from sys/mman.h that are not present in Solaris 8. 18317680Spst 18417680Spst#ifndef MAX_MEMINFO_CNT 18517680Spst/* 18617680Spst * info_req request type definitions for meminfo 18717680Spst * request types starting with MEMINFO_V are used for Virtual addresses 18817680Spst * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical 18917680Spst * addresses 19017680Spst */ 19117680Spst# define MEMINFO_SHIFT 16 19217680Spst# define MEMINFO_MASK (0xFF << MEMINFO_SHIFT) 19317680Spst# define MEMINFO_VPHYSICAL (0x01 << MEMINFO_SHIFT) /* get physical addr */ 19417680Spst# define MEMINFO_VLGRP (0x02 << MEMINFO_SHIFT) /* get lgroup */ 19517680Spst# define MEMINFO_VPAGESIZE (0x03 << MEMINFO_SHIFT) /* size of phys page */ 19617680Spst# define MEMINFO_VREPLCNT (0x04 << MEMINFO_SHIFT) /* no. of replica */ 19717680Spst# define MEMINFO_VREPL (0x05 << MEMINFO_SHIFT) /* physical replica */ 19817680Spst# define MEMINFO_VREPL_LGRP (0x06 << MEMINFO_SHIFT) /* lgrp of replica */ 19917680Spst# define MEMINFO_PLGRP (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */ 20017680Spst 20117680Spst/* maximum number of addresses meminfo() can process at a time */ 20217680Spst# define MAX_MEMINFO_CNT 256 20317680Spst 20417680Spst/* maximum number of request types */ 20517680Spst# define MAX_MEMINFO_REQ 31 20617680Spst#endif 207127675Sbms 208127675Sbms// see thr_setprio(3T) for the basis of these numbers 209127675Sbms#define MinimumPriority 0 210127675Sbms#define NormalPriority 64 211127675Sbms#define MaximumPriority 127 212127675Sbms 213127675Sbms// Values for ThreadPriorityPolicy == 1 214127675Sbmsint prio_policy1[CriticalPriority+1] = { 215127675Sbms -99999, 0, 16, 32, 48, 64, 216127675Sbms 80, 96, 112, 124, 127, 127 }; 217127675Sbms 218127675Sbms// System parameters used internally 219127675Sbmsstatic clock_t clock_tics_per_sec = 100; 220127675Sbms 221127675Sbms// Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+) 22217680Spststatic bool enabled_extended_FILE_stdio = false; 22398527Sfenner 22417680Spst// For diagnostics to print a message once. see run_periodic_checks 22517680Spststatic bool check_addr0_done = false; 22617680Spststatic sigset_t check_signal_done; 22717680Spststatic bool check_signals = true; 22817680Spst 22917680Spstaddress os::Solaris::handler_start; // start pc of thr_sighndlrinfo 23056896Sfenneraddress os::Solaris::handler_end; // end pc of thr_sighndlrinfo 23117680Spst 23217680Spstaddress os::Solaris::_main_stack_base = NULL; // 4352906 workaround 23317680Spst 23417680Spst 23517680Spst// "default" initializers for missing libc APIs 23617680Spstextern "C" { 23717680Spst static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; } 23817680Spst static int lwp_mutex_destroy(mutex_t *mx) { return 0; } 23917680Spst 240127675Sbms static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; } 241127675Sbms static int lwp_cond_destroy(cond_t *cv) { return 0; } 24239300Sfenner} 243127675Sbms 24439300Sfenner// "default" initializers for pthread-based synchronization 24517680Spstextern "C" { 24639300Sfenner static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; } 247127675Sbms static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; } 248127675Sbms} 249127675Sbms 250127675Sbms// Thread Local Storage 25117680Spst// This is common to all Solaris platforms so it is defined here, 252127675Sbms// in this common file. 253127675Sbms// The declarations are in the os_cpu threadLS*.hpp files. 254127675Sbms// 255127675Sbms// Static member initialization for TLS 256127675SbmsThread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL}; 257127675Sbms 25817680Spst#ifndef PRODUCT 259127675Sbms#define _PCT(n,d) ((100.0*(double)(n))/(double)(d)) 26017680Spst 26117680Spstint ThreadLocalStorage::_tcacheHit = 0; 26298527Sfennerint ThreadLocalStorage::_tcacheMiss = 0; 26317680Spst 26417680Spstvoid ThreadLocalStorage::print_statistics() { 26517680Spst int total = _tcacheMiss+_tcacheHit; 26656896Sfenner tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n", 26756896Sfenner _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total)); 26856896Sfenner} 26956896Sfenner#undef _PCT 27056896Sfenner#endif // PRODUCT 27198527Sfenner 27256896SfennerThread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id, 27356896Sfenner int index) { 27456896Sfenner Thread *thread = get_thread_slow(); 27556896Sfenner if (thread != NULL) { 27656896Sfenner address sp = os::current_stack_pointer(); 27798527Sfenner guarantee(thread->_stack_base == NULL || 27856896Sfenner (sp <= thread->_stack_base && 27956896Sfenner sp >= thread->_stack_base - thread->_stack_size) || 28056896Sfenner is_error_reported(), 28156896Sfenner "sp must be inside of selected thread stack"); 28256896Sfenner 28356896Sfenner thread->set_self_raw_id(raw_id); // mark for quick retrieval 28456896Sfenner _get_thread_cache[ index ] = thread; 28556896Sfenner } 28656896Sfenner return thread; 28756896Sfenner} 28856896Sfenner 28956896Sfenner 290127675Sbmsstatic const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0}; 29156896Sfenner#define NO_CACHED_THREAD ((Thread*)all_zero) 292127675Sbms 293127675Sbmsvoid ThreadLocalStorage::pd_set_thread(Thread* thread) { 294127675Sbms 295127675Sbms // Store the new value before updating the cache to prevent a race 29656896Sfenner // between get_thread_via_cache_slowly() and this store operation. 297127675Sbms os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread); 298127675Sbms 299127675Sbms // Update thread cache with new thread if setting on thread create, 300127675Sbms // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit. 301127675Sbms uintptr_t raw = pd_raw_thread_id(); 302127675Sbms int ix = pd_cache_index(raw); 30356896Sfenner _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread; 304127675Sbms} 30556896Sfenner 30656896Sfennervoid ThreadLocalStorage::pd_init() { 30798527Sfenner for (int i = 0; i < _pd_cache_size; i++) { 30898527Sfenner _get_thread_cache[i] = NO_CACHED_THREAD; 30956896Sfenner } 31056896Sfenner} 31156896Sfenner 31256896Sfenner// Invalidate all the caches (happens to be the same as pd_init). 31317680Spstvoid ThreadLocalStorage::pd_invalidate_all() { pd_init(); } 31417680Spst 31517680Spst#undef NO_CACHED_THREAD 31617680Spst 31717680Spst// END Thread Local Storage 31817680Spst 31917680Spststatic inline size_t adjust_stack_size(address base, size_t size) { 32017680Spst if ((ssize_t)size < 0) { 32117680Spst // 4759953: Compensate for ridiculous stack size. 32217680Spst size = max_intx; 32317680Spst } 32417680Spst if (size > (size_t)base) { 32517680Spst // 4812466: Make sure size doesn't allow the stack to wrap the address space. 32617680Spst size = (size_t)base; 32717680Spst } 32817680Spst return size; 32917680Spst} 33017680Spst 33117680Spststatic inline stack_t get_stack_info() { 33217680Spst stack_t st; 33317680Spst int retval = thr_stksegment(&st); 33417680Spst st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size); 33517680Spst assert(retval == 0, "incorrect return value from thr_stksegment"); 33617680Spst assert((address)&st < (address)st.ss_sp, "Invalid stack base returned"); 33717680Spst assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned"); 33817680Spst return st; 33917680Spst} 34017680Spst 34117680Spstaddress os::current_stack_base() { 34217680Spst int r = thr_main() ; 34317680Spst guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; 34417680Spst bool is_primordial_thread = r; 34517680Spst 34698527Sfenner // Workaround 4352906, avoid calls to thr_stksegment by 347127675Sbms // thr_main after the first one (it looks like we trash 34898527Sfenner // some data, causing the value for ss_sp to be incorrect). 34998527Sfenner if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) { 35098527Sfenner stack_t st = get_stack_info(); 35198527Sfenner if (is_primordial_thread) { 35298527Sfenner // cache initial value of stack base 35398527Sfenner os::Solaris::_main_stack_base = (address)st.ss_sp; 35498527Sfenner } 35598527Sfenner return (address)st.ss_sp; 35698527Sfenner } else { 35798527Sfenner guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base"); 35898527Sfenner return os::Solaris::_main_stack_base; 35998527Sfenner } 36098527Sfenner} 36198527Sfenner 36298527Sfennersize_t os::current_stack_size() { 36398527Sfenner size_t size; 36498527Sfenner 36598527Sfenner int r = thr_main() ; 36698527Sfenner guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; 36798527Sfenner if(!r) { 36898527Sfenner size = get_stack_info().ss_size; 36998527Sfenner } else { 37098527Sfenner struct rlimit limits; 37198527Sfenner getrlimit(RLIMIT_STACK, &limits); 37298527Sfenner size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur); 37398527Sfenner } 37498527Sfenner // base may not be page aligned 37598527Sfenner address base = current_stack_base(); 37698527Sfenner address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());; 37798527Sfenner return (size_t)(base - bottom); 37898527Sfenner} 37998527Sfenner 38098527Sfennerstruct tm* os::localtime_pd(const time_t* clock, struct tm* res) { 38198527Sfenner return localtime_r(clock, res); 38298527Sfenner} 38398527Sfenner 38498527Sfenner// interruptible infrastructure 38598527Sfenner 38698527Sfenner// setup_interruptible saves the thread state before going into an 38798527Sfenner// interruptible system call. 38898527Sfenner// The saved state is used to restore the thread to 38998527Sfenner// its former state whether or not an interrupt is received. 39098527Sfenner// Used by classloader os::read 39117680Spst// os::restartable_read calls skip this layer and stay in _thread_in_native 39217680Spst 39317680Spstvoid os::Solaris::setup_interruptible(JavaThread* thread) { 39417680Spst 39517680Spst JavaThreadState thread_state = thread->thread_state(); 39617680Spst 39798527Sfenner assert(thread_state != _thread_blocked, "Coming from the wrong thread"); 39817680Spst assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible"); 39917680Spst OSThread* osthread = thread->osthread(); 40017680Spst osthread->set_saved_interrupt_thread_state(thread_state); 40117680Spst thread->frame_anchor()->make_walkable(thread); 40217680Spst ThreadStateTransition::transition(thread, thread_state, _thread_blocked); 40317680Spst} 40417680Spst 40517680Spst// Version of setup_interruptible() for threads that are already in 40617680Spst// _thread_blocked. Used by os_sleep(). 40717680Spstvoid os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) { 40817680Spst thread->frame_anchor()->make_walkable(thread); 40917680Spst} 41017680Spst 41117680SpstJavaThread* os::Solaris::setup_interruptible() { 41217680Spst JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); 41317680Spst setup_interruptible(thread); 41417680Spst return thread; 41598527Sfenner} 41617680Spst 41717680Spstvoid os::Solaris::try_enable_extended_io() { 41817680Spst typedef int (*enable_extended_FILE_stdio_t)(int, int); 41917680Spst 42017680Spst if (!UseExtendedFileIO) { 42117680Spst return; 42217680Spst } 42317680Spst 42417680Spst enable_extended_FILE_stdio_t enabler = 42517680Spst (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT, 42698527Sfenner "enable_extended_FILE_stdio"); 42717680Spst if (enabler) { 42817680Spst enabler(-1, -1); 42917680Spst } 43017680Spst} 43117680Spst 43217680Spst 43317680Spst#ifdef ASSERT 43417680Spst 43517680SpstJavaThread* os::Solaris::setup_interruptible_native() { 43617680Spst JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); 43717680Spst JavaThreadState thread_state = thread->thread_state(); 43817680Spst assert(thread_state == _thread_in_native, "Assumed thread_in_native"); 43917680Spst return thread; 44017680Spst} 44117680Spst 44217680Spstvoid os::Solaris::cleanup_interruptible_native(JavaThread* thread) { 44317680Spst JavaThreadState thread_state = thread->thread_state(); 44417680Spst assert(thread_state == _thread_in_native, "Assumed thread_in_native"); 44517680Spst} 44617680Spst#endif 44717680Spst 44817680Spst// cleanup_interruptible reverses the effects of setup_interruptible 44917680Spst// setup_interruptible_already_blocked() does not need any cleanup. 45017680Spst 45117680Spstvoid os::Solaris::cleanup_interruptible(JavaThread* thread) { 45217680Spst OSThread* osthread = thread->osthread(); 45317680Spst 45417680Spst ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state()); 45517680Spst} 45617680Spst 45717680Spst// I/O interruption related counters called in _INTERRUPTIBLE 45817680Spst 45917680Spstvoid os::Solaris::bump_interrupted_before_count() { 46017680Spst RuntimeService::record_interrupted_before_count(); 46117680Spst} 46298527Sfenner 46317680Spstvoid os::Solaris::bump_interrupted_during_count() { 46417680Spst RuntimeService::record_interrupted_during_count(); 465162021Ssam} 46617680Spst 46717680Spststatic int _processors_online = 0; 468162021Ssam 469147904Ssam jint os::Solaris::_os_thread_limit = 0; 47017680Spstvolatile jint os::Solaris::_os_thread_count = 0; 47117680Spst 47217680Spstjulong os::available_memory() { 47317680Spst return Solaris::available_memory(); 47498527Sfenner} 47517680Spst 476147904Ssamjulong os::Solaris::available_memory() { 477146778Ssam return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size(); 478146778Ssam} 479146778Ssam 480162021Ssamjulong os::Solaris::_physical_memory = 0; 481162021Ssam 482162021Ssamjulong os::physical_memory() { 483146778Ssam return Solaris::physical_memory(); 484146778Ssam} 485127675Sbms 48617680Spstjulong os::allocatable_physical_memory(julong size) { 48717680Spst#ifdef _LP64 48817680Spst return size; 48917680Spst#else 49017680Spst julong result = MIN2(size, (julong)3835*M); 491162021Ssam if (!is_allocatable(result)) { 492146778Ssam // Memory allocations will be aligned but the alignment 49317680Spst // is not known at this point. Alignments will 494162021Ssam // be at most to LargePageSizeInBytes. Protect 495162021Ssam // allocations from alignments up to illegal 496162021Ssam // values. If at this point 2G is illegal. 497162021Ssam julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes; 498162021Ssam result = MIN2(size, reasonable_size); 499147904Ssam } 500162021Ssam return result; 501162021Ssam#endif 502162021Ssam} 503162021Ssam 504162021Ssamstatic hrtime_t first_hrtime = 0; 50598527Sfennerstatic const hrtime_t hrtime_hz = 1000*1000*1000; 50617680Spstconst int LOCK_BUSY = 1; 50717680Spstconst int LOCK_FREE = 0; 50817680Spstconst int LOCK_INVALID = -1; 50998527Sfennerstatic volatile hrtime_t max_hrtime = 0; 51098527Sfennerstatic volatile int max_hrtime_lock = LOCK_FREE; // Update counter with LSB as lock-in-progress 51198527Sfenner 512146778Ssam 51398527Sfennervoid os::Solaris::initialize_system_info() { 51498527Sfenner set_processor_count(sysconf(_SC_NPROCESSORS_CONF)); 51598527Sfenner _processors_online = sysconf (_SC_NPROCESSORS_ONLN); 51698527Sfenner _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE); 51798527Sfenner} 518127675Sbms 51998527Sfennerint os::active_processor_count() { 52098527Sfenner int online_cpus = sysconf(_SC_NPROCESSORS_ONLN); 52198527Sfenner pid_t pid = getpid(); 52298527Sfenner psetid_t pset = PS_NONE; 52398527Sfenner // Are we running in a processor set or is there any processor set around? 52498527Sfenner if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) { 52598527Sfenner uint_t pset_cpus; 526146778Ssam // Query the number of cpus available to us. 52798527Sfenner if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) { 52898527Sfenner assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check"); 52998527Sfenner _processors_online = pset_cpus; 530146778Ssam return pset_cpus; 53198527Sfenner } 53298527Sfenner } 53398527Sfenner // Otherwise return number of online cpus 53498527Sfenner return online_cpus; 53598527Sfenner} 53698527Sfenner 53798527Sfennerstatic bool find_processors_in_pset(psetid_t pset, 53817680Spst processorid_t** id_array, 53917680Spst uint_t* id_length) { 54017680Spst bool result = false; 54117680Spst // Find the number of processors in the processor set. 54217680Spst if (pset_info(pset, NULL, id_length, NULL) == 0) { 54317680Spst // Make up an array to hold their ids. 54417680Spst *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal); 54517680Spst // Fill in the array with their processor ids. 54617680Spst if (pset_info(pset, NULL, id_length, *id_array) == 0) { 54717680Spst result = true; 54817680Spst } 54917680Spst } 55017680Spst return result; 55117680Spst} 55217680Spst 55317680Spst// Callers of find_processors_online() must tolerate imprecise results -- 55417680Spst// the system configuration can change asynchronously because of DR 55517680Spst// or explicit psradm operations. 55617680Spst// 55717680Spst// We also need to take care that the loop (below) terminates as the 55817680Spst// number of processors online can change between the _SC_NPROCESSORS_ONLN 55998527Sfenner// request and the loop that builds the list of processor ids. Unfortunately 56017680Spst// there's no reliable way to determine the maximum valid processor id, 56117680Spst// so we use a manifest constant, MAX_PROCESSOR_ID, instead. See p_online 56217680Spst// man pages, which claim the processor id set is "sparse, but 56398527Sfenner// not too sparse". MAX_PROCESSOR_ID is used to ensure that we eventually 56417680Spst// exit the loop. 56517680Spst// 56617680Spst// In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's 56717680Spst// not available on S8.0. 56817680Spst 56917680Spststatic bool find_processors_online(processorid_t** id_array, 57017680Spst uint* id_length) { 57117680Spst const processorid_t MAX_PROCESSOR_ID = 100000 ; 57217680Spst // Find the number of processors online. 57317680Spst *id_length = sysconf(_SC_NPROCESSORS_ONLN); 57417680Spst // Make up an array to hold their ids. 57517680Spst *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal); 57617680Spst // Processors need not be numbered consecutively. 57717680Spst long found = 0; 57817680Spst processorid_t next = 0; 57917680Spst while (found < *id_length && next < MAX_PROCESSOR_ID) { 58017680Spst processor_info_t info; 58117680Spst if (processor_info(next, &info) == 0) { 58217680Spst // NB, PI_NOINTR processors are effectively online ... 58317680Spst if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) { 58417680Spst (*id_array)[found] = next; 58517680Spst found += 1; 58698527Sfenner } 58717680Spst } 58817680Spst next += 1; 58917680Spst } 590146778Ssam if (found < *id_length) { 59198527Sfenner // The loop above didn't identify the expected number of processors. 592146778Ssam // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN) 59317680Spst // and re-running the loop, above, but there's no guarantee of progress 594146778Ssam // if the system configuration is in flux. Instead, we just return what 59517680Spst // we've got. Note that in the worst case find_processors_online() could 59617680Spst // return an empty set. (As a fall-back in the case of the empty set we 59717680Spst // could just return the ID of the current processor). 598146778Ssam *id_length = found ; 599147904Ssam } 600146778Ssam 60117680Spst return true; 60217680Spst} 60317680Spst 60417680Spststatic bool assign_distribution(processorid_t* id_array, 605146778Ssam uint id_length, 60617680Spst uint* distribution, 60717680Spst uint distribution_length) { 60817680Spst // We assume we can assign processorid_t's to uint's. 609146778Ssam assert(sizeof(processorid_t) == sizeof(uint), 61017680Spst "can't convert processorid_t to uint"); 61117680Spst // Quick check to see if we won't succeed. 612146778Ssam if (id_length < distribution_length) { 613146778Ssam return false; 614146778Ssam } 615146778Ssam // Assign processor ids to the distribution. 61617680Spst // Try to shuffle processors to distribute work across boards, 61717680Spst // assuming 4 processors per board. 61817680Spst const uint processors_per_board = ProcessDistributionStride; 61917680Spst // Find the maximum processor id. 62017680Spst processorid_t max_id = 0; 62198527Sfenner for (uint m = 0; m < id_length; m += 1) { 62217680Spst max_id = MAX2(max_id, id_array[m]); 62317680Spst } 62417680Spst // The next id, to limit loops. 62517680Spst const processorid_t limit_id = max_id + 1; 62617680Spst // Make up markers for available processors. 62717680Spst bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal); 62817680Spst for (uint c = 0; c < limit_id; c += 1) { 62917680Spst available_id[c] = false; 63017680Spst } 63117680Spst for (uint a = 0; a < id_length; a += 1) { 63217680Spst available_id[id_array[a]] = true; 63317680Spst } 63417680Spst // Step by "boards", then by "slot", copying to "assigned". 63566644Skris // NEEDS_CLEANUP: The assignment of processors should be stateful, 63698527Sfenner // remembering which processors have been assigned by 63717680Spst // previous calls, etc., so as to distribute several 63817680Spst // independent calls of this method. What we'd like is 63917680Spst // It would be nice to have an API that let us ask 64098527Sfenner // how many processes are bound to a processor, 64117680Spst // but we don't have that, either. 64217680Spst // In the short term, "board" is static so that 64317680Spst // subsequent distributions don't all start at board 0. 64417680Spst static uint board = 0; 64517680Spst uint assigned = 0; 64617680Spst // Until we've found enough processors .... 64717680Spst while (assigned < distribution_length) { 64817680Spst // ... find the next available processor in the board. 64917680Spst for (uint slot = 0; slot < processors_per_board; slot += 1) { 65017680Spst uint try_id = board * processors_per_board + slot; 65117680Spst if ((try_id < limit_id) && (available_id[try_id] == true)) { 65217680Spst distribution[assigned] = try_id; 65317680Spst available_id[try_id] = false; 65466644Skris assigned += 1; 65598527Sfenner break; 65617680Spst } 65717680Spst } 65817680Spst board += 1; 659127675Sbms if (board * processors_per_board + 0 >= limit_id) { 660127675Sbms board = 0; 661127675Sbms } 662127675Sbms } 663127675Sbms if (available_id != NULL) { 664127675Sbms FREE_C_HEAP_ARRAY(bool, available_id, mtInternal); 665127675Sbms } 666127675Sbms return true; 667127675Sbms} 668127675Sbms 669127675Sbmsvoid os::set_native_thread_name(const char *name) { 670127675Sbms // Not yet implemented. 671127675Sbms return; 672127675Sbms} 673127675Sbms 674127675Sbmsbool os::distribute_processes(uint length, uint* distribution) { 675127675Sbms bool result = false; 676127675Sbms // Find the processor id's of all the available CPUs. 677127675Sbms processorid_t* id_array = NULL; 678127675Sbms uint id_length = 0; 679127675Sbms // There are some races between querying information and using it, 680127675Sbms // since processor sets can change dynamically. 681127675Sbms psetid_t pset = PS_NONE; 682127675Sbms // Are we running in a processor set? 683127675Sbms if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) { 684127675Sbms result = find_processors_in_pset(pset, &id_array, &id_length); 68517680Spst } else { 68617680Spst result = find_processors_online(&id_array, &id_length); 68717680Spst } 68817680Spst if (result == true) { 68917680Spst if (id_length >= length) { 69017680Spst result = assign_distribution(id_array, id_length, distribution, length); 69117680Spst } else { 69217680Spst result = false; 69317680Spst } 69417680Spst } 69517680Spst if (id_array != NULL) { 69617680Spst FREE_C_HEAP_ARRAY(processorid_t, id_array, mtInternal); 69717680Spst } 69817680Spst return result; 69917680Spst} 70017680Spst 70117680Spstbool os::bind_to_processor(uint processor_id) { 70217680Spst // We assume that a processorid_t can be stored in a uint. 70317680Spst assert(sizeof(uint) == sizeof(processorid_t), 70417680Spst "can't convert uint to processorid_t"); 70517680Spst int bind_result = 70666644Skris processor_bind(P_LWPID, // bind LWP. 70798527Sfenner P_MYID, // bind current LWP. 70817680Spst (processorid_t) processor_id, // id. 70998527Sfenner NULL); // don't return old binding. 71017680Spst return (bind_result == 0); 71117680Spst} 71217680Spst 71317680Spstbool os::getenv(const char* name, char* buffer, int len) { 71417680Spst char* val = ::getenv( name ); 71517680Spst if ( val == NULL 716146778Ssam || strlen(val) + 1 > len ) { 717146778Ssam if (len > 0) buffer[0] = 0; // return a null string 718146778Ssam return false; 719127675Sbms } 720146778Ssam strcpy( buffer, val ); 721127675Sbms return true; 722146778Ssam} 723146778Ssam 72417680Spst 72517680Spst// Return true if user is running as root. 72617680Spst 72717680Spstbool os::have_special_privileges() { 72817680Spst static bool init = false; 72917680Spst static bool privileges = false; 73017680Spst if (!init) { 73117680Spst privileges = (getuid() != geteuid()) || (getgid() != getegid()); 73217680Spst init = true; 73317680Spst } 734127675Sbms return privileges; 73517680Spst} 73617680Spst 73717680Spst 73817680Spstvoid os::init_system_properties_values() { 739127675Sbms char arch[12]; 74017680Spst sysinfo(SI_ARCHITECTURE, arch, sizeof(arch)); 74117680Spst 74217680Spst // The next steps are taken in the product version: 74317680Spst // 74498527Sfenner // Obtain the JAVA_HOME value from the location of libjvm[_g].so. 74598527Sfenner // This library should be located at: 74698527Sfenner // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so. 74798527Sfenner // 74898527Sfenner // If "/jre/lib/" appears at the right place in the path, then we 74998527Sfenner // assume libjvm[_g].so is installed in a JDK and we use this path. 75098527Sfenner // 75198527Sfenner // Otherwise exit with message: "Could not create the Java virtual machine." 75298527Sfenner // 75398527Sfenner // The following extra steps are taken in the debugging version: 75498527Sfenner // 75598527Sfenner // If "/jre/lib/" does NOT appear at the right place in the path 75617680Spst // instead of exit check for $JAVA_HOME environment variable. 75717680Spst // 75817680Spst // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>, 75917680Spst // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so 76017680Spst // it looks like libjvm[_g].so is installed there 76117680Spst // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so. 76217680Spst // 76317680Spst // Otherwise exit. 76417680Spst // 76598527Sfenner // Important note: if the location of libjvm.so changes this 76617680Spst // code needs to be changed accordingly. 76717680Spst 76817680Spst // The next few definitions allow the code to be verbatim: 76917680Spst#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal) 77017680Spst#define free(p) FREE_C_HEAP_ARRAY(char, p, mtInternal) 77117680Spst#define getenv(n) ::getenv(n) 77217680Spst 77317680Spst#define EXTENSIONS_DIR "/lib/ext" 77417680Spst#define ENDORSED_DIR "/lib/endorsed" 77517680Spst#define COMMON_DIR "/usr/jdk/packages" 77698527Sfenner 77717680Spst { 77898527Sfenner /* sysclasspath, java_home, dll_dir */ 77998527Sfenner { 78098527Sfenner char *home_path; 78198527Sfenner char *dll_path; 78298527Sfenner char *pslash; 78398527Sfenner char buf[MAXPATHLEN]; 78498527Sfenner os::jvm_path(buf, sizeof(buf)); 78598527Sfenner 78698527Sfenner // Found the full path to libjvm.so. 78717680Spst // Now cut the path to <java_home>/jre if we can. 78817680Spst *(strrchr(buf, '/')) = '\0'; /* get rid of /libjvm.so */ 78917680Spst pslash = strrchr(buf, '/'); 79098527Sfenner if (pslash != NULL) 79198527Sfenner *pslash = '\0'; /* get rid of /{client|server|hotspot} */ 79217680Spst dll_path = malloc(strlen(buf) + 1); 79317680Spst if (dll_path == NULL) 79417680Spst return; 79517680Spst strcpy(dll_path, buf); 79617680Spst Arguments::set_dll_dir(dll_path); 79717680Spst 79817680Spst if (pslash != NULL) { 79917680Spst pslash = strrchr(buf, '/'); 80017680Spst if (pslash != NULL) { 80117680Spst *pslash = '\0'; /* get rid of /<arch> */ 80217680Spst pslash = strrchr(buf, '/'); 80317680Spst if (pslash != NULL) 80417680Spst *pslash = '\0'; /* get rid of /lib */ 80517680Spst } 80617680Spst } 80717680Spst 80817680Spst home_path = malloc(strlen(buf) + 1); 80917680Spst if (home_path == NULL) 81017680Spst return; 81117680Spst strcpy(home_path, buf); 81217680Spst Arguments::set_java_home(home_path); 81317680Spst 81417680Spst if (!set_boot_path('/', ':')) 81517680Spst return; 81698527Sfenner } 81717680Spst 81817680Spst /* 81917680Spst * Where to look for native libraries 82017680Spst */ 82117680Spst { 82217680Spst // Use dlinfo() to determine the correct java.library.path. 82317680Spst // 82417680Spst // If we're launched by the Java launcher, and the user 82517680Spst // does not set java.library.path explicitly on the commandline, 82617680Spst // the Java launcher sets LD_LIBRARY_PATH for us and unsets 82798527Sfenner // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64. In this case 82817680Spst // dlinfo returns LD_LIBRARY_PATH + crle settings (including 82917680Spst // /usr/lib), which is exactly what we want. 83017680Spst // 83117680Spst // If the user does set java.library.path, it completely 83217680Spst // overwrites this setting, and always has. 83317680Spst // 83417680Spst // If we're not launched by the Java launcher, we may 83517680Spst // get here with any/all of the LD_LIBRARY_PATH[_32|64] 83617680Spst // settings. Again, dlinfo does exactly what we want. 83717680Spst 83817680Spst Dl_serinfo _info, *info = &_info; 83917680Spst Dl_serpath *path; 84098527Sfenner char* library_path; 841146778Ssam char *common_path; 842146778Ssam int i; 843146778Ssam 844146778Ssam // determine search path count and required buffer size 845146778Ssam if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) { 846146778Ssam vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror()); 847146778Ssam } 848146778Ssam 849146778Ssam // allocate new buffer and initialize 850146778Ssam info = (Dl_serinfo*)malloc(_info.dls_size); 85117680Spst if (info == NULL) { 85217680Spst vm_exit_out_of_memory(_info.dls_size, 85317680Spst "init_system_properties_values info"); 85417680Spst } 85517680Spst info->dls_size = _info.dls_size; 85617680Spst info->dls_cnt = _info.dls_cnt; 85717680Spst 858127675Sbms // obtain search path information 859127675Sbms if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) { 860127675Sbms free(info); 861127675Sbms vm_exit_during_initialization("dlinfo SERINFO request", dlerror()); 862127675Sbms } 863127675Sbms 864127675Sbms path = &info->dls_serpath[0]; 865127675Sbms 866127675Sbms // Note: Due to a legacy implementation, most of the library path 867127675Sbms // is set in the launcher. This was to accomodate linking restrictions 868127675Sbms // on legacy Solaris implementations (which are no longer supported). 869127675Sbms // Eventually, all the library path setting will be done here. 870127675Sbms // 871127675Sbms // However, to prevent the proliferation of improperly built native 872127675Sbms // libraries, the new path component /usr/jdk/packages is added here. 873127675Sbms 874127675Sbms // Determine the actual CPU architecture. 875127675Sbms char cpu_arch[12]; 876127675Sbms sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch)); 877127675Sbms#ifdef _LP64 878127675Sbms // If we are a 64-bit vm, perform the following translations: 879127675Sbms // sparc -> sparcv9 880127675Sbms // i386 -> amd64 881127675Sbms if (strcmp(cpu_arch, "sparc") == 0) 882127675Sbms strcat(cpu_arch, "v9"); 883127675Sbms else if (strcmp(cpu_arch, "i386") == 0) 884127675Sbms strcpy(cpu_arch, "amd64"); 885127675Sbms#endif 886127675Sbms 887127675Sbms // Construct the invariant part of ld_library_path. Note that the 888127675Sbms // space for the colon and the trailing null are provided by the 889127675Sbms // nulls included by the sizeof operator. 890127675Sbms size_t bufsize = sizeof(COMMON_DIR) + sizeof("/lib/") + strlen(cpu_arch); 891127675Sbms common_path = malloc(bufsize); 892127675Sbms if (common_path == NULL) { 893127675Sbms free(info); 894127675Sbms vm_exit_out_of_memory(bufsize, 895127675Sbms "init_system_properties_values common_path"); 896127675Sbms } 897127675Sbms sprintf(common_path, COMMON_DIR "/lib/%s", cpu_arch); 898127675Sbms 899127675Sbms // struct size is more than sufficient for the path components obtained 900127675Sbms // through the dlinfo() call, so only add additional space for the path 901127675Sbms // components explicitly added here. 902127675Sbms bufsize = info->dls_size + strlen(common_path); 903127675Sbms library_path = malloc(bufsize); 904127675Sbms if (library_path == NULL) { 905127675Sbms free(info); 906127675Sbms free(common_path); 907127675Sbms vm_exit_out_of_memory(bufsize, 908127675Sbms "init_system_properties_values library_path"); 909127675Sbms } 910127675Sbms library_path[0] = '\0'; 911127675Sbms 912127675Sbms // Construct the desired Java library path from the linker's library 913127675Sbms // search path. 914127675Sbms // 915127675Sbms // For compatibility, it is optimal that we insert the additional path 916127675Sbms // components specific to the Java VM after those components specified 917127675Sbms // in LD_LIBRARY_PATH (if any) but before those added by the ld.so 918127675Sbms // infrastructure. 919127675Sbms if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it 920127675Sbms strcpy(library_path, common_path); 921127675Sbms } else { 922127675Sbms int inserted = 0; 923127675Sbms for (i = 0; i < info->dls_cnt; i++, path++) { 924127675Sbms uint_t flags = path->dls_flags & LA_SER_MASK; 925127675Sbms if (((flags & LA_SER_LIBPATH) == 0) && !inserted) { 926127675Sbms strcat(library_path, common_path); 927127675Sbms strcat(library_path, os::path_separator()); 928127675Sbms inserted = 1; 929127675Sbms } 930127675Sbms strcat(library_path, path->dls_name); 931127675Sbms strcat(library_path, os::path_separator()); 932127675Sbms } 933127675Sbms // eliminate trailing path separator 934127675Sbms library_path[strlen(library_path)-1] = '\0'; 935127675Sbms } 936127675Sbms 937127675Sbms // happens before argument parsing - can't use a trace flag 938127675Sbms // tty->print_raw("init_system_properties_values: native lib path: "); 939127675Sbms // tty->print_raw_cr(library_path); 940127675Sbms 941127675Sbms // callee copies into its own buffer 942127675Sbms Arguments::set_library_path(library_path); 943127675Sbms 944127675Sbms free(common_path); 945127675Sbms free(library_path); 946127675Sbms free(info); 947127675Sbms } 948127675Sbms 949127675Sbms /* 950127675Sbms * Extensions directories. 951127675Sbms * 952127675Sbms * Note that the space for the colon and the trailing null are provided 953127675Sbms * by the nulls included by the sizeof operator (so actually one byte more 954127675Sbms * than necessary is allocated). 955127675Sbms */ 956127675Sbms { 957127675Sbms char *buf = (char *) malloc(strlen(Arguments::get_java_home()) + 958127675Sbms sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) + 959127675Sbms sizeof(EXTENSIONS_DIR)); 960127675Sbms sprintf(buf, "%s" EXTENSIONS_DIR ":" COMMON_DIR EXTENSIONS_DIR, 961127675Sbms Arguments::get_java_home()); 962127675Sbms Arguments::set_ext_dirs(buf); 963127675Sbms } 964127675Sbms 965127675Sbms /* Endorsed standards default directory. */ 966127675Sbms { 967127675Sbms char * buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR)); 968127675Sbms sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home()); 969127675Sbms Arguments::set_endorsed_dirs(buf); 970127675Sbms } 971127675Sbms } 972127675Sbms 973127675Sbms#undef malloc 974127675Sbms#undef free 975127675Sbms#undef getenv 976127675Sbms#undef EXTENSIONS_DIR 977127675Sbms#undef ENDORSED_DIR 978127675Sbms#undef COMMON_DIR 979127675Sbms 980127675Sbms} 981127675Sbms 982127675Sbmsvoid os::breakpoint() { 983127675Sbms BREAKPOINT; 984127675Sbms} 985127675Sbms 986127675Sbmsbool os::obsolete_option(const JavaVMOption *option) 987127675Sbms{ 988127675Sbms if (!strncmp(option->optionString, "-Xt", 3)) { 989127675Sbms return true; 990127675Sbms } else if (!strncmp(option->optionString, "-Xtm", 4)) { 991127675Sbms return true; 992127675Sbms } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) { 993127675Sbms return true; 994127675Sbms } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) { 995127675Sbms return true; 996127675Sbms } 997127675Sbms return false; 998127675Sbms} 999127675Sbms 1000127675Sbmsbool os::Solaris::valid_stack_address(Thread* thread, address sp) { 1001127675Sbms address stackStart = (address)thread->stack_base(); 1002127675Sbms address stackEnd = (address)(stackStart - (address)thread->stack_size()); 1003127675Sbms if (sp < stackStart && sp >= stackEnd ) return true; 1004127675Sbms return false; 1005127675Sbms} 1006127675Sbms 1007127675Sbmsextern "C" void breakpoint() { 1008127675Sbms // use debugger to set breakpoint here 1009127675Sbms} 1010127675Sbms 1011127675Sbmsstatic thread_t main_thread; 1012127675Sbms 1013127675Sbms// Thread start routine for all new Java threads 1014127675Sbmsextern "C" void* java_start(void* thread_addr) { 1015127675Sbms // Try to randomize the cache line index of hot stack frames. 1016127675Sbms // This helps when threads of the same stack traces evict each other's 1017127675Sbms // cache lines. The threads can be either from the same JVM instance, or 1018127675Sbms // from different JVM instances. The benefit is especially true for 1019127675Sbms // processors with hyperthreading technology. 1020127675Sbms static int counter = 0; 1021127675Sbms int pid = os::current_process_id(); 1022127675Sbms alloca(((pid ^ counter++) & 7) * 128); 1023127675Sbms 1024127675Sbms int prio; 1025127675Sbms Thread* thread = (Thread*)thread_addr; 1026127675Sbms OSThread* osthr = thread->osthread(); 1027127675Sbms 1028127675Sbms osthr->set_lwp_id( _lwp_self() ); // Store lwp in case we are bound 1029127675Sbms thread->_schedctl = (void *) schedctl_init () ; 1030127675Sbms 1031127675Sbms if (UseNUMA) { 1032127675Sbms int lgrp_id = os::numa_get_group_id(); 1033127675Sbms if (lgrp_id != -1) { 1034127675Sbms thread->set_lgrp_id(lgrp_id); 1035127675Sbms } 1036127675Sbms } 1037127675Sbms 1038127675Sbms // If the creator called set priority before we started, 1039127675Sbms // we need to call set_native_priority now that we have an lwp. 1040127675Sbms // We used to get the priority from thr_getprio (we called 1041127675Sbms // thr_setprio way back in create_thread) and pass it to 1042127675Sbms // set_native_priority, but Solaris scales the priority 1043127675Sbms // in java_to_os_priority, so when we read it back here, 1044127675Sbms // we pass trash to set_native_priority instead of what's 1045127675Sbms // in java_to_os_priority. So we save the native priority 1046127675Sbms // in the osThread and recall it here. 1047127675Sbms 1048127675Sbms if ( osthr->thread_id() != -1 ) { 1049127675Sbms if ( UseThreadPriorities ) { 1050127675Sbms int prio = osthr->native_priority(); 1051127675Sbms if (ThreadPriorityVerbose) { 1052127675Sbms tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is " 1053127675Sbms INTPTR_FORMAT ", setting priority: %d\n", 1054127675Sbms osthr->thread_id(), osthr->lwp_id(), prio); 1055127675Sbms } 1056127675Sbms os::set_native_priority(thread, prio); 1057127675Sbms } 1058127675Sbms } else if (ThreadPriorityVerbose) { 1059127675Sbms warning("Can't set priority in _start routine, thread id hasn't been set\n"); 1060127675Sbms } 1061127675Sbms 1062127675Sbms assert(osthr->get_state() == RUNNABLE, "invalid os thread state"); 1063127675Sbms 1064127675Sbms // initialize signal mask for this thread 1065127675Sbms os::Solaris::hotspot_sigmask(thread); 1066127675Sbms 1067127675Sbms thread->run(); 1068127675Sbms 1069127675Sbms // One less thread is executing 1070127675Sbms // When the VMThread gets here, the main thread may have already exited 1071127675Sbms // which frees the CodeHeap containing the Atomic::dec code 1072127675Sbms if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) { 1073127675Sbms Atomic::dec(&os::Solaris::_os_thread_count); 1074127675Sbms } 1075127675Sbms 1076127675Sbms if (UseDetachedThreads) { 1077127675Sbms thr_exit(NULL); 1078127675Sbms ShouldNotReachHere(); 1079127675Sbms } 1080127675Sbms return NULL; 1081127675Sbms} 1082127675Sbms 1083127675Sbmsstatic OSThread* create_os_thread(Thread* thread, thread_t thread_id) { 1084127675Sbms // Allocate the OSThread object 1085127675Sbms OSThread* osthread = new OSThread(NULL, NULL); 1086127675Sbms if (osthread == NULL) return NULL; 1087127675Sbms 1088127675Sbms // Store info on the Solaris thread into the OSThread 1089127675Sbms osthread->set_thread_id(thread_id); 1090127675Sbms osthread->set_lwp_id(_lwp_self()); 1091127675Sbms thread->_schedctl = (void *) schedctl_init () ; 109217680Spst 109317680Spst if (UseNUMA) { 109417680Spst int lgrp_id = os::numa_get_group_id(); 109517680Spst if (lgrp_id != -1) { 109617680Spst thread->set_lgrp_id(lgrp_id); 109717680Spst } 109817680Spst } 109939300Sfenner 110017680Spst if ( ThreadPriorityVerbose ) { 110117680Spst tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n", 110217680Spst osthread->thread_id(), osthread->lwp_id() ); 110317680Spst } 110417680Spst 110517680Spst // Initial thread state is INITIALIZED, not SUSPENDED 110617680Spst osthread->set_state(INITIALIZED); 110717680Spst 110817680Spst return osthread; 110917680Spst} 111017680Spst 111117680Spstvoid os::Solaris::hotspot_sigmask(Thread* thread) { 111217680Spst 111317680Spst //Save caller's signal mask 111417680Spst sigset_t sigmask; 1115127675Sbms thr_sigsetmask(SIG_SETMASK, NULL, &sigmask); 111617680Spst OSThread *osthread = thread->osthread(); 111717680Spst osthread->set_caller_sigmask(sigmask); 111898527Sfenner 111917680Spst thr_sigsetmask(SIG_UNBLOCK, os::Solaris::unblocked_signals(), NULL); 112017680Spst if (!ReduceSignalUsage) { 112117680Spst if (thread->is_VM_thread()) { 112217680Spst // Only the VM thread handles BREAK_SIGNAL ... 112317680Spst thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL); 112417680Spst } else { 112517680Spst // ... all other threads block BREAK_SIGNAL 112617680Spst assert(!sigismember(vm_signals(), SIGINT), "SIGINT should not be blocked"); 112717680Spst thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL); 112817680Spst } 112917680Spst } 113017680Spst} 113117680Spst 113217680Spstbool os::create_attached_thread(JavaThread* thread) { 113317680Spst#ifdef ASSERT 113417680Spst thread->verify_not_published(); 113517680Spst#endif 113617680Spst OSThread* osthread = create_os_thread(thread, thr_self()); 113717680Spst if (osthread == NULL) { 113817680Spst return false; 113917680Spst } 114026183Sfenner 114117680Spst // Initial thread state is RUNNABLE 114217680Spst osthread->set_state(RUNNABLE); 114317680Spst thread->set_osthread(osthread); 114417680Spst 114517680Spst // initialize signal mask for this thread 114617680Spst // and save the caller's signal mask 114717680Spst os::Solaris::hotspot_sigmask(thread); 114817680Spst 114917680Spst return true; 115017680Spst} 115117680Spst 115217680Spstbool os::create_main_thread(JavaThread* thread) { 115317680Spst#ifdef ASSERT 115417680Spst thread->verify_not_published(); 115517680Spst#endif 115656896Sfenner if (_starting_thread == NULL) { 115756896Sfenner _starting_thread = create_os_thread(thread, main_thread); 115856896Sfenner if (_starting_thread == NULL) { 115956896Sfenner return false; 116056896Sfenner } 116156896Sfenner } 116256896Sfenner 116356896Sfenner // The primodial thread is runnable from the start 116456896Sfenner _starting_thread->set_state(RUNNABLE); 116556896Sfenner 116656896Sfenner thread->set_osthread(_starting_thread); 116756896Sfenner 116856896Sfenner // initialize signal mask for this thread 116956896Sfenner // and save the caller's signal mask 117056896Sfenner os::Solaris::hotspot_sigmask(thread); 117156896Sfenner 117256896Sfenner return true; 117356896Sfenner} 117456896Sfenner 117556896Sfenner// _T2_libthread is true if we believe we are running with the newer 117656896Sfenner// SunSoft lwp/libthread.so (2.8 patch, 2.9 default) 1177bool os::Solaris::_T2_libthread = false; 1178 1179bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) { 1180 // Allocate the OSThread object 1181 OSThread* osthread = new OSThread(NULL, NULL); 1182 if (osthread == NULL) { 1183 return false; 1184 } 1185 1186 if ( ThreadPriorityVerbose ) { 1187 char *thrtyp; 1188 switch ( thr_type ) { 1189 case vm_thread: 1190 thrtyp = (char *)"vm"; 1191 break; 1192 case cgc_thread: 1193 thrtyp = (char *)"cgc"; 1194 break; 1195 case pgc_thread: 1196 thrtyp = (char *)"pgc"; 1197 break; 1198 case java_thread: 1199 thrtyp = (char *)"java"; 1200 break; 1201 case compiler_thread: 1202 thrtyp = (char *)"compiler"; 1203 break; 1204 case watcher_thread: 1205 thrtyp = (char *)"watcher"; 1206 break; 1207 default: 1208 thrtyp = (char *)"unknown"; 1209 break; 1210 } 1211 tty->print_cr("In create_thread, creating a %s thread\n", thrtyp); 1212 } 1213 1214 // Calculate stack size if it's not specified by caller. 1215 if (stack_size == 0) { 1216 // The default stack size 1M (2M for LP64). 1217 stack_size = (BytesPerWord >> 2) * K * K; 1218 1219 switch (thr_type) { 1220 case os::java_thread: 1221 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss 1222 if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create(); 1223 break; 1224 case os::compiler_thread: 1225 if (CompilerThreadStackSize > 0) { 1226 stack_size = (size_t)(CompilerThreadStackSize * K); 1227 break; 1228 } // else fall through: 1229 // use VMThreadStackSize if CompilerThreadStackSize is not defined 1230 case os::vm_thread: 1231 case os::pgc_thread: 1232 case os::cgc_thread: 1233 case os::watcher_thread: 1234 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K); 1235 break; 1236 } 1237 } 1238 stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed); 1239 1240 // Initial state is ALLOCATED but not INITIALIZED 1241 osthread->set_state(ALLOCATED); 1242 1243 if (os::Solaris::_os_thread_count > os::Solaris::_os_thread_limit) { 1244 // We got lots of threads. Check if we still have some address space left. 1245 // Need to be at least 5Mb of unreserved address space. We do check by 1246 // trying to reserve some. 1247 const size_t VirtualMemoryBangSize = 20*K*K; 1248 char* mem = os::reserve_memory(VirtualMemoryBangSize); 1249 if (mem == NULL) { 1250 delete osthread; 1251 return false; 1252 } else { 1253 // Release the memory again 1254 os::release_memory(mem, VirtualMemoryBangSize); 1255 } 1256 } 1257 1258 // Setup osthread because the child thread may need it. 1259 thread->set_osthread(osthread); 1260 1261 // Create the Solaris thread 1262 // explicit THR_BOUND for T2_libthread case in case 1263 // that assumption is not accurate, but our alternate signal stack 1264 // handling is based on it which must have bound threads 1265 thread_t tid = 0; 1266 long flags = (UseDetachedThreads ? THR_DETACHED : 0) | THR_SUSPENDED 1267 | ((UseBoundThreads || os::Solaris::T2_libthread() || 1268 (thr_type == vm_thread) || 1269 (thr_type == cgc_thread) || 1270 (thr_type == pgc_thread) || 1271 (thr_type == compiler_thread && BackgroundCompilation)) ? 1272 THR_BOUND : 0); 1273 int status; 1274 1275 // 4376845 -- libthread/kernel don't provide enough LWPs to utilize all CPUs. 1276 // 1277 // On multiprocessors systems, libthread sometimes under-provisions our 1278 // process with LWPs. On a 30-way systems, for instance, we could have 1279 // 50 user-level threads in ready state and only 2 or 3 LWPs assigned 1280 // to our process. This can result in under utilization of PEs. 1281 // I suspect the problem is related to libthread's LWP 1282 // pool management and to the kernel's SIGBLOCKING "last LWP parked" 1283 // upcall policy. 1284 // 1285 // The following code is palliative -- it attempts to ensure that our 1286 // process has sufficient LWPs to take advantage of multiple PEs. 1287 // Proper long-term cures include using user-level threads bound to LWPs 1288 // (THR_BOUND) or using LWP-based synchronization. Note that there is a 1289 // slight timing window with respect to sampling _os_thread_count, but 1290 // the race is benign. Also, we should periodically recompute 1291 // _processors_online as the min of SC_NPROCESSORS_ONLN and the 1292 // the number of PEs in our partition. You might be tempted to use 1293 // THR_NEW_LWP here, but I'd recommend against it as that could 1294 // result in undesirable growth of the libthread's LWP pool. 1295 // The fix below isn't sufficient; for instance, it doesn't take into count 1296 // LWPs parked on IO. It does, however, help certain CPU-bound benchmarks. 1297 // 1298 // Some pathologies this scheme doesn't handle: 1299 // * Threads can block, releasing the LWPs. The LWPs can age out. 1300 // When a large number of threads become ready again there aren't 1301 // enough LWPs available to service them. This can occur when the 1302 // number of ready threads oscillates. 1303 // * LWPs/Threads park on IO, thus taking the LWP out of circulation. 1304 // 1305 // Finally, we should call thr_setconcurrency() periodically to refresh 1306 // the LWP pool and thwart the LWP age-out mechanism. 1307 // The "+3" term provides a little slop -- we want to slightly overprovision. 1308 1309 if (AdjustConcurrency && os::Solaris::_os_thread_count < (_processors_online+3)) { 1310 if (!(flags & THR_BOUND)) { 1311 thr_setconcurrency (os::Solaris::_os_thread_count); // avoid starvation 1312 } 1313 } 1314 // Although this doesn't hurt, we should warn of undefined behavior 1315 // when using unbound T1 threads with schedctl(). This should never 1316 // happen, as the compiler and VM threads are always created bound 1317 DEBUG_ONLY( 1318 if ((VMThreadHintNoPreempt || CompilerThreadHintNoPreempt) && 1319 (!os::Solaris::T2_libthread() && (!(flags & THR_BOUND))) && 1320 ((thr_type == vm_thread) || (thr_type == cgc_thread) || 1321 (thr_type == pgc_thread) || (thr_type == compiler_thread && BackgroundCompilation))) { 1322 warning("schedctl behavior undefined when Compiler/VM/GC Threads are Unbound"); 1323 } 1324 ); 1325 1326 1327 // Mark that we don't have an lwp or thread id yet. 1328 // In case we attempt to set the priority before the thread starts. 1329 osthread->set_lwp_id(-1); 1330 osthread->set_thread_id(-1); 1331 1332 status = thr_create(NULL, stack_size, java_start, thread, flags, &tid); 1333 if (status != 0) { 1334 if (PrintMiscellaneous && (Verbose || WizardMode)) { 1335 perror("os::create_thread"); 1336 } 1337 thread->set_osthread(NULL); 1338 // Need to clean up stuff we've allocated so far 1339 delete osthread; 1340 return false; 1341 } 1342 1343 Atomic::inc(&os::Solaris::_os_thread_count); 1344 1345 // Store info on the Solaris thread into the OSThread 1346 osthread->set_thread_id(tid); 1347 1348 // Remember that we created this thread so we can set priority on it 1349 osthread->set_vm_created(); 1350 1351 // Set the default thread priority. If using bound threads, setting 1352 // lwp priority will be delayed until thread start. 1353 set_native_priority(thread, 1354 DefaultThreadPriority == -1 ? 1355 java_to_os_priority[NormPriority] : 1356 DefaultThreadPriority); 1357 1358 // Initial thread state is INITIALIZED, not SUSPENDED 1359 osthread->set_state(INITIALIZED); 1360 1361 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain 1362 return true; 1363} 1364 1365/* defined for >= Solaris 10. This allows builds on earlier versions 1366 * of Solaris to take advantage of the newly reserved Solaris JVM signals 1367 * With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2 1368 * and -XX:+UseAltSigs does nothing since these should have no conflict 1369 */ 1370#if !defined(SIGJVM1) 1371#define SIGJVM1 39 1372#define SIGJVM2 40 1373#endif 1374 1375debug_only(static bool signal_sets_initialized = false); 1376static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs; 1377int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL; 1378int os::Solaris::_SIGasync = ASYNC_SIGNAL; 1379 1380bool os::Solaris::is_sig_ignored(int sig) { 1381 struct sigaction oact; 1382 sigaction(sig, (struct sigaction*)NULL, &oact); 1383 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction) 1384 : CAST_FROM_FN_PTR(void*, oact.sa_handler); 1385 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) 1386 return true; 1387 else 1388 return false; 1389} 1390 1391// Note: SIGRTMIN is a macro that calls sysconf() so it will 1392// dynamically detect SIGRTMIN value for the system at runtime, not buildtime 1393static bool isJVM1available() { 1394 return SIGJVM1 < SIGRTMIN; 1395} 1396 1397void os::Solaris::signal_sets_init() { 1398 // Should also have an assertion stating we are still single-threaded. 1399 assert(!signal_sets_initialized, "Already initialized"); 1400 // Fill in signals that are necessarily unblocked for all threads in 1401 // the VM. Currently, we unblock the following signals: 1402 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden 1403 // by -Xrs (=ReduceSignalUsage)); 1404 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all 1405 // other threads. The "ReduceSignalUsage" boolean tells us not to alter 1406 // the dispositions or masks wrt these signals. 1407 // Programs embedding the VM that want to use the above signals for their 1408 // own purposes must, at this time, use the "-Xrs" option to prevent 1409 // interference with shutdown hooks and BREAK_SIGNAL thread dumping. 1410 // (See bug 4345157, and other related bugs). 1411 // In reality, though, unblocking these signals is really a nop, since 1412 // these signals are not blocked by default. 1413 sigemptyset(&unblocked_sigs); 1414 sigemptyset(&allowdebug_blocked_sigs); 1415 sigaddset(&unblocked_sigs, SIGILL); 1416 sigaddset(&unblocked_sigs, SIGSEGV); 1417 sigaddset(&unblocked_sigs, SIGBUS); 1418 sigaddset(&unblocked_sigs, SIGFPE); 1419 1420 if (isJVM1available) { 1421 os::Solaris::set_SIGinterrupt(SIGJVM1); 1422 os::Solaris::set_SIGasync(SIGJVM2); 1423 } else if (UseAltSigs) { 1424 os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL); 1425 os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL); 1426 } else { 1427 os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL); 1428 os::Solaris::set_SIGasync(ASYNC_SIGNAL); 1429 } 1430 1431 sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt()); 1432 sigaddset(&unblocked_sigs, os::Solaris::SIGasync()); 1433 1434 if (!ReduceSignalUsage) { 1435 if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) { 1436 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL); 1437 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL); 1438 } 1439 if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) { 1440 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL); 1441 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL); 1442 } 1443 if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) { 1444 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL); 1445 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL); 1446 } 1447 } 1448 // Fill in signals that are blocked by all but the VM thread. 1449 sigemptyset(&vm_sigs); 1450 if (!ReduceSignalUsage) 1451 sigaddset(&vm_sigs, BREAK_SIGNAL); 1452 debug_only(signal_sets_initialized = true); 1453 1454 // For diagnostics only used in run_periodic_checks 1455 sigemptyset(&check_signal_done); 1456} 1457 1458// These are signals that are unblocked while a thread is running Java. 1459// (For some reason, they get blocked by default.) 1460sigset_t* os::Solaris::unblocked_signals() { 1461 assert(signal_sets_initialized, "Not initialized"); 1462 return &unblocked_sigs; 1463} 1464 1465// These are the signals that are blocked while a (non-VM) thread is 1466// running Java. Only the VM thread handles these signals. 1467sigset_t* os::Solaris::vm_signals() { 1468 assert(signal_sets_initialized, "Not initialized"); 1469 return &vm_sigs; 1470} 1471 1472// These are signals that are blocked during cond_wait to allow debugger in 1473sigset_t* os::Solaris::allowdebug_blocked_signals() { 1474 assert(signal_sets_initialized, "Not initialized"); 1475 return &allowdebug_blocked_sigs; 1476} 1477 1478 1479void _handle_uncaught_cxx_exception() { 1480 VMError err("An uncaught C++ exception"); 1481 err.report_and_die(); 1482} 1483 1484 1485// First crack at OS-specific initialization, from inside the new thread. 1486void os::initialize_thread(Thread* thr) { 1487 int r = thr_main() ; 1488 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; 1489 if (r) { 1490 JavaThread* jt = (JavaThread *)thr; 1491 assert(jt != NULL,"Sanity check"); 1492 size_t stack_size; 1493 address base = jt->stack_base(); 1494 if (Arguments::created_by_java_launcher()) { 1495 // Use 2MB to allow for Solaris 7 64 bit mode. 1496 stack_size = JavaThread::stack_size_at_create() == 0 1497 ? 2048*K : JavaThread::stack_size_at_create(); 1498 1499 // There are rare cases when we may have already used more than 1500 // the basic stack size allotment before this method is invoked. 1501 // Attempt to allow for a normally sized java_stack. 1502 size_t current_stack_offset = (size_t)(base - (address)&stack_size); 1503 stack_size += ReservedSpace::page_align_size_down(current_stack_offset); 1504 } else { 1505 // 6269555: If we were not created by a Java launcher, i.e. if we are 1506 // running embedded in a native application, treat the primordial thread 1507 // as much like a native attached thread as possible. This means using 1508 // the current stack size from thr_stksegment(), unless it is too large 1509 // to reliably setup guard pages. A reasonable max size is 8MB. 1510 size_t current_size = current_stack_size(); 1511 // This should never happen, but just in case.... 1512 if (current_size == 0) current_size = 2 * K * K; 1513 stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size; 1514 } 1515 address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());; 1516 stack_size = (size_t)(base - bottom); 1517 1518 assert(stack_size > 0, "Stack size calculation problem"); 1519 1520 if (stack_size > jt->stack_size()) { 1521 NOT_PRODUCT( 1522 struct rlimit limits; 1523 getrlimit(RLIMIT_STACK, &limits); 1524 size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur); 1525 assert(size >= jt->stack_size(), "Stack size problem in main thread"); 1526 ) 1527 tty->print_cr( 1528 "Stack size of %d Kb exceeds current limit of %d Kb.\n" 1529 "(Stack sizes are rounded up to a multiple of the system page size.)\n" 1530 "See limit(1) to increase the stack size limit.", 1531 stack_size / K, jt->stack_size() / K); 1532 vm_exit(1); 1533 } 1534 assert(jt->stack_size() >= stack_size, 1535 "Attempt to map more stack than was allocated"); 1536 jt->set_stack_size(stack_size); 1537 } 1538 1539 // 5/22/01: Right now alternate signal stacks do not handle 1540 // throwing stack overflow exceptions, see bug 4463178 1541 // Until a fix is found for this, T2 will NOT imply alternate signal 1542 // stacks. 1543 // If using T2 libthread threads, install an alternate signal stack. 1544 // Because alternate stacks associate with LWPs on Solaris, 1545 // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads 1546 // we prefer to explicitly stack bang. 1547 // If not using T2 libthread, but using UseBoundThreads any threads 1548 // (primordial thread, jni_attachCurrentThread) we do not create, 1549 // probably are not bound, therefore they can not have an alternate 1550 // signal stack. Since our stack banging code is generated and 1551 // is shared across threads, all threads must be bound to allow 1552 // using alternate signal stacks. The alternative is to interpose 1553 // on _lwp_create to associate an alt sig stack with each LWP, 1554 // and this could be a problem when the JVM is embedded. 1555 // We would prefer to use alternate signal stacks with T2 1556 // Since there is currently no accurate way to detect T2 1557 // we do not. Assuming T2 when running T1 causes sig 11s or assertions 1558 // on installing alternate signal stacks 1559 1560 1561 // 05/09/03: removed alternate signal stack support for Solaris 1562 // The alternate signal stack mechanism is no longer needed to 1563 // handle stack overflow. This is now handled by allocating 1564 // guard pages (red zone) and stackbanging. 1565 // Initially the alternate signal stack mechanism was removed because 1566 // it did not work with T1 llibthread. Alternate 1567 // signal stacks MUST have all threads bound to lwps. Applications 1568 // can create their own threads and attach them without their being 1569 // bound under T1. This is frequently the case for the primordial thread. 1570 // If we were ever to reenable this mechanism we would need to 1571 // use the dynamic check for T2 libthread. 1572 1573 os::Solaris::init_thread_fpu_state(); 1574 std::set_terminate(_handle_uncaught_cxx_exception); 1575} 1576 1577 1578 1579// Free Solaris resources related to the OSThread 1580void os::free_thread(OSThread* osthread) { 1581 assert(osthread != NULL, "os::free_thread but osthread not set"); 1582 1583 1584 // We are told to free resources of the argument thread, 1585 // but we can only really operate on the current thread. 1586 // The main thread must take the VMThread down synchronously 1587 // before the main thread exits and frees up CodeHeap 1588 guarantee((Thread::current()->osthread() == osthread 1589 || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread"); 1590 if (Thread::current()->osthread() == osthread) { 1591 // Restore caller's signal mask 1592 sigset_t sigmask = osthread->caller_sigmask(); 1593 thr_sigsetmask(SIG_SETMASK, &sigmask, NULL); 1594 } 1595 delete osthread; 1596} 1597 1598void os::pd_start_thread(Thread* thread) { 1599 int status = thr_continue(thread->osthread()->thread_id()); 1600 assert_status(status == 0, status, "thr_continue failed"); 1601} 1602 1603 1604intx os::current_thread_id() { 1605 return (intx)thr_self(); 1606} 1607 1608static pid_t _initial_pid = 0; 1609 1610int os::current_process_id() { 1611 return (int)(_initial_pid ? _initial_pid : getpid()); 1612} 1613 1614int os::allocate_thread_local_storage() { 1615 // %%% in Win32 this allocates a memory segment pointed to by a 1616 // register. Dan Stein can implement a similar feature in 1617 // Solaris. Alternatively, the VM can do the same thing 1618 // explicitly: malloc some storage and keep the pointer in a 1619 // register (which is part of the thread's context) (or keep it 1620 // in TLS). 1621 // %%% In current versions of Solaris, thr_self and TSD can 1622 // be accessed via short sequences of displaced indirections. 1623 // The value of thr_self is available as %g7(36). 1624 // The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4), 1625 // assuming that the current thread already has a value bound to k. 1626 // It may be worth experimenting with such access patterns, 1627 // and later having the parameters formally exported from a Solaris 1628 // interface. I think, however, that it will be faster to 1629 // maintain the invariant that %g2 always contains the 1630 // JavaThread in Java code, and have stubs simply 1631 // treat %g2 as a caller-save register, preserving it in a %lN. 1632 thread_key_t tk; 1633 if (thr_keycreate( &tk, NULL ) ) 1634 fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed " 1635 "(%s)", strerror(errno))); 1636 return int(tk); 1637} 1638 1639void os::free_thread_local_storage(int index) { 1640 // %%% don't think we need anything here 1641 // if ( pthread_key_delete((pthread_key_t) tk) ) 1642 // fatal("os::free_thread_local_storage: pthread_key_delete failed"); 1643} 1644 1645#define SMALLINT 32 // libthread allocate for tsd_common is a version specific 1646 // small number - point is NO swap space available 1647void os::thread_local_storage_at_put(int index, void* value) { 1648 // %%% this is used only in threadLocalStorage.cpp 1649 if (thr_setspecific((thread_key_t)index, value)) { 1650 if (errno == ENOMEM) { 1651 vm_exit_out_of_memory(SMALLINT, "thr_setspecific: out of swap space"); 1652 } else { 1653 fatal(err_msg("os::thread_local_storage_at_put: thr_setspecific failed " 1654 "(%s)", strerror(errno))); 1655 } 1656 } else { 1657 ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ; 1658 } 1659} 1660 1661// This function could be called before TLS is initialized, for example, when 1662// VM receives an async signal or when VM causes a fatal error during 1663// initialization. Return NULL if thr_getspecific() fails. 1664void* os::thread_local_storage_at(int index) { 1665 // %%% this is used only in threadLocalStorage.cpp 1666 void* r = NULL; 1667 return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r; 1668} 1669 1670 1671// gethrtime can move backwards if read from one cpu and then a different cpu 1672// getTimeNanos is guaranteed to not move backward on Solaris 1673// local spinloop created as faster for a CAS on an int than 1674// a CAS on a 64bit jlong. Also Atomic::cmpxchg for jlong is not 1675// supported on sparc v8 or pre supports_cx8 intel boxes. 1676// oldgetTimeNanos for systems which do not support CAS on 64bit jlong 1677// i.e. sparc v8 and pre supports_cx8 (i486) intel boxes 1678inline hrtime_t oldgetTimeNanos() { 1679 int gotlock = LOCK_INVALID; 1680 hrtime_t newtime = gethrtime(); 1681 1682 for (;;) { 1683// grab lock for max_hrtime 1684 int curlock = max_hrtime_lock; 1685 if (curlock & LOCK_BUSY) continue; 1686 if (gotlock = Atomic::cmpxchg(LOCK_BUSY, &max_hrtime_lock, LOCK_FREE) != LOCK_FREE) continue; 1687 if (newtime > max_hrtime) { 1688 max_hrtime = newtime; 1689 } else { 1690 newtime = max_hrtime; 1691 } 1692 // release lock 1693 max_hrtime_lock = LOCK_FREE; 1694 return newtime; 1695 } 1696} 1697// gethrtime can move backwards if read from one cpu and then a different cpu 1698// getTimeNanos is guaranteed to not move backward on Solaris 1699inline hrtime_t getTimeNanos() { 1700 if (VM_Version::supports_cx8()) { 1701 const hrtime_t now = gethrtime(); 1702 // Use atomic long load since 32-bit x86 uses 2 registers to keep long. 1703 const hrtime_t prev = Atomic::load((volatile jlong*)&max_hrtime); 1704 if (now <= prev) return prev; // same or retrograde time; 1705 const hrtime_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&max_hrtime, prev); 1706 assert(obsv >= prev, "invariant"); // Monotonicity 1707 // If the CAS succeeded then we're done and return "now". 1708 // If the CAS failed and the observed value "obs" is >= now then 1709 // we should return "obs". If the CAS failed and now > obs > prv then 1710 // some other thread raced this thread and installed a new value, in which case 1711 // we could either (a) retry the entire operation, (b) retry trying to install now 1712 // or (c) just return obs. We use (c). No loop is required although in some cases 1713 // we might discard a higher "now" value in deference to a slightly lower but freshly 1714 // installed obs value. That's entirely benign -- it admits no new orderings compared 1715 // to (a) or (b) -- and greatly reduces coherence traffic. 1716 // We might also condition (c) on the magnitude of the delta between obs and now. 1717 // Avoiding excessive CAS operations to hot RW locations is critical. 1718 // See http://blogs.sun.com/dave/entry/cas_and_cache_trivia_invalidate 1719 return (prev == obsv) ? now : obsv ; 1720 } else { 1721 return oldgetTimeNanos(); 1722 } 1723} 1724 1725// Time since start-up in seconds to a fine granularity. 1726// Used by VMSelfDestructTimer and the MemProfiler. 1727double os::elapsedTime() { 1728 return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz; 1729} 1730 1731jlong os::elapsed_counter() { 1732 return (jlong)(getTimeNanos() - first_hrtime); 1733} 1734 1735jlong os::elapsed_frequency() { 1736 return hrtime_hz; 1737} 1738 1739// Return the real, user, and system times in seconds from an 1740// arbitrary fixed point in the past. 1741bool os::getTimesSecs(double* process_real_time, 1742 double* process_user_time, 1743 double* process_system_time) { 1744 struct tms ticks; 1745 clock_t real_ticks = times(&ticks); 1746 1747 if (real_ticks == (clock_t) (-1)) { 1748 return false; 1749 } else { 1750 double ticks_per_second = (double) clock_tics_per_sec; 1751 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second; 1752 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second; 1753 // For consistency return the real time from getTimeNanos() 1754 // converted to seconds. 1755 *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS); 1756 1757 return true; 1758 } 1759} 1760 1761bool os::supports_vtime() { return true; } 1762 1763bool os::enable_vtime() { 1764 int fd = ::open("/proc/self/ctl", O_WRONLY); 1765 if (fd == -1) 1766 return false; 1767 1768 long cmd[] = { PCSET, PR_MSACCT }; 1769 int res = ::write(fd, cmd, sizeof(long) * 2); 1770 ::close(fd); 1771 if (res != sizeof(long) * 2) 1772 return false; 1773 1774 return true; 1775} 1776 1777bool os::vtime_enabled() { 1778 int fd = ::open("/proc/self/status", O_RDONLY); 1779 if (fd == -1) 1780 return false; 1781 1782 pstatus_t status; 1783 int res = os::read(fd, (void*) &status, sizeof(pstatus_t)); 1784 ::close(fd); 1785 if (res != sizeof(pstatus_t)) 1786 return false; 1787 1788 return status.pr_flags & PR_MSACCT; 1789} 1790 1791double os::elapsedVTime() { 1792 return (double)gethrvtime() / (double)hrtime_hz; 1793} 1794 1795// Used internally for comparisons only 1796// getTimeMillis guaranteed to not move backwards on Solaris 1797jlong getTimeMillis() { 1798 jlong nanotime = getTimeNanos(); 1799 return (jlong)(nanotime / NANOSECS_PER_MILLISEC); 1800} 1801 1802// Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis 1803jlong os::javaTimeMillis() { 1804 timeval t; 1805 if (gettimeofday( &t, NULL) == -1) 1806 fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno))); 1807 return jlong(t.tv_sec) * 1000 + jlong(t.tv_usec) / 1000; 1808} 1809 1810jlong os::javaTimeNanos() { 1811 return (jlong)getTimeNanos(); 1812} 1813 1814void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { 1815 info_ptr->max_value = ALL_64_BITS; // gethrtime() uses all 64 bits 1816 info_ptr->may_skip_backward = false; // not subject to resetting or drifting 1817 info_ptr->may_skip_forward = false; // not subject to resetting or drifting 1818 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time 1819} 1820 1821char * os::local_time_string(char *buf, size_t buflen) { 1822 struct tm t; 1823 time_t long_time; 1824 time(&long_time); 1825 localtime_r(&long_time, &t); 1826 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d", 1827 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, 1828 t.tm_hour, t.tm_min, t.tm_sec); 1829 return buf; 1830} 1831 1832// Note: os::shutdown() might be called very early during initialization, or 1833// called from signal handler. Before adding something to os::shutdown(), make 1834// sure it is async-safe and can handle partially initialized VM. 1835void os::shutdown() { 1836 1837 // allow PerfMemory to attempt cleanup of any persistent resources 1838 perfMemory_exit(); 1839 1840 // needs to remove object in file system 1841 AttachListener::abort(); 1842 1843 // flush buffered output, finish log files 1844 ostream_abort(); 1845 1846 // Check for abort hook 1847 abort_hook_t abort_hook = Arguments::abort_hook(); 1848 if (abort_hook != NULL) { 1849 abort_hook(); 1850 } 1851} 1852 1853// Note: os::abort() might be called very early during initialization, or 1854// called from signal handler. Before adding something to os::abort(), make 1855// sure it is async-safe and can handle partially initialized VM. 1856void os::abort(bool dump_core) { 1857 os::shutdown(); 1858 if (dump_core) { 1859#ifndef PRODUCT 1860 fdStream out(defaultStream::output_fd()); 1861 out.print_raw("Current thread is "); 1862 char buf[16]; 1863 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id()); 1864 out.print_raw_cr(buf); 1865 out.print_raw_cr("Dumping core ..."); 1866#endif 1867 ::abort(); // dump core (for debugging) 1868 } 1869 1870 ::exit(1); 1871} 1872 1873// Die immediately, no exit hook, no abort hook, no cleanup. 1874void os::die() { 1875 _exit(-1); 1876} 1877 1878// unused 1879void os::set_error_file(const char *logfile) {} 1880 1881// DLL functions 1882 1883const char* os::dll_file_extension() { return ".so"; } 1884 1885// This must be hard coded because it's the system's temporary 1886// directory not the java application's temp directory, ala java.io.tmpdir. 1887const char* os::get_temp_directory() { return "/tmp"; } 1888 1889static bool file_exists(const char* filename) { 1890 struct stat statbuf; 1891 if (filename == NULL || strlen(filename) == 0) { 1892 return false; 1893 } 1894 return os::stat(filename, &statbuf) == 0; 1895} 1896 1897bool os::dll_build_name(char* buffer, size_t buflen, 1898 const char* pname, const char* fname) { 1899 bool retval = false; 1900 const size_t pnamelen = pname ? strlen(pname) : 0; 1901 1902 // Return error on buffer overflow. 1903 if (pnamelen + strlen(fname) + 10 > (size_t) buflen) { 1904 return retval; 1905 } 1906 1907 if (pnamelen == 0) { 1908 snprintf(buffer, buflen, "lib%s.so", fname); 1909 retval = true; 1910 } else if (strchr(pname, *os::path_separator()) != NULL) { 1911 int n; 1912 char** pelements = split_path(pname, &n); 1913 for (int i = 0 ; i < n ; i++) { 1914 // really shouldn't be NULL but what the heck, check can't hurt 1915 if (pelements[i] == NULL || strlen(pelements[i]) == 0) { 1916 continue; // skip the empty path values 1917 } 1918 snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname); 1919 if (file_exists(buffer)) { 1920 retval = true; 1921 break; 1922 } 1923 } 1924 // release the storage 1925 for (int i = 0 ; i < n ; i++) { 1926 if (pelements[i] != NULL) { 1927 FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal); 1928 } 1929 } 1930 if (pelements != NULL) { 1931 FREE_C_HEAP_ARRAY(char*, pelements, mtInternal); 1932 } 1933 } else { 1934 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname); 1935 retval = true; 1936 } 1937 return retval; 1938} 1939 1940const char* os::get_current_directory(char *buf, int buflen) { 1941 return getcwd(buf, buflen); 1942} 1943 1944// check if addr is inside libjvm[_g].so 1945bool os::address_is_in_vm(address addr) { 1946 static address libjvm_base_addr; 1947 Dl_info dlinfo; 1948 1949 if (libjvm_base_addr == NULL) { 1950 dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo); 1951 libjvm_base_addr = (address)dlinfo.dli_fbase; 1952 assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm"); 1953 } 1954 1955 if (dladdr((void *)addr, &dlinfo)) { 1956 if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true; 1957 } 1958 1959 return false; 1960} 1961 1962typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int); 1963static dladdr1_func_type dladdr1_func = NULL; 1964 1965bool os::dll_address_to_function_name(address addr, char *buf, 1966 int buflen, int * offset) { 1967 Dl_info dlinfo; 1968 1969 // dladdr1_func was initialized in os::init() 1970 if (dladdr1_func){ 1971 // yes, we have dladdr1 1972 1973 // Support for dladdr1 is checked at runtime; it may be 1974 // available even if the vm is built on a machine that does 1975 // not have dladdr1 support. Make sure there is a value for 1976 // RTLD_DL_SYMENT. 1977 #ifndef RTLD_DL_SYMENT 1978 #define RTLD_DL_SYMENT 1 1979 #endif 1980#ifdef _LP64 1981 Elf64_Sym * info; 1982#else 1983 Elf32_Sym * info; 1984#endif 1985 if (dladdr1_func((void *)addr, &dlinfo, (void **)&info, 1986 RTLD_DL_SYMENT)) { 1987 if ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr) { 1988 if (buf != NULL) { 1989 if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen)) 1990 jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname); 1991 } 1992 if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr; 1993 return true; 1994 } 1995 } 1996 if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) { 1997 if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase), 1998 buf, buflen, offset, dlinfo.dli_fname)) { 1999 return true; 2000 } 2001 } 2002 if (buf != NULL) buf[0] = '\0'; 2003 if (offset != NULL) *offset = -1; 2004 return false; 2005 } else { 2006 // no, only dladdr is available 2007 if (dladdr((void *)addr, &dlinfo)) { 2008 if (buf != NULL) { 2009 if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen)) 2010 jio_snprintf(buf, buflen, dlinfo.dli_sname); 2011 } 2012 if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr; 2013 return true; 2014 } else if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) { 2015 if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase), 2016 buf, buflen, offset, dlinfo.dli_fname)) { 2017 return true; 2018 } 2019 } 2020 if (buf != NULL) buf[0] = '\0'; 2021 if (offset != NULL) *offset = -1; 2022 return false; 2023 } 2024} 2025 2026bool os::dll_address_to_library_name(address addr, char* buf, 2027 int buflen, int* offset) { 2028 Dl_info dlinfo; 2029 2030 if (dladdr((void*)addr, &dlinfo)){ 2031 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname); 2032 if (offset) *offset = addr - (address)dlinfo.dli_fbase; 2033 return true; 2034 } else { 2035 if (buf) buf[0] = '\0'; 2036 if (offset) *offset = -1; 2037 return false; 2038 } 2039} 2040 2041// Prints the names and full paths of all opened dynamic libraries 2042// for current process 2043void os::print_dll_info(outputStream * st) { 2044 Dl_info dli; 2045 void *handle; 2046 Link_map *map; 2047 Link_map *p; 2048 2049 st->print_cr("Dynamic libraries:"); st->flush(); 2050 2051 if (!dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli)) { 2052 st->print_cr("Error: Cannot print dynamic libraries."); 2053 return; 2054 } 2055 handle = dlopen(dli.dli_fname, RTLD_LAZY); 2056 if (handle == NULL) { 2057 st->print_cr("Error: Cannot print dynamic libraries."); 2058 return; 2059 } 2060 dlinfo(handle, RTLD_DI_LINKMAP, &map); 2061 if (map == NULL) { 2062 st->print_cr("Error: Cannot print dynamic libraries."); 2063 return; 2064 } 2065 2066 while (map->l_prev != NULL) 2067 map = map->l_prev; 2068 2069 while (map != NULL) { 2070 st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name); 2071 map = map->l_next; 2072 } 2073 2074 dlclose(handle); 2075} 2076 2077 // Loads .dll/.so and 2078 // in case of error it checks if .dll/.so was built for the 2079 // same architecture as Hotspot is running on 2080 2081void * os::dll_load(const char *filename, char *ebuf, int ebuflen) 2082{ 2083 void * result= ::dlopen(filename, RTLD_LAZY); 2084 if (result != NULL) { 2085 // Successful loading 2086 return result; 2087 } 2088 2089 Elf32_Ehdr elf_head; 2090 2091 // Read system error message into ebuf 2092 // It may or may not be overwritten below 2093 ::strncpy(ebuf, ::dlerror(), ebuflen-1); 2094 ebuf[ebuflen-1]='\0'; 2095 int diag_msg_max_length=ebuflen-strlen(ebuf); 2096 char* diag_msg_buf=ebuf+strlen(ebuf); 2097 2098 if (diag_msg_max_length==0) { 2099 // No more space in ebuf for additional diagnostics message 2100 return NULL; 2101 } 2102 2103 2104 int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK); 2105 2106 if (file_descriptor < 0) { 2107 // Can't open library, report dlerror() message 2108 return NULL; 2109 } 2110 2111 bool failed_to_read_elf_head= 2112 (sizeof(elf_head)!= 2113 (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ; 2114 2115 ::close(file_descriptor); 2116 if (failed_to_read_elf_head) { 2117 // file i/o error - report dlerror() msg 2118 return NULL; 2119 } 2120 2121 typedef struct { 2122 Elf32_Half code; // Actual value as defined in elf.h 2123 Elf32_Half compat_class; // Compatibility of archs at VM's sense 2124 char elf_class; // 32 or 64 bit 2125 char endianess; // MSB or LSB 2126 char* name; // String representation 2127 } arch_t; 2128 2129 static const arch_t arch_array[]={ 2130 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, 2131 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, 2132 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"}, 2133 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"}, 2134 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"}, 2135 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"}, 2136 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"}, 2137 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"}, 2138 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"}, 2139 {EM_ARM, EM_ARM, ELFCLASS32, ELFDATA2LSB, (char*)"ARM 32"} 2140 }; 2141 2142 #if (defined IA32) 2143 static Elf32_Half running_arch_code=EM_386; 2144 #elif (defined AMD64) 2145 static Elf32_Half running_arch_code=EM_X86_64; 2146 #elif (defined IA64) 2147 static Elf32_Half running_arch_code=EM_IA_64; 2148 #elif (defined __sparc) && (defined _LP64) 2149 static Elf32_Half running_arch_code=EM_SPARCV9; 2150 #elif (defined __sparc) && (!defined _LP64) 2151 static Elf32_Half running_arch_code=EM_SPARC; 2152 #elif (defined __powerpc64__) 2153 static Elf32_Half running_arch_code=EM_PPC64; 2154 #elif (defined __powerpc__) 2155 static Elf32_Half running_arch_code=EM_PPC; 2156 #elif (defined ARM) 2157 static Elf32_Half running_arch_code=EM_ARM; 2158 #else 2159 #error Method os::dll_load requires that one of following is defined:\ 2160 IA32, AMD64, IA64, __sparc, __powerpc__, ARM, ARM 2161 #endif 2162 2163 // Identify compatability class for VM's architecture and library's architecture 2164 // Obtain string descriptions for architectures 2165 2166 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL}; 2167 int running_arch_index=-1; 2168 2169 for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) { 2170 if (running_arch_code == arch_array[i].code) { 2171 running_arch_index = i; 2172 } 2173 if (lib_arch.code == arch_array[i].code) { 2174 lib_arch.compat_class = arch_array[i].compat_class; 2175 lib_arch.name = arch_array[i].name; 2176 } 2177 } 2178 2179 assert(running_arch_index != -1, 2180 "Didn't find running architecture code (running_arch_code) in arch_array"); 2181 if (running_arch_index == -1) { 2182 // Even though running architecture detection failed 2183 // we may still continue with reporting dlerror() message 2184 return NULL; 2185 } 2186 2187 if (lib_arch.endianess != arch_array[running_arch_index].endianess) { 2188 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)"); 2189 return NULL; 2190 } 2191 2192 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) { 2193 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)"); 2194 return NULL; 2195 } 2196 2197 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) { 2198 if ( lib_arch.name!=NULL ) { 2199 ::snprintf(diag_msg_buf, diag_msg_max_length-1, 2200 " (Possible cause: can't load %s-bit .so on a %s-bit platform)", 2201 lib_arch.name, arch_array[running_arch_index].name); 2202 } else { 2203 ::snprintf(diag_msg_buf, diag_msg_max_length-1, 2204 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)", 2205 lib_arch.code, 2206 arch_array[running_arch_index].name); 2207 } 2208 } 2209 2210 return NULL; 2211} 2212 2213void* os::dll_lookup(void* handle, const char* name) { 2214 return dlsym(handle, name); 2215} 2216 2217int os::stat(const char *path, struct stat *sbuf) { 2218 char pathbuf[MAX_PATH]; 2219 if (strlen(path) > MAX_PATH - 1) { 2220 errno = ENAMETOOLONG; 2221 return -1; 2222 } 2223 os::native_path(strcpy(pathbuf, path)); 2224 return ::stat(pathbuf, sbuf); 2225} 2226 2227static bool _print_ascii_file(const char* filename, outputStream* st) { 2228 int fd = ::open(filename, O_RDONLY); 2229 if (fd == -1) { 2230 return false; 2231 } 2232 2233 char buf[32]; 2234 int bytes; 2235 while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) { 2236 st->print_raw(buf, bytes); 2237 } 2238 2239 ::close(fd); 2240 2241 return true; 2242} 2243 2244void os::print_os_info_brief(outputStream* st) { 2245 os::Solaris::print_distro_info(st); 2246 2247 os::Posix::print_uname_info(st); 2248 2249 os::Solaris::print_libversion_info(st); 2250} 2251 2252void os::print_os_info(outputStream* st) { 2253 st->print("OS:"); 2254 2255 os::Solaris::print_distro_info(st); 2256 2257 os::Posix::print_uname_info(st); 2258 2259 os::Solaris::print_libversion_info(st); 2260 2261 os::Posix::print_rlimit_info(st); 2262 2263 os::Posix::print_load_average(st); 2264} 2265 2266void os::Solaris::print_distro_info(outputStream* st) { 2267 if (!_print_ascii_file("/etc/release", st)) { 2268 st->print("Solaris"); 2269 } 2270 st->cr(); 2271} 2272 2273void os::Solaris::print_libversion_info(outputStream* st) { 2274 if (os::Solaris::T2_libthread()) { 2275 st->print(" (T2 libthread)"); 2276 } 2277 else { 2278 st->print(" (T1 libthread)"); 2279 } 2280 st->cr(); 2281} 2282 2283static bool check_addr0(outputStream* st) { 2284 jboolean status = false; 2285 int fd = ::open("/proc/self/map",O_RDONLY); 2286 if (fd >= 0) { 2287 prmap_t p; 2288 while(::read(fd, &p, sizeof(p)) > 0) { 2289 if (p.pr_vaddr == 0x0) { 2290 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname); 2291 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname); 2292 st->print("Access:"); 2293 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-"); 2294 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-"); 2295 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-"); 2296 st->cr(); 2297 status = true; 2298 } 2299 ::close(fd); 2300 } 2301 } 2302 return status; 2303} 2304 2305void os::pd_print_cpu_info(outputStream* st) { 2306 // Nothing to do for now. 2307} 2308 2309void os::print_memory_info(outputStream* st) { 2310 st->print("Memory:"); 2311 st->print(" %dk page", os::vm_page_size()>>10); 2312 st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10); 2313 st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10); 2314 st->cr(); 2315 (void) check_addr0(st); 2316} 2317 2318// Taken from /usr/include/sys/machsig.h Supposed to be architecture specific 2319// but they're the same for all the solaris architectures that we support. 2320const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR", 2321 "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG", 2322 "ILL_COPROC", "ILL_BADSTK" }; 2323 2324const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV", 2325 "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES", 2326 "FPE_FLTINV", "FPE_FLTSUB" }; 2327 2328const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" }; 2329 2330const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" }; 2331 2332void os::print_siginfo(outputStream* st, void* siginfo) { 2333 st->print("siginfo:"); 2334 2335 const int buflen = 100; 2336 char buf[buflen]; 2337 siginfo_t *si = (siginfo_t*)siginfo; 2338 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen)); 2339 char *err = strerror(si->si_errno); 2340 if (si->si_errno != 0 && err != NULL) { 2341 st->print("si_errno=%s", err); 2342 } else { 2343 st->print("si_errno=%d", si->si_errno); 2344 } 2345 const int c = si->si_code; 2346 assert(c > 0, "unexpected si_code"); 2347 switch (si->si_signo) { 2348 case SIGILL: 2349 st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]); 2350 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2351 break; 2352 case SIGFPE: 2353 st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]); 2354 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2355 break; 2356 case SIGSEGV: 2357 st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]); 2358 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2359 break; 2360 case SIGBUS: 2361 st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]); 2362 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2363 break; 2364 default: 2365 st->print(", si_code=%d", si->si_code); 2366 // no si_addr 2367 } 2368 2369 if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) && 2370 UseSharedSpaces) { 2371 FileMapInfo* mapinfo = FileMapInfo::current_info(); 2372 if (mapinfo->is_in_shared_space(si->si_addr)) { 2373 st->print("\n\nError accessing class data sharing archive." \ 2374 " Mapped file inaccessible during execution, " \ 2375 " possible disk/network problem."); 2376 } 2377 } 2378 st->cr(); 2379} 2380 2381// Moved from whole group, because we need them here for diagnostic 2382// prints. 2383#define OLDMAXSIGNUM 32 2384static int Maxsignum = 0; 2385static int *ourSigFlags = NULL; 2386 2387extern "C" void sigINTRHandler(int, siginfo_t*, void*); 2388 2389int os::Solaris::get_our_sigflags(int sig) { 2390 assert(ourSigFlags!=NULL, "signal data structure not initialized"); 2391 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range"); 2392 return ourSigFlags[sig]; 2393} 2394 2395void os::Solaris::set_our_sigflags(int sig, int flags) { 2396 assert(ourSigFlags!=NULL, "signal data structure not initialized"); 2397 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range"); 2398 ourSigFlags[sig] = flags; 2399} 2400 2401 2402static const char* get_signal_handler_name(address handler, 2403 char* buf, int buflen) { 2404 int offset; 2405 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset); 2406 if (found) { 2407 // skip directory names 2408 const char *p1, *p2; 2409 p1 = buf; 2410 size_t len = strlen(os::file_separator()); 2411 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len; 2412 jio_snprintf(buf, buflen, "%s+0x%x", p1, offset); 2413 } else { 2414 jio_snprintf(buf, buflen, PTR_FORMAT, handler); 2415 } 2416 return buf; 2417} 2418 2419static void print_signal_handler(outputStream* st, int sig, 2420 char* buf, size_t buflen) { 2421 struct sigaction sa; 2422 2423 sigaction(sig, NULL, &sa); 2424 2425 st->print("%s: ", os::exception_name(sig, buf, buflen)); 2426 2427 address handler = (sa.sa_flags & SA_SIGINFO) 2428 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction) 2429 : CAST_FROM_FN_PTR(address, sa.sa_handler); 2430 2431 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) { 2432 st->print("SIG_DFL"); 2433 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) { 2434 st->print("SIG_IGN"); 2435 } else { 2436 st->print("[%s]", get_signal_handler_name(handler, buf, buflen)); 2437 } 2438 2439 st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask); 2440 2441 address rh = VMError::get_resetted_sighandler(sig); 2442 // May be, handler was resetted by VMError? 2443 if(rh != NULL) { 2444 handler = rh; 2445 sa.sa_flags = VMError::get_resetted_sigflags(sig); 2446 } 2447 2448 st->print(", sa_flags=" PTR32_FORMAT, sa.sa_flags); 2449 2450 // Check: is it our handler? 2451 if(handler == CAST_FROM_FN_PTR(address, signalHandler) || 2452 handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) { 2453 // It is our signal handler 2454 // check for flags 2455 if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) { 2456 st->print( 2457 ", flags was changed from " PTR32_FORMAT ", consider using jsig library", 2458 os::Solaris::get_our_sigflags(sig)); 2459 } 2460 } 2461 st->cr(); 2462} 2463 2464void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 2465 st->print_cr("Signal Handlers:"); 2466 print_signal_handler(st, SIGSEGV, buf, buflen); 2467 print_signal_handler(st, SIGBUS , buf, buflen); 2468 print_signal_handler(st, SIGFPE , buf, buflen); 2469 print_signal_handler(st, SIGPIPE, buf, buflen); 2470 print_signal_handler(st, SIGXFSZ, buf, buflen); 2471 print_signal_handler(st, SIGILL , buf, buflen); 2472 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen); 2473 print_signal_handler(st, ASYNC_SIGNAL, buf, buflen); 2474 print_signal_handler(st, BREAK_SIGNAL, buf, buflen); 2475 print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen); 2476 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen); 2477 print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen); 2478 print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen); 2479 print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen); 2480} 2481 2482static char saved_jvm_path[MAXPATHLEN] = { 0 }; 2483 2484// Find the full path to the current module, libjvm.so or libjvm_g.so 2485void os::jvm_path(char *buf, jint buflen) { 2486 // Error checking. 2487 if (buflen < MAXPATHLEN) { 2488 assert(false, "must use a large-enough buffer"); 2489 buf[0] = '\0'; 2490 return; 2491 } 2492 // Lazy resolve the path to current module. 2493 if (saved_jvm_path[0] != 0) { 2494 strcpy(buf, saved_jvm_path); 2495 return; 2496 } 2497 2498 Dl_info dlinfo; 2499 int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo); 2500 assert(ret != 0, "cannot locate libjvm"); 2501 realpath((char *)dlinfo.dli_fname, buf); 2502 2503 if (Arguments::created_by_gamma_launcher()) { 2504 // Support for the gamma launcher. Typical value for buf is 2505 // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at 2506 // the right place in the string, then assume we are installed in a JDK and 2507 // we're done. Otherwise, check for a JAVA_HOME environment variable and fix 2508 // up the path so it looks like libjvm.so is installed there (append a 2509 // fake suffix hotspot/libjvm.so). 2510 const char *p = buf + strlen(buf) - 1; 2511 for (int count = 0; p > buf && count < 5; ++count) { 2512 for (--p; p > buf && *p != '/'; --p) 2513 /* empty */ ; 2514 } 2515 2516 if (strncmp(p, "/jre/lib/", 9) != 0) { 2517 // Look for JAVA_HOME in the environment. 2518 char* java_home_var = ::getenv("JAVA_HOME"); 2519 if (java_home_var != NULL && java_home_var[0] != 0) { 2520 char cpu_arch[12]; 2521 char* jrelib_p; 2522 int len; 2523 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch)); 2524#ifdef _LP64 2525 // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9. 2526 if (strcmp(cpu_arch, "sparc") == 0) { 2527 strcat(cpu_arch, "v9"); 2528 } else if (strcmp(cpu_arch, "i386") == 0) { 2529 strcpy(cpu_arch, "amd64"); 2530 } 2531#endif 2532 // Check the current module name "libjvm.so" or "libjvm_g.so". 2533 p = strrchr(buf, '/'); 2534 assert(strstr(p, "/libjvm") == p, "invalid library name"); 2535 p = strstr(p, "_g") ? "_g" : ""; 2536 2537 realpath(java_home_var, buf); 2538 // determine if this is a legacy image or modules image 2539 // modules image doesn't have "jre" subdirectory 2540 len = strlen(buf); 2541 jrelib_p = buf + len; 2542 snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch); 2543 if (0 != access(buf, F_OK)) { 2544 snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch); 2545 } 2546 2547 if (0 == access(buf, F_OK)) { 2548 // Use current module name "libjvm[_g].so" instead of 2549 // "libjvm"debug_only("_g")".so" since for fastdebug version 2550 // we should have "libjvm.so" but debug_only("_g") adds "_g"! 2551 len = strlen(buf); 2552 snprintf(buf + len, buflen-len, "/hotspot/libjvm%s.so", p); 2553 } else { 2554 // Go back to path of .so 2555 realpath((char *)dlinfo.dli_fname, buf); 2556 } 2557 } 2558 } 2559 } 2560 2561 strcpy(saved_jvm_path, buf); 2562} 2563 2564 2565void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 2566 // no prefix required, not even "_" 2567} 2568 2569 2570void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 2571 // no suffix required 2572} 2573 2574// This method is a copy of JDK's sysGetLastErrorString 2575// from src/solaris/hpi/src/system_md.c 2576 2577size_t os::lasterror(char *buf, size_t len) { 2578 2579 if (errno == 0) return 0; 2580 2581 const char *s = ::strerror(errno); 2582 size_t n = ::strlen(s); 2583 if (n >= len) { 2584 n = len - 1; 2585 } 2586 ::strncpy(buf, s, n); 2587 buf[n] = '\0'; 2588 return n; 2589} 2590 2591 2592// sun.misc.Signal 2593 2594extern "C" { 2595 static void UserHandler(int sig, void *siginfo, void *context) { 2596 // Ctrl-C is pressed during error reporting, likely because the error 2597 // handler fails to abort. Let VM die immediately. 2598 if (sig == SIGINT && is_error_reported()) { 2599 os::die(); 2600 } 2601 2602 os::signal_notify(sig); 2603 // We do not need to reinstate the signal handler each time... 2604 } 2605} 2606 2607void* os::user_handler() { 2608 return CAST_FROM_FN_PTR(void*, UserHandler); 2609} 2610 2611extern "C" { 2612 typedef void (*sa_handler_t)(int); 2613 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *); 2614} 2615 2616void* os::signal(int signal_number, void* handler) { 2617 struct sigaction sigAct, oldSigAct; 2618 sigfillset(&(sigAct.sa_mask)); 2619 sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND; 2620 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler); 2621 2622 if (sigaction(signal_number, &sigAct, &oldSigAct)) 2623 // -1 means registration failed 2624 return (void *)-1; 2625 2626 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler); 2627} 2628 2629void os::signal_raise(int signal_number) { 2630 raise(signal_number); 2631} 2632 2633/* 2634 * The following code is moved from os.cpp for making this 2635 * code platform specific, which it is by its very nature. 2636 */ 2637 2638// a counter for each possible signal value 2639static int Sigexit = 0; 2640static int Maxlibjsigsigs; 2641static jint *pending_signals = NULL; 2642static int *preinstalled_sigs = NULL; 2643static struct sigaction *chainedsigactions = NULL; 2644static sema_t sig_sem; 2645typedef int (*version_getting_t)(); 2646version_getting_t os::Solaris::get_libjsig_version = NULL; 2647static int libjsigversion = NULL; 2648 2649int os::sigexitnum_pd() { 2650 assert(Sigexit > 0, "signal memory not yet initialized"); 2651 return Sigexit; 2652} 2653 2654void os::Solaris::init_signal_mem() { 2655 // Initialize signal structures 2656 Maxsignum = SIGRTMAX; 2657 Sigexit = Maxsignum+1; 2658 assert(Maxsignum >0, "Unable to obtain max signal number"); 2659 2660 Maxlibjsigsigs = Maxsignum; 2661 2662 // pending_signals has one int per signal 2663 // The additional signal is for SIGEXIT - exit signal to signal_thread 2664 pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal); 2665 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1))); 2666 2667 if (UseSignalChaining) { 2668 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction) 2669 * (Maxsignum + 1), mtInternal); 2670 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1))); 2671 preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal); 2672 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1))); 2673 } 2674 ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ), mtInternal); 2675 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1)); 2676} 2677 2678void os::signal_init_pd() { 2679 int ret; 2680 2681 ret = ::sema_init(&sig_sem, 0, NULL, NULL); 2682 assert(ret == 0, "sema_init() failed"); 2683} 2684 2685void os::signal_notify(int signal_number) { 2686 int ret; 2687 2688 Atomic::inc(&pending_signals[signal_number]); 2689 ret = ::sema_post(&sig_sem); 2690 assert(ret == 0, "sema_post() failed"); 2691} 2692 2693static int check_pending_signals(bool wait_for_signal) { 2694 int ret; 2695 while (true) { 2696 for (int i = 0; i < Sigexit + 1; i++) { 2697 jint n = pending_signals[i]; 2698 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 2699 return i; 2700 } 2701 } 2702 if (!wait_for_signal) { 2703 return -1; 2704 } 2705 JavaThread *thread = JavaThread::current(); 2706 ThreadBlockInVM tbivm(thread); 2707 2708 bool threadIsSuspended; 2709 do { 2710 thread->set_suspend_equivalent(); 2711 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 2712 while((ret = ::sema_wait(&sig_sem)) == EINTR) 2713 ; 2714 assert(ret == 0, "sema_wait() failed"); 2715 2716 // were we externally suspended while we were waiting? 2717 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 2718 if (threadIsSuspended) { 2719 // 2720 // The semaphore has been incremented, but while we were waiting 2721 // another thread suspended us. We don't want to continue running 2722 // while suspended because that would surprise the thread that 2723 // suspended us. 2724 // 2725 ret = ::sema_post(&sig_sem); 2726 assert(ret == 0, "sema_post() failed"); 2727 2728 thread->java_suspend_self(); 2729 } 2730 } while (threadIsSuspended); 2731 } 2732} 2733 2734int os::signal_lookup() { 2735 return check_pending_signals(false); 2736} 2737 2738int os::signal_wait() { 2739 return check_pending_signals(true); 2740} 2741 2742//////////////////////////////////////////////////////////////////////////////// 2743// Virtual Memory 2744 2745static int page_size = -1; 2746 2747// The mmap MAP_ALIGN flag is supported on Solaris 9 and later. init_2() will 2748// clear this var if support is not available. 2749static bool has_map_align = true; 2750 2751int os::vm_page_size() { 2752 assert(page_size != -1, "must call os::init"); 2753 return page_size; 2754} 2755 2756// Solaris allocates memory by pages. 2757int os::vm_allocation_granularity() { 2758 assert(page_size != -1, "must call os::init"); 2759 return page_size; 2760} 2761 2762bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) { 2763 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; 2764 size_t size = bytes; 2765 char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot); 2766 if (res != NULL) { 2767 if (UseNUMAInterleaving) { 2768 numa_make_global(addr, bytes); 2769 } 2770 return true; 2771 } 2772 return false; 2773} 2774 2775bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint, 2776 bool exec) { 2777 if (commit_memory(addr, bytes, exec)) { 2778 if (UseMPSS && alignment_hint > (size_t)vm_page_size()) { 2779 // If the large page size has been set and the VM 2780 // is using large pages, use the large page size 2781 // if it is smaller than the alignment hint. This is 2782 // a case where the VM wants to use a larger alignment size 2783 // for its own reasons but still want to use large pages 2784 // (which is what matters to setting the mpss range. 2785 size_t page_size = 0; 2786 if (large_page_size() < alignment_hint) { 2787 assert(UseLargePages, "Expected to be here for large page use only"); 2788 page_size = large_page_size(); 2789 } else { 2790 // If the alignment hint is less than the large page 2791 // size, the VM wants a particular alignment (thus the hint) 2792 // for internal reasons. Try to set the mpss range using 2793 // the alignment_hint. 2794 page_size = alignment_hint; 2795 } 2796 // Since this is a hint, ignore any failures. 2797 (void)Solaris::set_mpss_range(addr, bytes, page_size); 2798 } 2799 return true; 2800 } 2801 return false; 2802} 2803 2804// Uncommit the pages in a specified region. 2805void os::pd_free_memory(char* addr, size_t bytes, size_t alignment_hint) { 2806 if (madvise(addr, bytes, MADV_FREE) < 0) { 2807 debug_only(warning("MADV_FREE failed.")); 2808 return; 2809 } 2810} 2811 2812bool os::pd_create_stack_guard_pages(char* addr, size_t size) { 2813 return os::commit_memory(addr, size); 2814} 2815 2816bool os::remove_stack_guard_pages(char* addr, size_t size) { 2817 return os::uncommit_memory(addr, size); 2818} 2819 2820// Change the page size in a given range. 2821void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { 2822 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned."); 2823 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned."); 2824 if (UseLargePages && UseMPSS) { 2825 Solaris::set_mpss_range(addr, bytes, alignment_hint); 2826 } 2827} 2828 2829// Tell the OS to make the range local to the first-touching LWP 2830void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { 2831 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned."); 2832 if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) { 2833 debug_only(warning("MADV_ACCESS_LWP failed.")); 2834 } 2835} 2836 2837// Tell the OS that this range would be accessed from different LWPs. 2838void os::numa_make_global(char *addr, size_t bytes) { 2839 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned."); 2840 if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) { 2841 debug_only(warning("MADV_ACCESS_MANY failed.")); 2842 } 2843} 2844 2845// Get the number of the locality groups. 2846size_t os::numa_get_groups_num() { 2847 size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie()); 2848 return n != -1 ? n : 1; 2849} 2850 2851// Get a list of leaf locality groups. A leaf lgroup is group that 2852// doesn't have any children. Typical leaf group is a CPU or a CPU/memory 2853// board. An LWP is assigned to one of these groups upon creation. 2854size_t os::numa_get_leaf_groups(int *ids, size_t size) { 2855 if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) { 2856 ids[0] = 0; 2857 return 1; 2858 } 2859 int result_size = 0, top = 1, bottom = 0, cur = 0; 2860 for (int k = 0; k < size; k++) { 2861 int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur], 2862 (Solaris::lgrp_id_t*)&ids[top], size - top); 2863 if (r == -1) { 2864 ids[0] = 0; 2865 return 1; 2866 } 2867 if (!r) { 2868 // That's a leaf node. 2869 assert (bottom <= cur, "Sanity check"); 2870 // Check if the node has memory 2871 if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur], 2872 NULL, 0, LGRP_RSRC_MEM) > 0) { 2873 ids[bottom++] = ids[cur]; 2874 } 2875 } 2876 top += r; 2877 cur++; 2878 } 2879 if (bottom == 0) { 2880 // Handle a situation, when the OS reports no memory available. 2881 // Assume UMA architecture. 2882 ids[0] = 0; 2883 return 1; 2884 } 2885 return bottom; 2886} 2887 2888// Detect the topology change. Typically happens during CPU plugging-unplugging. 2889bool os::numa_topology_changed() { 2890 int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie()); 2891 if (is_stale != -1 && is_stale) { 2892 Solaris::lgrp_fini(Solaris::lgrp_cookie()); 2893 Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER); 2894 assert(c != 0, "Failure to initialize LGRP API"); 2895 Solaris::set_lgrp_cookie(c); 2896 return true; 2897 } 2898 return false; 2899} 2900 2901// Get the group id of the current LWP. 2902int os::numa_get_group_id() { 2903 int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID); 2904 if (lgrp_id == -1) { 2905 return 0; 2906 } 2907 const int size = os::numa_get_groups_num(); 2908 int *ids = (int*)alloca(size * sizeof(int)); 2909 2910 // Get the ids of all lgroups with memory; r is the count. 2911 int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id, 2912 (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM); 2913 if (r <= 0) { 2914 return 0; 2915 } 2916 return ids[os::random() % r]; 2917} 2918 2919// Request information about the page. 2920bool os::get_page_info(char *start, page_info* info) { 2921 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE }; 2922 uint64_t addr = (uintptr_t)start; 2923 uint64_t outdata[2]; 2924 uint_t validity = 0; 2925 2926 if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) { 2927 return false; 2928 } 2929 2930 info->size = 0; 2931 info->lgrp_id = -1; 2932 2933 if ((validity & 1) != 0) { 2934 if ((validity & 2) != 0) { 2935 info->lgrp_id = outdata[0]; 2936 } 2937 if ((validity & 4) != 0) { 2938 info->size = outdata[1]; 2939 } 2940 return true; 2941 } 2942 return false; 2943} 2944 2945// Scan the pages from start to end until a page different than 2946// the one described in the info parameter is encountered. 2947char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 2948 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE }; 2949 const size_t types = sizeof(info_types) / sizeof(info_types[0]); 2950 uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT]; 2951 uint_t validity[MAX_MEMINFO_CNT]; 2952 2953 size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size); 2954 uint64_t p = (uint64_t)start; 2955 while (p < (uint64_t)end) { 2956 addrs[0] = p; 2957 size_t addrs_count = 1; 2958 while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] < (uint64_t)end) { 2959 addrs[addrs_count] = addrs[addrs_count - 1] + page_size; 2960 addrs_count++; 2961 } 2962 2963 if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) { 2964 return NULL; 2965 } 2966 2967 size_t i = 0; 2968 for (; i < addrs_count; i++) { 2969 if ((validity[i] & 1) != 0) { 2970 if ((validity[i] & 4) != 0) { 2971 if (outdata[types * i + 1] != page_expected->size) { 2972 break; 2973 } 2974 } else 2975 if (page_expected->size != 0) { 2976 break; 2977 } 2978 2979 if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) { 2980 if (outdata[types * i] != page_expected->lgrp_id) { 2981 break; 2982 } 2983 } 2984 } else { 2985 return NULL; 2986 } 2987 } 2988 2989 if (i != addrs_count) { 2990 if ((validity[i] & 2) != 0) { 2991 page_found->lgrp_id = outdata[types * i]; 2992 } else { 2993 page_found->lgrp_id = -1; 2994 } 2995 if ((validity[i] & 4) != 0) { 2996 page_found->size = outdata[types * i + 1]; 2997 } else { 2998 page_found->size = 0; 2999 } 3000 return (char*)addrs[i]; 3001 } 3002 3003 p = addrs[addrs_count - 1] + page_size; 3004 } 3005 return end; 3006} 3007 3008bool os::pd_uncommit_memory(char* addr, size_t bytes) { 3009 size_t size = bytes; 3010 // Map uncommitted pages PROT_NONE so we fail early if we touch an 3011 // uncommitted page. Otherwise, the read/write might succeed if we 3012 // have enough swap space to back the physical page. 3013 return 3014 NULL != Solaris::mmap_chunk(addr, size, 3015 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, 3016 PROT_NONE); 3017} 3018 3019char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) { 3020 char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0); 3021 3022 if (b == MAP_FAILED) { 3023 return NULL; 3024 } 3025 return b; 3026} 3027 3028char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) { 3029 char* addr = requested_addr; 3030 int flags = MAP_PRIVATE | MAP_NORESERVE; 3031 3032 assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap"); 3033 3034 if (fixed) { 3035 flags |= MAP_FIXED; 3036 } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) { 3037 flags |= MAP_ALIGN; 3038 addr = (char*) alignment_hint; 3039 } 3040 3041 // Map uncommitted pages PROT_NONE so we fail early if we touch an 3042 // uncommitted page. Otherwise, the read/write might succeed if we 3043 // have enough swap space to back the physical page. 3044 return mmap_chunk(addr, bytes, flags, PROT_NONE); 3045} 3046 3047char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { 3048 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL)); 3049 3050 guarantee(requested_addr == NULL || requested_addr == addr, 3051 "OS failed to return requested mmap address."); 3052 return addr; 3053} 3054 3055// Reserve memory at an arbitrary address, only if that area is 3056// available (and not reserved for something else). 3057 3058char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 3059 const int max_tries = 10; 3060 char* base[max_tries]; 3061 size_t size[max_tries]; 3062 3063 // Solaris adds a gap between mmap'ed regions. The size of the gap 3064 // is dependent on the requested size and the MMU. Our initial gap 3065 // value here is just a guess and will be corrected later. 3066 bool had_top_overlap = false; 3067 bool have_adjusted_gap = false; 3068 size_t gap = 0x400000; 3069 3070 // Assert only that the size is a multiple of the page size, since 3071 // that's all that mmap requires, and since that's all we really know 3072 // about at this low abstraction level. If we need higher alignment, 3073 // we can either pass an alignment to this method or verify alignment 3074 // in one of the methods further up the call chain. See bug 5044738. 3075 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block"); 3076 3077 // Since snv_84, Solaris attempts to honor the address hint - see 5003415. 3078 // Give it a try, if the kernel honors the hint we can return immediately. 3079 char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false); 3080 3081 volatile int err = errno; 3082 if (addr == requested_addr) { 3083 return addr; 3084 } else if (addr != NULL) { 3085 pd_unmap_memory(addr, bytes); 3086 } 3087 3088 if (PrintMiscellaneous && Verbose) { 3089 char buf[256]; 3090 buf[0] = '\0'; 3091 if (addr == NULL) { 3092 jio_snprintf(buf, sizeof(buf), ": %s", strerror(err)); 3093 } 3094 warning("attempt_reserve_memory_at: couldn't reserve " SIZE_FORMAT " bytes at " 3095 PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT 3096 "%s", bytes, requested_addr, addr, buf); 3097 } 3098 3099 // Address hint method didn't work. Fall back to the old method. 3100 // In theory, once SNV becomes our oldest supported platform, this 3101 // code will no longer be needed. 3102 // 3103 // Repeatedly allocate blocks until the block is allocated at the 3104 // right spot. Give up after max_tries. 3105 int i; 3106 for (i = 0; i < max_tries; ++i) { 3107 base[i] = reserve_memory(bytes); 3108 3109 if (base[i] != NULL) { 3110 // Is this the block we wanted? 3111 if (base[i] == requested_addr) { 3112 size[i] = bytes; 3113 break; 3114 } 3115 3116 // check that the gap value is right 3117 if (had_top_overlap && !have_adjusted_gap) { 3118 size_t actual_gap = base[i-1] - base[i] - bytes; 3119 if (gap != actual_gap) { 3120 // adjust the gap value and retry the last 2 allocations 3121 assert(i > 0, "gap adjustment code problem"); 3122 have_adjusted_gap = true; // adjust the gap only once, just in case 3123 gap = actual_gap; 3124 if (PrintMiscellaneous && Verbose) { 3125 warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap); 3126 } 3127 unmap_memory(base[i], bytes); 3128 unmap_memory(base[i-1], size[i-1]); 3129 i-=2; 3130 continue; 3131 } 3132 } 3133 3134 // Does this overlap the block we wanted? Give back the overlapped 3135 // parts and try again. 3136 // 3137 // There is still a bug in this code: if top_overlap == bytes, 3138 // the overlap is offset from requested region by the value of gap. 3139 // In this case giving back the overlapped part will not work, 3140 // because we'll give back the entire block at base[i] and 3141 // therefore the subsequent allocation will not generate a new gap. 3142 // This could be fixed with a new algorithm that used larger 3143 // or variable size chunks to find the requested region - 3144 // but such a change would introduce additional complications. 3145 // It's rare enough that the planets align for this bug, 3146 // so we'll just wait for a fix for 6204603/5003415 which 3147 // will provide a mmap flag to allow us to avoid this business. 3148 3149 size_t top_overlap = requested_addr + (bytes + gap) - base[i]; 3150 if (top_overlap >= 0 && top_overlap < bytes) { 3151 had_top_overlap = true; 3152 unmap_memory(base[i], top_overlap); 3153 base[i] += top_overlap; 3154 size[i] = bytes - top_overlap; 3155 } else { 3156 size_t bottom_overlap = base[i] + bytes - requested_addr; 3157 if (bottom_overlap >= 0 && bottom_overlap < bytes) { 3158 if (PrintMiscellaneous && Verbose && bottom_overlap == 0) { 3159 warning("attempt_reserve_memory_at: possible alignment bug"); 3160 } 3161 unmap_memory(requested_addr, bottom_overlap); 3162 size[i] = bytes - bottom_overlap; 3163 } else { 3164 size[i] = bytes; 3165 } 3166 } 3167 } 3168 } 3169 3170 // Give back the unused reserved pieces. 3171 3172 for (int j = 0; j < i; ++j) { 3173 if (base[j] != NULL) { 3174 unmap_memory(base[j], size[j]); 3175 } 3176 } 3177 3178 return (i < max_tries) ? requested_addr : NULL; 3179} 3180 3181bool os::pd_release_memory(char* addr, size_t bytes) { 3182 size_t size = bytes; 3183 return munmap(addr, size) == 0; 3184} 3185 3186static bool solaris_mprotect(char* addr, size_t bytes, int prot) { 3187 assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()), 3188 "addr must be page aligned"); 3189 int retVal = mprotect(addr, bytes, prot); 3190 return retVal == 0; 3191} 3192 3193// Protect memory (Used to pass readonly pages through 3194// JNI GetArray<type>Elements with empty arrays.) 3195// Also, used for serialization page and for compressed oops null pointer 3196// checking. 3197bool os::protect_memory(char* addr, size_t bytes, ProtType prot, 3198 bool is_committed) { 3199 unsigned int p = 0; 3200 switch (prot) { 3201 case MEM_PROT_NONE: p = PROT_NONE; break; 3202 case MEM_PROT_READ: p = PROT_READ; break; 3203 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break; 3204 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break; 3205 default: 3206 ShouldNotReachHere(); 3207 } 3208 // is_committed is unused. 3209 return solaris_mprotect(addr, bytes, p); 3210} 3211 3212// guard_memory and unguard_memory only happens within stack guard pages. 3213// Since ISM pertains only to the heap, guard and unguard memory should not 3214/// happen with an ISM region. 3215bool os::guard_memory(char* addr, size_t bytes) { 3216 return solaris_mprotect(addr, bytes, PROT_NONE); 3217} 3218 3219bool os::unguard_memory(char* addr, size_t bytes) { 3220 return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE); 3221} 3222 3223// Large page support 3224 3225// UseLargePages is the master flag to enable/disable large page memory. 3226// UseMPSS and UseISM are supported for compatibility reasons. Their combined 3227// effects can be described in the following table: 3228// 3229// UseLargePages UseMPSS UseISM 3230// false * * => UseLargePages is the master switch, turning 3231// it off will turn off both UseMPSS and 3232// UseISM. VM will not use large page memory 3233// regardless the settings of UseMPSS/UseISM. 3234// true false false => Unless future Solaris provides other 3235// mechanism to use large page memory, this 3236// combination is equivalent to -UseLargePages, 3237// VM will not use large page memory 3238// true true false => JVM will use MPSS for large page memory. 3239// This is the default behavior. 3240// true false true => JVM will use ISM for large page memory. 3241// true true true => JVM will use ISM if it is available. 3242// Otherwise, JVM will fall back to MPSS. 3243// Becaues ISM is now available on all 3244// supported Solaris versions, this combination 3245// is equivalent to +UseISM -UseMPSS. 3246 3247static size_t _large_page_size = 0; 3248 3249bool os::Solaris::ism_sanity_check(bool warn, size_t * page_size) { 3250 // x86 uses either 2M or 4M page, depending on whether PAE (Physical Address 3251 // Extensions) mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. Sparc 3252 // can support multiple page sizes. 3253 3254 // Don't bother to probe page size because getpagesizes() comes with MPSS. 3255 // ISM is only recommended on old Solaris where there is no MPSS support. 3256 // Simply choose a conservative value as default. 3257 *page_size = LargePageSizeInBytes ? LargePageSizeInBytes : 3258 SPARC_ONLY(4 * M) IA32_ONLY(4 * M) AMD64_ONLY(2 * M) 3259 ARM_ONLY(2 * M); 3260 3261 // ISM is available on all supported Solaris versions 3262 return true; 3263} 3264 3265// Insertion sort for small arrays (descending order). 3266static void insertion_sort_descending(size_t* array, int len) { 3267 for (int i = 0; i < len; i++) { 3268 size_t val = array[i]; 3269 for (size_t key = i; key > 0 && array[key - 1] < val; --key) { 3270 size_t tmp = array[key]; 3271 array[key] = array[key - 1]; 3272 array[key - 1] = tmp; 3273 } 3274 } 3275} 3276 3277bool os::Solaris::mpss_sanity_check(bool warn, size_t * page_size) { 3278 const unsigned int usable_count = VM_Version::page_size_count(); 3279 if (usable_count == 1) { 3280 return false; 3281 } 3282 3283 // Find the right getpagesizes interface. When solaris 11 is the minimum 3284 // build platform, getpagesizes() (without the '2') can be called directly. 3285 typedef int (*gps_t)(size_t[], int); 3286 gps_t gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes2")); 3287 if (gps_func == NULL) { 3288 gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes")); 3289 if (gps_func == NULL) { 3290 if (warn) { 3291 warning("MPSS is not supported by the operating system."); 3292 } 3293 return false; 3294 } 3295 } 3296 3297 // Fill the array of page sizes. 3298 int n = (*gps_func)(_page_sizes, page_sizes_max); 3299 assert(n > 0, "Solaris bug?"); 3300 3301 if (n == page_sizes_max) { 3302 // Add a sentinel value (necessary only if the array was completely filled 3303 // since it is static (zeroed at initialization)). 3304 _page_sizes[--n] = 0; 3305 DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");) 3306 } 3307 assert(_page_sizes[n] == 0, "missing sentinel"); 3308 trace_page_sizes("available page sizes", _page_sizes, n); 3309 3310 if (n == 1) return false; // Only one page size available. 3311 3312 // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and 3313 // select up to usable_count elements. First sort the array, find the first 3314 // acceptable value, then copy the usable sizes to the top of the array and 3315 // trim the rest. Make sure to include the default page size :-). 3316 // 3317 // A better policy could get rid of the 4M limit by taking the sizes of the 3318 // important VM memory regions (java heap and possibly the code cache) into 3319 // account. 3320 insertion_sort_descending(_page_sizes, n); 3321 const size_t size_limit = 3322 FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes; 3323 int beg; 3324 for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ; 3325 const int end = MIN2((int)usable_count, n) - 1; 3326 for (int cur = 0; cur < end; ++cur, ++beg) { 3327 _page_sizes[cur] = _page_sizes[beg]; 3328 } 3329 _page_sizes[end] = vm_page_size(); 3330 _page_sizes[end + 1] = 0; 3331 3332 if (_page_sizes[end] > _page_sizes[end - 1]) { 3333 // Default page size is not the smallest; sort again. 3334 insertion_sort_descending(_page_sizes, end + 1); 3335 } 3336 *page_size = _page_sizes[0]; 3337 3338 trace_page_sizes("usable page sizes", _page_sizes, end + 1); 3339 return true; 3340} 3341 3342void os::large_page_init() { 3343 if (!UseLargePages) { 3344 UseISM = false; 3345 UseMPSS = false; 3346 return; 3347 } 3348 3349 // print a warning if any large page related flag is specified on command line 3350 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || 3351 !FLAG_IS_DEFAULT(UseISM) || 3352 !FLAG_IS_DEFAULT(UseMPSS) || 3353 !FLAG_IS_DEFAULT(LargePageSizeInBytes); 3354 UseISM = UseISM && 3355 Solaris::ism_sanity_check(warn_on_failure, &_large_page_size); 3356 if (UseISM) { 3357 // ISM disables MPSS to be compatible with old JDK behavior 3358 UseMPSS = false; 3359 _page_sizes[0] = _large_page_size; 3360 _page_sizes[1] = vm_page_size(); 3361 } 3362 3363 UseMPSS = UseMPSS && 3364 Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size); 3365 3366 UseLargePages = UseISM || UseMPSS; 3367} 3368 3369bool os::Solaris::set_mpss_range(caddr_t start, size_t bytes, size_t align) { 3370 // Signal to OS that we want large pages for addresses 3371 // from addr, addr + bytes 3372 struct memcntl_mha mpss_struct; 3373 mpss_struct.mha_cmd = MHA_MAPSIZE_VA; 3374 mpss_struct.mha_pagesize = align; 3375 mpss_struct.mha_flags = 0; 3376 if (memcntl(start, bytes, MC_HAT_ADVISE, 3377 (caddr_t) &mpss_struct, 0, 0) < 0) { 3378 debug_only(warning("Attempt to use MPSS failed.")); 3379 return false; 3380 } 3381 return true; 3382} 3383 3384char* os::reserve_memory_special(size_t size, char* addr, bool exec) { 3385 // "exec" is passed in but not used. Creating the shared image for 3386 // the code cache doesn't have an SHM_X executable permission to check. 3387 assert(UseLargePages && UseISM, "only for ISM large pages"); 3388 3389 char* retAddr = NULL; 3390 int shmid; 3391 key_t ismKey; 3392 3393 bool warn_on_failure = UseISM && 3394 (!FLAG_IS_DEFAULT(UseLargePages) || 3395 !FLAG_IS_DEFAULT(UseISM) || 3396 !FLAG_IS_DEFAULT(LargePageSizeInBytes) 3397 ); 3398 char msg[128]; 3399 3400 ismKey = IPC_PRIVATE; 3401 3402 // Create a large shared memory region to attach to based on size. 3403 // Currently, size is the total size of the heap 3404 shmid = shmget(ismKey, size, SHM_R | SHM_W | IPC_CREAT); 3405 if (shmid == -1){ 3406 if (warn_on_failure) { 3407 jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno); 3408 warning(msg); 3409 } 3410 return NULL; 3411 } 3412 3413 // Attach to the region 3414 retAddr = (char *) shmat(shmid, 0, SHM_SHARE_MMU | SHM_R | SHM_W); 3415 int err = errno; 3416 3417 // Remove shmid. If shmat() is successful, the actual shared memory segment 3418 // will be deleted when it's detached by shmdt() or when the process 3419 // terminates. If shmat() is not successful this will remove the shared 3420 // segment immediately. 3421 shmctl(shmid, IPC_RMID, NULL); 3422 3423 if (retAddr == (char *) -1) { 3424 if (warn_on_failure) { 3425 jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err); 3426 warning(msg); 3427 } 3428 return NULL; 3429 } 3430 if ((retAddr != NULL) && UseNUMAInterleaving) { 3431 numa_make_global(retAddr, size); 3432 } 3433 return retAddr; 3434} 3435 3436bool os::release_memory_special(char* base, size_t bytes) { 3437 // detaching the SHM segment will also delete it, see reserve_memory_special() 3438 int rslt = shmdt(base); 3439 return rslt == 0; 3440} 3441 3442size_t os::large_page_size() { 3443 return _large_page_size; 3444} 3445 3446// MPSS allows application to commit large page memory on demand; with ISM 3447// the entire memory region must be allocated as shared memory. 3448bool os::can_commit_large_page_memory() { 3449 return UseISM ? false : true; 3450} 3451 3452bool os::can_execute_large_page_memory() { 3453 return UseISM ? false : true; 3454} 3455 3456static int os_sleep(jlong millis, bool interruptible) { 3457 const jlong limit = INT_MAX; 3458 jlong prevtime; 3459 int res; 3460 3461 while (millis > limit) { 3462 if ((res = os_sleep(limit, interruptible)) != OS_OK) 3463 return res; 3464 millis -= limit; 3465 } 3466 3467 // Restart interrupted polls with new parameters until the proper delay 3468 // has been completed. 3469 3470 prevtime = getTimeMillis(); 3471 3472 while (millis > 0) { 3473 jlong newtime; 3474 3475 if (!interruptible) { 3476 // Following assert fails for os::yield_all: 3477 // assert(!thread->is_Java_thread(), "must not be java thread"); 3478 res = poll(NULL, 0, millis); 3479 } else { 3480 JavaThread *jt = JavaThread::current(); 3481 3482 INTERRUPTIBLE_NORESTART_VM_ALWAYS(poll(NULL, 0, millis), res, jt, 3483 os::Solaris::clear_interrupted); 3484 } 3485 3486 // INTERRUPTIBLE_NORESTART_VM_ALWAYS returns res == OS_INTRPT for 3487 // thread.Interrupt. 3488 3489 // See c/r 6751923. Poll can return 0 before time 3490 // has elapsed if time is set via clock_settime (as NTP does). 3491 // res == 0 if poll timed out (see man poll RETURN VALUES) 3492 // using the logic below checks that we really did 3493 // sleep at least "millis" if not we'll sleep again. 3494 if( ( res == 0 ) || ((res == OS_ERR) && (errno == EINTR))) { 3495 newtime = getTimeMillis(); 3496 assert(newtime >= prevtime, "time moving backwards"); 3497 /* Doing prevtime and newtime in microseconds doesn't help precision, 3498 and trying to round up to avoid lost milliseconds can result in a 3499 too-short delay. */ 3500 millis -= newtime - prevtime; 3501 if(millis <= 0) 3502 return OS_OK; 3503 prevtime = newtime; 3504 } else 3505 return res; 3506 } 3507 3508 return OS_OK; 3509} 3510 3511// Read calls from inside the vm need to perform state transitions 3512size_t os::read(int fd, void *buf, unsigned int nBytes) { 3513 INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); 3514} 3515 3516size_t os::restartable_read(int fd, void *buf, unsigned int nBytes) { 3517 INTERRUPTIBLE_RETURN_INT(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); 3518} 3519 3520int os::sleep(Thread* thread, jlong millis, bool interruptible) { 3521 assert(thread == Thread::current(), "thread consistency check"); 3522 3523 // TODO-FIXME: this should be removed. 3524 // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock 3525 // situation with a JavaThread being starved out of a lwp. The kernel doesn't seem to generate 3526 // a SIGWAITING signal which would enable the threads library to create a new lwp for the starving 3527 // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel 3528 // is fooled into believing that the system is making progress. In the code below we block the 3529 // the watcher thread while safepoint is in progress so that it would not appear as though the 3530 // system is making progress. 3531 if (!Solaris::T2_libthread() && 3532 thread->is_Watcher_thread() && SafepointSynchronize::is_synchronizing() && !Arguments::has_profile()) { 3533 // We now try to acquire the threads lock. Since this lock is held by the VM thread during 3534 // the entire safepoint, the watcher thread will line up here during the safepoint. 3535 Threads_lock->lock_without_safepoint_check(); 3536 Threads_lock->unlock(); 3537 } 3538 3539 if (thread->is_Java_thread()) { 3540 // This is a JavaThread so we honor the _thread_blocked protocol 3541 // even for sleeps of 0 milliseconds. This was originally done 3542 // as a workaround for bug 4338139. However, now we also do it 3543 // to honor the suspend-equivalent protocol. 3544 3545 JavaThread *jt = (JavaThread *) thread; 3546 ThreadBlockInVM tbivm(jt); 3547 3548 jt->set_suspend_equivalent(); 3549 // cleared by handle_special_suspend_equivalent_condition() or 3550 // java_suspend_self() via check_and_wait_while_suspended() 3551 3552 int ret_code; 3553 if (millis <= 0) { 3554 thr_yield(); 3555 ret_code = 0; 3556 } else { 3557 // The original sleep() implementation did not create an 3558 // OSThreadWaitState helper for sleeps of 0 milliseconds. 3559 // I'm preserving that decision for now. 3560 OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */); 3561 3562 ret_code = os_sleep(millis, interruptible); 3563 } 3564 3565 // were we externally suspended while we were waiting? 3566 jt->check_and_wait_while_suspended(); 3567 3568 return ret_code; 3569 } 3570 3571 // non-JavaThread from this point on: 3572 3573 if (millis <= 0) { 3574 thr_yield(); 3575 return 0; 3576 } 3577 3578 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 3579 3580 return os_sleep(millis, interruptible); 3581} 3582 3583int os::naked_sleep() { 3584 // %% make the sleep time an integer flag. for now use 1 millisec. 3585 return os_sleep(1, false); 3586} 3587 3588// Sleep forever; naked call to OS-specific sleep; use with CAUTION 3589void os::infinite_sleep() { 3590 while (true) { // sleep forever ... 3591 ::sleep(100); // ... 100 seconds at a time 3592 } 3593} 3594 3595// Used to convert frequent JVM_Yield() to nops 3596bool os::dont_yield() { 3597 if (DontYieldALot) { 3598 static hrtime_t last_time = 0; 3599 hrtime_t diff = getTimeNanos() - last_time; 3600 3601 if (diff < DontYieldALotInterval * 1000000) 3602 return true; 3603 3604 last_time += diff; 3605 3606 return false; 3607 } 3608 else { 3609 return false; 3610 } 3611} 3612 3613// Caveat: Solaris os::yield() causes a thread-state transition whereas 3614// the linux and win32 implementations do not. This should be checked. 3615 3616void os::yield() { 3617 // Yields to all threads with same or greater priority 3618 os::sleep(Thread::current(), 0, false); 3619} 3620 3621// Note that yield semantics are defined by the scheduling class to which 3622// the thread currently belongs. Typically, yield will _not yield to 3623// other equal or higher priority threads that reside on the dispatch queues 3624// of other CPUs. 3625 3626os::YieldResult os::NakedYield() { thr_yield(); return os::YIELD_UNKNOWN; } 3627 3628 3629// On Solaris we found that yield_all doesn't always yield to all other threads. 3630// There have been cases where there is a thread ready to execute but it doesn't 3631// get an lwp as the VM thread continues to spin with sleeps of 1 millisecond. 3632// The 1 millisecond wait doesn't seem long enough for the kernel to issue a 3633// SIGWAITING signal which will cause a new lwp to be created. So we count the 3634// number of times yield_all is called in the one loop and increase the sleep 3635// time after 8 attempts. If this fails too we increase the concurrency level 3636// so that the starving thread would get an lwp 3637 3638void os::yield_all(int attempts) { 3639 // Yields to all threads, including threads with lower priorities 3640 if (attempts == 0) { 3641 os::sleep(Thread::current(), 1, false); 3642 } else { 3643 int iterations = attempts % 30; 3644 if (iterations == 0 && !os::Solaris::T2_libthread()) { 3645 // thr_setconcurrency and _getconcurrency make sense only under T1. 3646 int noofLWPS = thr_getconcurrency(); 3647 if (noofLWPS < (Threads::number_of_threads() + 2)) { 3648 thr_setconcurrency(thr_getconcurrency() + 1); 3649 } 3650 } else if (iterations < 25) { 3651 os::sleep(Thread::current(), 1, false); 3652 } else { 3653 os::sleep(Thread::current(), 10, false); 3654 } 3655 } 3656} 3657 3658// Called from the tight loops to possibly influence time-sharing heuristics 3659void os::loop_breaker(int attempts) { 3660 os::yield_all(attempts); 3661} 3662 3663 3664// Interface for setting lwp priorities. If we are using T2 libthread, 3665// which forces the use of BoundThreads or we manually set UseBoundThreads, 3666// all of our threads will be assigned to real lwp's. Using the thr_setprio 3667// function is meaningless in this mode so we must adjust the real lwp's priority 3668// The routines below implement the getting and setting of lwp priorities. 3669// 3670// Note: There are three priority scales used on Solaris. Java priotities 3671// which range from 1 to 10, libthread "thr_setprio" scale which range 3672// from 0 to 127, and the current scheduling class of the process we 3673// are running in. This is typically from -60 to +60. 3674// The setting of the lwp priorities in done after a call to thr_setprio 3675// so Java priorities are mapped to libthread priorities and we map from 3676// the latter to lwp priorities. We don't keep priorities stored in 3677// Java priorities since some of our worker threads want to set priorities 3678// higher than all Java threads. 3679// 3680// For related information: 3681// (1) man -s 2 priocntl 3682// (2) man -s 4 priocntl 3683// (3) man dispadmin 3684// = librt.so 3685// = libthread/common/rtsched.c - thrp_setlwpprio(). 3686// = ps -cL <pid> ... to validate priority. 3687// = sched_get_priority_min and _max 3688// pthread_create 3689// sched_setparam 3690// pthread_setschedparam 3691// 3692// Assumptions: 3693// + We assume that all threads in the process belong to the same 3694// scheduling class. IE. an homogenous process. 3695// + Must be root or in IA group to change change "interactive" attribute. 3696// Priocntl() will fail silently. The only indication of failure is when 3697// we read-back the value and notice that it hasn't changed. 3698// + Interactive threads enter the runq at the head, non-interactive at the tail. 3699// + For RT, change timeslice as well. Invariant: 3700// constant "priority integral" 3701// Konst == TimeSlice * (60-Priority) 3702// Given a priority, compute appropriate timeslice. 3703// + Higher numerical values have higher priority. 3704 3705// sched class attributes 3706typedef struct { 3707 int schedPolicy; // classID 3708 int maxPrio; 3709 int minPrio; 3710} SchedInfo; 3711 3712 3713static SchedInfo tsLimits, iaLimits, rtLimits, fxLimits; 3714 3715#ifdef ASSERT 3716static int ReadBackValidate = 1; 3717#endif 3718static int myClass = 0; 3719static int myMin = 0; 3720static int myMax = 0; 3721static int myCur = 0; 3722static bool priocntl_enable = false; 3723 3724static const int criticalPrio = 60; // FX/60 is critical thread class/priority on T4 3725static int java_MaxPriority_to_os_priority = 0; // Saved mapping 3726 3727// Call the version of priocntl suitable for all supported versions 3728// of Solaris. We need to call through this wrapper so that we can 3729// build on Solaris 9 and run on Solaris 8, 9 and 10. 3730// 3731// This code should be removed if we ever stop supporting Solaris 8 3732// and earlier releases. 3733 3734static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg); 3735typedef long (*priocntl_type)(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg); 3736static priocntl_type priocntl_ptr = priocntl_stub; 3737 3738// Stub to set the value of the real pointer, and then call the real 3739// function. 3740 3741static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg) { 3742 // Try Solaris 8- name only. 3743 priocntl_type tmp = (priocntl_type)dlsym(RTLD_DEFAULT, "__priocntl"); 3744 guarantee(tmp != NULL, "priocntl function not found."); 3745 priocntl_ptr = tmp; 3746 return (*priocntl_ptr)(PC_VERSION, idtype, id, cmd, arg); 3747} 3748 3749 3750// lwp_priocntl_init 3751// 3752// Try to determine the priority scale for our process. 3753// 3754// Return errno or 0 if OK. 3755// 3756static 3757int lwp_priocntl_init () 3758{ 3759 int rslt; 3760 pcinfo_t ClassInfo; 3761 pcparms_t ParmInfo; 3762 int i; 3763 3764 if (!UseThreadPriorities) return 0; 3765 3766 // We are using Bound threads, we need to determine our priority ranges 3767 if (os::Solaris::T2_libthread() || UseBoundThreads) { 3768 // If ThreadPriorityPolicy is 1, switch tables 3769 if (ThreadPriorityPolicy == 1) { 3770 for (i = 0 ; i < CriticalPriority+1; i++) 3771 os::java_to_os_priority[i] = prio_policy1[i]; 3772 } 3773 if (UseCriticalJavaThreadPriority) { 3774 // MaxPriority always maps to the FX scheduling class and criticalPrio. 3775 // See set_native_priority() and set_lwp_class_and_priority(). 3776 // Save original MaxPriority mapping in case attempt to 3777 // use critical priority fails. 3778 java_MaxPriority_to_os_priority = os::java_to_os_priority[MaxPriority]; 3779 // Set negative to distinguish from other priorities 3780 os::java_to_os_priority[MaxPriority] = -criticalPrio; 3781 } 3782 } 3783 // Not using Bound Threads, set to ThreadPolicy 1 3784 else { 3785 for ( i = 0 ; i < CriticalPriority+1; i++ ) { 3786 os::java_to_os_priority[i] = prio_policy1[i]; 3787 } 3788 return 0; 3789 } 3790 3791 // Get IDs for a set of well-known scheduling classes. 3792 // TODO-FIXME: GETCLINFO returns the current # of classes in the 3793 // the system. We should have a loop that iterates over the 3794 // classID values, which are known to be "small" integers. 3795 3796 strcpy(ClassInfo.pc_clname, "TS"); 3797 ClassInfo.pc_cid = -1; 3798 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3799 if (rslt < 0) return errno; 3800 assert(ClassInfo.pc_cid != -1, "cid for TS class is -1"); 3801 tsLimits.schedPolicy = ClassInfo.pc_cid; 3802 tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri; 3803 tsLimits.minPrio = -tsLimits.maxPrio; 3804 3805 strcpy(ClassInfo.pc_clname, "IA"); 3806 ClassInfo.pc_cid = -1; 3807 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3808 if (rslt < 0) return errno; 3809 assert(ClassInfo.pc_cid != -1, "cid for IA class is -1"); 3810 iaLimits.schedPolicy = ClassInfo.pc_cid; 3811 iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri; 3812 iaLimits.minPrio = -iaLimits.maxPrio; 3813 3814 strcpy(ClassInfo.pc_clname, "RT"); 3815 ClassInfo.pc_cid = -1; 3816 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3817 if (rslt < 0) return errno; 3818 assert(ClassInfo.pc_cid != -1, "cid for RT class is -1"); 3819 rtLimits.schedPolicy = ClassInfo.pc_cid; 3820 rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri; 3821 rtLimits.minPrio = 0; 3822 3823 strcpy(ClassInfo.pc_clname, "FX"); 3824 ClassInfo.pc_cid = -1; 3825 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3826 if (rslt < 0) return errno; 3827 assert(ClassInfo.pc_cid != -1, "cid for FX class is -1"); 3828 fxLimits.schedPolicy = ClassInfo.pc_cid; 3829 fxLimits.maxPrio = ((fxinfo_t*)ClassInfo.pc_clinfo)->fx_maxupri; 3830 fxLimits.minPrio = 0; 3831 3832 // Query our "current" scheduling class. 3833 // This will normally be IA, TS or, rarely, FX or RT. 3834 memset(&ParmInfo, 0, sizeof(ParmInfo)); 3835 ParmInfo.pc_cid = PC_CLNULL; 3836 rslt = (*priocntl_ptr) (PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo); 3837 if (rslt < 0) return errno; 3838 myClass = ParmInfo.pc_cid; 3839 3840 // We now know our scheduling classId, get specific information 3841 // about the class. 3842 ClassInfo.pc_cid = myClass; 3843 ClassInfo.pc_clname[0] = 0; 3844 rslt = (*priocntl_ptr) (PC_VERSION, (idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo); 3845 if (rslt < 0) return errno; 3846 3847 if (ThreadPriorityVerbose) { 3848 tty->print_cr("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname); 3849 } 3850 3851 memset(&ParmInfo, 0, sizeof(pcparms_t)); 3852 ParmInfo.pc_cid = PC_CLNULL; 3853 rslt = (*priocntl_ptr)(PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo); 3854 if (rslt < 0) return errno; 3855 3856 if (ParmInfo.pc_cid == rtLimits.schedPolicy) { 3857 myMin = rtLimits.minPrio; 3858 myMax = rtLimits.maxPrio; 3859 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) { 3860 iaparms_t *iaInfo = (iaparms_t*)ParmInfo.pc_clparms; 3861 myMin = iaLimits.minPrio; 3862 myMax = iaLimits.maxPrio; 3863 myMax = MIN2(myMax, (int)iaInfo->ia_uprilim); // clamp - restrict 3864 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) { 3865 tsparms_t *tsInfo = (tsparms_t*)ParmInfo.pc_clparms; 3866 myMin = tsLimits.minPrio; 3867 myMax = tsLimits.maxPrio; 3868 myMax = MIN2(myMax, (int)tsInfo->ts_uprilim); // clamp - restrict 3869 } else if (ParmInfo.pc_cid == fxLimits.schedPolicy) { 3870 fxparms_t *fxInfo = (fxparms_t*)ParmInfo.pc_clparms; 3871 myMin = fxLimits.minPrio; 3872 myMax = fxLimits.maxPrio; 3873 myMax = MIN2(myMax, (int)fxInfo->fx_uprilim); // clamp - restrict 3874 } else { 3875 // No clue - punt 3876 if (ThreadPriorityVerbose) 3877 tty->print_cr ("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname); 3878 return EINVAL; // no clue, punt 3879 } 3880 3881 if (ThreadPriorityVerbose) { 3882 tty->print_cr ("Thread priority Range: [%d..%d]\n", myMin, myMax); 3883 } 3884 3885 priocntl_enable = true; // Enable changing priorities 3886 return 0; 3887} 3888 3889#define IAPRI(x) ((iaparms_t *)((x).pc_clparms)) 3890#define RTPRI(x) ((rtparms_t *)((x).pc_clparms)) 3891#define TSPRI(x) ((tsparms_t *)((x).pc_clparms)) 3892#define FXPRI(x) ((fxparms_t *)((x).pc_clparms)) 3893 3894 3895// scale_to_lwp_priority 3896// 3897// Convert from the libthread "thr_setprio" scale to our current 3898// lwp scheduling class scale. 3899// 3900static 3901int scale_to_lwp_priority (int rMin, int rMax, int x) 3902{ 3903 int v; 3904 3905 if (x == 127) return rMax; // avoid round-down 3906 v = (((x*(rMax-rMin)))/128)+rMin; 3907 return v; 3908} 3909 3910 3911// set_lwp_class_and_priority 3912// 3913// Set the class and priority of the lwp. This call should only 3914// be made when using bound threads (T2 threads are bound by default). 3915// 3916int set_lwp_class_and_priority(int ThreadID, int lwpid, 3917 int newPrio, int new_class, bool scale) { 3918 int rslt; 3919 int Actual, Expected, prv; 3920 pcparms_t ParmInfo; // for GET-SET 3921#ifdef ASSERT 3922 pcparms_t ReadBack; // for readback 3923#endif 3924 3925 // Set priority via PC_GETPARMS, update, PC_SETPARMS 3926 // Query current values. 3927 // TODO: accelerate this by eliminating the PC_GETPARMS call. 3928 // Cache "pcparms_t" in global ParmCache. 3929 // TODO: elide set-to-same-value 3930 3931 // If something went wrong on init, don't change priorities. 3932 if ( !priocntl_enable ) { 3933 if (ThreadPriorityVerbose) 3934 tty->print_cr("Trying to set priority but init failed, ignoring"); 3935 return EINVAL; 3936 } 3937 3938 // If lwp hasn't started yet, just return 3939 // the _start routine will call us again. 3940 if ( lwpid <= 0 ) { 3941 if (ThreadPriorityVerbose) { 3942 tty->print_cr ("deferring the set_lwp_class_and_priority of thread " 3943 INTPTR_FORMAT " to %d, lwpid not set", 3944 ThreadID, newPrio); 3945 } 3946 return 0; 3947 } 3948 3949 if (ThreadPriorityVerbose) { 3950 tty->print_cr ("set_lwp_class_and_priority(" 3951 INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ", 3952 ThreadID, lwpid, newPrio); 3953 } 3954 3955 memset(&ParmInfo, 0, sizeof(pcparms_t)); 3956 ParmInfo.pc_cid = PC_CLNULL; 3957 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo); 3958 if (rslt < 0) return errno; 3959 3960 int cur_class = ParmInfo.pc_cid; 3961 ParmInfo.pc_cid = (id_t)new_class; 3962 3963 if (new_class == rtLimits.schedPolicy) { 3964 rtparms_t *rtInfo = (rtparms_t*)ParmInfo.pc_clparms; 3965 rtInfo->rt_pri = scale ? scale_to_lwp_priority(rtLimits.minPrio, 3966 rtLimits.maxPrio, newPrio) 3967 : newPrio; 3968 rtInfo->rt_tqsecs = RT_NOCHANGE; 3969 rtInfo->rt_tqnsecs = RT_NOCHANGE; 3970 if (ThreadPriorityVerbose) { 3971 tty->print_cr("RT: %d->%d\n", newPrio, rtInfo->rt_pri); 3972 } 3973 } else if (new_class == iaLimits.schedPolicy) { 3974 iaparms_t* iaInfo = (iaparms_t*)ParmInfo.pc_clparms; 3975 int maxClamped = MIN2(iaLimits.maxPrio, 3976 cur_class == new_class 3977 ? (int)iaInfo->ia_uprilim : iaLimits.maxPrio); 3978 iaInfo->ia_upri = scale ? scale_to_lwp_priority(iaLimits.minPrio, 3979 maxClamped, newPrio) 3980 : newPrio; 3981 iaInfo->ia_uprilim = cur_class == new_class 3982 ? IA_NOCHANGE : (pri_t)iaLimits.maxPrio; 3983 iaInfo->ia_mode = IA_NOCHANGE; 3984 if (ThreadPriorityVerbose) { 3985 tty->print_cr("IA: [%d...%d] %d->%d\n", 3986 iaLimits.minPrio, maxClamped, newPrio, iaInfo->ia_upri); 3987 } 3988 } else if (new_class == tsLimits.schedPolicy) { 3989 tsparms_t* tsInfo = (tsparms_t*)ParmInfo.pc_clparms; 3990 int maxClamped = MIN2(tsLimits.maxPrio, 3991 cur_class == new_class 3992 ? (int)tsInfo->ts_uprilim : tsLimits.maxPrio); 3993 tsInfo->ts_upri = scale ? scale_to_lwp_priority(tsLimits.minPrio, 3994 maxClamped, newPrio) 3995 : newPrio; 3996 tsInfo->ts_uprilim = cur_class == new_class 3997 ? TS_NOCHANGE : (pri_t)tsLimits.maxPrio; 3998 if (ThreadPriorityVerbose) { 3999 tty->print_cr("TS: [%d...%d] %d->%d\n", 4000 tsLimits.minPrio, maxClamped, newPrio, tsInfo->ts_upri); 4001 } 4002 } else if (new_class == fxLimits.schedPolicy) { 4003 fxparms_t* fxInfo = (fxparms_t*)ParmInfo.pc_clparms; 4004 int maxClamped = MIN2(fxLimits.maxPrio, 4005 cur_class == new_class 4006 ? (int)fxInfo->fx_uprilim : fxLimits.maxPrio); 4007 fxInfo->fx_upri = scale ? scale_to_lwp_priority(fxLimits.minPrio, 4008 maxClamped, newPrio) 4009 : newPrio; 4010 fxInfo->fx_uprilim = cur_class == new_class 4011 ? FX_NOCHANGE : (pri_t)fxLimits.maxPrio; 4012 fxInfo->fx_tqsecs = FX_NOCHANGE; 4013 fxInfo->fx_tqnsecs = FX_NOCHANGE; 4014 if (ThreadPriorityVerbose) { 4015 tty->print_cr("FX: [%d...%d] %d->%d\n", 4016 fxLimits.minPrio, maxClamped, newPrio, fxInfo->fx_upri); 4017 } 4018 } else { 4019 if (ThreadPriorityVerbose) { 4020 tty->print_cr("Unknown new scheduling class %d\n", new_class); 4021 } 4022 return EINVAL; // no clue, punt 4023 } 4024 4025 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_SETPARMS, (caddr_t)&ParmInfo); 4026 if (ThreadPriorityVerbose && rslt) { 4027 tty->print_cr ("PC_SETPARMS ->%d %d\n", rslt, errno); 4028 } 4029 if (rslt < 0) return errno; 4030 4031#ifdef ASSERT 4032 // Sanity check: read back what we just attempted to set. 4033 // In theory it could have changed in the interim ... 4034 // 4035 // The priocntl system call is tricky. 4036 // Sometimes it'll validate the priority value argument and 4037 // return EINVAL if unhappy. At other times it fails silently. 4038 // Readbacks are prudent. 4039 4040 if (!ReadBackValidate) return 0; 4041 4042 memset(&ReadBack, 0, sizeof(pcparms_t)); 4043 ReadBack.pc_cid = PC_CLNULL; 4044 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ReadBack); 4045 assert(rslt >= 0, "priocntl failed"); 4046 Actual = Expected = 0xBAD; 4047 assert(ParmInfo.pc_cid == ReadBack.pc_cid, "cid's don't match"); 4048 if (ParmInfo.pc_cid == rtLimits.schedPolicy) { 4049 Actual = RTPRI(ReadBack)->rt_pri; 4050 Expected = RTPRI(ParmInfo)->rt_pri; 4051 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) { 4052 Actual = IAPRI(ReadBack)->ia_upri; 4053 Expected = IAPRI(ParmInfo)->ia_upri; 4054 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) { 4055 Actual = TSPRI(ReadBack)->ts_upri; 4056 Expected = TSPRI(ParmInfo)->ts_upri; 4057 } else if (ParmInfo.pc_cid == fxLimits.schedPolicy) { 4058 Actual = FXPRI(ReadBack)->fx_upri; 4059 Expected = FXPRI(ParmInfo)->fx_upri; 4060 } else { 4061 if (ThreadPriorityVerbose) { 4062 tty->print_cr("set_lwp_class_and_priority: unexpected class in readback: %d\n", 4063 ParmInfo.pc_cid); 4064 } 4065 } 4066 4067 if (Actual != Expected) { 4068 if (ThreadPriorityVerbose) { 4069 tty->print_cr ("set_lwp_class_and_priority(%d %d) Class=%d: actual=%d vs expected=%d\n", 4070 lwpid, newPrio, ReadBack.pc_cid, Actual, Expected); 4071 } 4072 } 4073#endif 4074 4075 return 0; 4076} 4077 4078// Solaris only gives access to 128 real priorities at a time, 4079// so we expand Java's ten to fill this range. This would be better 4080// if we dynamically adjusted relative priorities. 4081// 4082// The ThreadPriorityPolicy option allows us to select 2 different 4083// priority scales. 4084// 4085// ThreadPriorityPolicy=0 4086// Since the Solaris' default priority is MaximumPriority, we do not 4087// set a priority lower than Max unless a priority lower than 4088// NormPriority is requested. 4089// 4090// ThreadPriorityPolicy=1 4091// This mode causes the priority table to get filled with 4092// linear values. NormPriority get's mapped to 50% of the 4093// Maximum priority an so on. This will cause VM threads 4094// to get unfair treatment against other Solaris processes 4095// which do not explicitly alter their thread priorities. 4096// 4097 4098int os::java_to_os_priority[CriticalPriority + 1] = { 4099 -99999, // 0 Entry should never be used 4100 4101 0, // 1 MinPriority 4102 32, // 2 4103 64, // 3 4104 4105 96, // 4 4106 127, // 5 NormPriority 4107 127, // 6 4108 4109 127, // 7 4110 127, // 8 4111 127, // 9 NearMaxPriority 4112 4113 127, // 10 MaxPriority 4114 4115 -criticalPrio // 11 CriticalPriority 4116}; 4117 4118OSReturn os::set_native_priority(Thread* thread, int newpri) { 4119 OSThread* osthread = thread->osthread(); 4120 4121 // Save requested priority in case the thread hasn't been started 4122 osthread->set_native_priority(newpri); 4123 4124 // Check for critical priority request 4125 bool fxcritical = false; 4126 if (newpri == -criticalPrio) { 4127 fxcritical = true; 4128 newpri = criticalPrio; 4129 } 4130 4131 assert(newpri >= MinimumPriority && newpri <= MaximumPriority, "bad priority mapping"); 4132 if (!UseThreadPriorities) return OS_OK; 4133 4134 int status = 0; 4135 4136 if (!fxcritical) { 4137 // Use thr_setprio only if we have a priority that thr_setprio understands 4138 status = thr_setprio(thread->osthread()->thread_id(), newpri); 4139 } 4140 4141 if (os::Solaris::T2_libthread() || 4142 (UseBoundThreads && osthread->is_vm_created())) { 4143 int lwp_status = 4144 set_lwp_class_and_priority(osthread->thread_id(), 4145 osthread->lwp_id(), 4146 newpri, 4147 fxcritical ? fxLimits.schedPolicy : myClass, 4148 !fxcritical); 4149 if (lwp_status != 0 && fxcritical) { 4150 // Try again, this time without changing the scheduling class 4151 newpri = java_MaxPriority_to_os_priority; 4152 lwp_status = set_lwp_class_and_priority(osthread->thread_id(), 4153 osthread->lwp_id(), 4154 newpri, myClass, false); 4155 } 4156 status |= lwp_status; 4157 } 4158 return (status == 0) ? OS_OK : OS_ERR; 4159} 4160 4161 4162OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) { 4163 int p; 4164 if ( !UseThreadPriorities ) { 4165 *priority_ptr = NormalPriority; 4166 return OS_OK; 4167 } 4168 int status = thr_getprio(thread->osthread()->thread_id(), &p); 4169 if (status != 0) { 4170 return OS_ERR; 4171 } 4172 *priority_ptr = p; 4173 return OS_OK; 4174} 4175 4176 4177// Hint to the underlying OS that a task switch would not be good. 4178// Void return because it's a hint and can fail. 4179void os::hint_no_preempt() { 4180 schedctl_start(schedctl_init()); 4181} 4182 4183void os::interrupt(Thread* thread) { 4184 assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer"); 4185 4186 OSThread* osthread = thread->osthread(); 4187 4188 int isInterrupted = osthread->interrupted(); 4189 if (!isInterrupted) { 4190 osthread->set_interrupted(true); 4191 OrderAccess::fence(); 4192 // os::sleep() is implemented with either poll (NULL,0,timeout) or 4193 // by parking on _SleepEvent. If the former, thr_kill will unwedge 4194 // the sleeper by SIGINTR, otherwise the unpark() will wake the sleeper. 4195 ParkEvent * const slp = thread->_SleepEvent ; 4196 if (slp != NULL) slp->unpark() ; 4197 } 4198 4199 // For JSR166: unpark after setting status but before thr_kill -dl 4200 if (thread->is_Java_thread()) { 4201 ((JavaThread*)thread)->parker()->unpark(); 4202 } 4203 4204 // Handle interruptible wait() ... 4205 ParkEvent * const ev = thread->_ParkEvent ; 4206 if (ev != NULL) ev->unpark() ; 4207 4208 // When events are used everywhere for os::sleep, then this thr_kill 4209 // will only be needed if UseVMInterruptibleIO is true. 4210 4211 if (!isInterrupted) { 4212 int status = thr_kill(osthread->thread_id(), os::Solaris::SIGinterrupt()); 4213 assert_status(status == 0, status, "thr_kill"); 4214 4215 // Bump thread interruption counter 4216 RuntimeService::record_thread_interrupt_signaled_count(); 4217 } 4218} 4219 4220 4221bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 4222 assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer"); 4223 4224 OSThread* osthread = thread->osthread(); 4225 4226 bool res = osthread->interrupted(); 4227 4228 // NOTE that since there is no "lock" around these two operations, 4229 // there is the possibility that the interrupted flag will be 4230 // "false" but that the interrupt event will be set. This is 4231 // intentional. The effect of this is that Object.wait() will appear 4232 // to have a spurious wakeup, which is not harmful, and the 4233 // possibility is so rare that it is not worth the added complexity 4234 // to add yet another lock. It has also been recommended not to put 4235 // the interrupted flag into the os::Solaris::Event structure, 4236 // because it hides the issue. 4237 if (res && clear_interrupted) { 4238 osthread->set_interrupted(false); 4239 } 4240 return res; 4241} 4242 4243 4244void os::print_statistics() { 4245} 4246 4247int os::message_box(const char* title, const char* message) { 4248 int i; 4249 fdStream err(defaultStream::error_fd()); 4250 for (i = 0; i < 78; i++) err.print_raw("="); 4251 err.cr(); 4252 err.print_raw_cr(title); 4253 for (i = 0; i < 78; i++) err.print_raw("-"); 4254 err.cr(); 4255 err.print_raw_cr(message); 4256 for (i = 0; i < 78; i++) err.print_raw("="); 4257 err.cr(); 4258 4259 char buf[16]; 4260 // Prevent process from exiting upon "read error" without consuming all CPU 4261 while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); } 4262 4263 return buf[0] == 'y' || buf[0] == 'Y'; 4264} 4265 4266// A lightweight implementation that does not suspend the target thread and 4267// thus returns only a hint. Used for profiling only! 4268ExtendedPC os::get_thread_pc(Thread* thread) { 4269 // Make sure that it is called by the watcher and the Threads lock is owned. 4270 assert(Thread::current()->is_Watcher_thread(), "Must be watcher and own Threads_lock"); 4271 // For now, is only used to profile the VM Thread 4272 assert(thread->is_VM_thread(), "Can only be called for VMThread"); 4273 ExtendedPC epc; 4274 4275 GetThreadPC_Callback cb(ProfileVM_lock); 4276 OSThread *osthread = thread->osthread(); 4277 const int time_to_wait = 400; // 400ms wait for initial response 4278 int status = cb.interrupt(thread, time_to_wait); 4279 4280 if (cb.is_done() ) { 4281 epc = cb.addr(); 4282 } else { 4283 DEBUG_ONLY(tty->print_cr("Failed to get pc for thread: %d got %d status", 4284 osthread->thread_id(), status);); 4285 // epc is already NULL 4286 } 4287 return epc; 4288} 4289 4290 4291// This does not do anything on Solaris. This is basically a hook for being 4292// able to use structured exception handling (thread-local exception filters) on, e.g., Win32. 4293void os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread) { 4294 f(value, method, args, thread); 4295} 4296 4297// This routine may be used by user applications as a "hook" to catch signals. 4298// The user-defined signal handler must pass unrecognized signals to this 4299// routine, and if it returns true (non-zero), then the signal handler must 4300// return immediately. If the flag "abort_if_unrecognized" is true, then this 4301// routine will never retun false (zero), but instead will execute a VM panic 4302// routine kill the process. 4303// 4304// If this routine returns false, it is OK to call it again. This allows 4305// the user-defined signal handler to perform checks either before or after 4306// the VM performs its own checks. Naturally, the user code would be making 4307// a serious error if it tried to handle an exception (such as a null check 4308// or breakpoint) that the VM was generating for its own correct operation. 4309// 4310// This routine may recognize any of the following kinds of signals: 4311// SIGBUS, SIGSEGV, SIGILL, SIGFPE, BREAK_SIGNAL, SIGPIPE, SIGXFSZ, 4312// os::Solaris::SIGasync 4313// It should be consulted by handlers for any of those signals. 4314// It explicitly does not recognize os::Solaris::SIGinterrupt 4315// 4316// The caller of this routine must pass in the three arguments supplied 4317// to the function referred to in the "sa_sigaction" (not the "sa_handler") 4318// field of the structure passed to sigaction(). This routine assumes that 4319// the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART. 4320// 4321// Note that the VM will print warnings if it detects conflicting signal 4322// handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers". 4323// 4324extern "C" JNIEXPORT int 4325JVM_handle_solaris_signal(int signo, siginfo_t* siginfo, void* ucontext, 4326 int abort_if_unrecognized); 4327 4328 4329void signalHandler(int sig, siginfo_t* info, void* ucVoid) { 4330 JVM_handle_solaris_signal(sig, info, ucVoid, true); 4331} 4332 4333/* Do not delete - if guarantee is ever removed, a signal handler (even empty) 4334 is needed to provoke threads blocked on IO to return an EINTR 4335 Note: this explicitly does NOT call JVM_handle_solaris_signal and 4336 does NOT participate in signal chaining due to requirement for 4337 NOT setting SA_RESTART to make EINTR work. */ 4338extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) { 4339 if (UseSignalChaining) { 4340 struct sigaction *actp = os::Solaris::get_chained_signal_action(sig); 4341 if (actp && actp->sa_handler) { 4342 vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs"); 4343 } 4344 } 4345} 4346 4347// This boolean allows users to forward their own non-matching signals 4348// to JVM_handle_solaris_signal, harmlessly. 4349bool os::Solaris::signal_handlers_are_installed = false; 4350 4351// For signal-chaining 4352bool os::Solaris::libjsig_is_loaded = false; 4353typedef struct sigaction *(*get_signal_t)(int); 4354get_signal_t os::Solaris::get_signal_action = NULL; 4355 4356struct sigaction* os::Solaris::get_chained_signal_action(int sig) { 4357 struct sigaction *actp = NULL; 4358 4359 if ((libjsig_is_loaded) && (sig <= Maxlibjsigsigs)) { 4360 // Retrieve the old signal handler from libjsig 4361 actp = (*get_signal_action)(sig); 4362 } 4363 if (actp == NULL) { 4364 // Retrieve the preinstalled signal handler from jvm 4365 actp = get_preinstalled_handler(sig); 4366 } 4367 4368 return actp; 4369} 4370 4371static bool call_chained_handler(struct sigaction *actp, int sig, 4372 siginfo_t *siginfo, void *context) { 4373 // Call the old signal handler 4374 if (actp->sa_handler == SIG_DFL) { 4375 // It's more reasonable to let jvm treat it as an unexpected exception 4376 // instead of taking the default action. 4377 return false; 4378 } else if (actp->sa_handler != SIG_IGN) { 4379 if ((actp->sa_flags & SA_NODEFER) == 0) { 4380 // automaticlly block the signal 4381 sigaddset(&(actp->sa_mask), sig); 4382 } 4383 4384 sa_handler_t hand; 4385 sa_sigaction_t sa; 4386 bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0; 4387 // retrieve the chained handler 4388 if (siginfo_flag_set) { 4389 sa = actp->sa_sigaction; 4390 } else { 4391 hand = actp->sa_handler; 4392 } 4393 4394 if ((actp->sa_flags & SA_RESETHAND) != 0) { 4395 actp->sa_handler = SIG_DFL; 4396 } 4397 4398 // try to honor the signal mask 4399 sigset_t oset; 4400 thr_sigsetmask(SIG_SETMASK, &(actp->sa_mask), &oset); 4401 4402 // call into the chained handler 4403 if (siginfo_flag_set) { 4404 (*sa)(sig, siginfo, context); 4405 } else { 4406 (*hand)(sig); 4407 } 4408 4409 // restore the signal mask 4410 thr_sigsetmask(SIG_SETMASK, &oset, 0); 4411 } 4412 // Tell jvm's signal handler the signal is taken care of. 4413 return true; 4414} 4415 4416bool os::Solaris::chained_handler(int sig, siginfo_t* siginfo, void* context) { 4417 bool chained = false; 4418 // signal-chaining 4419 if (UseSignalChaining) { 4420 struct sigaction *actp = get_chained_signal_action(sig); 4421 if (actp != NULL) { 4422 chained = call_chained_handler(actp, sig, siginfo, context); 4423 } 4424 } 4425 return chained; 4426} 4427 4428struct sigaction* os::Solaris::get_preinstalled_handler(int sig) { 4429 assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized"); 4430 if (preinstalled_sigs[sig] != 0) { 4431 return &chainedsigactions[sig]; 4432 } 4433 return NULL; 4434} 4435 4436void os::Solaris::save_preinstalled_handler(int sig, struct sigaction& oldAct) { 4437 4438 assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range"); 4439 assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized"); 4440 chainedsigactions[sig] = oldAct; 4441 preinstalled_sigs[sig] = 1; 4442} 4443 4444void os::Solaris::set_signal_handler(int sig, bool set_installed, bool oktochain) { 4445 // Check for overwrite. 4446 struct sigaction oldAct; 4447 sigaction(sig, (struct sigaction*)NULL, &oldAct); 4448 void* oldhand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 4449 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 4450 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) && 4451 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) && 4452 oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) { 4453 if (AllowUserSignalHandlers || !set_installed) { 4454 // Do not overwrite; user takes responsibility to forward to us. 4455 return; 4456 } else if (UseSignalChaining) { 4457 if (oktochain) { 4458 // save the old handler in jvm 4459 save_preinstalled_handler(sig, oldAct); 4460 } else { 4461 vm_exit_during_initialization("Signal chaining not allowed for VM interrupt signal, try -XX:+UseAltSigs."); 4462 } 4463 // libjsig also interposes the sigaction() call below and saves the 4464 // old sigaction on it own. 4465 } else { 4466 fatal(err_msg("Encountered unexpected pre-existing sigaction handler " 4467 "%#lx for signal %d.", (long)oldhand, sig)); 4468 } 4469 } 4470 4471 struct sigaction sigAct; 4472 sigfillset(&(sigAct.sa_mask)); 4473 sigAct.sa_handler = SIG_DFL; 4474 4475 sigAct.sa_sigaction = signalHandler; 4476 // Handle SIGSEGV on alternate signal stack if 4477 // not using stack banging 4478 if (!UseStackBanging && sig == SIGSEGV) { 4479 sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK; 4480 // Interruptible i/o requires SA_RESTART cleared so EINTR 4481 // is returned instead of restarting system calls 4482 } else if (sig == os::Solaris::SIGinterrupt()) { 4483 sigemptyset(&sigAct.sa_mask); 4484 sigAct.sa_handler = NULL; 4485 sigAct.sa_flags = SA_SIGINFO; 4486 sigAct.sa_sigaction = sigINTRHandler; 4487 } else { 4488 sigAct.sa_flags = SA_SIGINFO | SA_RESTART; 4489 } 4490 os::Solaris::set_our_sigflags(sig, sigAct.sa_flags); 4491 4492 sigaction(sig, &sigAct, &oldAct); 4493 4494 void* oldhand2 = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 4495 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 4496 assert(oldhand2 == oldhand, "no concurrent signal handler installation"); 4497} 4498 4499 4500#define DO_SIGNAL_CHECK(sig) \ 4501 if (!sigismember(&check_signal_done, sig)) \ 4502 os::Solaris::check_signal_handler(sig) 4503 4504// This method is a periodic task to check for misbehaving JNI applications 4505// under CheckJNI, we can add any periodic checks here 4506 4507void os::run_periodic_checks() { 4508 // A big source of grief is hijacking virt. addr 0x0 on Solaris, 4509 // thereby preventing a NULL checks. 4510 if(!check_addr0_done) check_addr0_done = check_addr0(tty); 4511 4512 if (check_signals == false) return; 4513 4514 // SEGV and BUS if overridden could potentially prevent 4515 // generation of hs*.log in the event of a crash, debugging 4516 // such a case can be very challenging, so we absolutely 4517 // check for the following for a good measure: 4518 DO_SIGNAL_CHECK(SIGSEGV); 4519 DO_SIGNAL_CHECK(SIGILL); 4520 DO_SIGNAL_CHECK(SIGFPE); 4521 DO_SIGNAL_CHECK(SIGBUS); 4522 DO_SIGNAL_CHECK(SIGPIPE); 4523 DO_SIGNAL_CHECK(SIGXFSZ); 4524 4525 // ReduceSignalUsage allows the user to override these handlers 4526 // see comments at the very top and jvm_solaris.h 4527 if (!ReduceSignalUsage) { 4528 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL); 4529 DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL); 4530 DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL); 4531 DO_SIGNAL_CHECK(BREAK_SIGNAL); 4532 } 4533 4534 // See comments above for using JVM1/JVM2 and UseAltSigs 4535 DO_SIGNAL_CHECK(os::Solaris::SIGinterrupt()); 4536 DO_SIGNAL_CHECK(os::Solaris::SIGasync()); 4537 4538} 4539 4540typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *); 4541 4542static os_sigaction_t os_sigaction = NULL; 4543 4544void os::Solaris::check_signal_handler(int sig) { 4545 char buf[O_BUFLEN]; 4546 address jvmHandler = NULL; 4547 4548 struct sigaction act; 4549 if (os_sigaction == NULL) { 4550 // only trust the default sigaction, in case it has been interposed 4551 os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction"); 4552 if (os_sigaction == NULL) return; 4553 } 4554 4555 os_sigaction(sig, (struct sigaction*)NULL, &act); 4556 4557 address thisHandler = (act.sa_flags & SA_SIGINFO) 4558 ? CAST_FROM_FN_PTR(address, act.sa_sigaction) 4559 : CAST_FROM_FN_PTR(address, act.sa_handler) ; 4560 4561 4562 switch(sig) { 4563 case SIGSEGV: 4564 case SIGBUS: 4565 case SIGFPE: 4566 case SIGPIPE: 4567 case SIGXFSZ: 4568 case SIGILL: 4569 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler); 4570 break; 4571 4572 case SHUTDOWN1_SIGNAL: 4573 case SHUTDOWN2_SIGNAL: 4574 case SHUTDOWN3_SIGNAL: 4575 case BREAK_SIGNAL: 4576 jvmHandler = (address)user_handler(); 4577 break; 4578 4579 default: 4580 int intrsig = os::Solaris::SIGinterrupt(); 4581 int asynsig = os::Solaris::SIGasync(); 4582 4583 if (sig == intrsig) { 4584 jvmHandler = CAST_FROM_FN_PTR(address, sigINTRHandler); 4585 } else if (sig == asynsig) { 4586 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler); 4587 } else { 4588 return; 4589 } 4590 break; 4591 } 4592 4593 4594 if (thisHandler != jvmHandler) { 4595 tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN)); 4596 tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN)); 4597 tty->print_cr(" found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN)); 4598 // No need to check this sig any longer 4599 sigaddset(&check_signal_done, sig); 4600 } else if(os::Solaris::get_our_sigflags(sig) != 0 && act.sa_flags != os::Solaris::get_our_sigflags(sig)) { 4601 tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN)); 4602 tty->print("expected:" PTR32_FORMAT, os::Solaris::get_our_sigflags(sig)); 4603 tty->print_cr(" found:" PTR32_FORMAT, act.sa_flags); 4604 // No need to check this sig any longer 4605 sigaddset(&check_signal_done, sig); 4606 } 4607 4608 // Print all the signal handler state 4609 if (sigismember(&check_signal_done, sig)) { 4610 print_signal_handlers(tty, buf, O_BUFLEN); 4611 } 4612 4613} 4614 4615void os::Solaris::install_signal_handlers() { 4616 bool libjsigdone = false; 4617 signal_handlers_are_installed = true; 4618 4619 // signal-chaining 4620 typedef void (*signal_setting_t)(); 4621 signal_setting_t begin_signal_setting = NULL; 4622 signal_setting_t end_signal_setting = NULL; 4623 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 4624 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting")); 4625 if (begin_signal_setting != NULL) { 4626 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 4627 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting")); 4628 get_signal_action = CAST_TO_FN_PTR(get_signal_t, 4629 dlsym(RTLD_DEFAULT, "JVM_get_signal_action")); 4630 get_libjsig_version = CAST_TO_FN_PTR(version_getting_t, 4631 dlsym(RTLD_DEFAULT, "JVM_get_libjsig_version")); 4632 libjsig_is_loaded = true; 4633 if (os::Solaris::get_libjsig_version != NULL) { 4634 libjsigversion = (*os::Solaris::get_libjsig_version)(); 4635 } 4636 assert(UseSignalChaining, "should enable signal-chaining"); 4637 } 4638 if (libjsig_is_loaded) { 4639 // Tell libjsig jvm is setting signal handlers 4640 (*begin_signal_setting)(); 4641 } 4642 4643 set_signal_handler(SIGSEGV, true, true); 4644 set_signal_handler(SIGPIPE, true, true); 4645 set_signal_handler(SIGXFSZ, true, true); 4646 set_signal_handler(SIGBUS, true, true); 4647 set_signal_handler(SIGILL, true, true); 4648 set_signal_handler(SIGFPE, true, true); 4649 4650 4651 if (os::Solaris::SIGinterrupt() > OLDMAXSIGNUM || os::Solaris::SIGasync() > OLDMAXSIGNUM) { 4652 4653 // Pre-1.4.1 Libjsig limited to signal chaining signals <= 32 so 4654 // can not register overridable signals which might be > 32 4655 if (libjsig_is_loaded && libjsigversion <= JSIG_VERSION_1_4_1) { 4656 // Tell libjsig jvm has finished setting signal handlers 4657 (*end_signal_setting)(); 4658 libjsigdone = true; 4659 } 4660 } 4661 4662 // Never ok to chain our SIGinterrupt 4663 set_signal_handler(os::Solaris::SIGinterrupt(), true, false); 4664 set_signal_handler(os::Solaris::SIGasync(), true, true); 4665 4666 if (libjsig_is_loaded && !libjsigdone) { 4667 // Tell libjsig jvm finishes setting signal handlers 4668 (*end_signal_setting)(); 4669 } 4670 4671 // We don't activate signal checker if libjsig is in place, we trust ourselves 4672 // and if UserSignalHandler is installed all bets are off. 4673 // Log that signal checking is off only if -verbose:jni is specified. 4674 if (CheckJNICalls) { 4675 if (libjsig_is_loaded) { 4676 if (PrintJNIResolving) { 4677 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled"); 4678 } 4679 check_signals = false; 4680 } 4681 if (AllowUserSignalHandlers) { 4682 if (PrintJNIResolving) { 4683 tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled"); 4684 } 4685 check_signals = false; 4686 } 4687 } 4688} 4689 4690 4691void report_error(const char* file_name, int line_no, const char* title, const char* format, ...); 4692 4693const char * signames[] = { 4694 "SIG0", 4695 "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", 4696 "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS", 4697 "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM", 4698 "SIGUSR1", "SIGUSR2", "SIGCLD", "SIGPWR", "SIGWINCH", 4699 "SIGURG", "SIGPOLL", "SIGSTOP", "SIGTSTP", "SIGCONT", 4700 "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU", 4701 "SIGXFSZ", "SIGWAITING", "SIGLWP", "SIGFREEZE", "SIGTHAW", 4702 "SIGCANCEL", "SIGLOST" 4703}; 4704 4705const char* os::exception_name(int exception_code, char* buf, size_t size) { 4706 if (0 < exception_code && exception_code <= SIGRTMAX) { 4707 // signal 4708 if (exception_code < sizeof(signames)/sizeof(const char*)) { 4709 jio_snprintf(buf, size, "%s", signames[exception_code]); 4710 } else { 4711 jio_snprintf(buf, size, "SIG%d", exception_code); 4712 } 4713 return buf; 4714 } else { 4715 return NULL; 4716 } 4717} 4718 4719// (Static) wrappers for the new libthread API 4720int_fnP_thread_t_iP_uP_stack_tP_gregset_t os::Solaris::_thr_getstate; 4721int_fnP_thread_t_i_gregset_t os::Solaris::_thr_setstate; 4722int_fnP_thread_t_i os::Solaris::_thr_setmutator; 4723int_fnP_thread_t os::Solaris::_thr_suspend_mutator; 4724int_fnP_thread_t os::Solaris::_thr_continue_mutator; 4725 4726// (Static) wrapper for getisax(2) call. 4727os::Solaris::getisax_func_t os::Solaris::_getisax = 0; 4728 4729// (Static) wrappers for the liblgrp API 4730os::Solaris::lgrp_home_func_t os::Solaris::_lgrp_home; 4731os::Solaris::lgrp_init_func_t os::Solaris::_lgrp_init; 4732os::Solaris::lgrp_fini_func_t os::Solaris::_lgrp_fini; 4733os::Solaris::lgrp_root_func_t os::Solaris::_lgrp_root; 4734os::Solaris::lgrp_children_func_t os::Solaris::_lgrp_children; 4735os::Solaris::lgrp_resources_func_t os::Solaris::_lgrp_resources; 4736os::Solaris::lgrp_nlgrps_func_t os::Solaris::_lgrp_nlgrps; 4737os::Solaris::lgrp_cookie_stale_func_t os::Solaris::_lgrp_cookie_stale; 4738os::Solaris::lgrp_cookie_t os::Solaris::_lgrp_cookie = 0; 4739 4740// (Static) wrapper for meminfo() call. 4741os::Solaris::meminfo_func_t os::Solaris::_meminfo = 0; 4742 4743static address resolve_symbol_lazy(const char* name) { 4744 address addr = (address) dlsym(RTLD_DEFAULT, name); 4745 if(addr == NULL) { 4746 // RTLD_DEFAULT was not defined on some early versions of 2.5.1 4747 addr = (address) dlsym(RTLD_NEXT, name); 4748 } 4749 return addr; 4750} 4751 4752static address resolve_symbol(const char* name) { 4753 address addr = resolve_symbol_lazy(name); 4754 if(addr == NULL) { 4755 fatal(dlerror()); 4756 } 4757 return addr; 4758} 4759 4760 4761 4762// isT2_libthread() 4763// 4764// Routine to determine if we are currently using the new T2 libthread. 4765// 4766// We determine if we are using T2 by reading /proc/self/lstatus and 4767// looking for a thread with the ASLWP bit set. If we find this status 4768// bit set, we must assume that we are NOT using T2. The T2 team 4769// has approved this algorithm. 4770// 4771// We need to determine if we are running with the new T2 libthread 4772// since setting native thread priorities is handled differently 4773// when using this library. All threads created using T2 are bound 4774// threads. Calling thr_setprio is meaningless in this case. 4775// 4776bool isT2_libthread() { 4777 static prheader_t * lwpArray = NULL; 4778 static int lwpSize = 0; 4779 static int lwpFile = -1; 4780 lwpstatus_t * that; 4781 char lwpName [128]; 4782 bool isT2 = false; 4783 4784#define ADR(x) ((uintptr_t)(x)) 4785#define LWPINDEX(ary,ix) ((lwpstatus_t *)(((ary)->pr_entsize * (ix)) + (ADR((ary) + 1)))) 4786 4787 lwpFile = ::open("/proc/self/lstatus", O_RDONLY, 0); 4788 if (lwpFile < 0) { 4789 if (ThreadPriorityVerbose) warning ("Couldn't open /proc/self/lstatus\n"); 4790 return false; 4791 } 4792 lwpSize = 16*1024; 4793 for (;;) { 4794 ::lseek64 (lwpFile, 0, SEEK_SET); 4795 lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize, mtInternal); 4796 if (::read(lwpFile, lwpArray, lwpSize) < 0) { 4797 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n"); 4798 break; 4799 } 4800 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) { 4801 // We got a good snapshot - now iterate over the list. 4802 int aslwpcount = 0; 4803 for (int i = 0; i < lwpArray->pr_nent; i++ ) { 4804 that = LWPINDEX(lwpArray,i); 4805 if (that->pr_flags & PR_ASLWP) { 4806 aslwpcount++; 4807 } 4808 } 4809 if (aslwpcount == 0) isT2 = true; 4810 break; 4811 } 4812 lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize; 4813 FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal); // retry. 4814 } 4815 4816 FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal); 4817 ::close (lwpFile); 4818 if (ThreadPriorityVerbose) { 4819 if (isT2) tty->print_cr("We are running with a T2 libthread\n"); 4820 else tty->print_cr("We are not running with a T2 libthread\n"); 4821 } 4822 return isT2; 4823} 4824 4825 4826void os::Solaris::libthread_init() { 4827 address func = (address)dlsym(RTLD_DEFAULT, "_thr_suspend_allmutators"); 4828 4829 // Determine if we are running with the new T2 libthread 4830 os::Solaris::set_T2_libthread(isT2_libthread()); 4831 4832 lwp_priocntl_init(); 4833 4834 // RTLD_DEFAULT was not defined on some early versions of 5.5.1 4835 if(func == NULL) { 4836 func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators"); 4837 // Guarantee that this VM is running on an new enough OS (5.6 or 4838 // later) that it will have a new enough libthread.so. 4839 guarantee(func != NULL, "libthread.so is too old."); 4840 } 4841 4842 // Initialize the new libthread getstate API wrappers 4843 func = resolve_symbol("thr_getstate"); 4844 os::Solaris::set_thr_getstate(CAST_TO_FN_PTR(int_fnP_thread_t_iP_uP_stack_tP_gregset_t, func)); 4845 4846 func = resolve_symbol("thr_setstate"); 4847 os::Solaris::set_thr_setstate(CAST_TO_FN_PTR(int_fnP_thread_t_i_gregset_t, func)); 4848 4849 func = resolve_symbol("thr_setmutator"); 4850 os::Solaris::set_thr_setmutator(CAST_TO_FN_PTR(int_fnP_thread_t_i, func)); 4851 4852 func = resolve_symbol("thr_suspend_mutator"); 4853 os::Solaris::set_thr_suspend_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func)); 4854 4855 func = resolve_symbol("thr_continue_mutator"); 4856 os::Solaris::set_thr_continue_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func)); 4857 4858 int size; 4859 void (*handler_info_func)(address *, int *); 4860 handler_info_func = CAST_TO_FN_PTR(void (*)(address *, int *), resolve_symbol("thr_sighndlrinfo")); 4861 handler_info_func(&handler_start, &size); 4862 handler_end = handler_start + size; 4863} 4864 4865 4866int_fnP_mutex_tP os::Solaris::_mutex_lock; 4867int_fnP_mutex_tP os::Solaris::_mutex_trylock; 4868int_fnP_mutex_tP os::Solaris::_mutex_unlock; 4869int_fnP_mutex_tP_i_vP os::Solaris::_mutex_init; 4870int_fnP_mutex_tP os::Solaris::_mutex_destroy; 4871int os::Solaris::_mutex_scope = USYNC_THREAD; 4872 4873int_fnP_cond_tP_mutex_tP_timestruc_tP os::Solaris::_cond_timedwait; 4874int_fnP_cond_tP_mutex_tP os::Solaris::_cond_wait; 4875int_fnP_cond_tP os::Solaris::_cond_signal; 4876int_fnP_cond_tP os::Solaris::_cond_broadcast; 4877int_fnP_cond_tP_i_vP os::Solaris::_cond_init; 4878int_fnP_cond_tP os::Solaris::_cond_destroy; 4879int os::Solaris::_cond_scope = USYNC_THREAD; 4880 4881void os::Solaris::synchronization_init() { 4882 if(UseLWPSynchronization) { 4883 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock"))); 4884 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock"))); 4885 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock"))); 4886 os::Solaris::set_mutex_init(lwp_mutex_init); 4887 os::Solaris::set_mutex_destroy(lwp_mutex_destroy); 4888 os::Solaris::set_mutex_scope(USYNC_THREAD); 4889 4890 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("_lwp_cond_timedwait"))); 4891 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("_lwp_cond_wait"))); 4892 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal"))); 4893 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast"))); 4894 os::Solaris::set_cond_init(lwp_cond_init); 4895 os::Solaris::set_cond_destroy(lwp_cond_destroy); 4896 os::Solaris::set_cond_scope(USYNC_THREAD); 4897 } 4898 else { 4899 os::Solaris::set_mutex_scope(USYNC_THREAD); 4900 os::Solaris::set_cond_scope(USYNC_THREAD); 4901 4902 if(UsePthreads) { 4903 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock"))); 4904 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock"))); 4905 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock"))); 4906 os::Solaris::set_mutex_init(pthread_mutex_default_init); 4907 os::Solaris::set_mutex_destroy(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_destroy"))); 4908 4909 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("pthread_cond_timedwait"))); 4910 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait"))); 4911 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal"))); 4912 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast"))); 4913 os::Solaris::set_cond_init(pthread_cond_default_init); 4914 os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy"))); 4915 } 4916 else { 4917 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock"))); 4918 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock"))); 4919 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock"))); 4920 os::Solaris::set_mutex_init(::mutex_init); 4921 os::Solaris::set_mutex_destroy(::mutex_destroy); 4922 4923 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("cond_timedwait"))); 4924 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("cond_wait"))); 4925 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_signal"))); 4926 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_broadcast"))); 4927 os::Solaris::set_cond_init(::cond_init); 4928 os::Solaris::set_cond_destroy(::cond_destroy); 4929 } 4930 } 4931} 4932 4933bool os::Solaris::liblgrp_init() { 4934 void *handle = dlopen("liblgrp.so.1", RTLD_LAZY); 4935 if (handle != NULL) { 4936 os::Solaris::set_lgrp_home(CAST_TO_FN_PTR(lgrp_home_func_t, dlsym(handle, "lgrp_home"))); 4937 os::Solaris::set_lgrp_init(CAST_TO_FN_PTR(lgrp_init_func_t, dlsym(handle, "lgrp_init"))); 4938 os::Solaris::set_lgrp_fini(CAST_TO_FN_PTR(lgrp_fini_func_t, dlsym(handle, "lgrp_fini"))); 4939 os::Solaris::set_lgrp_root(CAST_TO_FN_PTR(lgrp_root_func_t, dlsym(handle, "lgrp_root"))); 4940 os::Solaris::set_lgrp_children(CAST_TO_FN_PTR(lgrp_children_func_t, dlsym(handle, "lgrp_children"))); 4941 os::Solaris::set_lgrp_resources(CAST_TO_FN_PTR(lgrp_resources_func_t, dlsym(handle, "lgrp_resources"))); 4942 os::Solaris::set_lgrp_nlgrps(CAST_TO_FN_PTR(lgrp_nlgrps_func_t, dlsym(handle, "lgrp_nlgrps"))); 4943 os::Solaris::set_lgrp_cookie_stale(CAST_TO_FN_PTR(lgrp_cookie_stale_func_t, 4944 dlsym(handle, "lgrp_cookie_stale"))); 4945 4946 lgrp_cookie_t c = lgrp_init(LGRP_VIEW_CALLER); 4947 set_lgrp_cookie(c); 4948 return true; 4949 } 4950 return false; 4951} 4952 4953void os::Solaris::misc_sym_init() { 4954 address func; 4955 4956 // getisax 4957 func = resolve_symbol_lazy("getisax"); 4958 if (func != NULL) { 4959 os::Solaris::_getisax = CAST_TO_FN_PTR(getisax_func_t, func); 4960 } 4961 4962 // meminfo 4963 func = resolve_symbol_lazy("meminfo"); 4964 if (func != NULL) { 4965 os::Solaris::set_meminfo(CAST_TO_FN_PTR(meminfo_func_t, func)); 4966 } 4967} 4968 4969uint_t os::Solaris::getisax(uint32_t* array, uint_t n) { 4970 assert(_getisax != NULL, "_getisax not set"); 4971 return _getisax(array, n); 4972} 4973 4974// Symbol doesn't exist in Solaris 8 pset.h 4975#ifndef PS_MYID 4976#define PS_MYID -3 4977#endif 4978 4979// int pset_getloadavg(psetid_t pset, double loadavg[], int nelem); 4980typedef long (*pset_getloadavg_type)(psetid_t pset, double loadavg[], int nelem); 4981static pset_getloadavg_type pset_getloadavg_ptr = NULL; 4982 4983void init_pset_getloadavg_ptr(void) { 4984 pset_getloadavg_ptr = 4985 (pset_getloadavg_type)dlsym(RTLD_DEFAULT, "pset_getloadavg"); 4986 if (PrintMiscellaneous && Verbose && pset_getloadavg_ptr == NULL) { 4987 warning("pset_getloadavg function not found"); 4988 } 4989} 4990 4991int os::Solaris::_dev_zero_fd = -1; 4992 4993// this is called _before_ the global arguments have been parsed 4994void os::init(void) { 4995 _initial_pid = getpid(); 4996 4997 max_hrtime = first_hrtime = gethrtime(); 4998 4999 init_random(1234567); 5000 5001 page_size = sysconf(_SC_PAGESIZE); 5002 if (page_size == -1) 5003 fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)", 5004 strerror(errno))); 5005 init_page_sizes((size_t) page_size); 5006 5007 Solaris::initialize_system_info(); 5008 5009 // Initialize misc. symbols as soon as possible, so we can use them 5010 // if we need them. 5011 Solaris::misc_sym_init(); 5012 5013 int fd = ::open("/dev/zero", O_RDWR); 5014 if (fd < 0) { 5015 fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno))); 5016 } else { 5017 Solaris::set_dev_zero_fd(fd); 5018 5019 // Close on exec, child won't inherit. 5020 fcntl(fd, F_SETFD, FD_CLOEXEC); 5021 } 5022 5023 clock_tics_per_sec = CLK_TCK; 5024 5025 // check if dladdr1() exists; dladdr1 can provide more information than 5026 // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9 5027 // and is available on linker patches for 5.7 and 5.8. 5028 // libdl.so must have been loaded, this call is just an entry lookup 5029 void * hdl = dlopen("libdl.so", RTLD_NOW); 5030 if (hdl) 5031 dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1")); 5032 5033 // (Solaris only) this switches to calls that actually do locking. 5034 ThreadCritical::initialize(); 5035 5036 main_thread = thr_self(); 5037 5038 // Constant minimum stack size allowed. It must be at least 5039 // the minimum of what the OS supports (thr_min_stack()), and 5040 // enough to allow the thread to get to user bytecode execution. 5041 Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed); 5042 // If the pagesize of the VM is greater than 8K determine the appropriate 5043 // number of initial guard pages. The user can change this with the 5044 // command line arguments, if needed. 5045 if (vm_page_size() > 8*K) { 5046 StackYellowPages = 1; 5047 StackRedPages = 1; 5048 StackShadowPages = round_to((StackShadowPages*8*K), vm_page_size()) / vm_page_size(); 5049 } 5050} 5051 5052// To install functions for atexit system call 5053extern "C" { 5054 static void perfMemory_exit_helper() { 5055 perfMemory_exit(); 5056 } 5057} 5058 5059// this is called _after_ the global arguments have been parsed 5060jint os::init_2(void) { 5061 // try to enable extended file IO ASAP, see 6431278 5062 os::Solaris::try_enable_extended_io(); 5063 5064 // Allocate a single page and mark it as readable for safepoint polling. Also 5065 // use this first mmap call to check support for MAP_ALIGN. 5066 address polling_page = (address)Solaris::mmap_chunk((char*)page_size, 5067 page_size, 5068 MAP_PRIVATE | MAP_ALIGN, 5069 PROT_READ); 5070 if (polling_page == NULL) { 5071 has_map_align = false; 5072 polling_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE, 5073 PROT_READ); 5074 } 5075 5076 os::set_polling_page(polling_page); 5077 5078#ifndef PRODUCT 5079 if( Verbose && PrintMiscellaneous ) 5080 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page); 5081#endif 5082 5083 if (!UseMembar) { 5084 address mem_serialize_page = (address)Solaris::mmap_chunk( NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE ); 5085 guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page"); 5086 os::set_memory_serialize_page( mem_serialize_page ); 5087 5088#ifndef PRODUCT 5089 if(Verbose && PrintMiscellaneous) 5090 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page); 5091#endif 5092} 5093 5094 os::large_page_init(); 5095 5096 // Check minimum allowable stack size for thread creation and to initialize 5097 // the java system classes, including StackOverflowError - depends on page 5098 // size. Add a page for compiler2 recursion in main thread. 5099 // Add in 2*BytesPerWord times page size to account for VM stack during 5100 // class initialization depending on 32 or 64 bit VM. 5101 os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed, 5102 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ 5103 2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size); 5104 5105 size_t threadStackSizeInBytes = ThreadStackSize * K; 5106 if (threadStackSizeInBytes != 0 && 5107 threadStackSizeInBytes < os::Solaris::min_stack_allowed) { 5108 tty->print_cr("\nThe stack size specified is too small, Specify at least %dk", 5109 os::Solaris::min_stack_allowed/K); 5110 return JNI_ERR; 5111 } 5112 5113 // For 64kbps there will be a 64kb page size, which makes 5114 // the usable default stack size quite a bit less. Increase the 5115 // stack for 64kb (or any > than 8kb) pages, this increases 5116 // virtual memory fragmentation (since we're not creating the 5117 // stack on a power of 2 boundary. The real fix for this 5118 // should be to fix the guard page mechanism. 5119 5120 if (vm_page_size() > 8*K) { 5121 threadStackSizeInBytes = (threadStackSizeInBytes != 0) 5122 ? threadStackSizeInBytes + 5123 ((StackYellowPages + StackRedPages) * vm_page_size()) 5124 : 0; 5125 ThreadStackSize = threadStackSizeInBytes/K; 5126 } 5127 5128 // Make the stack size a multiple of the page size so that 5129 // the yellow/red zones can be guarded. 5130 JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, 5131 vm_page_size())); 5132 5133 Solaris::libthread_init(); 5134 5135 if (UseNUMA) { 5136 if (!Solaris::liblgrp_init()) { 5137 UseNUMA = false; 5138 } else { 5139 size_t lgrp_limit = os::numa_get_groups_num(); 5140 int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtInternal); 5141 size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit); 5142 FREE_C_HEAP_ARRAY(int, lgrp_ids, mtInternal); 5143 if (lgrp_num < 2) { 5144 // There's only one locality group, disable NUMA. 5145 UseNUMA = false; 5146 } 5147 } 5148 // ISM is not compatible with the NUMA allocator - it always allocates 5149 // pages round-robin across the lgroups. 5150 if (UseNUMA && UseLargePages && UseISM) { 5151 if (!FLAG_IS_DEFAULT(UseNUMA)) { 5152 if (FLAG_IS_DEFAULT(UseLargePages) && FLAG_IS_DEFAULT(UseISM)) { 5153 UseLargePages = false; 5154 } else { 5155 warning("UseNUMA is not compatible with ISM large pages, disabling NUMA allocator"); 5156 UseNUMA = false; 5157 } 5158 } else { 5159 UseNUMA = false; 5160 } 5161 } 5162 if (!UseNUMA && ForceNUMA) { 5163 UseNUMA = true; 5164 } 5165 } 5166 5167 Solaris::signal_sets_init(); 5168 Solaris::init_signal_mem(); 5169 Solaris::install_signal_handlers(); 5170 5171 if (libjsigversion < JSIG_VERSION_1_4_1) { 5172 Maxlibjsigsigs = OLDMAXSIGNUM; 5173 } 5174 5175 // initialize synchronization primitives to use either thread or 5176 // lwp synchronization (controlled by UseLWPSynchronization) 5177 Solaris::synchronization_init(); 5178 5179 if (MaxFDLimit) { 5180 // set the number of file descriptors to max. print out error 5181 // if getrlimit/setrlimit fails but continue regardless. 5182 struct rlimit nbr_files; 5183 int status = getrlimit(RLIMIT_NOFILE, &nbr_files); 5184 if (status != 0) { 5185 if (PrintMiscellaneous && (Verbose || WizardMode)) 5186 perror("os::init_2 getrlimit failed"); 5187 } else { 5188 nbr_files.rlim_cur = nbr_files.rlim_max; 5189 status = setrlimit(RLIMIT_NOFILE, &nbr_files); 5190 if (status != 0) { 5191 if (PrintMiscellaneous && (Verbose || WizardMode)) 5192 perror("os::init_2 setrlimit failed"); 5193 } 5194 } 5195 } 5196 5197 // Calculate theoretical max. size of Threads to guard gainst 5198 // artifical out-of-memory situations, where all available address- 5199 // space has been reserved by thread stacks. Default stack size is 1Mb. 5200 size_t pre_thread_stack_size = (JavaThread::stack_size_at_create()) ? 5201 JavaThread::stack_size_at_create() : (1*K*K); 5202 assert(pre_thread_stack_size != 0, "Must have a stack"); 5203 // Solaris has a maximum of 4Gb of user programs. Calculate the thread limit when 5204 // we should start doing Virtual Memory banging. Currently when the threads will 5205 // have used all but 200Mb of space. 5206 size_t max_address_space = ((unsigned int)4 * K * K * K) - (200 * K * K); 5207 Solaris::_os_thread_limit = max_address_space / pre_thread_stack_size; 5208 5209 // at-exit methods are called in the reverse order of their registration. 5210 // In Solaris 7 and earlier, atexit functions are called on return from 5211 // main or as a result of a call to exit(3C). There can be only 32 of 5212 // these functions registered and atexit() does not set errno. In Solaris 5213 // 8 and later, there is no limit to the number of functions registered 5214 // and atexit() sets errno. In addition, in Solaris 8 and later, atexit 5215 // functions are called upon dlclose(3DL) in addition to return from main 5216 // and exit(3C). 5217 5218 if (PerfAllowAtExitRegistration) { 5219 // only register atexit functions if PerfAllowAtExitRegistration is set. 5220 // atexit functions can be delayed until process exit time, which 5221 // can be problematic for embedded VM situations. Embedded VMs should 5222 // call DestroyJavaVM() to assure that VM resources are released. 5223 5224 // note: perfMemory_exit_helper atexit function may be removed in 5225 // the future if the appropriate cleanup code can be added to the 5226 // VM_Exit VMOperation's doit method. 5227 if (atexit(perfMemory_exit_helper) != 0) { 5228 warning("os::init2 atexit(perfMemory_exit_helper) failed"); 5229 } 5230 } 5231 5232 // Init pset_loadavg function pointer 5233 init_pset_getloadavg_ptr(); 5234 5235 return JNI_OK; 5236} 5237 5238void os::init_3(void) { 5239 return; 5240} 5241 5242// Mark the polling page as unreadable 5243void os::make_polling_page_unreadable(void) { 5244 if( mprotect((char *)_polling_page, page_size, PROT_NONE) != 0 ) 5245 fatal("Could not disable polling page"); 5246}; 5247 5248// Mark the polling page as readable 5249void os::make_polling_page_readable(void) { 5250 if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 ) 5251 fatal("Could not enable polling page"); 5252}; 5253 5254// OS interface. 5255 5256bool os::check_heap(bool force) { return true; } 5257 5258typedef int (*vsnprintf_t)(char* buf, size_t count, const char* fmt, va_list argptr); 5259static vsnprintf_t sol_vsnprintf = NULL; 5260 5261int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr) { 5262 if (!sol_vsnprintf) { 5263 //search for the named symbol in the objects that were loaded after libjvm 5264 void* where = RTLD_NEXT; 5265 if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL) 5266 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf")); 5267 if (!sol_vsnprintf){ 5268 //search for the named symbol in the objects that were loaded before libjvm 5269 where = RTLD_DEFAULT; 5270 if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL) 5271 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf")); 5272 assert(sol_vsnprintf != NULL, "vsnprintf not found"); 5273 } 5274 } 5275 return (*sol_vsnprintf)(buf, count, fmt, argptr); 5276} 5277 5278 5279// Is a (classpath) directory empty? 5280bool os::dir_is_empty(const char* path) { 5281 DIR *dir = NULL; 5282 struct dirent *ptr; 5283 5284 dir = opendir(path); 5285 if (dir == NULL) return true; 5286 5287 /* Scan the directory */ 5288 bool result = true; 5289 char buf[sizeof(struct dirent) + MAX_PATH]; 5290 struct dirent *dbuf = (struct dirent *) buf; 5291 while (result && (ptr = readdir(dir, dbuf)) != NULL) { 5292 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) { 5293 result = false; 5294 } 5295 } 5296 closedir(dir); 5297 return result; 5298} 5299 5300// This code originates from JDK's sysOpen and open64_w 5301// from src/solaris/hpi/src/system_md.c 5302 5303#ifndef O_DELETE 5304#define O_DELETE 0x10000 5305#endif 5306 5307// Open a file. Unlink the file immediately after open returns 5308// if the specified oflag has the O_DELETE flag set. 5309// O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c 5310 5311int os::open(const char *path, int oflag, int mode) { 5312 if (strlen(path) > MAX_PATH - 1) { 5313 errno = ENAMETOOLONG; 5314 return -1; 5315 } 5316 int fd; 5317 int o_delete = (oflag & O_DELETE); 5318 oflag = oflag & ~O_DELETE; 5319 5320 fd = ::open64(path, oflag, mode); 5321 if (fd == -1) return -1; 5322 5323 //If the open succeeded, the file might still be a directory 5324 { 5325 struct stat64 buf64; 5326 int ret = ::fstat64(fd, &buf64); 5327 int st_mode = buf64.st_mode; 5328 5329 if (ret != -1) { 5330 if ((st_mode & S_IFMT) == S_IFDIR) { 5331 errno = EISDIR; 5332 ::close(fd); 5333 return -1; 5334 } 5335 } else { 5336 ::close(fd); 5337 return -1; 5338 } 5339 } 5340 /* 5341 * 32-bit Solaris systems suffer from: 5342 * 5343 * - an historical default soft limit of 256 per-process file 5344 * descriptors that is too low for many Java programs. 5345 * 5346 * - a design flaw where file descriptors created using stdio 5347 * fopen must be less than 256, _even_ when the first limit above 5348 * has been raised. This can cause calls to fopen (but not calls to 5349 * open, for example) to fail mysteriously, perhaps in 3rd party 5350 * native code (although the JDK itself uses fopen). One can hardly 5351 * criticize them for using this most standard of all functions. 5352 * 5353 * We attempt to make everything work anyways by: 5354 * 5355 * - raising the soft limit on per-process file descriptors beyond 5356 * 256 5357 * 5358 * - As of Solaris 10u4, we can request that Solaris raise the 256 5359 * stdio fopen limit by calling function enable_extended_FILE_stdio. 5360 * This is done in init_2 and recorded in enabled_extended_FILE_stdio 5361 * 5362 * - If we are stuck on an old (pre 10u4) Solaris system, we can 5363 * workaround the bug by remapping non-stdio file descriptors below 5364 * 256 to ones beyond 256, which is done below. 5365 * 5366 * See: 5367 * 1085341: 32-bit stdio routines should support file descriptors >255 5368 * 6533291: Work around 32-bit Solaris stdio limit of 256 open files 5369 * 6431278: Netbeans crash on 32 bit Solaris: need to call 5370 * enable_extended_FILE_stdio() in VM initialisation 5371 * Giri Mandalika's blog 5372 * http://technopark02.blogspot.com/2005_05_01_archive.html 5373 */ 5374#ifndef _LP64 5375 if ((!enabled_extended_FILE_stdio) && fd < 256) { 5376 int newfd = ::fcntl(fd, F_DUPFD, 256); 5377 if (newfd != -1) { 5378 ::close(fd); 5379 fd = newfd; 5380 } 5381 } 5382#endif // 32-bit Solaris 5383 /* 5384 * All file descriptors that are opened in the JVM and not 5385 * specifically destined for a subprocess should have the 5386 * close-on-exec flag set. If we don't set it, then careless 3rd 5387 * party native code might fork and exec without closing all 5388 * appropriate file descriptors (e.g. as we do in closeDescriptors in 5389 * UNIXProcess.c), and this in turn might: 5390 * 5391 * - cause end-of-file to fail to be detected on some file 5392 * descriptors, resulting in mysterious hangs, or 5393 * 5394 * - might cause an fopen in the subprocess to fail on a system 5395 * suffering from bug 1085341. 5396 * 5397 * (Yes, the default setting of the close-on-exec flag is a Unix 5398 * design flaw) 5399 * 5400 * See: 5401 * 1085341: 32-bit stdio routines should support file descriptors >255 5402 * 4843136: (process) pipe file descriptor from Runtime.exec not being closed 5403 * 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9 5404 */ 5405#ifdef FD_CLOEXEC 5406 { 5407 int flags = ::fcntl(fd, F_GETFD); 5408 if (flags != -1) 5409 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC); 5410 } 5411#endif 5412 5413 if (o_delete != 0) { 5414 ::unlink(path); 5415 } 5416 return fd; 5417} 5418 5419// create binary file, rewriting existing file if required 5420int os::create_binary_file(const char* path, bool rewrite_existing) { 5421 int oflags = O_WRONLY | O_CREAT; 5422 if (!rewrite_existing) { 5423 oflags |= O_EXCL; 5424 } 5425 return ::open64(path, oflags, S_IREAD | S_IWRITE); 5426} 5427 5428// return current position of file pointer 5429jlong os::current_file_offset(int fd) { 5430 return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR); 5431} 5432 5433// move file pointer to the specified offset 5434jlong os::seek_to_file_offset(int fd, jlong offset) { 5435 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET); 5436} 5437 5438jlong os::lseek(int fd, jlong offset, int whence) { 5439 return (jlong) ::lseek64(fd, offset, whence); 5440} 5441 5442char * os::native_path(char *path) { 5443 return path; 5444} 5445 5446int os::ftruncate(int fd, jlong length) { 5447 return ::ftruncate64(fd, length); 5448} 5449 5450int os::fsync(int fd) { 5451 RESTARTABLE_RETURN_INT(::fsync(fd)); 5452} 5453 5454int os::available(int fd, jlong *bytes) { 5455 jlong cur, end; 5456 int mode; 5457 struct stat64 buf64; 5458 5459 if (::fstat64(fd, &buf64) >= 0) { 5460 mode = buf64.st_mode; 5461 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) { 5462 /* 5463 * XXX: is the following call interruptible? If so, this might 5464 * need to go through the INTERRUPT_IO() wrapper as for other 5465 * blocking, interruptible calls in this file. 5466 */ 5467 int n,ioctl_return; 5468 5469 INTERRUPTIBLE(::ioctl(fd, FIONREAD, &n),ioctl_return,os::Solaris::clear_interrupted); 5470 if (ioctl_return>= 0) { 5471 *bytes = n; 5472 return 1; 5473 } 5474 } 5475 } 5476 if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) { 5477 return 0; 5478 } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) { 5479 return 0; 5480 } else if (::lseek64(fd, cur, SEEK_SET) == -1) { 5481 return 0; 5482 } 5483 *bytes = end - cur; 5484 return 1; 5485} 5486 5487// Map a block of memory. 5488char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, 5489 char *addr, size_t bytes, bool read_only, 5490 bool allow_exec) { 5491 int prot; 5492 int flags; 5493 5494 if (read_only) { 5495 prot = PROT_READ; 5496 flags = MAP_SHARED; 5497 } else { 5498 prot = PROT_READ | PROT_WRITE; 5499 flags = MAP_PRIVATE; 5500 } 5501 5502 if (allow_exec) { 5503 prot |= PROT_EXEC; 5504 } 5505 5506 if (addr != NULL) { 5507 flags |= MAP_FIXED; 5508 } 5509 5510 char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags, 5511 fd, file_offset); 5512 if (mapped_address == MAP_FAILED) { 5513 return NULL; 5514 } 5515 return mapped_address; 5516} 5517 5518 5519// Remap a block of memory. 5520char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, 5521 char *addr, size_t bytes, bool read_only, 5522 bool allow_exec) { 5523 // same as map_memory() on this OS 5524 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 5525 allow_exec); 5526} 5527 5528 5529// Unmap a block of memory. 5530bool os::pd_unmap_memory(char* addr, size_t bytes) { 5531 return munmap(addr, bytes) == 0; 5532} 5533 5534void os::pause() { 5535 char filename[MAX_PATH]; 5536 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 5537 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 5538 } else { 5539 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 5540 } 5541 5542 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 5543 if (fd != -1) { 5544 struct stat buf; 5545 ::close(fd); 5546 while (::stat(filename, &buf) == 0) { 5547 (void)::poll(NULL, 0, 100); 5548 } 5549 } else { 5550 jio_fprintf(stderr, 5551 "Could not open pause file '%s', continuing immediately.\n", filename); 5552 } 5553} 5554 5555#ifndef PRODUCT 5556#ifdef INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS 5557// Turn this on if you need to trace synch operations. 5558// Set RECORD_SYNCH_LIMIT to a large-enough value, 5559// and call record_synch_enable and record_synch_disable 5560// around the computation of interest. 5561 5562void record_synch(char* name, bool returning); // defined below 5563 5564class RecordSynch { 5565 char* _name; 5566 public: 5567 RecordSynch(char* name) :_name(name) 5568 { record_synch(_name, false); } 5569 ~RecordSynch() { record_synch(_name, true); } 5570}; 5571 5572#define CHECK_SYNCH_OP(ret, name, params, args, inner) \ 5573extern "C" ret name params { \ 5574 typedef ret name##_t params; \ 5575 static name##_t* implem = NULL; \ 5576 static int callcount = 0; \ 5577 if (implem == NULL) { \ 5578 implem = (name##_t*) dlsym(RTLD_NEXT, #name); \ 5579 if (implem == NULL) fatal(dlerror()); \ 5580 } \ 5581 ++callcount; \ 5582 RecordSynch _rs(#name); \ 5583 inner; \ 5584 return implem args; \ 5585} 5586// in dbx, examine callcounts this way: 5587// for n in $(eval whereis callcount | awk '{print $2}'); do print $n; done 5588 5589#define CHECK_POINTER_OK(p) \ 5590 (!Universe::is_fully_initialized() || !Universe::is_reserved_heap((oop)(p))) 5591#define CHECK_MU \ 5592 if (!CHECK_POINTER_OK(mu)) fatal("Mutex must be in C heap only."); 5593#define CHECK_CV \ 5594 if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only."); 5595#define CHECK_P(p) \ 5596 if (!CHECK_POINTER_OK(p)) fatal(false, "Pointer must be in C heap only."); 5597 5598#define CHECK_MUTEX(mutex_op) \ 5599CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU); 5600 5601CHECK_MUTEX( mutex_lock) 5602CHECK_MUTEX( _mutex_lock) 5603CHECK_MUTEX( mutex_unlock) 5604CHECK_MUTEX(_mutex_unlock) 5605CHECK_MUTEX( mutex_trylock) 5606CHECK_MUTEX(_mutex_trylock) 5607 5608#define CHECK_COND(cond_op) \ 5609CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU;CHECK_CV); 5610 5611CHECK_COND( cond_wait); 5612CHECK_COND(_cond_wait); 5613CHECK_COND(_cond_wait_cancel); 5614 5615#define CHECK_COND2(cond_op) \ 5616CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU;CHECK_CV); 5617 5618CHECK_COND2( cond_timedwait); 5619CHECK_COND2(_cond_timedwait); 5620CHECK_COND2(_cond_timedwait_cancel); 5621 5622// do the _lwp_* versions too 5623#define mutex_t lwp_mutex_t 5624#define cond_t lwp_cond_t 5625CHECK_MUTEX( _lwp_mutex_lock) 5626CHECK_MUTEX( _lwp_mutex_unlock) 5627CHECK_MUTEX( _lwp_mutex_trylock) 5628CHECK_MUTEX( __lwp_mutex_lock) 5629CHECK_MUTEX( __lwp_mutex_unlock) 5630CHECK_MUTEX( __lwp_mutex_trylock) 5631CHECK_MUTEX(___lwp_mutex_lock) 5632CHECK_MUTEX(___lwp_mutex_unlock) 5633 5634CHECK_COND( _lwp_cond_wait); 5635CHECK_COND( __lwp_cond_wait); 5636CHECK_COND(___lwp_cond_wait); 5637 5638CHECK_COND2( _lwp_cond_timedwait); 5639CHECK_COND2( __lwp_cond_timedwait); 5640#undef mutex_t 5641#undef cond_t 5642 5643CHECK_SYNCH_OP(int, _lwp_suspend2, (int lwp, int *n), (lwp, n), 0); 5644CHECK_SYNCH_OP(int,__lwp_suspend2, (int lwp, int *n), (lwp, n), 0); 5645CHECK_SYNCH_OP(int, _lwp_kill, (int lwp, int n), (lwp, n), 0); 5646CHECK_SYNCH_OP(int,__lwp_kill, (int lwp, int n), (lwp, n), 0); 5647CHECK_SYNCH_OP(int, _lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p)); 5648CHECK_SYNCH_OP(int,__lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p)); 5649CHECK_SYNCH_OP(int, _lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV); 5650CHECK_SYNCH_OP(int,__lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV); 5651 5652 5653// recording machinery: 5654 5655enum { RECORD_SYNCH_LIMIT = 200 }; 5656char* record_synch_name[RECORD_SYNCH_LIMIT]; 5657void* record_synch_arg0ptr[RECORD_SYNCH_LIMIT]; 5658bool record_synch_returning[RECORD_SYNCH_LIMIT]; 5659thread_t record_synch_thread[RECORD_SYNCH_LIMIT]; 5660int record_synch_count = 0; 5661bool record_synch_enabled = false; 5662 5663// in dbx, examine recorded data this way: 5664// for n in name arg0ptr returning thread; do print record_synch_$n[0..record_synch_count-1]; done 5665 5666void record_synch(char* name, bool returning) { 5667 if (record_synch_enabled) { 5668 if (record_synch_count < RECORD_SYNCH_LIMIT) { 5669 record_synch_name[record_synch_count] = name; 5670 record_synch_returning[record_synch_count] = returning; 5671 record_synch_thread[record_synch_count] = thr_self(); 5672 record_synch_arg0ptr[record_synch_count] = &name; 5673 record_synch_count++; 5674 } 5675 // put more checking code here: 5676 // ... 5677 } 5678} 5679 5680void record_synch_enable() { 5681 // start collecting trace data, if not already doing so 5682 if (!record_synch_enabled) record_synch_count = 0; 5683 record_synch_enabled = true; 5684} 5685 5686void record_synch_disable() { 5687 // stop collecting trace data 5688 record_synch_enabled = false; 5689} 5690 5691#endif // INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS 5692#endif // PRODUCT 5693 5694const intptr_t thr_time_off = (intptr_t)(&((prusage_t *)(NULL))->pr_utime); 5695const intptr_t thr_time_size = (intptr_t)(&((prusage_t *)(NULL))->pr_ttime) - 5696 (intptr_t)(&((prusage_t *)(NULL))->pr_utime); 5697 5698 5699// JVMTI & JVM monitoring and management support 5700// The thread_cpu_time() and current_thread_cpu_time() are only 5701// supported if is_thread_cpu_time_supported() returns true. 5702// They are not supported on Solaris T1. 5703 5704// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 5705// are used by JVM M&M and JVMTI to get user+sys or user CPU time 5706// of a thread. 5707// 5708// current_thread_cpu_time() and thread_cpu_time(Thread *) 5709// returns the fast estimate available on the platform. 5710 5711// hrtime_t gethrvtime() return value includes 5712// user time but does not include system time 5713jlong os::current_thread_cpu_time() { 5714 return (jlong) gethrvtime(); 5715} 5716 5717jlong os::thread_cpu_time(Thread *thread) { 5718 // return user level CPU time only to be consistent with 5719 // what current_thread_cpu_time returns. 5720 // thread_cpu_time_info() must be changed if this changes 5721 return os::thread_cpu_time(thread, false /* user time only */); 5722} 5723 5724jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 5725 if (user_sys_cpu_time) { 5726 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 5727 } else { 5728 return os::current_thread_cpu_time(); 5729 } 5730} 5731 5732jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) { 5733 char proc_name[64]; 5734 int count; 5735 prusage_t prusage; 5736 jlong lwp_time; 5737 int fd; 5738 5739 sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage", 5740 getpid(), 5741 thread->osthread()->lwp_id()); 5742 fd = ::open(proc_name, O_RDONLY); 5743 if ( fd == -1 ) return -1; 5744 5745 do { 5746 count = ::pread(fd, 5747 (void *)&prusage.pr_utime, 5748 thr_time_size, 5749 thr_time_off); 5750 } while (count < 0 && errno == EINTR); 5751 ::close(fd); 5752 if ( count < 0 ) return -1; 5753 5754 if (user_sys_cpu_time) { 5755 // user + system CPU time 5756 lwp_time = (((jlong)prusage.pr_stime.tv_sec + 5757 (jlong)prusage.pr_utime.tv_sec) * (jlong)1000000000) + 5758 (jlong)prusage.pr_stime.tv_nsec + 5759 (jlong)prusage.pr_utime.tv_nsec; 5760 } else { 5761 // user level CPU time only 5762 lwp_time = ((jlong)prusage.pr_utime.tv_sec * (jlong)1000000000) + 5763 (jlong)prusage.pr_utime.tv_nsec; 5764 } 5765 5766 return(lwp_time); 5767} 5768 5769void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 5770 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 5771 info_ptr->may_skip_backward = false; // elapsed time not wall time 5772 info_ptr->may_skip_forward = false; // elapsed time not wall time 5773 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned 5774} 5775 5776void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 5777 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 5778 info_ptr->may_skip_backward = false; // elapsed time not wall time 5779 info_ptr->may_skip_forward = false; // elapsed time not wall time 5780 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned 5781} 5782 5783bool os::is_thread_cpu_time_supported() { 5784 if ( os::Solaris::T2_libthread() || UseBoundThreads ) { 5785 return true; 5786 } else { 5787 return false; 5788 } 5789} 5790 5791// System loadavg support. Returns -1 if load average cannot be obtained. 5792// Return the load average for our processor set if the primitive exists 5793// (Solaris 9 and later). Otherwise just return system wide loadavg. 5794int os::loadavg(double loadavg[], int nelem) { 5795 if (pset_getloadavg_ptr != NULL) { 5796 return (*pset_getloadavg_ptr)(PS_MYID, loadavg, nelem); 5797 } else { 5798 return ::getloadavg(loadavg, nelem); 5799 } 5800} 5801 5802//--------------------------------------------------------------------------------- 5803 5804static address same_page(address x, address y) { 5805 intptr_t page_bits = -os::vm_page_size(); 5806 if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits)) 5807 return x; 5808 else if (x > y) 5809 return (address)(intptr_t(y) | ~page_bits) + 1; 5810 else 5811 return (address)(intptr_t(y) & page_bits); 5812} 5813 5814bool os::find(address addr, outputStream* st) { 5815 Dl_info dlinfo; 5816 memset(&dlinfo, 0, sizeof(dlinfo)); 5817 if (dladdr(addr, &dlinfo)) { 5818#ifdef _LP64 5819 st->print("0x%016lx: ", addr); 5820#else 5821 st->print("0x%08x: ", addr); 5822#endif 5823 if (dlinfo.dli_sname != NULL) 5824 st->print("%s+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr); 5825 else if (dlinfo.dli_fname) 5826 st->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase); 5827 else 5828 st->print("<absolute address>"); 5829 if (dlinfo.dli_fname) st->print(" in %s", dlinfo.dli_fname); 5830#ifdef _LP64 5831 if (dlinfo.dli_fbase) st->print(" at 0x%016lx", dlinfo.dli_fbase); 5832#else 5833 if (dlinfo.dli_fbase) st->print(" at 0x%08x", dlinfo.dli_fbase); 5834#endif 5835 st->cr(); 5836 5837 if (Verbose) { 5838 // decode some bytes around the PC 5839 address begin = same_page(addr-40, addr); 5840 address end = same_page(addr+40, addr); 5841 address lowest = (address) dlinfo.dli_sname; 5842 if (!lowest) lowest = (address) dlinfo.dli_fbase; 5843 if (begin < lowest) begin = lowest; 5844 Dl_info dlinfo2; 5845 if (dladdr(end, &dlinfo2) && dlinfo2.dli_saddr != dlinfo.dli_saddr 5846 && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) 5847 end = (address) dlinfo2.dli_saddr; 5848 Disassembler::decode(begin, end, st); 5849 } 5850 return true; 5851 } 5852 return false; 5853} 5854 5855// Following function has been added to support HotSparc's libjvm.so running 5856// under Solaris production JDK 1.2.2 / 1.3.0. These came from 5857// src/solaris/hpi/native_threads in the EVM codebase. 5858// 5859// NOTE: This is no longer needed in the 1.3.1 and 1.4 production release 5860// libraries and should thus be removed. We will leave it behind for a while 5861// until we no longer want to able to run on top of 1.3.0 Solaris production 5862// JDK. See 4341971. 5863 5864#define STACK_SLACK 0x800 5865 5866extern "C" { 5867 intptr_t sysThreadAvailableStackWithSlack() { 5868 stack_t st; 5869 intptr_t retval, stack_top; 5870 retval = thr_stksegment(&st); 5871 assert(retval == 0, "incorrect return value from thr_stksegment"); 5872 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned"); 5873 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned"); 5874 stack_top=(intptr_t)st.ss_sp-st.ss_size; 5875 return ((intptr_t)&stack_top - stack_top - STACK_SLACK); 5876 } 5877} 5878 5879// ObjectMonitor park-unpark infrastructure ... 5880// 5881// We implement Solaris and Linux PlatformEvents with the 5882// obvious condvar-mutex-flag triple. 5883// Another alternative that works quite well is pipes: 5884// Each PlatformEvent consists of a pipe-pair. 5885// The thread associated with the PlatformEvent 5886// calls park(), which reads from the input end of the pipe. 5887// Unpark() writes into the other end of the pipe. 5888// The write-side of the pipe must be set NDELAY. 5889// Unfortunately pipes consume a large # of handles. 5890// Native solaris lwp_park() and lwp_unpark() work nicely, too. 5891// Using pipes for the 1st few threads might be workable, however. 5892// 5893// park() is permitted to return spuriously. 5894// Callers of park() should wrap the call to park() in 5895// an appropriate loop. A litmus test for the correct 5896// usage of park is the following: if park() were modified 5897// to immediately return 0 your code should still work, 5898// albeit degenerating to a spin loop. 5899// 5900// An interesting optimization for park() is to use a trylock() 5901// to attempt to acquire the mutex. If the trylock() fails 5902// then we know that a concurrent unpark() operation is in-progress. 5903// in that case the park() code could simply set _count to 0 5904// and return immediately. The subsequent park() operation *might* 5905// return immediately. That's harmless as the caller of park() is 5906// expected to loop. By using trylock() we will have avoided a 5907// avoided a context switch caused by contention on the per-thread mutex. 5908// 5909// TODO-FIXME: 5910// 1. Reconcile Doug's JSR166 j.u.c park-unpark with the 5911// objectmonitor implementation. 5912// 2. Collapse the JSR166 parker event, and the 5913// objectmonitor ParkEvent into a single "Event" construct. 5914// 3. In park() and unpark() add: 5915// assert (Thread::current() == AssociatedWith). 5916// 4. add spurious wakeup injection on a -XX:EarlyParkReturn=N switch. 5917// 1-out-of-N park() operations will return immediately. 5918// 5919// _Event transitions in park() 5920// -1 => -1 : illegal 5921// 1 => 0 : pass - return immediately 5922// 0 => -1 : block 5923// 5924// _Event serves as a restricted-range semaphore. 5925// 5926// Another possible encoding of _Event would be with 5927// explicit "PARKED" == 01b and "SIGNALED" == 10b bits. 5928// 5929// TODO-FIXME: add DTRACE probes for: 5930// 1. Tx parks 5931// 2. Ty unparks Tx 5932// 3. Tx resumes from park 5933 5934 5935// value determined through experimentation 5936#define ROUNDINGFIX 11 5937 5938// utility to compute the abstime argument to timedwait. 5939// TODO-FIXME: switch from compute_abstime() to unpackTime(). 5940 5941static timestruc_t* compute_abstime(timestruc_t* abstime, jlong millis) { 5942 // millis is the relative timeout time 5943 // abstime will be the absolute timeout time 5944 if (millis < 0) millis = 0; 5945 struct timeval now; 5946 int status = gettimeofday(&now, NULL); 5947 assert(status == 0, "gettimeofday"); 5948 jlong seconds = millis / 1000; 5949 jlong max_wait_period; 5950 5951 if (UseLWPSynchronization) { 5952 // forward port of fix for 4275818 (not sleeping long enough) 5953 // There was a bug in Solaris 6, 7 and pre-patch 5 of 8 where 5954 // _lwp_cond_timedwait() used a round_down algorithm rather 5955 // than a round_up. For millis less than our roundfactor 5956 // it rounded down to 0 which doesn't meet the spec. 5957 // For millis > roundfactor we may return a bit sooner, but 5958 // since we can not accurately identify the patch level and 5959 // this has already been fixed in Solaris 9 and 8 we will 5960 // leave it alone rather than always rounding down. 5961 5962 if (millis > 0 && millis < ROUNDINGFIX) millis = ROUNDINGFIX; 5963 // It appears that when we go directly through Solaris _lwp_cond_timedwait() 5964 // the acceptable max time threshold is smaller than for libthread on 2.5.1 and 2.6 5965 max_wait_period = 21000000; 5966 } else { 5967 max_wait_period = 50000000; 5968 } 5969 millis %= 1000; 5970 if (seconds > max_wait_period) { // see man cond_timedwait(3T) 5971 seconds = max_wait_period; 5972 } 5973 abstime->tv_sec = now.tv_sec + seconds; 5974 long usec = now.tv_usec + millis * 1000; 5975 if (usec >= 1000000) { 5976 abstime->tv_sec += 1; 5977 usec -= 1000000; 5978 } 5979 abstime->tv_nsec = usec * 1000; 5980 return abstime; 5981} 5982 5983// Test-and-clear _Event, always leaves _Event set to 0, returns immediately. 5984// Conceptually TryPark() should be equivalent to park(0). 5985 5986int os::PlatformEvent::TryPark() { 5987 for (;;) { 5988 const int v = _Event ; 5989 guarantee ((v == 0) || (v == 1), "invariant") ; 5990 if (Atomic::cmpxchg (0, &_Event, v) == v) return v ; 5991 } 5992} 5993 5994void os::PlatformEvent::park() { // AKA: down() 5995 // Invariant: Only the thread associated with the Event/PlatformEvent 5996 // may call park(). 5997 int v ; 5998 for (;;) { 5999 v = _Event ; 6000 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 6001 } 6002 guarantee (v >= 0, "invariant") ; 6003 if (v == 0) { 6004 // Do this the hard way by blocking ... 6005 // See http://monaco.sfbay/detail.jsf?cr=5094058. 6006 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking. 6007 // Only for SPARC >= V8PlusA 6008#if defined(__sparc) && defined(COMPILER2) 6009 if (ClearFPUAtPark) { _mark_fpu_nosave() ; } 6010#endif 6011 int status = os::Solaris::mutex_lock(_mutex); 6012 assert_status(status == 0, status, "mutex_lock"); 6013 guarantee (_nParked == 0, "invariant") ; 6014 ++ _nParked ; 6015 while (_Event < 0) { 6016 // for some reason, under 2.7 lwp_cond_wait() may return ETIME ... 6017 // Treat this the same as if the wait was interrupted 6018 // With usr/lib/lwp going to kernel, always handle ETIME 6019 status = os::Solaris::cond_wait(_cond, _mutex); 6020 if (status == ETIME) status = EINTR ; 6021 assert_status(status == 0 || status == EINTR, status, "cond_wait"); 6022 } 6023 -- _nParked ; 6024 _Event = 0 ; 6025 status = os::Solaris::mutex_unlock(_mutex); 6026 assert_status(status == 0, status, "mutex_unlock"); 6027 } 6028} 6029 6030int os::PlatformEvent::park(jlong millis) { 6031 guarantee (_nParked == 0, "invariant") ; 6032 int v ; 6033 for (;;) { 6034 v = _Event ; 6035 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 6036 } 6037 guarantee (v >= 0, "invariant") ; 6038 if (v != 0) return OS_OK ; 6039 6040 int ret = OS_TIMEOUT; 6041 timestruc_t abst; 6042 compute_abstime (&abst, millis); 6043 6044 // See http://monaco.sfbay/detail.jsf?cr=5094058. 6045 // For Solaris SPARC set fprs.FEF=0 prior to parking. 6046 // Only for SPARC >= V8PlusA 6047#if defined(__sparc) && defined(COMPILER2) 6048 if (ClearFPUAtPark) { _mark_fpu_nosave() ; } 6049#endif 6050 int status = os::Solaris::mutex_lock(_mutex); 6051 assert_status(status == 0, status, "mutex_lock"); 6052 guarantee (_nParked == 0, "invariant") ; 6053 ++ _nParked ; 6054 while (_Event < 0) { 6055 int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst); 6056 assert_status(status == 0 || status == EINTR || 6057 status == ETIME || status == ETIMEDOUT, 6058 status, "cond_timedwait"); 6059 if (!FilterSpuriousWakeups) break ; // previous semantics 6060 if (status == ETIME || status == ETIMEDOUT) break ; 6061 // We consume and ignore EINTR and spurious wakeups. 6062 } 6063 -- _nParked ; 6064 if (_Event >= 0) ret = OS_OK ; 6065 _Event = 0 ; 6066 status = os::Solaris::mutex_unlock(_mutex); 6067 assert_status(status == 0, status, "mutex_unlock"); 6068 return ret; 6069} 6070 6071void os::PlatformEvent::unpark() { 6072 int v, AnyWaiters; 6073 6074 // Increment _Event. 6075 // Another acceptable implementation would be to simply swap 1 6076 // into _Event: 6077 // if (Swap (&_Event, 1) < 0) { 6078 // mutex_lock (_mutex) ; AnyWaiters = nParked; mutex_unlock (_mutex) ; 6079 // if (AnyWaiters) cond_signal (_cond) ; 6080 // } 6081 6082 for (;;) { 6083 v = _Event ; 6084 if (v > 0) { 6085 // The LD of _Event could have reordered or be satisfied 6086 // by a read-aside from this processor's write buffer. 6087 // To avoid problems execute a barrier and then 6088 // ratify the value. A degenerate CAS() would also work. 6089 // Viz., CAS (v+0, &_Event, v) == v). 6090 OrderAccess::fence() ; 6091 if (_Event == v) return ; 6092 continue ; 6093 } 6094 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ; 6095 } 6096 6097 // If the thread associated with the event was parked, wake it. 6098 if (v < 0) { 6099 int status ; 6100 // Wait for the thread assoc with the PlatformEvent to vacate. 6101 status = os::Solaris::mutex_lock(_mutex); 6102 assert_status(status == 0, status, "mutex_lock"); 6103 AnyWaiters = _nParked ; 6104 status = os::Solaris::mutex_unlock(_mutex); 6105 assert_status(status == 0, status, "mutex_unlock"); 6106 guarantee (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ; 6107 if (AnyWaiters != 0) { 6108 // We intentional signal *after* dropping the lock 6109 // to avoid a common class of futile wakeups. 6110 status = os::Solaris::cond_signal(_cond); 6111 assert_status(status == 0, status, "cond_signal"); 6112 } 6113 } 6114} 6115 6116// JSR166 6117// ------------------------------------------------------- 6118 6119/* 6120 * The solaris and linux implementations of park/unpark are fairly 6121 * conservative for now, but can be improved. They currently use a 6122 * mutex/condvar pair, plus _counter. 6123 * Park decrements _counter if > 0, else does a condvar wait. Unpark 6124 * sets count to 1 and signals condvar. Only one thread ever waits 6125 * on the condvar. Contention seen when trying to park implies that someone 6126 * is unparking you, so don't wait. And spurious returns are fine, so there 6127 * is no need to track notifications. 6128 */ 6129 6130#define MAX_SECS 100000000 6131/* 6132 * This code is common to linux and solaris and will be moved to a 6133 * common place in dolphin. 6134 * 6135 * The passed in time value is either a relative time in nanoseconds 6136 * or an absolute time in milliseconds. Either way it has to be unpacked 6137 * into suitable seconds and nanoseconds components and stored in the 6138 * given timespec structure. 6139 * Given time is a 64-bit value and the time_t used in the timespec is only 6140 * a signed-32-bit value (except on 64-bit Linux) we have to watch for 6141 * overflow if times way in the future are given. Further on Solaris versions 6142 * prior to 10 there is a restriction (see cond_timedwait) that the specified 6143 * number of seconds, in abstime, is less than current_time + 100,000,000. 6144 * As it will be 28 years before "now + 100000000" will overflow we can 6145 * ignore overflow and just impose a hard-limit on seconds using the value 6146 * of "now + 100,000,000". This places a limit on the timeout of about 3.17 6147 * years from "now". 6148 */ 6149static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) { 6150 assert (time > 0, "convertTime"); 6151 6152 struct timeval now; 6153 int status = gettimeofday(&now, NULL); 6154 assert(status == 0, "gettimeofday"); 6155 6156 time_t max_secs = now.tv_sec + MAX_SECS; 6157 6158 if (isAbsolute) { 6159 jlong secs = time / 1000; 6160 if (secs > max_secs) { 6161 absTime->tv_sec = max_secs; 6162 } 6163 else { 6164 absTime->tv_sec = secs; 6165 } 6166 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC; 6167 } 6168 else { 6169 jlong secs = time / NANOSECS_PER_SEC; 6170 if (secs >= MAX_SECS) { 6171 absTime->tv_sec = max_secs; 6172 absTime->tv_nsec = 0; 6173 } 6174 else { 6175 absTime->tv_sec = now.tv_sec + secs; 6176 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000; 6177 if (absTime->tv_nsec >= NANOSECS_PER_SEC) { 6178 absTime->tv_nsec -= NANOSECS_PER_SEC; 6179 ++absTime->tv_sec; // note: this must be <= max_secs 6180 } 6181 } 6182 } 6183 assert(absTime->tv_sec >= 0, "tv_sec < 0"); 6184 assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs"); 6185 assert(absTime->tv_nsec >= 0, "tv_nsec < 0"); 6186 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec"); 6187} 6188 6189void Parker::park(bool isAbsolute, jlong time) { 6190 6191 // Optional fast-path check: 6192 // Return immediately if a permit is available. 6193 if (_counter > 0) { 6194 _counter = 0 ; 6195 OrderAccess::fence(); 6196 return ; 6197 } 6198 6199 // Optional fast-exit: Check interrupt before trying to wait 6200 Thread* thread = Thread::current(); 6201 assert(thread->is_Java_thread(), "Must be JavaThread"); 6202 JavaThread *jt = (JavaThread *)thread; 6203 if (Thread::is_interrupted(thread, false)) { 6204 return; 6205 } 6206 6207 // First, demultiplex/decode time arguments 6208 timespec absTime; 6209 if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all 6210 return; 6211 } 6212 if (time > 0) { 6213 // Warning: this code might be exposed to the old Solaris time 6214 // round-down bugs. Grep "roundingFix" for details. 6215 unpackTime(&absTime, isAbsolute, time); 6216 } 6217 6218 // Enter safepoint region 6219 // Beware of deadlocks such as 6317397. 6220 // The per-thread Parker:: _mutex is a classic leaf-lock. 6221 // In particular a thread must never block on the Threads_lock while 6222 // holding the Parker:: mutex. If safepoints are pending both the 6223 // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock. 6224 ThreadBlockInVM tbivm(jt); 6225 6226 // Don't wait if cannot get lock since interference arises from 6227 // unblocking. Also. check interrupt before trying wait 6228 if (Thread::is_interrupted(thread, false) || 6229 os::Solaris::mutex_trylock(_mutex) != 0) { 6230 return; 6231 } 6232 6233 int status ; 6234 6235 if (_counter > 0) { // no wait needed 6236 _counter = 0; 6237 status = os::Solaris::mutex_unlock(_mutex); 6238 assert (status == 0, "invariant") ; 6239 OrderAccess::fence(); 6240 return; 6241 } 6242 6243#ifdef ASSERT 6244 // Don't catch signals while blocked; let the running threads have the signals. 6245 // (This allows a debugger to break into the running thread.) 6246 sigset_t oldsigs; 6247 sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals(); 6248 thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs); 6249#endif 6250 6251 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 6252 jt->set_suspend_equivalent(); 6253 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 6254 6255 // Do this the hard way by blocking ... 6256 // See http://monaco.sfbay/detail.jsf?cr=5094058. 6257 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking. 6258 // Only for SPARC >= V8PlusA 6259#if defined(__sparc) && defined(COMPILER2) 6260 if (ClearFPUAtPark) { _mark_fpu_nosave() ; } 6261#endif 6262 6263 if (time == 0) { 6264 status = os::Solaris::cond_wait (_cond, _mutex) ; 6265 } else { 6266 status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime); 6267 } 6268 // Note that an untimed cond_wait() can sometimes return ETIME on older 6269 // versions of the Solaris. 6270 assert_status(status == 0 || status == EINTR || 6271 status == ETIME || status == ETIMEDOUT, 6272 status, "cond_timedwait"); 6273 6274#ifdef ASSERT 6275 thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL); 6276#endif 6277 _counter = 0 ; 6278 status = os::Solaris::mutex_unlock(_mutex); 6279 assert_status(status == 0, status, "mutex_unlock") ; 6280 6281 // If externally suspended while waiting, re-suspend 6282 if (jt->handle_special_suspend_equivalent_condition()) { 6283 jt->java_suspend_self(); 6284 } 6285 OrderAccess::fence(); 6286} 6287 6288void Parker::unpark() { 6289 int s, status ; 6290 status = os::Solaris::mutex_lock (_mutex) ; 6291 assert (status == 0, "invariant") ; 6292 s = _counter; 6293 _counter = 1; 6294 status = os::Solaris::mutex_unlock (_mutex) ; 6295 assert (status == 0, "invariant") ; 6296 6297 if (s < 1) { 6298 status = os::Solaris::cond_signal (_cond) ; 6299 assert (status == 0, "invariant") ; 6300 } 6301} 6302 6303extern char** environ; 6304 6305// Run the specified command in a separate process. Return its exit value, 6306// or -1 on failure (e.g. can't fork a new process). 6307// Unlike system(), this function can be called from signal handler. It 6308// doesn't block SIGINT et al. 6309int os::fork_and_exec(char* cmd) { 6310 char * argv[4]; 6311 argv[0] = (char *)"sh"; 6312 argv[1] = (char *)"-c"; 6313 argv[2] = cmd; 6314 argv[3] = NULL; 6315 6316 // fork is async-safe, fork1 is not so can't use in signal handler 6317 pid_t pid; 6318 Thread* t = ThreadLocalStorage::get_thread_slow(); 6319 if (t != NULL && t->is_inside_signal_handler()) { 6320 pid = fork(); 6321 } else { 6322 pid = fork1(); 6323 } 6324 6325 if (pid < 0) { 6326 // fork failed 6327 warning("fork failed: %s", strerror(errno)); 6328 return -1; 6329 6330 } else if (pid == 0) { 6331 // child process 6332 6333 // try to be consistent with system(), which uses "/usr/bin/sh" on Solaris 6334 execve("/usr/bin/sh", argv, environ); 6335 6336 // execve failed 6337 _exit(-1); 6338 6339 } else { 6340 // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't 6341 // care about the actual exit code, for now. 6342 6343 int status; 6344 6345 // Wait for the child process to exit. This returns immediately if 6346 // the child has already exited. */ 6347 while (waitpid(pid, &status, 0) < 0) { 6348 switch (errno) { 6349 case ECHILD: return 0; 6350 case EINTR: break; 6351 default: return -1; 6352 } 6353 } 6354 6355 if (WIFEXITED(status)) { 6356 // The child exited normally; get its exit code. 6357 return WEXITSTATUS(status); 6358 } else if (WIFSIGNALED(status)) { 6359 // The child exited because of a signal 6360 // The best value to return is 0x80 + signal number, 6361 // because that is what all Unix shells do, and because 6362 // it allows callers to distinguish between process exit and 6363 // process death by signal. 6364 return 0x80 + WTERMSIG(status); 6365 } else { 6366 // Unknown exit code; pass it through 6367 return status; 6368 } 6369 } 6370} 6371 6372// is_headless_jre() 6373// 6374// Test for the existence of xawt/libmawt.so or libawt_xawt.so 6375// in order to report if we are running in a headless jre 6376// 6377// Since JDK8 xawt/libmawt.so was moved into the same directory 6378// as libawt.so, and renamed libawt_xawt.so 6379// 6380bool os::is_headless_jre() { 6381 struct stat statbuf; 6382 char buf[MAXPATHLEN]; 6383 char libmawtpath[MAXPATHLEN]; 6384 const char *xawtstr = "/xawt/libmawt.so"; 6385 const char *new_xawtstr = "/libawt_xawt.so"; 6386 char *p; 6387 6388 // Get path to libjvm.so 6389 os::jvm_path(buf, sizeof(buf)); 6390 6391 // Get rid of libjvm.so 6392 p = strrchr(buf, '/'); 6393 if (p == NULL) return false; 6394 else *p = '\0'; 6395 6396 // Get rid of client or server 6397 p = strrchr(buf, '/'); 6398 if (p == NULL) return false; 6399 else *p = '\0'; 6400 6401 // check xawt/libmawt.so 6402 strcpy(libmawtpath, buf); 6403 strcat(libmawtpath, xawtstr); 6404 if (::stat(libmawtpath, &statbuf) == 0) return false; 6405 6406 // check libawt_xawt.so 6407 strcpy(libmawtpath, buf); 6408 strcat(libmawtpath, new_xawtstr); 6409 if (::stat(libmawtpath, &statbuf) == 0) return false; 6410 6411 return true; 6412} 6413 6414size_t os::write(int fd, const void *buf, unsigned int nBytes) { 6415 INTERRUPTIBLE_RETURN_INT(::write(fd, buf, nBytes), os::Solaris::clear_interrupted); 6416} 6417 6418int os::close(int fd) { 6419 RESTARTABLE_RETURN_INT(::close(fd)); 6420} 6421 6422int os::socket_close(int fd) { 6423 RESTARTABLE_RETURN_INT(::close(fd)); 6424} 6425 6426int os::recv(int fd, char* buf, size_t nBytes, uint flags) { 6427 INTERRUPTIBLE_RETURN_INT((int)::recv(fd, buf, nBytes, flags), os::Solaris::clear_interrupted); 6428} 6429 6430int os::send(int fd, char* buf, size_t nBytes, uint flags) { 6431 INTERRUPTIBLE_RETURN_INT((int)::send(fd, buf, nBytes, flags), os::Solaris::clear_interrupted); 6432} 6433 6434int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) { 6435 RESTARTABLE_RETURN_INT((int)::send(fd, buf, nBytes, flags)); 6436} 6437 6438// As both poll and select can be interrupted by signals, we have to be 6439// prepared to restart the system call after updating the timeout, unless 6440// a poll() is done with timeout == -1, in which case we repeat with this 6441// "wait forever" value. 6442 6443int os::timeout(int fd, long timeout) { 6444 int res; 6445 struct timeval t; 6446 julong prevtime, newtime; 6447 static const char* aNull = 0; 6448 struct pollfd pfd; 6449 pfd.fd = fd; 6450 pfd.events = POLLIN; 6451 6452 gettimeofday(&t, &aNull); 6453 prevtime = ((julong)t.tv_sec * 1000) + t.tv_usec / 1000; 6454 6455 for(;;) { 6456 INTERRUPTIBLE_NORESTART(::poll(&pfd, 1, timeout), res, os::Solaris::clear_interrupted); 6457 if(res == OS_ERR && errno == EINTR) { 6458 if(timeout != -1) { 6459 gettimeofday(&t, &aNull); 6460 newtime = ((julong)t.tv_sec * 1000) + t.tv_usec /1000; 6461 timeout -= newtime - prevtime; 6462 if(timeout <= 0) 6463 return OS_OK; 6464 prevtime = newtime; 6465 } 6466 } else return res; 6467 } 6468} 6469 6470int os::connect(int fd, struct sockaddr *him, socklen_t len) { 6471 int _result; 6472 INTERRUPTIBLE_NORESTART(::connect(fd, him, len), _result,\ 6473 os::Solaris::clear_interrupted); 6474 6475 // Depending on when thread interruption is reset, _result could be 6476 // one of two values when errno == EINTR 6477 6478 if (((_result == OS_INTRPT) || (_result == OS_ERR)) 6479 && (errno == EINTR)) { 6480 /* restarting a connect() changes its errno semantics */ 6481 INTERRUPTIBLE(::connect(fd, him, len), _result,\ 6482 os::Solaris::clear_interrupted); 6483 /* undo these changes */ 6484 if (_result == OS_ERR) { 6485 if (errno == EALREADY) { 6486 errno = EINPROGRESS; /* fall through */ 6487 } else if (errno == EISCONN) { 6488 errno = 0; 6489 return OS_OK; 6490 } 6491 } 6492 } 6493 return _result; 6494 } 6495 6496int os::accept(int fd, struct sockaddr* him, socklen_t* len) { 6497 if (fd < 0) { 6498 return OS_ERR; 6499 } 6500 INTERRUPTIBLE_RETURN_INT((int)::accept(fd, him, len),\ 6501 os::Solaris::clear_interrupted); 6502} 6503 6504int os::recvfrom(int fd, char* buf, size_t nBytes, uint flags, 6505 sockaddr* from, socklen_t* fromlen) { 6506 INTERRUPTIBLE_RETURN_INT((int)::recvfrom(fd, buf, nBytes, flags, from, fromlen),\ 6507 os::Solaris::clear_interrupted); 6508} 6509 6510int os::sendto(int fd, char* buf, size_t len, uint flags, 6511 struct sockaddr* to, socklen_t tolen) { 6512 INTERRUPTIBLE_RETURN_INT((int)::sendto(fd, buf, len, flags, to, tolen),\ 6513 os::Solaris::clear_interrupted); 6514} 6515 6516int os::socket_available(int fd, jint *pbytes) { 6517 if (fd < 0) { 6518 return OS_OK; 6519 } 6520 int ret; 6521 RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret); 6522 // note: ioctl can return 0 when successful, JVM_SocketAvailable 6523 // is expected to return 0 on failure and 1 on success to the jdk. 6524 return (ret == OS_ERR) ? 0 : 1; 6525} 6526 6527int os::bind(int fd, struct sockaddr* him, socklen_t len) { 6528 INTERRUPTIBLE_RETURN_INT_NORESTART(::bind(fd, him, len),\ 6529 os::Solaris::clear_interrupted); 6530} 6531 6532// Get the default path to the core file 6533// Returns the length of the string 6534int os::get_core_path(char* buffer, size_t bufferSize) { 6535 const char* p = get_current_directory(buffer, bufferSize); 6536 6537 if (p == NULL) { 6538 assert(p != NULL, "failed to get current directory"); 6539 return 0; 6540 } 6541 6542 return strlen(buffer); 6543} 6544