os_solaris.cpp revision 1472:c18cbe5936b8
1/* 2 * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25// do not include precompiled header file 26# include "incls/_os_solaris.cpp.incl" 27 28// put OS-includes here 29# include <dlfcn.h> 30# include <errno.h> 31# include <link.h> 32# include <poll.h> 33# include <pthread.h> 34# include <pwd.h> 35# include <schedctl.h> 36# include <setjmp.h> 37# include <signal.h> 38# include <stdio.h> 39# include <alloca.h> 40# include <sys/filio.h> 41# include <sys/ipc.h> 42# include <sys/lwp.h> 43# include <sys/machelf.h> // for elf Sym structure used by dladdr1 44# include <sys/mman.h> 45# include <sys/processor.h> 46# include <sys/procset.h> 47# include <sys/pset.h> 48# include <sys/resource.h> 49# include <sys/shm.h> 50# include <sys/socket.h> 51# include <sys/stat.h> 52# include <sys/systeminfo.h> 53# include <sys/time.h> 54# include <sys/times.h> 55# include <sys/types.h> 56# include <sys/wait.h> 57# include <sys/utsname.h> 58# include <thread.h> 59# include <unistd.h> 60# include <sys/priocntl.h> 61# include <sys/rtpriocntl.h> 62# include <sys/tspriocntl.h> 63# include <sys/iapriocntl.h> 64# include <sys/loadavg.h> 65# include <string.h> 66 67# define _STRUCTURED_PROC 1 // this gets us the new structured proc interfaces of 5.6 & later 68# include <sys/procfs.h> // see comment in <sys/procfs.h> 69 70#define MAX_PATH (2 * K) 71 72// for timer info max values which include all bits 73#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF) 74 75#ifdef _GNU_SOURCE 76// See bug #6514594 77extern "C" int madvise(caddr_t, size_t, int); 78extern "C" int memcntl(caddr_t addr, size_t len, int cmd, caddr_t arg, 79 int attr, int mask); 80#endif //_GNU_SOURCE 81 82/* 83 MPSS Changes Start. 84 The JVM binary needs to be built and run on pre-Solaris 9 85 systems, but the constants needed by MPSS are only in Solaris 9 86 header files. They are textually replicated here to allow 87 building on earlier systems. Once building on Solaris 8 is 88 no longer a requirement, these #defines can be replaced by ordinary 89 system .h inclusion. 90 91 In earlier versions of the JDK and Solaris, we used ISM for large pages. 92 But ISM requires shared memory to achieve this and thus has many caveats. 93 MPSS is a fully transparent and is a cleaner way to get large pages. 94 Although we still require keeping ISM for backward compatiblitiy as well as 95 giving the opportunity to use large pages on older systems it is 96 recommended that MPSS be used for Solaris 9 and above. 97 98*/ 99 100#ifndef MC_HAT_ADVISE 101 102struct memcntl_mha { 103 uint_t mha_cmd; /* command(s) */ 104 uint_t mha_flags; 105 size_t mha_pagesize; 106}; 107#define MC_HAT_ADVISE 7 /* advise hat map size */ 108#define MHA_MAPSIZE_VA 0x1 /* set preferred page size */ 109#define MAP_ALIGN 0x200 /* addr specifies alignment */ 110 111#endif 112// MPSS Changes End. 113 114 115// Here are some liblgrp types from sys/lgrp_user.h to be able to 116// compile on older systems without this header file. 117 118#ifndef MADV_ACCESS_LWP 119# define MADV_ACCESS_LWP 7 /* next LWP to access heavily */ 120#endif 121#ifndef MADV_ACCESS_MANY 122# define MADV_ACCESS_MANY 8 /* many processes to access heavily */ 123#endif 124 125#ifndef LGRP_RSRC_CPU 126# define LGRP_RSRC_CPU 0 /* CPU resources */ 127#endif 128#ifndef LGRP_RSRC_MEM 129# define LGRP_RSRC_MEM 1 /* memory resources */ 130#endif 131 132// Some more macros from sys/mman.h that are not present in Solaris 8. 133 134#ifndef MAX_MEMINFO_CNT 135/* 136 * info_req request type definitions for meminfo 137 * request types starting with MEMINFO_V are used for Virtual addresses 138 * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical 139 * addresses 140 */ 141# define MEMINFO_SHIFT 16 142# define MEMINFO_MASK (0xFF << MEMINFO_SHIFT) 143# define MEMINFO_VPHYSICAL (0x01 << MEMINFO_SHIFT) /* get physical addr */ 144# define MEMINFO_VLGRP (0x02 << MEMINFO_SHIFT) /* get lgroup */ 145# define MEMINFO_VPAGESIZE (0x03 << MEMINFO_SHIFT) /* size of phys page */ 146# define MEMINFO_VREPLCNT (0x04 << MEMINFO_SHIFT) /* no. of replica */ 147# define MEMINFO_VREPL (0x05 << MEMINFO_SHIFT) /* physical replica */ 148# define MEMINFO_VREPL_LGRP (0x06 << MEMINFO_SHIFT) /* lgrp of replica */ 149# define MEMINFO_PLGRP (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */ 150 151/* maximum number of addresses meminfo() can process at a time */ 152# define MAX_MEMINFO_CNT 256 153 154/* maximum number of request types */ 155# define MAX_MEMINFO_REQ 31 156#endif 157 158// see thr_setprio(3T) for the basis of these numbers 159#define MinimumPriority 0 160#define NormalPriority 64 161#define MaximumPriority 127 162 163// Values for ThreadPriorityPolicy == 1 164int prio_policy1[MaxPriority+1] = { -99999, 0, 16, 32, 48, 64, 165 80, 96, 112, 124, 127 }; 166 167// System parameters used internally 168static clock_t clock_tics_per_sec = 100; 169 170// For diagnostics to print a message once. see run_periodic_checks 171static bool check_addr0_done = false; 172static sigset_t check_signal_done; 173static bool check_signals = true; 174 175address os::Solaris::handler_start; // start pc of thr_sighndlrinfo 176address os::Solaris::handler_end; // end pc of thr_sighndlrinfo 177 178address os::Solaris::_main_stack_base = NULL; // 4352906 workaround 179 180 181// "default" initializers for missing libc APIs 182extern "C" { 183 static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; } 184 static int lwp_mutex_destroy(mutex_t *mx) { return 0; } 185 186 static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; } 187 static int lwp_cond_destroy(cond_t *cv) { return 0; } 188} 189 190// "default" initializers for pthread-based synchronization 191extern "C" { 192 static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; } 193 static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; } 194} 195 196// Thread Local Storage 197// This is common to all Solaris platforms so it is defined here, 198// in this common file. 199// The declarations are in the os_cpu threadLS*.hpp files. 200// 201// Static member initialization for TLS 202Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL}; 203 204#ifndef PRODUCT 205#define _PCT(n,d) ((100.0*(double)(n))/(double)(d)) 206 207int ThreadLocalStorage::_tcacheHit = 0; 208int ThreadLocalStorage::_tcacheMiss = 0; 209 210void ThreadLocalStorage::print_statistics() { 211 int total = _tcacheMiss+_tcacheHit; 212 tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n", 213 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total)); 214} 215#undef _PCT 216#endif // PRODUCT 217 218Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id, 219 int index) { 220 Thread *thread = get_thread_slow(); 221 if (thread != NULL) { 222 address sp = os::current_stack_pointer(); 223 guarantee(thread->_stack_base == NULL || 224 (sp <= thread->_stack_base && 225 sp >= thread->_stack_base - thread->_stack_size) || 226 is_error_reported(), 227 "sp must be inside of selected thread stack"); 228 229 thread->_self_raw_id = raw_id; // mark for quick retrieval 230 _get_thread_cache[ index ] = thread; 231 } 232 return thread; 233} 234 235 236static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0}; 237#define NO_CACHED_THREAD ((Thread*)all_zero) 238 239void ThreadLocalStorage::pd_set_thread(Thread* thread) { 240 241 // Store the new value before updating the cache to prevent a race 242 // between get_thread_via_cache_slowly() and this store operation. 243 os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread); 244 245 // Update thread cache with new thread if setting on thread create, 246 // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit. 247 uintptr_t raw = pd_raw_thread_id(); 248 int ix = pd_cache_index(raw); 249 _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread; 250} 251 252void ThreadLocalStorage::pd_init() { 253 for (int i = 0; i < _pd_cache_size; i++) { 254 _get_thread_cache[i] = NO_CACHED_THREAD; 255 } 256} 257 258// Invalidate all the caches (happens to be the same as pd_init). 259void ThreadLocalStorage::pd_invalidate_all() { pd_init(); } 260 261#undef NO_CACHED_THREAD 262 263// END Thread Local Storage 264 265static inline size_t adjust_stack_size(address base, size_t size) { 266 if ((ssize_t)size < 0) { 267 // 4759953: Compensate for ridiculous stack size. 268 size = max_intx; 269 } 270 if (size > (size_t)base) { 271 // 4812466: Make sure size doesn't allow the stack to wrap the address space. 272 size = (size_t)base; 273 } 274 return size; 275} 276 277static inline stack_t get_stack_info() { 278 stack_t st; 279 int retval = thr_stksegment(&st); 280 st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size); 281 assert(retval == 0, "incorrect return value from thr_stksegment"); 282 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned"); 283 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned"); 284 return st; 285} 286 287address os::current_stack_base() { 288 int r = thr_main() ; 289 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; 290 bool is_primordial_thread = r; 291 292 // Workaround 4352906, avoid calls to thr_stksegment by 293 // thr_main after the first one (it looks like we trash 294 // some data, causing the value for ss_sp to be incorrect). 295 if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) { 296 stack_t st = get_stack_info(); 297 if (is_primordial_thread) { 298 // cache initial value of stack base 299 os::Solaris::_main_stack_base = (address)st.ss_sp; 300 } 301 return (address)st.ss_sp; 302 } else { 303 guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base"); 304 return os::Solaris::_main_stack_base; 305 } 306} 307 308size_t os::current_stack_size() { 309 size_t size; 310 311 int r = thr_main() ; 312 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; 313 if(!r) { 314 size = get_stack_info().ss_size; 315 } else { 316 struct rlimit limits; 317 getrlimit(RLIMIT_STACK, &limits); 318 size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur); 319 } 320 // base may not be page aligned 321 address base = current_stack_base(); 322 address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());; 323 return (size_t)(base - bottom); 324} 325 326struct tm* os::localtime_pd(const time_t* clock, struct tm* res) { 327 return localtime_r(clock, res); 328} 329 330// interruptible infrastructure 331 332// setup_interruptible saves the thread state before going into an 333// interruptible system call. 334// The saved state is used to restore the thread to 335// its former state whether or not an interrupt is received. 336// Used by classloader os::read 337// hpi calls skip this layer and stay in _thread_in_native 338 339void os::Solaris::setup_interruptible(JavaThread* thread) { 340 341 JavaThreadState thread_state = thread->thread_state(); 342 343 assert(thread_state != _thread_blocked, "Coming from the wrong thread"); 344 assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible"); 345 OSThread* osthread = thread->osthread(); 346 osthread->set_saved_interrupt_thread_state(thread_state); 347 thread->frame_anchor()->make_walkable(thread); 348 ThreadStateTransition::transition(thread, thread_state, _thread_blocked); 349} 350 351// Version of setup_interruptible() for threads that are already in 352// _thread_blocked. Used by os_sleep(). 353void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) { 354 thread->frame_anchor()->make_walkable(thread); 355} 356 357JavaThread* os::Solaris::setup_interruptible() { 358 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); 359 setup_interruptible(thread); 360 return thread; 361} 362 363void os::Solaris::try_enable_extended_io() { 364 typedef int (*enable_extended_FILE_stdio_t)(int, int); 365 366 if (!UseExtendedFileIO) { 367 return; 368 } 369 370 enable_extended_FILE_stdio_t enabler = 371 (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT, 372 "enable_extended_FILE_stdio"); 373 if (enabler) { 374 enabler(-1, -1); 375 } 376} 377 378 379#ifdef ASSERT 380 381JavaThread* os::Solaris::setup_interruptible_native() { 382 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread(); 383 JavaThreadState thread_state = thread->thread_state(); 384 assert(thread_state == _thread_in_native, "Assumed thread_in_native"); 385 return thread; 386} 387 388void os::Solaris::cleanup_interruptible_native(JavaThread* thread) { 389 JavaThreadState thread_state = thread->thread_state(); 390 assert(thread_state == _thread_in_native, "Assumed thread_in_native"); 391} 392#endif 393 394// cleanup_interruptible reverses the effects of setup_interruptible 395// setup_interruptible_already_blocked() does not need any cleanup. 396 397void os::Solaris::cleanup_interruptible(JavaThread* thread) { 398 OSThread* osthread = thread->osthread(); 399 400 ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state()); 401} 402 403// I/O interruption related counters called in _INTERRUPTIBLE 404 405void os::Solaris::bump_interrupted_before_count() { 406 RuntimeService::record_interrupted_before_count(); 407} 408 409void os::Solaris::bump_interrupted_during_count() { 410 RuntimeService::record_interrupted_during_count(); 411} 412 413static int _processors_online = 0; 414 415 jint os::Solaris::_os_thread_limit = 0; 416volatile jint os::Solaris::_os_thread_count = 0; 417 418julong os::available_memory() { 419 return Solaris::available_memory(); 420} 421 422julong os::Solaris::available_memory() { 423 return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size(); 424} 425 426julong os::Solaris::_physical_memory = 0; 427 428julong os::physical_memory() { 429 return Solaris::physical_memory(); 430} 431 432julong os::allocatable_physical_memory(julong size) { 433#ifdef _LP64 434 return size; 435#else 436 julong result = MIN2(size, (julong)3835*M); 437 if (!is_allocatable(result)) { 438 // Memory allocations will be aligned but the alignment 439 // is not known at this point. Alignments will 440 // be at most to LargePageSizeInBytes. Protect 441 // allocations from alignments up to illegal 442 // values. If at this point 2G is illegal. 443 julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes; 444 result = MIN2(size, reasonable_size); 445 } 446 return result; 447#endif 448} 449 450static hrtime_t first_hrtime = 0; 451static const hrtime_t hrtime_hz = 1000*1000*1000; 452const int LOCK_BUSY = 1; 453const int LOCK_FREE = 0; 454const int LOCK_INVALID = -1; 455static volatile hrtime_t max_hrtime = 0; 456static volatile int max_hrtime_lock = LOCK_FREE; // Update counter with LSB as lock-in-progress 457 458 459void os::Solaris::initialize_system_info() { 460 set_processor_count(sysconf(_SC_NPROCESSORS_CONF)); 461 _processors_online = sysconf (_SC_NPROCESSORS_ONLN); 462 _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE); 463} 464 465int os::active_processor_count() { 466 int online_cpus = sysconf(_SC_NPROCESSORS_ONLN); 467 pid_t pid = getpid(); 468 psetid_t pset = PS_NONE; 469 // Are we running in a processor set or is there any processor set around? 470 if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) { 471 uint_t pset_cpus; 472 // Query the number of cpus available to us. 473 if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) { 474 assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check"); 475 _processors_online = pset_cpus; 476 return pset_cpus; 477 } 478 } 479 // Otherwise return number of online cpus 480 return online_cpus; 481} 482 483static bool find_processors_in_pset(psetid_t pset, 484 processorid_t** id_array, 485 uint_t* id_length) { 486 bool result = false; 487 // Find the number of processors in the processor set. 488 if (pset_info(pset, NULL, id_length, NULL) == 0) { 489 // Make up an array to hold their ids. 490 *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length); 491 // Fill in the array with their processor ids. 492 if (pset_info(pset, NULL, id_length, *id_array) == 0) { 493 result = true; 494 } 495 } 496 return result; 497} 498 499// Callers of find_processors_online() must tolerate imprecise results -- 500// the system configuration can change asynchronously because of DR 501// or explicit psradm operations. 502// 503// We also need to take care that the loop (below) terminates as the 504// number of processors online can change between the _SC_NPROCESSORS_ONLN 505// request and the loop that builds the list of processor ids. Unfortunately 506// there's no reliable way to determine the maximum valid processor id, 507// so we use a manifest constant, MAX_PROCESSOR_ID, instead. See p_online 508// man pages, which claim the processor id set is "sparse, but 509// not too sparse". MAX_PROCESSOR_ID is used to ensure that we eventually 510// exit the loop. 511// 512// In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's 513// not available on S8.0. 514 515static bool find_processors_online(processorid_t** id_array, 516 uint* id_length) { 517 const processorid_t MAX_PROCESSOR_ID = 100000 ; 518 // Find the number of processors online. 519 *id_length = sysconf(_SC_NPROCESSORS_ONLN); 520 // Make up an array to hold their ids. 521 *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length); 522 // Processors need not be numbered consecutively. 523 long found = 0; 524 processorid_t next = 0; 525 while (found < *id_length && next < MAX_PROCESSOR_ID) { 526 processor_info_t info; 527 if (processor_info(next, &info) == 0) { 528 // NB, PI_NOINTR processors are effectively online ... 529 if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) { 530 (*id_array)[found] = next; 531 found += 1; 532 } 533 } 534 next += 1; 535 } 536 if (found < *id_length) { 537 // The loop above didn't identify the expected number of processors. 538 // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN) 539 // and re-running the loop, above, but there's no guarantee of progress 540 // if the system configuration is in flux. Instead, we just return what 541 // we've got. Note that in the worst case find_processors_online() could 542 // return an empty set. (As a fall-back in the case of the empty set we 543 // could just return the ID of the current processor). 544 *id_length = found ; 545 } 546 547 return true; 548} 549 550static bool assign_distribution(processorid_t* id_array, 551 uint id_length, 552 uint* distribution, 553 uint distribution_length) { 554 // We assume we can assign processorid_t's to uint's. 555 assert(sizeof(processorid_t) == sizeof(uint), 556 "can't convert processorid_t to uint"); 557 // Quick check to see if we won't succeed. 558 if (id_length < distribution_length) { 559 return false; 560 } 561 // Assign processor ids to the distribution. 562 // Try to shuffle processors to distribute work across boards, 563 // assuming 4 processors per board. 564 const uint processors_per_board = ProcessDistributionStride; 565 // Find the maximum processor id. 566 processorid_t max_id = 0; 567 for (uint m = 0; m < id_length; m += 1) { 568 max_id = MAX2(max_id, id_array[m]); 569 } 570 // The next id, to limit loops. 571 const processorid_t limit_id = max_id + 1; 572 // Make up markers for available processors. 573 bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id); 574 for (uint c = 0; c < limit_id; c += 1) { 575 available_id[c] = false; 576 } 577 for (uint a = 0; a < id_length; a += 1) { 578 available_id[id_array[a]] = true; 579 } 580 // Step by "boards", then by "slot", copying to "assigned". 581 // NEEDS_CLEANUP: The assignment of processors should be stateful, 582 // remembering which processors have been assigned by 583 // previous calls, etc., so as to distribute several 584 // independent calls of this method. What we'd like is 585 // It would be nice to have an API that let us ask 586 // how many processes are bound to a processor, 587 // but we don't have that, either. 588 // In the short term, "board" is static so that 589 // subsequent distributions don't all start at board 0. 590 static uint board = 0; 591 uint assigned = 0; 592 // Until we've found enough processors .... 593 while (assigned < distribution_length) { 594 // ... find the next available processor in the board. 595 for (uint slot = 0; slot < processors_per_board; slot += 1) { 596 uint try_id = board * processors_per_board + slot; 597 if ((try_id < limit_id) && (available_id[try_id] == true)) { 598 distribution[assigned] = try_id; 599 available_id[try_id] = false; 600 assigned += 1; 601 break; 602 } 603 } 604 board += 1; 605 if (board * processors_per_board + 0 >= limit_id) { 606 board = 0; 607 } 608 } 609 if (available_id != NULL) { 610 FREE_C_HEAP_ARRAY(bool, available_id); 611 } 612 return true; 613} 614 615bool os::distribute_processes(uint length, uint* distribution) { 616 bool result = false; 617 // Find the processor id's of all the available CPUs. 618 processorid_t* id_array = NULL; 619 uint id_length = 0; 620 // There are some races between querying information and using it, 621 // since processor sets can change dynamically. 622 psetid_t pset = PS_NONE; 623 // Are we running in a processor set? 624 if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) { 625 result = find_processors_in_pset(pset, &id_array, &id_length); 626 } else { 627 result = find_processors_online(&id_array, &id_length); 628 } 629 if (result == true) { 630 if (id_length >= length) { 631 result = assign_distribution(id_array, id_length, distribution, length); 632 } else { 633 result = false; 634 } 635 } 636 if (id_array != NULL) { 637 FREE_C_HEAP_ARRAY(processorid_t, id_array); 638 } 639 return result; 640} 641 642bool os::bind_to_processor(uint processor_id) { 643 // We assume that a processorid_t can be stored in a uint. 644 assert(sizeof(uint) == sizeof(processorid_t), 645 "can't convert uint to processorid_t"); 646 int bind_result = 647 processor_bind(P_LWPID, // bind LWP. 648 P_MYID, // bind current LWP. 649 (processorid_t) processor_id, // id. 650 NULL); // don't return old binding. 651 return (bind_result == 0); 652} 653 654bool os::getenv(const char* name, char* buffer, int len) { 655 char* val = ::getenv( name ); 656 if ( val == NULL 657 || strlen(val) + 1 > len ) { 658 if (len > 0) buffer[0] = 0; // return a null string 659 return false; 660 } 661 strcpy( buffer, val ); 662 return true; 663} 664 665 666// Return true if user is running as root. 667 668bool os::have_special_privileges() { 669 static bool init = false; 670 static bool privileges = false; 671 if (!init) { 672 privileges = (getuid() != geteuid()) || (getgid() != getegid()); 673 init = true; 674 } 675 return privileges; 676} 677 678 679void os::init_system_properties_values() { 680 char arch[12]; 681 sysinfo(SI_ARCHITECTURE, arch, sizeof(arch)); 682 683 // The next steps are taken in the product version: 684 // 685 // Obtain the JAVA_HOME value from the location of libjvm[_g].so. 686 // This library should be located at: 687 // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so. 688 // 689 // If "/jre/lib/" appears at the right place in the path, then we 690 // assume libjvm[_g].so is installed in a JDK and we use this path. 691 // 692 // Otherwise exit with message: "Could not create the Java virtual machine." 693 // 694 // The following extra steps are taken in the debugging version: 695 // 696 // If "/jre/lib/" does NOT appear at the right place in the path 697 // instead of exit check for $JAVA_HOME environment variable. 698 // 699 // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>, 700 // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so 701 // it looks like libjvm[_g].so is installed there 702 // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so. 703 // 704 // Otherwise exit. 705 // 706 // Important note: if the location of libjvm.so changes this 707 // code needs to be changed accordingly. 708 709 // The next few definitions allow the code to be verbatim: 710#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n)) 711#define free(p) FREE_C_HEAP_ARRAY(char, p) 712#define getenv(n) ::getenv(n) 713 714#define EXTENSIONS_DIR "/lib/ext" 715#define ENDORSED_DIR "/lib/endorsed" 716#define COMMON_DIR "/usr/jdk/packages" 717 718 { 719 /* sysclasspath, java_home, dll_dir */ 720 { 721 char *home_path; 722 char *dll_path; 723 char *pslash; 724 char buf[MAXPATHLEN]; 725 os::jvm_path(buf, sizeof(buf)); 726 727 // Found the full path to libjvm.so. 728 // Now cut the path to <java_home>/jre if we can. 729 *(strrchr(buf, '/')) = '\0'; /* get rid of /libjvm.so */ 730 pslash = strrchr(buf, '/'); 731 if (pslash != NULL) 732 *pslash = '\0'; /* get rid of /{client|server|hotspot} */ 733 dll_path = malloc(strlen(buf) + 1); 734 if (dll_path == NULL) 735 return; 736 strcpy(dll_path, buf); 737 Arguments::set_dll_dir(dll_path); 738 739 if (pslash != NULL) { 740 pslash = strrchr(buf, '/'); 741 if (pslash != NULL) { 742 *pslash = '\0'; /* get rid of /<arch> */ 743 pslash = strrchr(buf, '/'); 744 if (pslash != NULL) 745 *pslash = '\0'; /* get rid of /lib */ 746 } 747 } 748 749 home_path = malloc(strlen(buf) + 1); 750 if (home_path == NULL) 751 return; 752 strcpy(home_path, buf); 753 Arguments::set_java_home(home_path); 754 755 if (!set_boot_path('/', ':')) 756 return; 757 } 758 759 /* 760 * Where to look for native libraries 761 */ 762 { 763 // Use dlinfo() to determine the correct java.library.path. 764 // 765 // If we're launched by the Java launcher, and the user 766 // does not set java.library.path explicitly on the commandline, 767 // the Java launcher sets LD_LIBRARY_PATH for us and unsets 768 // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64. In this case 769 // dlinfo returns LD_LIBRARY_PATH + crle settings (including 770 // /usr/lib), which is exactly what we want. 771 // 772 // If the user does set java.library.path, it completely 773 // overwrites this setting, and always has. 774 // 775 // If we're not launched by the Java launcher, we may 776 // get here with any/all of the LD_LIBRARY_PATH[_32|64] 777 // settings. Again, dlinfo does exactly what we want. 778 779 Dl_serinfo _info, *info = &_info; 780 Dl_serpath *path; 781 char* library_path; 782 char *common_path; 783 int i; 784 785 // determine search path count and required buffer size 786 if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) { 787 vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror()); 788 } 789 790 // allocate new buffer and initialize 791 info = (Dl_serinfo*)malloc(_info.dls_size); 792 if (info == NULL) { 793 vm_exit_out_of_memory(_info.dls_size, 794 "init_system_properties_values info"); 795 } 796 info->dls_size = _info.dls_size; 797 info->dls_cnt = _info.dls_cnt; 798 799 // obtain search path information 800 if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) { 801 free(info); 802 vm_exit_during_initialization("dlinfo SERINFO request", dlerror()); 803 } 804 805 path = &info->dls_serpath[0]; 806 807 // Note: Due to a legacy implementation, most of the library path 808 // is set in the launcher. This was to accomodate linking restrictions 809 // on legacy Solaris implementations (which are no longer supported). 810 // Eventually, all the library path setting will be done here. 811 // 812 // However, to prevent the proliferation of improperly built native 813 // libraries, the new path component /usr/jdk/packages is added here. 814 815 // Determine the actual CPU architecture. 816 char cpu_arch[12]; 817 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch)); 818#ifdef _LP64 819 // If we are a 64-bit vm, perform the following translations: 820 // sparc -> sparcv9 821 // i386 -> amd64 822 if (strcmp(cpu_arch, "sparc") == 0) 823 strcat(cpu_arch, "v9"); 824 else if (strcmp(cpu_arch, "i386") == 0) 825 strcpy(cpu_arch, "amd64"); 826#endif 827 828 // Construct the invariant part of ld_library_path. Note that the 829 // space for the colon and the trailing null are provided by the 830 // nulls included by the sizeof operator. 831 size_t bufsize = sizeof(COMMON_DIR) + sizeof("/lib/") + strlen(cpu_arch); 832 common_path = malloc(bufsize); 833 if (common_path == NULL) { 834 free(info); 835 vm_exit_out_of_memory(bufsize, 836 "init_system_properties_values common_path"); 837 } 838 sprintf(common_path, COMMON_DIR "/lib/%s", cpu_arch); 839 840 // struct size is more than sufficient for the path components obtained 841 // through the dlinfo() call, so only add additional space for the path 842 // components explicitly added here. 843 bufsize = info->dls_size + strlen(common_path); 844 library_path = malloc(bufsize); 845 if (library_path == NULL) { 846 free(info); 847 free(common_path); 848 vm_exit_out_of_memory(bufsize, 849 "init_system_properties_values library_path"); 850 } 851 library_path[0] = '\0'; 852 853 // Construct the desired Java library path from the linker's library 854 // search path. 855 // 856 // For compatibility, it is optimal that we insert the additional path 857 // components specific to the Java VM after those components specified 858 // in LD_LIBRARY_PATH (if any) but before those added by the ld.so 859 // infrastructure. 860 if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it 861 strcpy(library_path, common_path); 862 } else { 863 int inserted = 0; 864 for (i = 0; i < info->dls_cnt; i++, path++) { 865 uint_t flags = path->dls_flags & LA_SER_MASK; 866 if (((flags & LA_SER_LIBPATH) == 0) && !inserted) { 867 strcat(library_path, common_path); 868 strcat(library_path, os::path_separator()); 869 inserted = 1; 870 } 871 strcat(library_path, path->dls_name); 872 strcat(library_path, os::path_separator()); 873 } 874 // eliminate trailing path separator 875 library_path[strlen(library_path)-1] = '\0'; 876 } 877 878 // happens before argument parsing - can't use a trace flag 879 // tty->print_raw("init_system_properties_values: native lib path: "); 880 // tty->print_raw_cr(library_path); 881 882 // callee copies into its own buffer 883 Arguments::set_library_path(library_path); 884 885 free(common_path); 886 free(library_path); 887 free(info); 888 } 889 890 /* 891 * Extensions directories. 892 * 893 * Note that the space for the colon and the trailing null are provided 894 * by the nulls included by the sizeof operator (so actually one byte more 895 * than necessary is allocated). 896 */ 897 { 898 char *buf = (char *) malloc(strlen(Arguments::get_java_home()) + 899 sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) + 900 sizeof(EXTENSIONS_DIR)); 901 sprintf(buf, "%s" EXTENSIONS_DIR ":" COMMON_DIR EXTENSIONS_DIR, 902 Arguments::get_java_home()); 903 Arguments::set_ext_dirs(buf); 904 } 905 906 /* Endorsed standards default directory. */ 907 { 908 char * buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR)); 909 sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home()); 910 Arguments::set_endorsed_dirs(buf); 911 } 912 } 913 914#undef malloc 915#undef free 916#undef getenv 917#undef EXTENSIONS_DIR 918#undef ENDORSED_DIR 919#undef COMMON_DIR 920 921} 922 923void os::breakpoint() { 924 BREAKPOINT; 925} 926 927bool os::obsolete_option(const JavaVMOption *option) 928{ 929 if (!strncmp(option->optionString, "-Xt", 3)) { 930 return true; 931 } else if (!strncmp(option->optionString, "-Xtm", 4)) { 932 return true; 933 } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) { 934 return true; 935 } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) { 936 return true; 937 } 938 return false; 939} 940 941bool os::Solaris::valid_stack_address(Thread* thread, address sp) { 942 address stackStart = (address)thread->stack_base(); 943 address stackEnd = (address)(stackStart - (address)thread->stack_size()); 944 if (sp < stackStart && sp >= stackEnd ) return true; 945 return false; 946} 947 948extern "C" void breakpoint() { 949 // use debugger to set breakpoint here 950} 951 952// Returns an estimate of the current stack pointer. Result must be guaranteed to 953// point into the calling threads stack, and be no lower than the current stack 954// pointer. 955address os::current_stack_pointer() { 956 volatile int dummy; 957 address sp = (address)&dummy + 8; // %%%% need to confirm if this is right 958 return sp; 959} 960 961static thread_t main_thread; 962 963// Thread start routine for all new Java threads 964extern "C" void* java_start(void* thread_addr) { 965 // Try to randomize the cache line index of hot stack frames. 966 // This helps when threads of the same stack traces evict each other's 967 // cache lines. The threads can be either from the same JVM instance, or 968 // from different JVM instances. The benefit is especially true for 969 // processors with hyperthreading technology. 970 static int counter = 0; 971 int pid = os::current_process_id(); 972 alloca(((pid ^ counter++) & 7) * 128); 973 974 int prio; 975 Thread* thread = (Thread*)thread_addr; 976 OSThread* osthr = thread->osthread(); 977 978 osthr->set_lwp_id( _lwp_self() ); // Store lwp in case we are bound 979 thread->_schedctl = (void *) schedctl_init () ; 980 981 if (UseNUMA) { 982 int lgrp_id = os::numa_get_group_id(); 983 if (lgrp_id != -1) { 984 thread->set_lgrp_id(lgrp_id); 985 } 986 } 987 988 // If the creator called set priority before we started, 989 // we need to call set priority now that we have an lwp. 990 // Get the priority from libthread and set the priority 991 // for the new Solaris lwp. 992 if ( osthr->thread_id() != -1 ) { 993 if ( UseThreadPriorities ) { 994 thr_getprio(osthr->thread_id(), &prio); 995 if (ThreadPriorityVerbose) { 996 tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT ", setting priority: %d\n", 997 osthr->thread_id(), osthr->lwp_id(), prio ); 998 } 999 os::set_native_priority(thread, prio); 1000 } 1001 } else if (ThreadPriorityVerbose) { 1002 warning("Can't set priority in _start routine, thread id hasn't been set\n"); 1003 } 1004 1005 assert(osthr->get_state() == RUNNABLE, "invalid os thread state"); 1006 1007 // initialize signal mask for this thread 1008 os::Solaris::hotspot_sigmask(thread); 1009 1010 thread->run(); 1011 1012 // One less thread is executing 1013 // When the VMThread gets here, the main thread may have already exited 1014 // which frees the CodeHeap containing the Atomic::dec code 1015 if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) { 1016 Atomic::dec(&os::Solaris::_os_thread_count); 1017 } 1018 1019 if (UseDetachedThreads) { 1020 thr_exit(NULL); 1021 ShouldNotReachHere(); 1022 } 1023 return NULL; 1024} 1025 1026static OSThread* create_os_thread(Thread* thread, thread_t thread_id) { 1027 // Allocate the OSThread object 1028 OSThread* osthread = new OSThread(NULL, NULL); 1029 if (osthread == NULL) return NULL; 1030 1031 // Store info on the Solaris thread into the OSThread 1032 osthread->set_thread_id(thread_id); 1033 osthread->set_lwp_id(_lwp_self()); 1034 thread->_schedctl = (void *) schedctl_init () ; 1035 1036 if (UseNUMA) { 1037 int lgrp_id = os::numa_get_group_id(); 1038 if (lgrp_id != -1) { 1039 thread->set_lgrp_id(lgrp_id); 1040 } 1041 } 1042 1043 if ( ThreadPriorityVerbose ) { 1044 tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n", 1045 osthread->thread_id(), osthread->lwp_id() ); 1046 } 1047 1048 // Initial thread state is INITIALIZED, not SUSPENDED 1049 osthread->set_state(INITIALIZED); 1050 1051 return osthread; 1052} 1053 1054void os::Solaris::hotspot_sigmask(Thread* thread) { 1055 1056 //Save caller's signal mask 1057 sigset_t sigmask; 1058 thr_sigsetmask(SIG_SETMASK, NULL, &sigmask); 1059 OSThread *osthread = thread->osthread(); 1060 osthread->set_caller_sigmask(sigmask); 1061 1062 thr_sigsetmask(SIG_UNBLOCK, os::Solaris::unblocked_signals(), NULL); 1063 if (!ReduceSignalUsage) { 1064 if (thread->is_VM_thread()) { 1065 // Only the VM thread handles BREAK_SIGNAL ... 1066 thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL); 1067 } else { 1068 // ... all other threads block BREAK_SIGNAL 1069 assert(!sigismember(vm_signals(), SIGINT), "SIGINT should not be blocked"); 1070 thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL); 1071 } 1072 } 1073} 1074 1075bool os::create_attached_thread(JavaThread* thread) { 1076#ifdef ASSERT 1077 thread->verify_not_published(); 1078#endif 1079 OSThread* osthread = create_os_thread(thread, thr_self()); 1080 if (osthread == NULL) { 1081 return false; 1082 } 1083 1084 // Initial thread state is RUNNABLE 1085 osthread->set_state(RUNNABLE); 1086 thread->set_osthread(osthread); 1087 1088 // initialize signal mask for this thread 1089 // and save the caller's signal mask 1090 os::Solaris::hotspot_sigmask(thread); 1091 1092 return true; 1093} 1094 1095bool os::create_main_thread(JavaThread* thread) { 1096#ifdef ASSERT 1097 thread->verify_not_published(); 1098#endif 1099 if (_starting_thread == NULL) { 1100 _starting_thread = create_os_thread(thread, main_thread); 1101 if (_starting_thread == NULL) { 1102 return false; 1103 } 1104 } 1105 1106 // The primodial thread is runnable from the start 1107 _starting_thread->set_state(RUNNABLE); 1108 1109 thread->set_osthread(_starting_thread); 1110 1111 // initialize signal mask for this thread 1112 // and save the caller's signal mask 1113 os::Solaris::hotspot_sigmask(thread); 1114 1115 return true; 1116} 1117 1118// _T2_libthread is true if we believe we are running with the newer 1119// SunSoft lwp/libthread.so (2.8 patch, 2.9 default) 1120bool os::Solaris::_T2_libthread = false; 1121 1122bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) { 1123 // Allocate the OSThread object 1124 OSThread* osthread = new OSThread(NULL, NULL); 1125 if (osthread == NULL) { 1126 return false; 1127 } 1128 1129 if ( ThreadPriorityVerbose ) { 1130 char *thrtyp; 1131 switch ( thr_type ) { 1132 case vm_thread: 1133 thrtyp = (char *)"vm"; 1134 break; 1135 case cgc_thread: 1136 thrtyp = (char *)"cgc"; 1137 break; 1138 case pgc_thread: 1139 thrtyp = (char *)"pgc"; 1140 break; 1141 case java_thread: 1142 thrtyp = (char *)"java"; 1143 break; 1144 case compiler_thread: 1145 thrtyp = (char *)"compiler"; 1146 break; 1147 case watcher_thread: 1148 thrtyp = (char *)"watcher"; 1149 break; 1150 default: 1151 thrtyp = (char *)"unknown"; 1152 break; 1153 } 1154 tty->print_cr("In create_thread, creating a %s thread\n", thrtyp); 1155 } 1156 1157 // Calculate stack size if it's not specified by caller. 1158 if (stack_size == 0) { 1159 // The default stack size 1M (2M for LP64). 1160 stack_size = (BytesPerWord >> 2) * K * K; 1161 1162 switch (thr_type) { 1163 case os::java_thread: 1164 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss 1165 if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create(); 1166 break; 1167 case os::compiler_thread: 1168 if (CompilerThreadStackSize > 0) { 1169 stack_size = (size_t)(CompilerThreadStackSize * K); 1170 break; 1171 } // else fall through: 1172 // use VMThreadStackSize if CompilerThreadStackSize is not defined 1173 case os::vm_thread: 1174 case os::pgc_thread: 1175 case os::cgc_thread: 1176 case os::watcher_thread: 1177 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K); 1178 break; 1179 } 1180 } 1181 stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed); 1182 1183 // Initial state is ALLOCATED but not INITIALIZED 1184 osthread->set_state(ALLOCATED); 1185 1186 if (os::Solaris::_os_thread_count > os::Solaris::_os_thread_limit) { 1187 // We got lots of threads. Check if we still have some address space left. 1188 // Need to be at least 5Mb of unreserved address space. We do check by 1189 // trying to reserve some. 1190 const size_t VirtualMemoryBangSize = 20*K*K; 1191 char* mem = os::reserve_memory(VirtualMemoryBangSize); 1192 if (mem == NULL) { 1193 delete osthread; 1194 return false; 1195 } else { 1196 // Release the memory again 1197 os::release_memory(mem, VirtualMemoryBangSize); 1198 } 1199 } 1200 1201 // Setup osthread because the child thread may need it. 1202 thread->set_osthread(osthread); 1203 1204 // Create the Solaris thread 1205 // explicit THR_BOUND for T2_libthread case in case 1206 // that assumption is not accurate, but our alternate signal stack 1207 // handling is based on it which must have bound threads 1208 thread_t tid = 0; 1209 long flags = (UseDetachedThreads ? THR_DETACHED : 0) | THR_SUSPENDED 1210 | ((UseBoundThreads || os::Solaris::T2_libthread() || 1211 (thr_type == vm_thread) || 1212 (thr_type == cgc_thread) || 1213 (thr_type == pgc_thread) || 1214 (thr_type == compiler_thread && BackgroundCompilation)) ? 1215 THR_BOUND : 0); 1216 int status; 1217 1218 // 4376845 -- libthread/kernel don't provide enough LWPs to utilize all CPUs. 1219 // 1220 // On multiprocessors systems, libthread sometimes under-provisions our 1221 // process with LWPs. On a 30-way systems, for instance, we could have 1222 // 50 user-level threads in ready state and only 2 or 3 LWPs assigned 1223 // to our process. This can result in under utilization of PEs. 1224 // I suspect the problem is related to libthread's LWP 1225 // pool management and to the kernel's SIGBLOCKING "last LWP parked" 1226 // upcall policy. 1227 // 1228 // The following code is palliative -- it attempts to ensure that our 1229 // process has sufficient LWPs to take advantage of multiple PEs. 1230 // Proper long-term cures include using user-level threads bound to LWPs 1231 // (THR_BOUND) or using LWP-based synchronization. Note that there is a 1232 // slight timing window with respect to sampling _os_thread_count, but 1233 // the race is benign. Also, we should periodically recompute 1234 // _processors_online as the min of SC_NPROCESSORS_ONLN and the 1235 // the number of PEs in our partition. You might be tempted to use 1236 // THR_NEW_LWP here, but I'd recommend against it as that could 1237 // result in undesirable growth of the libthread's LWP pool. 1238 // The fix below isn't sufficient; for instance, it doesn't take into count 1239 // LWPs parked on IO. It does, however, help certain CPU-bound benchmarks. 1240 // 1241 // Some pathologies this scheme doesn't handle: 1242 // * Threads can block, releasing the LWPs. The LWPs can age out. 1243 // When a large number of threads become ready again there aren't 1244 // enough LWPs available to service them. This can occur when the 1245 // number of ready threads oscillates. 1246 // * LWPs/Threads park on IO, thus taking the LWP out of circulation. 1247 // 1248 // Finally, we should call thr_setconcurrency() periodically to refresh 1249 // the LWP pool and thwart the LWP age-out mechanism. 1250 // The "+3" term provides a little slop -- we want to slightly overprovision. 1251 1252 if (AdjustConcurrency && os::Solaris::_os_thread_count < (_processors_online+3)) { 1253 if (!(flags & THR_BOUND)) { 1254 thr_setconcurrency (os::Solaris::_os_thread_count); // avoid starvation 1255 } 1256 } 1257 // Although this doesn't hurt, we should warn of undefined behavior 1258 // when using unbound T1 threads with schedctl(). This should never 1259 // happen, as the compiler and VM threads are always created bound 1260 DEBUG_ONLY( 1261 if ((VMThreadHintNoPreempt || CompilerThreadHintNoPreempt) && 1262 (!os::Solaris::T2_libthread() && (!(flags & THR_BOUND))) && 1263 ((thr_type == vm_thread) || (thr_type == cgc_thread) || 1264 (thr_type == pgc_thread) || (thr_type == compiler_thread && BackgroundCompilation))) { 1265 warning("schedctl behavior undefined when Compiler/VM/GC Threads are Unbound"); 1266 } 1267 ); 1268 1269 1270 // Mark that we don't have an lwp or thread id yet. 1271 // In case we attempt to set the priority before the thread starts. 1272 osthread->set_lwp_id(-1); 1273 osthread->set_thread_id(-1); 1274 1275 status = thr_create(NULL, stack_size, java_start, thread, flags, &tid); 1276 if (status != 0) { 1277 if (PrintMiscellaneous && (Verbose || WizardMode)) { 1278 perror("os::create_thread"); 1279 } 1280 thread->set_osthread(NULL); 1281 // Need to clean up stuff we've allocated so far 1282 delete osthread; 1283 return false; 1284 } 1285 1286 Atomic::inc(&os::Solaris::_os_thread_count); 1287 1288 // Store info on the Solaris thread into the OSThread 1289 osthread->set_thread_id(tid); 1290 1291 // Remember that we created this thread so we can set priority on it 1292 osthread->set_vm_created(); 1293 1294 // Set the default thread priority otherwise use NormalPriority 1295 1296 if ( UseThreadPriorities ) { 1297 thr_setprio(tid, (DefaultThreadPriority == -1) ? 1298 java_to_os_priority[NormPriority] : 1299 DefaultThreadPriority); 1300 } 1301 1302 // Initial thread state is INITIALIZED, not SUSPENDED 1303 osthread->set_state(INITIALIZED); 1304 1305 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain 1306 return true; 1307} 1308 1309/* defined for >= Solaris 10. This allows builds on earlier versions 1310 * of Solaris to take advantage of the newly reserved Solaris JVM signals 1311 * With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2 1312 * and -XX:+UseAltSigs does nothing since these should have no conflict 1313 */ 1314#if !defined(SIGJVM1) 1315#define SIGJVM1 39 1316#define SIGJVM2 40 1317#endif 1318 1319debug_only(static bool signal_sets_initialized = false); 1320static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs; 1321int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL; 1322int os::Solaris::_SIGasync = ASYNC_SIGNAL; 1323 1324bool os::Solaris::is_sig_ignored(int sig) { 1325 struct sigaction oact; 1326 sigaction(sig, (struct sigaction*)NULL, &oact); 1327 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction) 1328 : CAST_FROM_FN_PTR(void*, oact.sa_handler); 1329 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) 1330 return true; 1331 else 1332 return false; 1333} 1334 1335// Note: SIGRTMIN is a macro that calls sysconf() so it will 1336// dynamically detect SIGRTMIN value for the system at runtime, not buildtime 1337static bool isJVM1available() { 1338 return SIGJVM1 < SIGRTMIN; 1339} 1340 1341void os::Solaris::signal_sets_init() { 1342 // Should also have an assertion stating we are still single-threaded. 1343 assert(!signal_sets_initialized, "Already initialized"); 1344 // Fill in signals that are necessarily unblocked for all threads in 1345 // the VM. Currently, we unblock the following signals: 1346 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden 1347 // by -Xrs (=ReduceSignalUsage)); 1348 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all 1349 // other threads. The "ReduceSignalUsage" boolean tells us not to alter 1350 // the dispositions or masks wrt these signals. 1351 // Programs embedding the VM that want to use the above signals for their 1352 // own purposes must, at this time, use the "-Xrs" option to prevent 1353 // interference with shutdown hooks and BREAK_SIGNAL thread dumping. 1354 // (See bug 4345157, and other related bugs). 1355 // In reality, though, unblocking these signals is really a nop, since 1356 // these signals are not blocked by default. 1357 sigemptyset(&unblocked_sigs); 1358 sigemptyset(&allowdebug_blocked_sigs); 1359 sigaddset(&unblocked_sigs, SIGILL); 1360 sigaddset(&unblocked_sigs, SIGSEGV); 1361 sigaddset(&unblocked_sigs, SIGBUS); 1362 sigaddset(&unblocked_sigs, SIGFPE); 1363 1364 if (isJVM1available) { 1365 os::Solaris::set_SIGinterrupt(SIGJVM1); 1366 os::Solaris::set_SIGasync(SIGJVM2); 1367 } else if (UseAltSigs) { 1368 os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL); 1369 os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL); 1370 } else { 1371 os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL); 1372 os::Solaris::set_SIGasync(ASYNC_SIGNAL); 1373 } 1374 1375 sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt()); 1376 sigaddset(&unblocked_sigs, os::Solaris::SIGasync()); 1377 1378 if (!ReduceSignalUsage) { 1379 if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) { 1380 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL); 1381 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL); 1382 } 1383 if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) { 1384 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL); 1385 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL); 1386 } 1387 if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) { 1388 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL); 1389 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL); 1390 } 1391 } 1392 // Fill in signals that are blocked by all but the VM thread. 1393 sigemptyset(&vm_sigs); 1394 if (!ReduceSignalUsage) 1395 sigaddset(&vm_sigs, BREAK_SIGNAL); 1396 debug_only(signal_sets_initialized = true); 1397 1398 // For diagnostics only used in run_periodic_checks 1399 sigemptyset(&check_signal_done); 1400} 1401 1402// These are signals that are unblocked while a thread is running Java. 1403// (For some reason, they get blocked by default.) 1404sigset_t* os::Solaris::unblocked_signals() { 1405 assert(signal_sets_initialized, "Not initialized"); 1406 return &unblocked_sigs; 1407} 1408 1409// These are the signals that are blocked while a (non-VM) thread is 1410// running Java. Only the VM thread handles these signals. 1411sigset_t* os::Solaris::vm_signals() { 1412 assert(signal_sets_initialized, "Not initialized"); 1413 return &vm_sigs; 1414} 1415 1416// These are signals that are blocked during cond_wait to allow debugger in 1417sigset_t* os::Solaris::allowdebug_blocked_signals() { 1418 assert(signal_sets_initialized, "Not initialized"); 1419 return &allowdebug_blocked_sigs; 1420} 1421 1422// First crack at OS-specific initialization, from inside the new thread. 1423void os::initialize_thread() { 1424 int r = thr_main() ; 1425 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; 1426 if (r) { 1427 JavaThread* jt = (JavaThread *)Thread::current(); 1428 assert(jt != NULL,"Sanity check"); 1429 size_t stack_size; 1430 address base = jt->stack_base(); 1431 if (Arguments::created_by_java_launcher()) { 1432 // Use 2MB to allow for Solaris 7 64 bit mode. 1433 stack_size = JavaThread::stack_size_at_create() == 0 1434 ? 2048*K : JavaThread::stack_size_at_create(); 1435 1436 // There are rare cases when we may have already used more than 1437 // the basic stack size allotment before this method is invoked. 1438 // Attempt to allow for a normally sized java_stack. 1439 size_t current_stack_offset = (size_t)(base - (address)&stack_size); 1440 stack_size += ReservedSpace::page_align_size_down(current_stack_offset); 1441 } else { 1442 // 6269555: If we were not created by a Java launcher, i.e. if we are 1443 // running embedded in a native application, treat the primordial thread 1444 // as much like a native attached thread as possible. This means using 1445 // the current stack size from thr_stksegment(), unless it is too large 1446 // to reliably setup guard pages. A reasonable max size is 8MB. 1447 size_t current_size = current_stack_size(); 1448 // This should never happen, but just in case.... 1449 if (current_size == 0) current_size = 2 * K * K; 1450 stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size; 1451 } 1452 address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());; 1453 stack_size = (size_t)(base - bottom); 1454 1455 assert(stack_size > 0, "Stack size calculation problem"); 1456 1457 if (stack_size > jt->stack_size()) { 1458 NOT_PRODUCT( 1459 struct rlimit limits; 1460 getrlimit(RLIMIT_STACK, &limits); 1461 size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur); 1462 assert(size >= jt->stack_size(), "Stack size problem in main thread"); 1463 ) 1464 tty->print_cr( 1465 "Stack size of %d Kb exceeds current limit of %d Kb.\n" 1466 "(Stack sizes are rounded up to a multiple of the system page size.)\n" 1467 "See limit(1) to increase the stack size limit.", 1468 stack_size / K, jt->stack_size() / K); 1469 vm_exit(1); 1470 } 1471 assert(jt->stack_size() >= stack_size, 1472 "Attempt to map more stack than was allocated"); 1473 jt->set_stack_size(stack_size); 1474 } 1475 1476 // 5/22/01: Right now alternate signal stacks do not handle 1477 // throwing stack overflow exceptions, see bug 4463178 1478 // Until a fix is found for this, T2 will NOT imply alternate signal 1479 // stacks. 1480 // If using T2 libthread threads, install an alternate signal stack. 1481 // Because alternate stacks associate with LWPs on Solaris, 1482 // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads 1483 // we prefer to explicitly stack bang. 1484 // If not using T2 libthread, but using UseBoundThreads any threads 1485 // (primordial thread, jni_attachCurrentThread) we do not create, 1486 // probably are not bound, therefore they can not have an alternate 1487 // signal stack. Since our stack banging code is generated and 1488 // is shared across threads, all threads must be bound to allow 1489 // using alternate signal stacks. The alternative is to interpose 1490 // on _lwp_create to associate an alt sig stack with each LWP, 1491 // and this could be a problem when the JVM is embedded. 1492 // We would prefer to use alternate signal stacks with T2 1493 // Since there is currently no accurate way to detect T2 1494 // we do not. Assuming T2 when running T1 causes sig 11s or assertions 1495 // on installing alternate signal stacks 1496 1497 1498 // 05/09/03: removed alternate signal stack support for Solaris 1499 // The alternate signal stack mechanism is no longer needed to 1500 // handle stack overflow. This is now handled by allocating 1501 // guard pages (red zone) and stackbanging. 1502 // Initially the alternate signal stack mechanism was removed because 1503 // it did not work with T1 llibthread. Alternate 1504 // signal stacks MUST have all threads bound to lwps. Applications 1505 // can create their own threads and attach them without their being 1506 // bound under T1. This is frequently the case for the primordial thread. 1507 // If we were ever to reenable this mechanism we would need to 1508 // use the dynamic check for T2 libthread. 1509 1510 os::Solaris::init_thread_fpu_state(); 1511} 1512 1513 1514 1515// Free Solaris resources related to the OSThread 1516void os::free_thread(OSThread* osthread) { 1517 assert(osthread != NULL, "os::free_thread but osthread not set"); 1518 1519 1520 // We are told to free resources of the argument thread, 1521 // but we can only really operate on the current thread. 1522 // The main thread must take the VMThread down synchronously 1523 // before the main thread exits and frees up CodeHeap 1524 guarantee((Thread::current()->osthread() == osthread 1525 || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread"); 1526 if (Thread::current()->osthread() == osthread) { 1527 // Restore caller's signal mask 1528 sigset_t sigmask = osthread->caller_sigmask(); 1529 thr_sigsetmask(SIG_SETMASK, &sigmask, NULL); 1530 } 1531 delete osthread; 1532} 1533 1534void os::pd_start_thread(Thread* thread) { 1535 int status = thr_continue(thread->osthread()->thread_id()); 1536 assert_status(status == 0, status, "thr_continue failed"); 1537} 1538 1539 1540intx os::current_thread_id() { 1541 return (intx)thr_self(); 1542} 1543 1544static pid_t _initial_pid = 0; 1545 1546int os::current_process_id() { 1547 return (int)(_initial_pid ? _initial_pid : getpid()); 1548} 1549 1550int os::allocate_thread_local_storage() { 1551 // %%% in Win32 this allocates a memory segment pointed to by a 1552 // register. Dan Stein can implement a similar feature in 1553 // Solaris. Alternatively, the VM can do the same thing 1554 // explicitly: malloc some storage and keep the pointer in a 1555 // register (which is part of the thread's context) (or keep it 1556 // in TLS). 1557 // %%% In current versions of Solaris, thr_self and TSD can 1558 // be accessed via short sequences of displaced indirections. 1559 // The value of thr_self is available as %g7(36). 1560 // The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4), 1561 // assuming that the current thread already has a value bound to k. 1562 // It may be worth experimenting with such access patterns, 1563 // and later having the parameters formally exported from a Solaris 1564 // interface. I think, however, that it will be faster to 1565 // maintain the invariant that %g2 always contains the 1566 // JavaThread in Java code, and have stubs simply 1567 // treat %g2 as a caller-save register, preserving it in a %lN. 1568 thread_key_t tk; 1569 if (thr_keycreate( &tk, NULL ) ) 1570 fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed " 1571 "(%s)", strerror(errno))); 1572 return int(tk); 1573} 1574 1575void os::free_thread_local_storage(int index) { 1576 // %%% don't think we need anything here 1577 // if ( pthread_key_delete((pthread_key_t) tk) ) 1578 // fatal("os::free_thread_local_storage: pthread_key_delete failed"); 1579} 1580 1581#define SMALLINT 32 // libthread allocate for tsd_common is a version specific 1582 // small number - point is NO swap space available 1583void os::thread_local_storage_at_put(int index, void* value) { 1584 // %%% this is used only in threadLocalStorage.cpp 1585 if (thr_setspecific((thread_key_t)index, value)) { 1586 if (errno == ENOMEM) { 1587 vm_exit_out_of_memory(SMALLINT, "thr_setspecific: out of swap space"); 1588 } else { 1589 fatal(err_msg("os::thread_local_storage_at_put: thr_setspecific failed " 1590 "(%s)", strerror(errno))); 1591 } 1592 } else { 1593 ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ; 1594 } 1595} 1596 1597// This function could be called before TLS is initialized, for example, when 1598// VM receives an async signal or when VM causes a fatal error during 1599// initialization. Return NULL if thr_getspecific() fails. 1600void* os::thread_local_storage_at(int index) { 1601 // %%% this is used only in threadLocalStorage.cpp 1602 void* r = NULL; 1603 return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r; 1604} 1605 1606 1607const int NANOSECS_PER_MILLISECS = 1000000; 1608// gethrtime can move backwards if read from one cpu and then a different cpu 1609// getTimeNanos is guaranteed to not move backward on Solaris 1610// local spinloop created as faster for a CAS on an int than 1611// a CAS on a 64bit jlong. Also Atomic::cmpxchg for jlong is not 1612// supported on sparc v8 or pre supports_cx8 intel boxes. 1613// oldgetTimeNanos for systems which do not support CAS on 64bit jlong 1614// i.e. sparc v8 and pre supports_cx8 (i486) intel boxes 1615inline hrtime_t oldgetTimeNanos() { 1616 int gotlock = LOCK_INVALID; 1617 hrtime_t newtime = gethrtime(); 1618 1619 for (;;) { 1620// grab lock for max_hrtime 1621 int curlock = max_hrtime_lock; 1622 if (curlock & LOCK_BUSY) continue; 1623 if (gotlock = Atomic::cmpxchg(LOCK_BUSY, &max_hrtime_lock, LOCK_FREE) != LOCK_FREE) continue; 1624 if (newtime > max_hrtime) { 1625 max_hrtime = newtime; 1626 } else { 1627 newtime = max_hrtime; 1628 } 1629 // release lock 1630 max_hrtime_lock = LOCK_FREE; 1631 return newtime; 1632 } 1633} 1634// gethrtime can move backwards if read from one cpu and then a different cpu 1635// getTimeNanos is guaranteed to not move backward on Solaris 1636inline hrtime_t getTimeNanos() { 1637 if (VM_Version::supports_cx8()) { 1638 const hrtime_t now = gethrtime(); 1639 // Use atomic long load since 32-bit x86 uses 2 registers to keep long. 1640 const hrtime_t prev = Atomic::load((volatile jlong*)&max_hrtime); 1641 if (now <= prev) return prev; // same or retrograde time; 1642 const hrtime_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&max_hrtime, prev); 1643 assert(obsv >= prev, "invariant"); // Monotonicity 1644 // If the CAS succeeded then we're done and return "now". 1645 // If the CAS failed and the observed value "obs" is >= now then 1646 // we should return "obs". If the CAS failed and now > obs > prv then 1647 // some other thread raced this thread and installed a new value, in which case 1648 // we could either (a) retry the entire operation, (b) retry trying to install now 1649 // or (c) just return obs. We use (c). No loop is required although in some cases 1650 // we might discard a higher "now" value in deference to a slightly lower but freshly 1651 // installed obs value. That's entirely benign -- it admits no new orderings compared 1652 // to (a) or (b) -- and greatly reduces coherence traffic. 1653 // We might also condition (c) on the magnitude of the delta between obs and now. 1654 // Avoiding excessive CAS operations to hot RW locations is critical. 1655 // See http://blogs.sun.com/dave/entry/cas_and_cache_trivia_invalidate 1656 return (prev == obsv) ? now : obsv ; 1657 } else { 1658 return oldgetTimeNanos(); 1659 } 1660} 1661 1662// Time since start-up in seconds to a fine granularity. 1663// Used by VMSelfDestructTimer and the MemProfiler. 1664double os::elapsedTime() { 1665 return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz; 1666} 1667 1668jlong os::elapsed_counter() { 1669 return (jlong)(getTimeNanos() - first_hrtime); 1670} 1671 1672jlong os::elapsed_frequency() { 1673 return hrtime_hz; 1674} 1675 1676// Return the real, user, and system times in seconds from an 1677// arbitrary fixed point in the past. 1678bool os::getTimesSecs(double* process_real_time, 1679 double* process_user_time, 1680 double* process_system_time) { 1681 struct tms ticks; 1682 clock_t real_ticks = times(&ticks); 1683 1684 if (real_ticks == (clock_t) (-1)) { 1685 return false; 1686 } else { 1687 double ticks_per_second = (double) clock_tics_per_sec; 1688 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second; 1689 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second; 1690 // For consistency return the real time from getTimeNanos() 1691 // converted to seconds. 1692 *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS); 1693 1694 return true; 1695 } 1696} 1697 1698bool os::supports_vtime() { return true; } 1699 1700bool os::enable_vtime() { 1701 int fd = open("/proc/self/ctl", O_WRONLY); 1702 if (fd == -1) 1703 return false; 1704 1705 long cmd[] = { PCSET, PR_MSACCT }; 1706 int res = write(fd, cmd, sizeof(long) * 2); 1707 close(fd); 1708 if (res != sizeof(long) * 2) 1709 return false; 1710 1711 return true; 1712} 1713 1714bool os::vtime_enabled() { 1715 int fd = open("/proc/self/status", O_RDONLY); 1716 if (fd == -1) 1717 return false; 1718 1719 pstatus_t status; 1720 int res = read(fd, (void*) &status, sizeof(pstatus_t)); 1721 close(fd); 1722 if (res != sizeof(pstatus_t)) 1723 return false; 1724 1725 return status.pr_flags & PR_MSACCT; 1726} 1727 1728double os::elapsedVTime() { 1729 return (double)gethrvtime() / (double)hrtime_hz; 1730} 1731 1732// Used internally for comparisons only 1733// getTimeMillis guaranteed to not move backwards on Solaris 1734jlong getTimeMillis() { 1735 jlong nanotime = getTimeNanos(); 1736 return (jlong)(nanotime / NANOSECS_PER_MILLISECS); 1737} 1738 1739// Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis 1740jlong os::javaTimeMillis() { 1741 timeval t; 1742 if (gettimeofday( &t, NULL) == -1) 1743 fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno))); 1744 return jlong(t.tv_sec) * 1000 + jlong(t.tv_usec) / 1000; 1745} 1746 1747jlong os::javaTimeNanos() { 1748 return (jlong)getTimeNanos(); 1749} 1750 1751void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { 1752 info_ptr->max_value = ALL_64_BITS; // gethrtime() uses all 64 bits 1753 info_ptr->may_skip_backward = false; // not subject to resetting or drifting 1754 info_ptr->may_skip_forward = false; // not subject to resetting or drifting 1755 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time 1756} 1757 1758char * os::local_time_string(char *buf, size_t buflen) { 1759 struct tm t; 1760 time_t long_time; 1761 time(&long_time); 1762 localtime_r(&long_time, &t); 1763 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d", 1764 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, 1765 t.tm_hour, t.tm_min, t.tm_sec); 1766 return buf; 1767} 1768 1769// Note: os::shutdown() might be called very early during initialization, or 1770// called from signal handler. Before adding something to os::shutdown(), make 1771// sure it is async-safe and can handle partially initialized VM. 1772void os::shutdown() { 1773 1774 // allow PerfMemory to attempt cleanup of any persistent resources 1775 perfMemory_exit(); 1776 1777 // needs to remove object in file system 1778 AttachListener::abort(); 1779 1780 // flush buffered output, finish log files 1781 ostream_abort(); 1782 1783 // Check for abort hook 1784 abort_hook_t abort_hook = Arguments::abort_hook(); 1785 if (abort_hook != NULL) { 1786 abort_hook(); 1787 } 1788} 1789 1790// Note: os::abort() might be called very early during initialization, or 1791// called from signal handler. Before adding something to os::abort(), make 1792// sure it is async-safe and can handle partially initialized VM. 1793void os::abort(bool dump_core) { 1794 os::shutdown(); 1795 if (dump_core) { 1796#ifndef PRODUCT 1797 fdStream out(defaultStream::output_fd()); 1798 out.print_raw("Current thread is "); 1799 char buf[16]; 1800 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id()); 1801 out.print_raw_cr(buf); 1802 out.print_raw_cr("Dumping core ..."); 1803#endif 1804 ::abort(); // dump core (for debugging) 1805 } 1806 1807 ::exit(1); 1808} 1809 1810// Die immediately, no exit hook, no abort hook, no cleanup. 1811void os::die() { 1812 _exit(-1); 1813} 1814 1815// unused 1816void os::set_error_file(const char *logfile) {} 1817 1818// DLL functions 1819 1820const char* os::dll_file_extension() { return ".so"; } 1821 1822const char* os::get_temp_directory() { 1823 const char *prop = Arguments::get_property("java.io.tmpdir"); 1824 return prop == NULL ? "/tmp" : prop; 1825} 1826 1827static bool file_exists(const char* filename) { 1828 struct stat statbuf; 1829 if (filename == NULL || strlen(filename) == 0) { 1830 return false; 1831 } 1832 return os::stat(filename, &statbuf) == 0; 1833} 1834 1835void os::dll_build_name(char* buffer, size_t buflen, 1836 const char* pname, const char* fname) { 1837 // Copied from libhpi 1838 const size_t pnamelen = pname ? strlen(pname) : 0; 1839 1840 // Quietly truncate on buffer overflow. Should be an error. 1841 if (pnamelen + strlen(fname) + 10 > (size_t) buflen) { 1842 *buffer = '\0'; 1843 return; 1844 } 1845 1846 if (pnamelen == 0) { 1847 snprintf(buffer, buflen, "lib%s.so", fname); 1848 } else if (strchr(pname, *os::path_separator()) != NULL) { 1849 int n; 1850 char** pelements = split_path(pname, &n); 1851 for (int i = 0 ; i < n ; i++) { 1852 // really shouldn't be NULL but what the heck, check can't hurt 1853 if (pelements[i] == NULL || strlen(pelements[i]) == 0) { 1854 continue; // skip the empty path values 1855 } 1856 snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname); 1857 if (file_exists(buffer)) { 1858 break; 1859 } 1860 } 1861 // release the storage 1862 for (int i = 0 ; i < n ; i++) { 1863 if (pelements[i] != NULL) { 1864 FREE_C_HEAP_ARRAY(char, pelements[i]); 1865 } 1866 } 1867 if (pelements != NULL) { 1868 FREE_C_HEAP_ARRAY(char*, pelements); 1869 } 1870 } else { 1871 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname); 1872 } 1873} 1874 1875const char* os::get_current_directory(char *buf, int buflen) { 1876 return getcwd(buf, buflen); 1877} 1878 1879// check if addr is inside libjvm[_g].so 1880bool os::address_is_in_vm(address addr) { 1881 static address libjvm_base_addr; 1882 Dl_info dlinfo; 1883 1884 if (libjvm_base_addr == NULL) { 1885 dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo); 1886 libjvm_base_addr = (address)dlinfo.dli_fbase; 1887 assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm"); 1888 } 1889 1890 if (dladdr((void *)addr, &dlinfo)) { 1891 if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true; 1892 } 1893 1894 return false; 1895} 1896 1897typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int); 1898static dladdr1_func_type dladdr1_func = NULL; 1899 1900bool os::dll_address_to_function_name(address addr, char *buf, 1901 int buflen, int * offset) { 1902 Dl_info dlinfo; 1903 1904 // dladdr1_func was initialized in os::init() 1905 if (dladdr1_func){ 1906 // yes, we have dladdr1 1907 1908 // Support for dladdr1 is checked at runtime; it may be 1909 // available even if the vm is built on a machine that does 1910 // not have dladdr1 support. Make sure there is a value for 1911 // RTLD_DL_SYMENT. 1912 #ifndef RTLD_DL_SYMENT 1913 #define RTLD_DL_SYMENT 1 1914 #endif 1915 Sym * info; 1916 if (dladdr1_func((void *)addr, &dlinfo, (void **)&info, 1917 RTLD_DL_SYMENT)) { 1918 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname); 1919 if (offset) *offset = addr - (address)dlinfo.dli_saddr; 1920 1921 // check if the returned symbol really covers addr 1922 return ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr); 1923 } else { 1924 if (buf) buf[0] = '\0'; 1925 if (offset) *offset = -1; 1926 return false; 1927 } 1928 } else { 1929 // no, only dladdr is available 1930 if(dladdr((void *)addr, &dlinfo)) { 1931 if (buf) jio_snprintf(buf, buflen, dlinfo.dli_sname); 1932 if (offset) *offset = addr - (address)dlinfo.dli_saddr; 1933 return true; 1934 } else { 1935 if (buf) buf[0] = '\0'; 1936 if (offset) *offset = -1; 1937 return false; 1938 } 1939 } 1940} 1941 1942bool os::dll_address_to_library_name(address addr, char* buf, 1943 int buflen, int* offset) { 1944 Dl_info dlinfo; 1945 1946 if (dladdr((void*)addr, &dlinfo)){ 1947 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname); 1948 if (offset) *offset = addr - (address)dlinfo.dli_fbase; 1949 return true; 1950 } else { 1951 if (buf) buf[0] = '\0'; 1952 if (offset) *offset = -1; 1953 return false; 1954 } 1955} 1956 1957// Prints the names and full paths of all opened dynamic libraries 1958// for current process 1959void os::print_dll_info(outputStream * st) { 1960 Dl_info dli; 1961 void *handle; 1962 Link_map *map; 1963 Link_map *p; 1964 1965 st->print_cr("Dynamic libraries:"); st->flush(); 1966 1967 if (!dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli)) { 1968 st->print_cr("Error: Cannot print dynamic libraries."); 1969 return; 1970 } 1971 handle = dlopen(dli.dli_fname, RTLD_LAZY); 1972 if (handle == NULL) { 1973 st->print_cr("Error: Cannot print dynamic libraries."); 1974 return; 1975 } 1976 dlinfo(handle, RTLD_DI_LINKMAP, &map); 1977 if (map == NULL) { 1978 st->print_cr("Error: Cannot print dynamic libraries."); 1979 return; 1980 } 1981 1982 while (map->l_prev != NULL) 1983 map = map->l_prev; 1984 1985 while (map != NULL) { 1986 st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name); 1987 map = map->l_next; 1988 } 1989 1990 dlclose(handle); 1991} 1992 1993 // Loads .dll/.so and 1994 // in case of error it checks if .dll/.so was built for the 1995 // same architecture as Hotspot is running on 1996 1997void * os::dll_load(const char *filename, char *ebuf, int ebuflen) 1998{ 1999 void * result= ::dlopen(filename, RTLD_LAZY); 2000 if (result != NULL) { 2001 // Successful loading 2002 return result; 2003 } 2004 2005 Elf32_Ehdr elf_head; 2006 2007 // Read system error message into ebuf 2008 // It may or may not be overwritten below 2009 ::strncpy(ebuf, ::dlerror(), ebuflen-1); 2010 ebuf[ebuflen-1]='\0'; 2011 int diag_msg_max_length=ebuflen-strlen(ebuf); 2012 char* diag_msg_buf=ebuf+strlen(ebuf); 2013 2014 if (diag_msg_max_length==0) { 2015 // No more space in ebuf for additional diagnostics message 2016 return NULL; 2017 } 2018 2019 2020 int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK); 2021 2022 if (file_descriptor < 0) { 2023 // Can't open library, report dlerror() message 2024 return NULL; 2025 } 2026 2027 bool failed_to_read_elf_head= 2028 (sizeof(elf_head)!= 2029 (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ; 2030 2031 ::close(file_descriptor); 2032 if (failed_to_read_elf_head) { 2033 // file i/o error - report dlerror() msg 2034 return NULL; 2035 } 2036 2037 typedef struct { 2038 Elf32_Half code; // Actual value as defined in elf.h 2039 Elf32_Half compat_class; // Compatibility of archs at VM's sense 2040 char elf_class; // 32 or 64 bit 2041 char endianess; // MSB or LSB 2042 char* name; // String representation 2043 } arch_t; 2044 2045 static const arch_t arch_array[]={ 2046 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, 2047 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"}, 2048 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"}, 2049 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"}, 2050 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"}, 2051 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"}, 2052 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"}, 2053 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"}, 2054 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"} 2055 }; 2056 2057 #if (defined IA32) 2058 static Elf32_Half running_arch_code=EM_386; 2059 #elif (defined AMD64) 2060 static Elf32_Half running_arch_code=EM_X86_64; 2061 #elif (defined IA64) 2062 static Elf32_Half running_arch_code=EM_IA_64; 2063 #elif (defined __sparc) && (defined _LP64) 2064 static Elf32_Half running_arch_code=EM_SPARCV9; 2065 #elif (defined __sparc) && (!defined _LP64) 2066 static Elf32_Half running_arch_code=EM_SPARC; 2067 #elif (defined __powerpc64__) 2068 static Elf32_Half running_arch_code=EM_PPC64; 2069 #elif (defined __powerpc__) 2070 static Elf32_Half running_arch_code=EM_PPC; 2071 #else 2072 #error Method os::dll_load requires that one of following is defined:\ 2073 IA32, AMD64, IA64, __sparc, __powerpc__ 2074 #endif 2075 2076 // Identify compatability class for VM's architecture and library's architecture 2077 // Obtain string descriptions for architectures 2078 2079 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL}; 2080 int running_arch_index=-1; 2081 2082 for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) { 2083 if (running_arch_code == arch_array[i].code) { 2084 running_arch_index = i; 2085 } 2086 if (lib_arch.code == arch_array[i].code) { 2087 lib_arch.compat_class = arch_array[i].compat_class; 2088 lib_arch.name = arch_array[i].name; 2089 } 2090 } 2091 2092 assert(running_arch_index != -1, 2093 "Didn't find running architecture code (running_arch_code) in arch_array"); 2094 if (running_arch_index == -1) { 2095 // Even though running architecture detection failed 2096 // we may still continue with reporting dlerror() message 2097 return NULL; 2098 } 2099 2100 if (lib_arch.endianess != arch_array[running_arch_index].endianess) { 2101 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)"); 2102 return NULL; 2103 } 2104 2105 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) { 2106 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)"); 2107 return NULL; 2108 } 2109 2110 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) { 2111 if ( lib_arch.name!=NULL ) { 2112 ::snprintf(diag_msg_buf, diag_msg_max_length-1, 2113 " (Possible cause: can't load %s-bit .so on a %s-bit platform)", 2114 lib_arch.name, arch_array[running_arch_index].name); 2115 } else { 2116 ::snprintf(diag_msg_buf, diag_msg_max_length-1, 2117 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)", 2118 lib_arch.code, 2119 arch_array[running_arch_index].name); 2120 } 2121 } 2122 2123 return NULL; 2124} 2125 2126void* os::dll_lookup(void* handle, const char* name) { 2127 return dlsym(handle, name); 2128} 2129 2130 2131bool _print_ascii_file(const char* filename, outputStream* st) { 2132 int fd = open(filename, O_RDONLY); 2133 if (fd == -1) { 2134 return false; 2135 } 2136 2137 char buf[32]; 2138 int bytes; 2139 while ((bytes = read(fd, buf, sizeof(buf))) > 0) { 2140 st->print_raw(buf, bytes); 2141 } 2142 2143 close(fd); 2144 2145 return true; 2146} 2147 2148void os::print_os_info(outputStream* st) { 2149 st->print("OS:"); 2150 2151 if (!_print_ascii_file("/etc/release", st)) { 2152 st->print("Solaris"); 2153 } 2154 st->cr(); 2155 2156 // kernel 2157 st->print("uname:"); 2158 struct utsname name; 2159 uname(&name); 2160 st->print(name.sysname); st->print(" "); 2161 st->print(name.release); st->print(" "); 2162 st->print(name.version); st->print(" "); 2163 st->print(name.machine); 2164 2165 // libthread 2166 if (os::Solaris::T2_libthread()) st->print(" (T2 libthread)"); 2167 else st->print(" (T1 libthread)"); 2168 st->cr(); 2169 2170 // rlimit 2171 st->print("rlimit:"); 2172 struct rlimit rlim; 2173 2174 st->print(" STACK "); 2175 getrlimit(RLIMIT_STACK, &rlim); 2176 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 2177 else st->print("%uk", rlim.rlim_cur >> 10); 2178 2179 st->print(", CORE "); 2180 getrlimit(RLIMIT_CORE, &rlim); 2181 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 2182 else st->print("%uk", rlim.rlim_cur >> 10); 2183 2184 st->print(", NOFILE "); 2185 getrlimit(RLIMIT_NOFILE, &rlim); 2186 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 2187 else st->print("%d", rlim.rlim_cur); 2188 2189 st->print(", AS "); 2190 getrlimit(RLIMIT_AS, &rlim); 2191 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 2192 else st->print("%uk", rlim.rlim_cur >> 10); 2193 st->cr(); 2194 2195 // load average 2196 st->print("load average:"); 2197 double loadavg[3]; 2198 os::loadavg(loadavg, 3); 2199 st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); 2200 st->cr(); 2201} 2202 2203 2204static bool check_addr0(outputStream* st) { 2205 jboolean status = false; 2206 int fd = open("/proc/self/map",O_RDONLY); 2207 if (fd >= 0) { 2208 prmap_t p; 2209 while(read(fd, &p, sizeof(p)) > 0) { 2210 if (p.pr_vaddr == 0x0) { 2211 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname); 2212 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname); 2213 st->print("Access:"); 2214 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-"); 2215 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-"); 2216 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-"); 2217 st->cr(); 2218 status = true; 2219 } 2220 close(fd); 2221 } 2222 } 2223 return status; 2224} 2225 2226void os::print_memory_info(outputStream* st) { 2227 st->print("Memory:"); 2228 st->print(" %dk page", os::vm_page_size()>>10); 2229 st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10); 2230 st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10); 2231 st->cr(); 2232 (void) check_addr0(st); 2233} 2234 2235// Taken from /usr/include/sys/machsig.h Supposed to be architecture specific 2236// but they're the same for all the solaris architectures that we support. 2237const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR", 2238 "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG", 2239 "ILL_COPROC", "ILL_BADSTK" }; 2240 2241const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV", 2242 "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES", 2243 "FPE_FLTINV", "FPE_FLTSUB" }; 2244 2245const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" }; 2246 2247const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" }; 2248 2249void os::print_siginfo(outputStream* st, void* siginfo) { 2250 st->print("siginfo:"); 2251 2252 const int buflen = 100; 2253 char buf[buflen]; 2254 siginfo_t *si = (siginfo_t*)siginfo; 2255 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen)); 2256 char *err = strerror(si->si_errno); 2257 if (si->si_errno != 0 && err != NULL) { 2258 st->print("si_errno=%s", err); 2259 } else { 2260 st->print("si_errno=%d", si->si_errno); 2261 } 2262 const int c = si->si_code; 2263 assert(c > 0, "unexpected si_code"); 2264 switch (si->si_signo) { 2265 case SIGILL: 2266 st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]); 2267 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2268 break; 2269 case SIGFPE: 2270 st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]); 2271 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2272 break; 2273 case SIGSEGV: 2274 st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]); 2275 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2276 break; 2277 case SIGBUS: 2278 st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]); 2279 st->print(", si_addr=" PTR_FORMAT, si->si_addr); 2280 break; 2281 default: 2282 st->print(", si_code=%d", si->si_code); 2283 // no si_addr 2284 } 2285 2286 if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) && 2287 UseSharedSpaces) { 2288 FileMapInfo* mapinfo = FileMapInfo::current_info(); 2289 if (mapinfo->is_in_shared_space(si->si_addr)) { 2290 st->print("\n\nError accessing class data sharing archive." \ 2291 " Mapped file inaccessible during execution, " \ 2292 " possible disk/network problem."); 2293 } 2294 } 2295 st->cr(); 2296} 2297 2298// Moved from whole group, because we need them here for diagnostic 2299// prints. 2300#define OLDMAXSIGNUM 32 2301static int Maxsignum = 0; 2302static int *ourSigFlags = NULL; 2303 2304extern "C" void sigINTRHandler(int, siginfo_t*, void*); 2305 2306int os::Solaris::get_our_sigflags(int sig) { 2307 assert(ourSigFlags!=NULL, "signal data structure not initialized"); 2308 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range"); 2309 return ourSigFlags[sig]; 2310} 2311 2312void os::Solaris::set_our_sigflags(int sig, int flags) { 2313 assert(ourSigFlags!=NULL, "signal data structure not initialized"); 2314 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range"); 2315 ourSigFlags[sig] = flags; 2316} 2317 2318 2319static const char* get_signal_handler_name(address handler, 2320 char* buf, int buflen) { 2321 int offset; 2322 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset); 2323 if (found) { 2324 // skip directory names 2325 const char *p1, *p2; 2326 p1 = buf; 2327 size_t len = strlen(os::file_separator()); 2328 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len; 2329 jio_snprintf(buf, buflen, "%s+0x%x", p1, offset); 2330 } else { 2331 jio_snprintf(buf, buflen, PTR_FORMAT, handler); 2332 } 2333 return buf; 2334} 2335 2336static void print_signal_handler(outputStream* st, int sig, 2337 char* buf, size_t buflen) { 2338 struct sigaction sa; 2339 2340 sigaction(sig, NULL, &sa); 2341 2342 st->print("%s: ", os::exception_name(sig, buf, buflen)); 2343 2344 address handler = (sa.sa_flags & SA_SIGINFO) 2345 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction) 2346 : CAST_FROM_FN_PTR(address, sa.sa_handler); 2347 2348 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) { 2349 st->print("SIG_DFL"); 2350 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) { 2351 st->print("SIG_IGN"); 2352 } else { 2353 st->print("[%s]", get_signal_handler_name(handler, buf, buflen)); 2354 } 2355 2356 st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask); 2357 2358 address rh = VMError::get_resetted_sighandler(sig); 2359 // May be, handler was resetted by VMError? 2360 if(rh != NULL) { 2361 handler = rh; 2362 sa.sa_flags = VMError::get_resetted_sigflags(sig); 2363 } 2364 2365 st->print(", sa_flags=" PTR32_FORMAT, sa.sa_flags); 2366 2367 // Check: is it our handler? 2368 if(handler == CAST_FROM_FN_PTR(address, signalHandler) || 2369 handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) { 2370 // It is our signal handler 2371 // check for flags 2372 if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) { 2373 st->print( 2374 ", flags was changed from " PTR32_FORMAT ", consider using jsig library", 2375 os::Solaris::get_our_sigflags(sig)); 2376 } 2377 } 2378 st->cr(); 2379} 2380 2381void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 2382 st->print_cr("Signal Handlers:"); 2383 print_signal_handler(st, SIGSEGV, buf, buflen); 2384 print_signal_handler(st, SIGBUS , buf, buflen); 2385 print_signal_handler(st, SIGFPE , buf, buflen); 2386 print_signal_handler(st, SIGPIPE, buf, buflen); 2387 print_signal_handler(st, SIGXFSZ, buf, buflen); 2388 print_signal_handler(st, SIGILL , buf, buflen); 2389 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen); 2390 print_signal_handler(st, ASYNC_SIGNAL, buf, buflen); 2391 print_signal_handler(st, BREAK_SIGNAL, buf, buflen); 2392 print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen); 2393 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen); 2394 print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen); 2395 print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen); 2396 print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen); 2397} 2398 2399static char saved_jvm_path[MAXPATHLEN] = { 0 }; 2400 2401// Find the full path to the current module, libjvm.so or libjvm_g.so 2402void os::jvm_path(char *buf, jint buflen) { 2403 // Error checking. 2404 if (buflen < MAXPATHLEN) { 2405 assert(false, "must use a large-enough buffer"); 2406 buf[0] = '\0'; 2407 return; 2408 } 2409 // Lazy resolve the path to current module. 2410 if (saved_jvm_path[0] != 0) { 2411 strcpy(buf, saved_jvm_path); 2412 return; 2413 } 2414 2415 Dl_info dlinfo; 2416 int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo); 2417 assert(ret != 0, "cannot locate libjvm"); 2418 realpath((char *)dlinfo.dli_fname, buf); 2419 2420 if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) { 2421 // Support for the gamma launcher. Typical value for buf is 2422 // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at 2423 // the right place in the string, then assume we are installed in a JDK and 2424 // we're done. Otherwise, check for a JAVA_HOME environment variable and fix 2425 // up the path so it looks like libjvm.so is installed there (append a 2426 // fake suffix hotspot/libjvm.so). 2427 const char *p = buf + strlen(buf) - 1; 2428 for (int count = 0; p > buf && count < 5; ++count) { 2429 for (--p; p > buf && *p != '/'; --p) 2430 /* empty */ ; 2431 } 2432 2433 if (strncmp(p, "/jre/lib/", 9) != 0) { 2434 // Look for JAVA_HOME in the environment. 2435 char* java_home_var = ::getenv("JAVA_HOME"); 2436 if (java_home_var != NULL && java_home_var[0] != 0) { 2437 char cpu_arch[12]; 2438 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch)); 2439#ifdef _LP64 2440 // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9. 2441 if (strcmp(cpu_arch, "sparc") == 0) { 2442 strcat(cpu_arch, "v9"); 2443 } else if (strcmp(cpu_arch, "i386") == 0) { 2444 strcpy(cpu_arch, "amd64"); 2445 } 2446#endif 2447 // Check the current module name "libjvm.so" or "libjvm_g.so". 2448 p = strrchr(buf, '/'); 2449 assert(strstr(p, "/libjvm") == p, "invalid library name"); 2450 p = strstr(p, "_g") ? "_g" : ""; 2451 2452 realpath(java_home_var, buf); 2453 sprintf(buf + strlen(buf), "/jre/lib/%s", cpu_arch); 2454 if (0 == access(buf, F_OK)) { 2455 // Use current module name "libjvm[_g].so" instead of 2456 // "libjvm"debug_only("_g")".so" since for fastdebug version 2457 // we should have "libjvm.so" but debug_only("_g") adds "_g"! 2458 // It is used when we are choosing the HPI library's name 2459 // "libhpi[_g].so" in hpi::initialize_get_interface(). 2460 sprintf(buf + strlen(buf), "/hotspot/libjvm%s.so", p); 2461 } else { 2462 // Go back to path of .so 2463 realpath((char *)dlinfo.dli_fname, buf); 2464 } 2465 } 2466 } 2467 } 2468 2469 strcpy(saved_jvm_path, buf); 2470} 2471 2472 2473void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 2474 // no prefix required, not even "_" 2475} 2476 2477 2478void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 2479 // no suffix required 2480} 2481 2482 2483// sun.misc.Signal 2484 2485extern "C" { 2486 static void UserHandler(int sig, void *siginfo, void *context) { 2487 // Ctrl-C is pressed during error reporting, likely because the error 2488 // handler fails to abort. Let VM die immediately. 2489 if (sig == SIGINT && is_error_reported()) { 2490 os::die(); 2491 } 2492 2493 os::signal_notify(sig); 2494 // We do not need to reinstate the signal handler each time... 2495 } 2496} 2497 2498void* os::user_handler() { 2499 return CAST_FROM_FN_PTR(void*, UserHandler); 2500} 2501 2502extern "C" { 2503 typedef void (*sa_handler_t)(int); 2504 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *); 2505} 2506 2507void* os::signal(int signal_number, void* handler) { 2508 struct sigaction sigAct, oldSigAct; 2509 sigfillset(&(sigAct.sa_mask)); 2510 sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND; 2511 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler); 2512 2513 if (sigaction(signal_number, &sigAct, &oldSigAct)) 2514 // -1 means registration failed 2515 return (void *)-1; 2516 2517 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler); 2518} 2519 2520void os::signal_raise(int signal_number) { 2521 raise(signal_number); 2522} 2523 2524/* 2525 * The following code is moved from os.cpp for making this 2526 * code platform specific, which it is by its very nature. 2527 */ 2528 2529// a counter for each possible signal value 2530static int Sigexit = 0; 2531static int Maxlibjsigsigs; 2532static jint *pending_signals = NULL; 2533static int *preinstalled_sigs = NULL; 2534static struct sigaction *chainedsigactions = NULL; 2535static sema_t sig_sem; 2536typedef int (*version_getting_t)(); 2537version_getting_t os::Solaris::get_libjsig_version = NULL; 2538static int libjsigversion = NULL; 2539 2540int os::sigexitnum_pd() { 2541 assert(Sigexit > 0, "signal memory not yet initialized"); 2542 return Sigexit; 2543} 2544 2545void os::Solaris::init_signal_mem() { 2546 // Initialize signal structures 2547 Maxsignum = SIGRTMAX; 2548 Sigexit = Maxsignum+1; 2549 assert(Maxsignum >0, "Unable to obtain max signal number"); 2550 2551 Maxlibjsigsigs = Maxsignum; 2552 2553 // pending_signals has one int per signal 2554 // The additional signal is for SIGEXIT - exit signal to signal_thread 2555 pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1)); 2556 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1))); 2557 2558 if (UseSignalChaining) { 2559 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction) 2560 * (Maxsignum + 1)); 2561 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1))); 2562 preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1)); 2563 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1))); 2564 } 2565 ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 )); 2566 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1)); 2567} 2568 2569void os::signal_init_pd() { 2570 int ret; 2571 2572 ret = ::sema_init(&sig_sem, 0, NULL, NULL); 2573 assert(ret == 0, "sema_init() failed"); 2574} 2575 2576void os::signal_notify(int signal_number) { 2577 int ret; 2578 2579 Atomic::inc(&pending_signals[signal_number]); 2580 ret = ::sema_post(&sig_sem); 2581 assert(ret == 0, "sema_post() failed"); 2582} 2583 2584static int check_pending_signals(bool wait_for_signal) { 2585 int ret; 2586 while (true) { 2587 for (int i = 0; i < Sigexit + 1; i++) { 2588 jint n = pending_signals[i]; 2589 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 2590 return i; 2591 } 2592 } 2593 if (!wait_for_signal) { 2594 return -1; 2595 } 2596 JavaThread *thread = JavaThread::current(); 2597 ThreadBlockInVM tbivm(thread); 2598 2599 bool threadIsSuspended; 2600 do { 2601 thread->set_suspend_equivalent(); 2602 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 2603 while((ret = ::sema_wait(&sig_sem)) == EINTR) 2604 ; 2605 assert(ret == 0, "sema_wait() failed"); 2606 2607 // were we externally suspended while we were waiting? 2608 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 2609 if (threadIsSuspended) { 2610 // 2611 // The semaphore has been incremented, but while we were waiting 2612 // another thread suspended us. We don't want to continue running 2613 // while suspended because that would surprise the thread that 2614 // suspended us. 2615 // 2616 ret = ::sema_post(&sig_sem); 2617 assert(ret == 0, "sema_post() failed"); 2618 2619 thread->java_suspend_self(); 2620 } 2621 } while (threadIsSuspended); 2622 } 2623} 2624 2625int os::signal_lookup() { 2626 return check_pending_signals(false); 2627} 2628 2629int os::signal_wait() { 2630 return check_pending_signals(true); 2631} 2632 2633//////////////////////////////////////////////////////////////////////////////// 2634// Virtual Memory 2635 2636static int page_size = -1; 2637 2638// The mmap MAP_ALIGN flag is supported on Solaris 9 and later. init_2() will 2639// clear this var if support is not available. 2640static bool has_map_align = true; 2641 2642int os::vm_page_size() { 2643 assert(page_size != -1, "must call os::init"); 2644 return page_size; 2645} 2646 2647// Solaris allocates memory by pages. 2648int os::vm_allocation_granularity() { 2649 assert(page_size != -1, "must call os::init"); 2650 return page_size; 2651} 2652 2653bool os::commit_memory(char* addr, size_t bytes, bool exec) { 2654 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE; 2655 size_t size = bytes; 2656 return 2657 NULL != Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot); 2658} 2659 2660bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint, 2661 bool exec) { 2662 if (commit_memory(addr, bytes, exec)) { 2663 if (UseMPSS && alignment_hint > (size_t)vm_page_size()) { 2664 // If the large page size has been set and the VM 2665 // is using large pages, use the large page size 2666 // if it is smaller than the alignment hint. This is 2667 // a case where the VM wants to use a larger alignment size 2668 // for its own reasons but still want to use large pages 2669 // (which is what matters to setting the mpss range. 2670 size_t page_size = 0; 2671 if (large_page_size() < alignment_hint) { 2672 assert(UseLargePages, "Expected to be here for large page use only"); 2673 page_size = large_page_size(); 2674 } else { 2675 // If the alignment hint is less than the large page 2676 // size, the VM wants a particular alignment (thus the hint) 2677 // for internal reasons. Try to set the mpss range using 2678 // the alignment_hint. 2679 page_size = alignment_hint; 2680 } 2681 // Since this is a hint, ignore any failures. 2682 (void)Solaris::set_mpss_range(addr, bytes, page_size); 2683 } 2684 return true; 2685 } 2686 return false; 2687} 2688 2689// Uncommit the pages in a specified region. 2690void os::free_memory(char* addr, size_t bytes) { 2691 if (madvise(addr, bytes, MADV_FREE) < 0) { 2692 debug_only(warning("MADV_FREE failed.")); 2693 return; 2694 } 2695} 2696 2697bool os::create_stack_guard_pages(char* addr, size_t size) { 2698 return os::commit_memory(addr, size); 2699} 2700 2701bool os::remove_stack_guard_pages(char* addr, size_t size) { 2702 return os::uncommit_memory(addr, size); 2703} 2704 2705// Change the page size in a given range. 2706void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { 2707 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned."); 2708 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned."); 2709 Solaris::set_mpss_range(addr, bytes, alignment_hint); 2710} 2711 2712// Tell the OS to make the range local to the first-touching LWP 2713void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { 2714 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned."); 2715 if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) { 2716 debug_only(warning("MADV_ACCESS_LWP failed.")); 2717 } 2718} 2719 2720// Tell the OS that this range would be accessed from different LWPs. 2721void os::numa_make_global(char *addr, size_t bytes) { 2722 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned."); 2723 if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) { 2724 debug_only(warning("MADV_ACCESS_MANY failed.")); 2725 } 2726} 2727 2728// Get the number of the locality groups. 2729size_t os::numa_get_groups_num() { 2730 size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie()); 2731 return n != -1 ? n : 1; 2732} 2733 2734// Get a list of leaf locality groups. A leaf lgroup is group that 2735// doesn't have any children. Typical leaf group is a CPU or a CPU/memory 2736// board. An LWP is assigned to one of these groups upon creation. 2737size_t os::numa_get_leaf_groups(int *ids, size_t size) { 2738 if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) { 2739 ids[0] = 0; 2740 return 1; 2741 } 2742 int result_size = 0, top = 1, bottom = 0, cur = 0; 2743 for (int k = 0; k < size; k++) { 2744 int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur], 2745 (Solaris::lgrp_id_t*)&ids[top], size - top); 2746 if (r == -1) { 2747 ids[0] = 0; 2748 return 1; 2749 } 2750 if (!r) { 2751 // That's a leaf node. 2752 assert (bottom <= cur, "Sanity check"); 2753 // Check if the node has memory 2754 if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur], 2755 NULL, 0, LGRP_RSRC_MEM) > 0) { 2756 ids[bottom++] = ids[cur]; 2757 } 2758 } 2759 top += r; 2760 cur++; 2761 } 2762 if (bottom == 0) { 2763 // Handle a situation, when the OS reports no memory available. 2764 // Assume UMA architecture. 2765 ids[0] = 0; 2766 return 1; 2767 } 2768 return bottom; 2769} 2770 2771// Detect the topology change. Typically happens during CPU plugging-unplugging. 2772bool os::numa_topology_changed() { 2773 int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie()); 2774 if (is_stale != -1 && is_stale) { 2775 Solaris::lgrp_fini(Solaris::lgrp_cookie()); 2776 Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER); 2777 assert(c != 0, "Failure to initialize LGRP API"); 2778 Solaris::set_lgrp_cookie(c); 2779 return true; 2780 } 2781 return false; 2782} 2783 2784// Get the group id of the current LWP. 2785int os::numa_get_group_id() { 2786 int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID); 2787 if (lgrp_id == -1) { 2788 return 0; 2789 } 2790 const int size = os::numa_get_groups_num(); 2791 int *ids = (int*)alloca(size * sizeof(int)); 2792 2793 // Get the ids of all lgroups with memory; r is the count. 2794 int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id, 2795 (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM); 2796 if (r <= 0) { 2797 return 0; 2798 } 2799 return ids[os::random() % r]; 2800} 2801 2802// Request information about the page. 2803bool os::get_page_info(char *start, page_info* info) { 2804 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE }; 2805 uint64_t addr = (uintptr_t)start; 2806 uint64_t outdata[2]; 2807 uint_t validity = 0; 2808 2809 if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) { 2810 return false; 2811 } 2812 2813 info->size = 0; 2814 info->lgrp_id = -1; 2815 2816 if ((validity & 1) != 0) { 2817 if ((validity & 2) != 0) { 2818 info->lgrp_id = outdata[0]; 2819 } 2820 if ((validity & 4) != 0) { 2821 info->size = outdata[1]; 2822 } 2823 return true; 2824 } 2825 return false; 2826} 2827 2828// Scan the pages from start to end until a page different than 2829// the one described in the info parameter is encountered. 2830char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 2831 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE }; 2832 const size_t types = sizeof(info_types) / sizeof(info_types[0]); 2833 uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT]; 2834 uint_t validity[MAX_MEMINFO_CNT]; 2835 2836 size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size); 2837 uint64_t p = (uint64_t)start; 2838 while (p < (uint64_t)end) { 2839 addrs[0] = p; 2840 size_t addrs_count = 1; 2841 while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] < (uint64_t)end) { 2842 addrs[addrs_count] = addrs[addrs_count - 1] + page_size; 2843 addrs_count++; 2844 } 2845 2846 if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) { 2847 return NULL; 2848 } 2849 2850 size_t i = 0; 2851 for (; i < addrs_count; i++) { 2852 if ((validity[i] & 1) != 0) { 2853 if ((validity[i] & 4) != 0) { 2854 if (outdata[types * i + 1] != page_expected->size) { 2855 break; 2856 } 2857 } else 2858 if (page_expected->size != 0) { 2859 break; 2860 } 2861 2862 if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) { 2863 if (outdata[types * i] != page_expected->lgrp_id) { 2864 break; 2865 } 2866 } 2867 } else { 2868 return NULL; 2869 } 2870 } 2871 2872 if (i != addrs_count) { 2873 if ((validity[i] & 2) != 0) { 2874 page_found->lgrp_id = outdata[types * i]; 2875 } else { 2876 page_found->lgrp_id = -1; 2877 } 2878 if ((validity[i] & 4) != 0) { 2879 page_found->size = outdata[types * i + 1]; 2880 } else { 2881 page_found->size = 0; 2882 } 2883 return (char*)addrs[i]; 2884 } 2885 2886 p = addrs[addrs_count - 1] + page_size; 2887 } 2888 return end; 2889} 2890 2891bool os::uncommit_memory(char* addr, size_t bytes) { 2892 size_t size = bytes; 2893 // Map uncommitted pages PROT_NONE so we fail early if we touch an 2894 // uncommitted page. Otherwise, the read/write might succeed if we 2895 // have enough swap space to back the physical page. 2896 return 2897 NULL != Solaris::mmap_chunk(addr, size, 2898 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, 2899 PROT_NONE); 2900} 2901 2902char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) { 2903 char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0); 2904 2905 if (b == MAP_FAILED) { 2906 return NULL; 2907 } 2908 return b; 2909} 2910 2911char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) { 2912 char* addr = requested_addr; 2913 int flags = MAP_PRIVATE | MAP_NORESERVE; 2914 2915 assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap"); 2916 2917 if (fixed) { 2918 flags |= MAP_FIXED; 2919 } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) { 2920 flags |= MAP_ALIGN; 2921 addr = (char*) alignment_hint; 2922 } 2923 2924 // Map uncommitted pages PROT_NONE so we fail early if we touch an 2925 // uncommitted page. Otherwise, the read/write might succeed if we 2926 // have enough swap space to back the physical page. 2927 return mmap_chunk(addr, bytes, flags, PROT_NONE); 2928} 2929 2930char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { 2931 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL)); 2932 2933 guarantee(requested_addr == NULL || requested_addr == addr, 2934 "OS failed to return requested mmap address."); 2935 return addr; 2936} 2937 2938// Reserve memory at an arbitrary address, only if that area is 2939// available (and not reserved for something else). 2940 2941char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2942 const int max_tries = 10; 2943 char* base[max_tries]; 2944 size_t size[max_tries]; 2945 2946 // Solaris adds a gap between mmap'ed regions. The size of the gap 2947 // is dependent on the requested size and the MMU. Our initial gap 2948 // value here is just a guess and will be corrected later. 2949 bool had_top_overlap = false; 2950 bool have_adjusted_gap = false; 2951 size_t gap = 0x400000; 2952 2953 // Assert only that the size is a multiple of the page size, since 2954 // that's all that mmap requires, and since that's all we really know 2955 // about at this low abstraction level. If we need higher alignment, 2956 // we can either pass an alignment to this method or verify alignment 2957 // in one of the methods further up the call chain. See bug 5044738. 2958 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block"); 2959 2960 // Since snv_84, Solaris attempts to honor the address hint - see 5003415. 2961 // Give it a try, if the kernel honors the hint we can return immediately. 2962 char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false); 2963 volatile int err = errno; 2964 if (addr == requested_addr) { 2965 return addr; 2966 } else if (addr != NULL) { 2967 unmap_memory(addr, bytes); 2968 } 2969 2970 if (PrintMiscellaneous && Verbose) { 2971 char buf[256]; 2972 buf[0] = '\0'; 2973 if (addr == NULL) { 2974 jio_snprintf(buf, sizeof(buf), ": %s", strerror(err)); 2975 } 2976 warning("attempt_reserve_memory_at: couldn't reserve %d bytes at " 2977 PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT 2978 "%s", bytes, requested_addr, addr, buf); 2979 } 2980 2981 // Address hint method didn't work. Fall back to the old method. 2982 // In theory, once SNV becomes our oldest supported platform, this 2983 // code will no longer be needed. 2984 // 2985 // Repeatedly allocate blocks until the block is allocated at the 2986 // right spot. Give up after max_tries. 2987 int i; 2988 for (i = 0; i < max_tries; ++i) { 2989 base[i] = reserve_memory(bytes); 2990 2991 if (base[i] != NULL) { 2992 // Is this the block we wanted? 2993 if (base[i] == requested_addr) { 2994 size[i] = bytes; 2995 break; 2996 } 2997 2998 // check that the gap value is right 2999 if (had_top_overlap && !have_adjusted_gap) { 3000 size_t actual_gap = base[i-1] - base[i] - bytes; 3001 if (gap != actual_gap) { 3002 // adjust the gap value and retry the last 2 allocations 3003 assert(i > 0, "gap adjustment code problem"); 3004 have_adjusted_gap = true; // adjust the gap only once, just in case 3005 gap = actual_gap; 3006 if (PrintMiscellaneous && Verbose) { 3007 warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap); 3008 } 3009 unmap_memory(base[i], bytes); 3010 unmap_memory(base[i-1], size[i-1]); 3011 i-=2; 3012 continue; 3013 } 3014 } 3015 3016 // Does this overlap the block we wanted? Give back the overlapped 3017 // parts and try again. 3018 // 3019 // There is still a bug in this code: if top_overlap == bytes, 3020 // the overlap is offset from requested region by the value of gap. 3021 // In this case giving back the overlapped part will not work, 3022 // because we'll give back the entire block at base[i] and 3023 // therefore the subsequent allocation will not generate a new gap. 3024 // This could be fixed with a new algorithm that used larger 3025 // or variable size chunks to find the requested region - 3026 // but such a change would introduce additional complications. 3027 // It's rare enough that the planets align for this bug, 3028 // so we'll just wait for a fix for 6204603/5003415 which 3029 // will provide a mmap flag to allow us to avoid this business. 3030 3031 size_t top_overlap = requested_addr + (bytes + gap) - base[i]; 3032 if (top_overlap >= 0 && top_overlap < bytes) { 3033 had_top_overlap = true; 3034 unmap_memory(base[i], top_overlap); 3035 base[i] += top_overlap; 3036 size[i] = bytes - top_overlap; 3037 } else { 3038 size_t bottom_overlap = base[i] + bytes - requested_addr; 3039 if (bottom_overlap >= 0 && bottom_overlap < bytes) { 3040 if (PrintMiscellaneous && Verbose && bottom_overlap == 0) { 3041 warning("attempt_reserve_memory_at: possible alignment bug"); 3042 } 3043 unmap_memory(requested_addr, bottom_overlap); 3044 size[i] = bytes - bottom_overlap; 3045 } else { 3046 size[i] = bytes; 3047 } 3048 } 3049 } 3050 } 3051 3052 // Give back the unused reserved pieces. 3053 3054 for (int j = 0; j < i; ++j) { 3055 if (base[j] != NULL) { 3056 unmap_memory(base[j], size[j]); 3057 } 3058 } 3059 3060 return (i < max_tries) ? requested_addr : NULL; 3061} 3062 3063bool os::release_memory(char* addr, size_t bytes) { 3064 size_t size = bytes; 3065 return munmap(addr, size) == 0; 3066} 3067 3068static bool solaris_mprotect(char* addr, size_t bytes, int prot) { 3069 assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()), 3070 "addr must be page aligned"); 3071 int retVal = mprotect(addr, bytes, prot); 3072 return retVal == 0; 3073} 3074 3075// Protect memory (Used to pass readonly pages through 3076// JNI GetArray<type>Elements with empty arrays.) 3077// Also, used for serialization page and for compressed oops null pointer 3078// checking. 3079bool os::protect_memory(char* addr, size_t bytes, ProtType prot, 3080 bool is_committed) { 3081 unsigned int p = 0; 3082 switch (prot) { 3083 case MEM_PROT_NONE: p = PROT_NONE; break; 3084 case MEM_PROT_READ: p = PROT_READ; break; 3085 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break; 3086 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break; 3087 default: 3088 ShouldNotReachHere(); 3089 } 3090 // is_committed is unused. 3091 return solaris_mprotect(addr, bytes, p); 3092} 3093 3094// guard_memory and unguard_memory only happens within stack guard pages. 3095// Since ISM pertains only to the heap, guard and unguard memory should not 3096/// happen with an ISM region. 3097bool os::guard_memory(char* addr, size_t bytes) { 3098 return solaris_mprotect(addr, bytes, PROT_NONE); 3099} 3100 3101bool os::unguard_memory(char* addr, size_t bytes) { 3102 return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE); 3103} 3104 3105// Large page support 3106 3107// UseLargePages is the master flag to enable/disable large page memory. 3108// UseMPSS and UseISM are supported for compatibility reasons. Their combined 3109// effects can be described in the following table: 3110// 3111// UseLargePages UseMPSS UseISM 3112// false * * => UseLargePages is the master switch, turning 3113// it off will turn off both UseMPSS and 3114// UseISM. VM will not use large page memory 3115// regardless the settings of UseMPSS/UseISM. 3116// true false false => Unless future Solaris provides other 3117// mechanism to use large page memory, this 3118// combination is equivalent to -UseLargePages, 3119// VM will not use large page memory 3120// true true false => JVM will use MPSS for large page memory. 3121// This is the default behavior. 3122// true false true => JVM will use ISM for large page memory. 3123// true true true => JVM will use ISM if it is available. 3124// Otherwise, JVM will fall back to MPSS. 3125// Becaues ISM is now available on all 3126// supported Solaris versions, this combination 3127// is equivalent to +UseISM -UseMPSS. 3128 3129typedef int (*getpagesizes_func_type) (size_t[], int); 3130static size_t _large_page_size = 0; 3131 3132bool os::Solaris::ism_sanity_check(bool warn, size_t * page_size) { 3133 // x86 uses either 2M or 4M page, depending on whether PAE (Physical Address 3134 // Extensions) mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. Sparc 3135 // can support multiple page sizes. 3136 3137 // Don't bother to probe page size because getpagesizes() comes with MPSS. 3138 // ISM is only recommended on old Solaris where there is no MPSS support. 3139 // Simply choose a conservative value as default. 3140 *page_size = LargePageSizeInBytes ? LargePageSizeInBytes : 3141 SPARC_ONLY(4 * M) IA32_ONLY(4 * M) AMD64_ONLY(2 * M); 3142 3143 // ISM is available on all supported Solaris versions 3144 return true; 3145} 3146 3147// Insertion sort for small arrays (descending order). 3148static void insertion_sort_descending(size_t* array, int len) { 3149 for (int i = 0; i < len; i++) { 3150 size_t val = array[i]; 3151 for (size_t key = i; key > 0 && array[key - 1] < val; --key) { 3152 size_t tmp = array[key]; 3153 array[key] = array[key - 1]; 3154 array[key - 1] = tmp; 3155 } 3156 } 3157} 3158 3159bool os::Solaris::mpss_sanity_check(bool warn, size_t * page_size) { 3160 getpagesizes_func_type getpagesizes_func = 3161 CAST_TO_FN_PTR(getpagesizes_func_type, dlsym(RTLD_DEFAULT, "getpagesizes")); 3162 if (getpagesizes_func == NULL) { 3163 if (warn) { 3164 warning("MPSS is not supported by the operating system."); 3165 } 3166 return false; 3167 } 3168 3169 const unsigned int usable_count = VM_Version::page_size_count(); 3170 if (usable_count == 1) { 3171 return false; 3172 } 3173 3174 // Fill the array of page sizes. 3175 int n = getpagesizes_func(_page_sizes, page_sizes_max); 3176 assert(n > 0, "Solaris bug?"); 3177 if (n == page_sizes_max) { 3178 // Add a sentinel value (necessary only if the array was completely filled 3179 // since it is static (zeroed at initialization)). 3180 _page_sizes[--n] = 0; 3181 DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");) 3182 } 3183 assert(_page_sizes[n] == 0, "missing sentinel"); 3184 3185 if (n == 1) return false; // Only one page size available. 3186 3187 // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and 3188 // select up to usable_count elements. First sort the array, find the first 3189 // acceptable value, then copy the usable sizes to the top of the array and 3190 // trim the rest. Make sure to include the default page size :-). 3191 // 3192 // A better policy could get rid of the 4M limit by taking the sizes of the 3193 // important VM memory regions (java heap and possibly the code cache) into 3194 // account. 3195 insertion_sort_descending(_page_sizes, n); 3196 const size_t size_limit = 3197 FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes; 3198 int beg; 3199 for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ; 3200 const int end = MIN2((int)usable_count, n) - 1; 3201 for (int cur = 0; cur < end; ++cur, ++beg) { 3202 _page_sizes[cur] = _page_sizes[beg]; 3203 } 3204 _page_sizes[end] = vm_page_size(); 3205 _page_sizes[end + 1] = 0; 3206 3207 if (_page_sizes[end] > _page_sizes[end - 1]) { 3208 // Default page size is not the smallest; sort again. 3209 insertion_sort_descending(_page_sizes, end + 1); 3210 } 3211 *page_size = _page_sizes[0]; 3212 3213 return true; 3214} 3215 3216bool os::large_page_init() { 3217 if (!UseLargePages) { 3218 UseISM = false; 3219 UseMPSS = false; 3220 return false; 3221 } 3222 3223 // print a warning if any large page related flag is specified on command line 3224 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || 3225 !FLAG_IS_DEFAULT(UseISM) || 3226 !FLAG_IS_DEFAULT(UseMPSS) || 3227 !FLAG_IS_DEFAULT(LargePageSizeInBytes); 3228 UseISM = UseISM && 3229 Solaris::ism_sanity_check(warn_on_failure, &_large_page_size); 3230 if (UseISM) { 3231 // ISM disables MPSS to be compatible with old JDK behavior 3232 UseMPSS = false; 3233 _page_sizes[0] = _large_page_size; 3234 _page_sizes[1] = vm_page_size(); 3235 } 3236 3237 UseMPSS = UseMPSS && 3238 Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size); 3239 3240 UseLargePages = UseISM || UseMPSS; 3241 return UseLargePages; 3242} 3243 3244bool os::Solaris::set_mpss_range(caddr_t start, size_t bytes, size_t align) { 3245 // Signal to OS that we want large pages for addresses 3246 // from addr, addr + bytes 3247 struct memcntl_mha mpss_struct; 3248 mpss_struct.mha_cmd = MHA_MAPSIZE_VA; 3249 mpss_struct.mha_pagesize = align; 3250 mpss_struct.mha_flags = 0; 3251 if (memcntl(start, bytes, MC_HAT_ADVISE, 3252 (caddr_t) &mpss_struct, 0, 0) < 0) { 3253 debug_only(warning("Attempt to use MPSS failed.")); 3254 return false; 3255 } 3256 return true; 3257} 3258 3259char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) { 3260 // "exec" is passed in but not used. Creating the shared image for 3261 // the code cache doesn't have an SHM_X executable permission to check. 3262 assert(UseLargePages && UseISM, "only for ISM large pages"); 3263 3264 size_t size = bytes; 3265 char* retAddr = NULL; 3266 int shmid; 3267 key_t ismKey; 3268 3269 bool warn_on_failure = UseISM && 3270 (!FLAG_IS_DEFAULT(UseLargePages) || 3271 !FLAG_IS_DEFAULT(UseISM) || 3272 !FLAG_IS_DEFAULT(LargePageSizeInBytes) 3273 ); 3274 char msg[128]; 3275 3276 ismKey = IPC_PRIVATE; 3277 3278 // Create a large shared memory region to attach to based on size. 3279 // Currently, size is the total size of the heap 3280 shmid = shmget(ismKey, size, SHM_R | SHM_W | IPC_CREAT); 3281 if (shmid == -1){ 3282 if (warn_on_failure) { 3283 jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno); 3284 warning(msg); 3285 } 3286 return NULL; 3287 } 3288 3289 // Attach to the region 3290 retAddr = (char *) shmat(shmid, 0, SHM_SHARE_MMU | SHM_R | SHM_W); 3291 int err = errno; 3292 3293 // Remove shmid. If shmat() is successful, the actual shared memory segment 3294 // will be deleted when it's detached by shmdt() or when the process 3295 // terminates. If shmat() is not successful this will remove the shared 3296 // segment immediately. 3297 shmctl(shmid, IPC_RMID, NULL); 3298 3299 if (retAddr == (char *) -1) { 3300 if (warn_on_failure) { 3301 jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err); 3302 warning(msg); 3303 } 3304 return NULL; 3305 } 3306 3307 return retAddr; 3308} 3309 3310bool os::release_memory_special(char* base, size_t bytes) { 3311 // detaching the SHM segment will also delete it, see reserve_memory_special() 3312 int rslt = shmdt(base); 3313 return rslt == 0; 3314} 3315 3316size_t os::large_page_size() { 3317 return _large_page_size; 3318} 3319 3320// MPSS allows application to commit large page memory on demand; with ISM 3321// the entire memory region must be allocated as shared memory. 3322bool os::can_commit_large_page_memory() { 3323 return UseISM ? false : true; 3324} 3325 3326bool os::can_execute_large_page_memory() { 3327 return UseISM ? false : true; 3328} 3329 3330static int os_sleep(jlong millis, bool interruptible) { 3331 const jlong limit = INT_MAX; 3332 jlong prevtime; 3333 int res; 3334 3335 while (millis > limit) { 3336 if ((res = os_sleep(limit, interruptible)) != OS_OK) 3337 return res; 3338 millis -= limit; 3339 } 3340 3341 // Restart interrupted polls with new parameters until the proper delay 3342 // has been completed. 3343 3344 prevtime = getTimeMillis(); 3345 3346 while (millis > 0) { 3347 jlong newtime; 3348 3349 if (!interruptible) { 3350 // Following assert fails for os::yield_all: 3351 // assert(!thread->is_Java_thread(), "must not be java thread"); 3352 res = poll(NULL, 0, millis); 3353 } else { 3354 JavaThread *jt = JavaThread::current(); 3355 3356 INTERRUPTIBLE_NORESTART_VM_ALWAYS(poll(NULL, 0, millis), res, jt, 3357 os::Solaris::clear_interrupted); 3358 } 3359 3360 // INTERRUPTIBLE_NORESTART_VM_ALWAYS returns res == OS_INTRPT for 3361 // thread.Interrupt. 3362 3363 if((res == OS_ERR) && (errno == EINTR)) { 3364 newtime = getTimeMillis(); 3365 assert(newtime >= prevtime, "time moving backwards"); 3366 /* Doing prevtime and newtime in microseconds doesn't help precision, 3367 and trying to round up to avoid lost milliseconds can result in a 3368 too-short delay. */ 3369 millis -= newtime - prevtime; 3370 if(millis <= 0) 3371 return OS_OK; 3372 prevtime = newtime; 3373 } else 3374 return res; 3375 } 3376 3377 return OS_OK; 3378} 3379 3380// Read calls from inside the vm need to perform state transitions 3381size_t os::read(int fd, void *buf, unsigned int nBytes) { 3382 INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted); 3383} 3384 3385int os::sleep(Thread* thread, jlong millis, bool interruptible) { 3386 assert(thread == Thread::current(), "thread consistency check"); 3387 3388 // TODO-FIXME: this should be removed. 3389 // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock 3390 // situation with a JavaThread being starved out of a lwp. The kernel doesn't seem to generate 3391 // a SIGWAITING signal which would enable the threads library to create a new lwp for the starving 3392 // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel 3393 // is fooled into believing that the system is making progress. In the code below we block the 3394 // the watcher thread while safepoint is in progress so that it would not appear as though the 3395 // system is making progress. 3396 if (!Solaris::T2_libthread() && 3397 thread->is_Watcher_thread() && SafepointSynchronize::is_synchronizing() && !Arguments::has_profile()) { 3398 // We now try to acquire the threads lock. Since this lock is held by the VM thread during 3399 // the entire safepoint, the watcher thread will line up here during the safepoint. 3400 Threads_lock->lock_without_safepoint_check(); 3401 Threads_lock->unlock(); 3402 } 3403 3404 if (thread->is_Java_thread()) { 3405 // This is a JavaThread so we honor the _thread_blocked protocol 3406 // even for sleeps of 0 milliseconds. This was originally done 3407 // as a workaround for bug 4338139. However, now we also do it 3408 // to honor the suspend-equivalent protocol. 3409 3410 JavaThread *jt = (JavaThread *) thread; 3411 ThreadBlockInVM tbivm(jt); 3412 3413 jt->set_suspend_equivalent(); 3414 // cleared by handle_special_suspend_equivalent_condition() or 3415 // java_suspend_self() via check_and_wait_while_suspended() 3416 3417 int ret_code; 3418 if (millis <= 0) { 3419 thr_yield(); 3420 ret_code = 0; 3421 } else { 3422 // The original sleep() implementation did not create an 3423 // OSThreadWaitState helper for sleeps of 0 milliseconds. 3424 // I'm preserving that decision for now. 3425 OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */); 3426 3427 ret_code = os_sleep(millis, interruptible); 3428 } 3429 3430 // were we externally suspended while we were waiting? 3431 jt->check_and_wait_while_suspended(); 3432 3433 return ret_code; 3434 } 3435 3436 // non-JavaThread from this point on: 3437 3438 if (millis <= 0) { 3439 thr_yield(); 3440 return 0; 3441 } 3442 3443 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 3444 3445 return os_sleep(millis, interruptible); 3446} 3447 3448int os::naked_sleep() { 3449 // %% make the sleep time an integer flag. for now use 1 millisec. 3450 return os_sleep(1, false); 3451} 3452 3453// Sleep forever; naked call to OS-specific sleep; use with CAUTION 3454void os::infinite_sleep() { 3455 while (true) { // sleep forever ... 3456 ::sleep(100); // ... 100 seconds at a time 3457 } 3458} 3459 3460// Used to convert frequent JVM_Yield() to nops 3461bool os::dont_yield() { 3462 if (DontYieldALot) { 3463 static hrtime_t last_time = 0; 3464 hrtime_t diff = getTimeNanos() - last_time; 3465 3466 if (diff < DontYieldALotInterval * 1000000) 3467 return true; 3468 3469 last_time += diff; 3470 3471 return false; 3472 } 3473 else { 3474 return false; 3475 } 3476} 3477 3478// Caveat: Solaris os::yield() causes a thread-state transition whereas 3479// the linux and win32 implementations do not. This should be checked. 3480 3481void os::yield() { 3482 // Yields to all threads with same or greater priority 3483 os::sleep(Thread::current(), 0, false); 3484} 3485 3486// Note that yield semantics are defined by the scheduling class to which 3487// the thread currently belongs. Typically, yield will _not yield to 3488// other equal or higher priority threads that reside on the dispatch queues 3489// of other CPUs. 3490 3491os::YieldResult os::NakedYield() { thr_yield(); return os::YIELD_UNKNOWN; } 3492 3493 3494// On Solaris we found that yield_all doesn't always yield to all other threads. 3495// There have been cases where there is a thread ready to execute but it doesn't 3496// get an lwp as the VM thread continues to spin with sleeps of 1 millisecond. 3497// The 1 millisecond wait doesn't seem long enough for the kernel to issue a 3498// SIGWAITING signal which will cause a new lwp to be created. So we count the 3499// number of times yield_all is called in the one loop and increase the sleep 3500// time after 8 attempts. If this fails too we increase the concurrency level 3501// so that the starving thread would get an lwp 3502 3503void os::yield_all(int attempts) { 3504 // Yields to all threads, including threads with lower priorities 3505 if (attempts == 0) { 3506 os::sleep(Thread::current(), 1, false); 3507 } else { 3508 int iterations = attempts % 30; 3509 if (iterations == 0 && !os::Solaris::T2_libthread()) { 3510 // thr_setconcurrency and _getconcurrency make sense only under T1. 3511 int noofLWPS = thr_getconcurrency(); 3512 if (noofLWPS < (Threads::number_of_threads() + 2)) { 3513 thr_setconcurrency(thr_getconcurrency() + 1); 3514 } 3515 } else if (iterations < 25) { 3516 os::sleep(Thread::current(), 1, false); 3517 } else { 3518 os::sleep(Thread::current(), 10, false); 3519 } 3520 } 3521} 3522 3523// Called from the tight loops to possibly influence time-sharing heuristics 3524void os::loop_breaker(int attempts) { 3525 os::yield_all(attempts); 3526} 3527 3528 3529// Interface for setting lwp priorities. If we are using T2 libthread, 3530// which forces the use of BoundThreads or we manually set UseBoundThreads, 3531// all of our threads will be assigned to real lwp's. Using the thr_setprio 3532// function is meaningless in this mode so we must adjust the real lwp's priority 3533// The routines below implement the getting and setting of lwp priorities. 3534// 3535// Note: There are three priority scales used on Solaris. Java priotities 3536// which range from 1 to 10, libthread "thr_setprio" scale which range 3537// from 0 to 127, and the current scheduling class of the process we 3538// are running in. This is typically from -60 to +60. 3539// The setting of the lwp priorities in done after a call to thr_setprio 3540// so Java priorities are mapped to libthread priorities and we map from 3541// the latter to lwp priorities. We don't keep priorities stored in 3542// Java priorities since some of our worker threads want to set priorities 3543// higher than all Java threads. 3544// 3545// For related information: 3546// (1) man -s 2 priocntl 3547// (2) man -s 4 priocntl 3548// (3) man dispadmin 3549// = librt.so 3550// = libthread/common/rtsched.c - thrp_setlwpprio(). 3551// = ps -cL <pid> ... to validate priority. 3552// = sched_get_priority_min and _max 3553// pthread_create 3554// sched_setparam 3555// pthread_setschedparam 3556// 3557// Assumptions: 3558// + We assume that all threads in the process belong to the same 3559// scheduling class. IE. an homogenous process. 3560// + Must be root or in IA group to change change "interactive" attribute. 3561// Priocntl() will fail silently. The only indication of failure is when 3562// we read-back the value and notice that it hasn't changed. 3563// + Interactive threads enter the runq at the head, non-interactive at the tail. 3564// + For RT, change timeslice as well. Invariant: 3565// constant "priority integral" 3566// Konst == TimeSlice * (60-Priority) 3567// Given a priority, compute appropriate timeslice. 3568// + Higher numerical values have higher priority. 3569 3570// sched class attributes 3571typedef struct { 3572 int schedPolicy; // classID 3573 int maxPrio; 3574 int minPrio; 3575} SchedInfo; 3576 3577 3578static SchedInfo tsLimits, iaLimits, rtLimits; 3579 3580#ifdef ASSERT 3581static int ReadBackValidate = 1; 3582#endif 3583static int myClass = 0; 3584static int myMin = 0; 3585static int myMax = 0; 3586static int myCur = 0; 3587static bool priocntl_enable = false; 3588 3589 3590// Call the version of priocntl suitable for all supported versions 3591// of Solaris. We need to call through this wrapper so that we can 3592// build on Solaris 9 and run on Solaris 8, 9 and 10. 3593// 3594// This code should be removed if we ever stop supporting Solaris 8 3595// and earlier releases. 3596 3597static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg); 3598typedef long (*priocntl_type)(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg); 3599static priocntl_type priocntl_ptr = priocntl_stub; 3600 3601// Stub to set the value of the real pointer, and then call the real 3602// function. 3603 3604static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg) { 3605 // Try Solaris 8- name only. 3606 priocntl_type tmp = (priocntl_type)dlsym(RTLD_DEFAULT, "__priocntl"); 3607 guarantee(tmp != NULL, "priocntl function not found."); 3608 priocntl_ptr = tmp; 3609 return (*priocntl_ptr)(PC_VERSION, idtype, id, cmd, arg); 3610} 3611 3612 3613// lwp_priocntl_init 3614// 3615// Try to determine the priority scale for our process. 3616// 3617// Return errno or 0 if OK. 3618// 3619static 3620int lwp_priocntl_init () 3621{ 3622 int rslt; 3623 pcinfo_t ClassInfo; 3624 pcparms_t ParmInfo; 3625 int i; 3626 3627 if (!UseThreadPriorities) return 0; 3628 3629 // We are using Bound threads, we need to determine our priority ranges 3630 if (os::Solaris::T2_libthread() || UseBoundThreads) { 3631 // If ThreadPriorityPolicy is 1, switch tables 3632 if (ThreadPriorityPolicy == 1) { 3633 for (i = 0 ; i < MaxPriority+1; i++) 3634 os::java_to_os_priority[i] = prio_policy1[i]; 3635 } 3636 } 3637 // Not using Bound Threads, set to ThreadPolicy 1 3638 else { 3639 for ( i = 0 ; i < MaxPriority+1; i++ ) { 3640 os::java_to_os_priority[i] = prio_policy1[i]; 3641 } 3642 return 0; 3643 } 3644 3645 3646 // Get IDs for a set of well-known scheduling classes. 3647 // TODO-FIXME: GETCLINFO returns the current # of classes in the 3648 // the system. We should have a loop that iterates over the 3649 // classID values, which are known to be "small" integers. 3650 3651 strcpy(ClassInfo.pc_clname, "TS"); 3652 ClassInfo.pc_cid = -1; 3653 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3654 if (rslt < 0) return errno; 3655 assert(ClassInfo.pc_cid != -1, "cid for TS class is -1"); 3656 tsLimits.schedPolicy = ClassInfo.pc_cid; 3657 tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri; 3658 tsLimits.minPrio = -tsLimits.maxPrio; 3659 3660 strcpy(ClassInfo.pc_clname, "IA"); 3661 ClassInfo.pc_cid = -1; 3662 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3663 if (rslt < 0) return errno; 3664 assert(ClassInfo.pc_cid != -1, "cid for IA class is -1"); 3665 iaLimits.schedPolicy = ClassInfo.pc_cid; 3666 iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri; 3667 iaLimits.minPrio = -iaLimits.maxPrio; 3668 3669 strcpy(ClassInfo.pc_clname, "RT"); 3670 ClassInfo.pc_cid = -1; 3671 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo); 3672 if (rslt < 0) return errno; 3673 assert(ClassInfo.pc_cid != -1, "cid for RT class is -1"); 3674 rtLimits.schedPolicy = ClassInfo.pc_cid; 3675 rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri; 3676 rtLimits.minPrio = 0; 3677 3678 3679 // Query our "current" scheduling class. 3680 // This will normally be IA,TS or, rarely, RT. 3681 memset (&ParmInfo, 0, sizeof(ParmInfo)); 3682 ParmInfo.pc_cid = PC_CLNULL; 3683 rslt = (*priocntl_ptr) (PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo ); 3684 if ( rslt < 0 ) return errno; 3685 myClass = ParmInfo.pc_cid; 3686 3687 // We now know our scheduling classId, get specific information 3688 // the class. 3689 ClassInfo.pc_cid = myClass; 3690 ClassInfo.pc_clname[0] = 0; 3691 rslt = (*priocntl_ptr) (PC_VERSION, (idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo ); 3692 if ( rslt < 0 ) return errno; 3693 3694 if (ThreadPriorityVerbose) 3695 tty->print_cr ("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname); 3696 3697 memset(&ParmInfo, 0, sizeof(pcparms_t)); 3698 ParmInfo.pc_cid = PC_CLNULL; 3699 rslt = (*priocntl_ptr)(PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo); 3700 if (rslt < 0) return errno; 3701 3702 if (ParmInfo.pc_cid == rtLimits.schedPolicy) { 3703 myMin = rtLimits.minPrio; 3704 myMax = rtLimits.maxPrio; 3705 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) { 3706 iaparms_t *iaInfo = (iaparms_t*)ParmInfo.pc_clparms; 3707 myMin = iaLimits.minPrio; 3708 myMax = iaLimits.maxPrio; 3709 myMax = MIN2(myMax, (int)iaInfo->ia_uprilim); // clamp - restrict 3710 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) { 3711 tsparms_t *tsInfo = (tsparms_t*)ParmInfo.pc_clparms; 3712 myMin = tsLimits.minPrio; 3713 myMax = tsLimits.maxPrio; 3714 myMax = MIN2(myMax, (int)tsInfo->ts_uprilim); // clamp - restrict 3715 } else { 3716 // No clue - punt 3717 if (ThreadPriorityVerbose) 3718 tty->print_cr ("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname); 3719 return EINVAL; // no clue, punt 3720 } 3721 3722 if (ThreadPriorityVerbose) 3723 tty->print_cr ("Thread priority Range: [%d..%d]\n", myMin, myMax); 3724 3725 priocntl_enable = true; // Enable changing priorities 3726 return 0; 3727} 3728 3729#define IAPRI(x) ((iaparms_t *)((x).pc_clparms)) 3730#define RTPRI(x) ((rtparms_t *)((x).pc_clparms)) 3731#define TSPRI(x) ((tsparms_t *)((x).pc_clparms)) 3732 3733 3734// scale_to_lwp_priority 3735// 3736// Convert from the libthread "thr_setprio" scale to our current 3737// lwp scheduling class scale. 3738// 3739static 3740int scale_to_lwp_priority (int rMin, int rMax, int x) 3741{ 3742 int v; 3743 3744 if (x == 127) return rMax; // avoid round-down 3745 v = (((x*(rMax-rMin)))/128)+rMin; 3746 return v; 3747} 3748 3749 3750// set_lwp_priority 3751// 3752// Set the priority of the lwp. This call should only be made 3753// when using bound threads (T2 threads are bound by default). 3754// 3755int set_lwp_priority (int ThreadID, int lwpid, int newPrio ) 3756{ 3757 int rslt; 3758 int Actual, Expected, prv; 3759 pcparms_t ParmInfo; // for GET-SET 3760#ifdef ASSERT 3761 pcparms_t ReadBack; // for readback 3762#endif 3763 3764 // Set priority via PC_GETPARMS, update, PC_SETPARMS 3765 // Query current values. 3766 // TODO: accelerate this by eliminating the PC_GETPARMS call. 3767 // Cache "pcparms_t" in global ParmCache. 3768 // TODO: elide set-to-same-value 3769 3770 // If something went wrong on init, don't change priorities. 3771 if ( !priocntl_enable ) { 3772 if (ThreadPriorityVerbose) 3773 tty->print_cr("Trying to set priority but init failed, ignoring"); 3774 return EINVAL; 3775 } 3776 3777 3778 // If lwp hasn't started yet, just return 3779 // the _start routine will call us again. 3780 if ( lwpid <= 0 ) { 3781 if (ThreadPriorityVerbose) { 3782 tty->print_cr ("deferring the set_lwp_priority of thread " INTPTR_FORMAT " to %d, lwpid not set", 3783 ThreadID, newPrio); 3784 } 3785 return 0; 3786 } 3787 3788 if (ThreadPriorityVerbose) { 3789 tty->print_cr ("set_lwp_priority(" INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ", 3790 ThreadID, lwpid, newPrio); 3791 } 3792 3793 memset(&ParmInfo, 0, sizeof(pcparms_t)); 3794 ParmInfo.pc_cid = PC_CLNULL; 3795 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo); 3796 if (rslt < 0) return errno; 3797 3798 if (ParmInfo.pc_cid == rtLimits.schedPolicy) { 3799 rtparms_t *rtInfo = (rtparms_t*)ParmInfo.pc_clparms; 3800 rtInfo->rt_pri = scale_to_lwp_priority (rtLimits.minPrio, rtLimits.maxPrio, newPrio); 3801 rtInfo->rt_tqsecs = RT_NOCHANGE; 3802 rtInfo->rt_tqnsecs = RT_NOCHANGE; 3803 if (ThreadPriorityVerbose) { 3804 tty->print_cr("RT: %d->%d\n", newPrio, rtInfo->rt_pri); 3805 } 3806 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) { 3807 iaparms_t *iaInfo = (iaparms_t*)ParmInfo.pc_clparms; 3808 int maxClamped = MIN2(iaLimits.maxPrio, (int)iaInfo->ia_uprilim); 3809 iaInfo->ia_upri = scale_to_lwp_priority(iaLimits.minPrio, maxClamped, newPrio); 3810 iaInfo->ia_uprilim = IA_NOCHANGE; 3811 iaInfo->ia_mode = IA_NOCHANGE; 3812 if (ThreadPriorityVerbose) { 3813 tty->print_cr ("IA: [%d...%d] %d->%d\n", 3814 iaLimits.minPrio, maxClamped, newPrio, iaInfo->ia_upri); 3815 } 3816 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) { 3817 tsparms_t *tsInfo = (tsparms_t*)ParmInfo.pc_clparms; 3818 int maxClamped = MIN2(tsLimits.maxPrio, (int)tsInfo->ts_uprilim); 3819 prv = tsInfo->ts_upri; 3820 tsInfo->ts_upri = scale_to_lwp_priority(tsLimits.minPrio, maxClamped, newPrio); 3821 tsInfo->ts_uprilim = IA_NOCHANGE; 3822 if (ThreadPriorityVerbose) { 3823 tty->print_cr ("TS: %d [%d...%d] %d->%d\n", 3824 prv, tsLimits.minPrio, maxClamped, newPrio, tsInfo->ts_upri); 3825 } 3826 if (prv == tsInfo->ts_upri) return 0; 3827 } else { 3828 if ( ThreadPriorityVerbose ) { 3829 tty->print_cr ("Unknown scheduling class\n"); 3830 } 3831 return EINVAL; // no clue, punt 3832 } 3833 3834 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_SETPARMS, (caddr_t)&ParmInfo); 3835 if (ThreadPriorityVerbose && rslt) { 3836 tty->print_cr ("PC_SETPARMS ->%d %d\n", rslt, errno); 3837 } 3838 if (rslt < 0) return errno; 3839 3840#ifdef ASSERT 3841 // Sanity check: read back what we just attempted to set. 3842 // In theory it could have changed in the interim ... 3843 // 3844 // The priocntl system call is tricky. 3845 // Sometimes it'll validate the priority value argument and 3846 // return EINVAL if unhappy. At other times it fails silently. 3847 // Readbacks are prudent. 3848 3849 if (!ReadBackValidate) return 0; 3850 3851 memset(&ReadBack, 0, sizeof(pcparms_t)); 3852 ReadBack.pc_cid = PC_CLNULL; 3853 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ReadBack); 3854 assert(rslt >= 0, "priocntl failed"); 3855 Actual = Expected = 0xBAD; 3856 assert(ParmInfo.pc_cid == ReadBack.pc_cid, "cid's don't match"); 3857 if (ParmInfo.pc_cid == rtLimits.schedPolicy) { 3858 Actual = RTPRI(ReadBack)->rt_pri; 3859 Expected = RTPRI(ParmInfo)->rt_pri; 3860 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) { 3861 Actual = IAPRI(ReadBack)->ia_upri; 3862 Expected = IAPRI(ParmInfo)->ia_upri; 3863 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) { 3864 Actual = TSPRI(ReadBack)->ts_upri; 3865 Expected = TSPRI(ParmInfo)->ts_upri; 3866 } else { 3867 if ( ThreadPriorityVerbose ) { 3868 tty->print_cr("set_lwp_priority: unexpected class in readback: %d\n", ParmInfo.pc_cid); 3869 } 3870 } 3871 3872 if (Actual != Expected) { 3873 if ( ThreadPriorityVerbose ) { 3874 tty->print_cr ("set_lwp_priority(%d %d) Class=%d: actual=%d vs expected=%d\n", 3875 lwpid, newPrio, ReadBack.pc_cid, Actual, Expected); 3876 } 3877 } 3878#endif 3879 3880 return 0; 3881} 3882 3883 3884 3885// Solaris only gives access to 128 real priorities at a time, 3886// so we expand Java's ten to fill this range. This would be better 3887// if we dynamically adjusted relative priorities. 3888// 3889// The ThreadPriorityPolicy option allows us to select 2 different 3890// priority scales. 3891// 3892// ThreadPriorityPolicy=0 3893// Since the Solaris' default priority is MaximumPriority, we do not 3894// set a priority lower than Max unless a priority lower than 3895// NormPriority is requested. 3896// 3897// ThreadPriorityPolicy=1 3898// This mode causes the priority table to get filled with 3899// linear values. NormPriority get's mapped to 50% of the 3900// Maximum priority an so on. This will cause VM threads 3901// to get unfair treatment against other Solaris processes 3902// which do not explicitly alter their thread priorities. 3903// 3904 3905 3906int os::java_to_os_priority[MaxPriority + 1] = { 3907 -99999, // 0 Entry should never be used 3908 3909 0, // 1 MinPriority 3910 32, // 2 3911 64, // 3 3912 3913 96, // 4 3914 127, // 5 NormPriority 3915 127, // 6 3916 3917 127, // 7 3918 127, // 8 3919 127, // 9 NearMaxPriority 3920 3921 127 // 10 MaxPriority 3922}; 3923 3924 3925OSReturn os::set_native_priority(Thread* thread, int newpri) { 3926 assert(newpri >= MinimumPriority && newpri <= MaximumPriority, "bad priority mapping"); 3927 if ( !UseThreadPriorities ) return OS_OK; 3928 int status = thr_setprio(thread->osthread()->thread_id(), newpri); 3929 if ( os::Solaris::T2_libthread() || (UseBoundThreads && thread->osthread()->is_vm_created()) ) 3930 status |= (set_lwp_priority (thread->osthread()->thread_id(), 3931 thread->osthread()->lwp_id(), newpri )); 3932 return (status == 0) ? OS_OK : OS_ERR; 3933} 3934 3935 3936OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) { 3937 int p; 3938 if ( !UseThreadPriorities ) { 3939 *priority_ptr = NormalPriority; 3940 return OS_OK; 3941 } 3942 int status = thr_getprio(thread->osthread()->thread_id(), &p); 3943 if (status != 0) { 3944 return OS_ERR; 3945 } 3946 *priority_ptr = p; 3947 return OS_OK; 3948} 3949 3950 3951// Hint to the underlying OS that a task switch would not be good. 3952// Void return because it's a hint and can fail. 3953void os::hint_no_preempt() { 3954 schedctl_start(schedctl_init()); 3955} 3956 3957void os::interrupt(Thread* thread) { 3958 assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer"); 3959 3960 OSThread* osthread = thread->osthread(); 3961 3962 int isInterrupted = osthread->interrupted(); 3963 if (!isInterrupted) { 3964 osthread->set_interrupted(true); 3965 OrderAccess::fence(); 3966 // os::sleep() is implemented with either poll (NULL,0,timeout) or 3967 // by parking on _SleepEvent. If the former, thr_kill will unwedge 3968 // the sleeper by SIGINTR, otherwise the unpark() will wake the sleeper. 3969 ParkEvent * const slp = thread->_SleepEvent ; 3970 if (slp != NULL) slp->unpark() ; 3971 } 3972 3973 // For JSR166: unpark after setting status but before thr_kill -dl 3974 if (thread->is_Java_thread()) { 3975 ((JavaThread*)thread)->parker()->unpark(); 3976 } 3977 3978 // Handle interruptible wait() ... 3979 ParkEvent * const ev = thread->_ParkEvent ; 3980 if (ev != NULL) ev->unpark() ; 3981 3982 // When events are used everywhere for os::sleep, then this thr_kill 3983 // will only be needed if UseVMInterruptibleIO is true. 3984 3985 if (!isInterrupted) { 3986 int status = thr_kill(osthread->thread_id(), os::Solaris::SIGinterrupt()); 3987 assert_status(status == 0, status, "thr_kill"); 3988 3989 // Bump thread interruption counter 3990 RuntimeService::record_thread_interrupt_signaled_count(); 3991 } 3992} 3993 3994 3995bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 3996 assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer"); 3997 3998 OSThread* osthread = thread->osthread(); 3999 4000 bool res = osthread->interrupted(); 4001 4002 // NOTE that since there is no "lock" around these two operations, 4003 // there is the possibility that the interrupted flag will be 4004 // "false" but that the interrupt event will be set. This is 4005 // intentional. The effect of this is that Object.wait() will appear 4006 // to have a spurious wakeup, which is not harmful, and the 4007 // possibility is so rare that it is not worth the added complexity 4008 // to add yet another lock. It has also been recommended not to put 4009 // the interrupted flag into the os::Solaris::Event structure, 4010 // because it hides the issue. 4011 if (res && clear_interrupted) { 4012 osthread->set_interrupted(false); 4013 } 4014 return res; 4015} 4016 4017 4018void os::print_statistics() { 4019} 4020 4021int os::message_box(const char* title, const char* message) { 4022 int i; 4023 fdStream err(defaultStream::error_fd()); 4024 for (i = 0; i < 78; i++) err.print_raw("="); 4025 err.cr(); 4026 err.print_raw_cr(title); 4027 for (i = 0; i < 78; i++) err.print_raw("-"); 4028 err.cr(); 4029 err.print_raw_cr(message); 4030 for (i = 0; i < 78; i++) err.print_raw("="); 4031 err.cr(); 4032 4033 char buf[16]; 4034 // Prevent process from exiting upon "read error" without consuming all CPU 4035 while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); } 4036 4037 return buf[0] == 'y' || buf[0] == 'Y'; 4038} 4039 4040// A lightweight implementation that does not suspend the target thread and 4041// thus returns only a hint. Used for profiling only! 4042ExtendedPC os::get_thread_pc(Thread* thread) { 4043 // Make sure that it is called by the watcher and the Threads lock is owned. 4044 assert(Thread::current()->is_Watcher_thread(), "Must be watcher and own Threads_lock"); 4045 // For now, is only used to profile the VM Thread 4046 assert(thread->is_VM_thread(), "Can only be called for VMThread"); 4047 ExtendedPC epc; 4048 4049 GetThreadPC_Callback cb(ProfileVM_lock); 4050 OSThread *osthread = thread->osthread(); 4051 const int time_to_wait = 400; // 400ms wait for initial response 4052 int status = cb.interrupt(thread, time_to_wait); 4053 4054 if (cb.is_done() ) { 4055 epc = cb.addr(); 4056 } else { 4057 DEBUG_ONLY(tty->print_cr("Failed to get pc for thread: %d got %d status", 4058 osthread->thread_id(), status);); 4059 // epc is already NULL 4060 } 4061 return epc; 4062} 4063 4064 4065// This does not do anything on Solaris. This is basically a hook for being 4066// able to use structured exception handling (thread-local exception filters) on, e.g., Win32. 4067void os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread) { 4068 f(value, method, args, thread); 4069} 4070 4071// This routine may be used by user applications as a "hook" to catch signals. 4072// The user-defined signal handler must pass unrecognized signals to this 4073// routine, and if it returns true (non-zero), then the signal handler must 4074// return immediately. If the flag "abort_if_unrecognized" is true, then this 4075// routine will never retun false (zero), but instead will execute a VM panic 4076// routine kill the process. 4077// 4078// If this routine returns false, it is OK to call it again. This allows 4079// the user-defined signal handler to perform checks either before or after 4080// the VM performs its own checks. Naturally, the user code would be making 4081// a serious error if it tried to handle an exception (such as a null check 4082// or breakpoint) that the VM was generating for its own correct operation. 4083// 4084// This routine may recognize any of the following kinds of signals: 4085// SIGBUS, SIGSEGV, SIGILL, SIGFPE, BREAK_SIGNAL, SIGPIPE, SIGXFSZ, 4086// os::Solaris::SIGasync 4087// It should be consulted by handlers for any of those signals. 4088// It explicitly does not recognize os::Solaris::SIGinterrupt 4089// 4090// The caller of this routine must pass in the three arguments supplied 4091// to the function referred to in the "sa_sigaction" (not the "sa_handler") 4092// field of the structure passed to sigaction(). This routine assumes that 4093// the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART. 4094// 4095// Note that the VM will print warnings if it detects conflicting signal 4096// handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers". 4097// 4098extern "C" int JVM_handle_solaris_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized); 4099 4100 4101void signalHandler(int sig, siginfo_t* info, void* ucVoid) { 4102 JVM_handle_solaris_signal(sig, info, ucVoid, true); 4103} 4104 4105/* Do not delete - if guarantee is ever removed, a signal handler (even empty) 4106 is needed to provoke threads blocked on IO to return an EINTR 4107 Note: this explicitly does NOT call JVM_handle_solaris_signal and 4108 does NOT participate in signal chaining due to requirement for 4109 NOT setting SA_RESTART to make EINTR work. */ 4110extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) { 4111 if (UseSignalChaining) { 4112 struct sigaction *actp = os::Solaris::get_chained_signal_action(sig); 4113 if (actp && actp->sa_handler) { 4114 vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs"); 4115 } 4116 } 4117} 4118 4119// This boolean allows users to forward their own non-matching signals 4120// to JVM_handle_solaris_signal, harmlessly. 4121bool os::Solaris::signal_handlers_are_installed = false; 4122 4123// For signal-chaining 4124bool os::Solaris::libjsig_is_loaded = false; 4125typedef struct sigaction *(*get_signal_t)(int); 4126get_signal_t os::Solaris::get_signal_action = NULL; 4127 4128struct sigaction* os::Solaris::get_chained_signal_action(int sig) { 4129 struct sigaction *actp = NULL; 4130 4131 if ((libjsig_is_loaded) && (sig <= Maxlibjsigsigs)) { 4132 // Retrieve the old signal handler from libjsig 4133 actp = (*get_signal_action)(sig); 4134 } 4135 if (actp == NULL) { 4136 // Retrieve the preinstalled signal handler from jvm 4137 actp = get_preinstalled_handler(sig); 4138 } 4139 4140 return actp; 4141} 4142 4143static bool call_chained_handler(struct sigaction *actp, int sig, 4144 siginfo_t *siginfo, void *context) { 4145 // Call the old signal handler 4146 if (actp->sa_handler == SIG_DFL) { 4147 // It's more reasonable to let jvm treat it as an unexpected exception 4148 // instead of taking the default action. 4149 return false; 4150 } else if (actp->sa_handler != SIG_IGN) { 4151 if ((actp->sa_flags & SA_NODEFER) == 0) { 4152 // automaticlly block the signal 4153 sigaddset(&(actp->sa_mask), sig); 4154 } 4155 4156 sa_handler_t hand; 4157 sa_sigaction_t sa; 4158 bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0; 4159 // retrieve the chained handler 4160 if (siginfo_flag_set) { 4161 sa = actp->sa_sigaction; 4162 } else { 4163 hand = actp->sa_handler; 4164 } 4165 4166 if ((actp->sa_flags & SA_RESETHAND) != 0) { 4167 actp->sa_handler = SIG_DFL; 4168 } 4169 4170 // try to honor the signal mask 4171 sigset_t oset; 4172 thr_sigsetmask(SIG_SETMASK, &(actp->sa_mask), &oset); 4173 4174 // call into the chained handler 4175 if (siginfo_flag_set) { 4176 (*sa)(sig, siginfo, context); 4177 } else { 4178 (*hand)(sig); 4179 } 4180 4181 // restore the signal mask 4182 thr_sigsetmask(SIG_SETMASK, &oset, 0); 4183 } 4184 // Tell jvm's signal handler the signal is taken care of. 4185 return true; 4186} 4187 4188bool os::Solaris::chained_handler(int sig, siginfo_t* siginfo, void* context) { 4189 bool chained = false; 4190 // signal-chaining 4191 if (UseSignalChaining) { 4192 struct sigaction *actp = get_chained_signal_action(sig); 4193 if (actp != NULL) { 4194 chained = call_chained_handler(actp, sig, siginfo, context); 4195 } 4196 } 4197 return chained; 4198} 4199 4200struct sigaction* os::Solaris::get_preinstalled_handler(int sig) { 4201 assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized"); 4202 if (preinstalled_sigs[sig] != 0) { 4203 return &chainedsigactions[sig]; 4204 } 4205 return NULL; 4206} 4207 4208void os::Solaris::save_preinstalled_handler(int sig, struct sigaction& oldAct) { 4209 4210 assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range"); 4211 assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized"); 4212 chainedsigactions[sig] = oldAct; 4213 preinstalled_sigs[sig] = 1; 4214} 4215 4216void os::Solaris::set_signal_handler(int sig, bool set_installed, bool oktochain) { 4217 // Check for overwrite. 4218 struct sigaction oldAct; 4219 sigaction(sig, (struct sigaction*)NULL, &oldAct); 4220 void* oldhand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 4221 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 4222 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) && 4223 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) && 4224 oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) { 4225 if (AllowUserSignalHandlers || !set_installed) { 4226 // Do not overwrite; user takes responsibility to forward to us. 4227 return; 4228 } else if (UseSignalChaining) { 4229 if (oktochain) { 4230 // save the old handler in jvm 4231 save_preinstalled_handler(sig, oldAct); 4232 } else { 4233 vm_exit_during_initialization("Signal chaining not allowed for VM interrupt signal, try -XX:+UseAltSigs."); 4234 } 4235 // libjsig also interposes the sigaction() call below and saves the 4236 // old sigaction on it own. 4237 } else { 4238 fatal(err_msg("Encountered unexpected pre-existing sigaction handler " 4239 "%#lx for signal %d.", (long)oldhand, sig)); 4240 } 4241 } 4242 4243 struct sigaction sigAct; 4244 sigfillset(&(sigAct.sa_mask)); 4245 sigAct.sa_handler = SIG_DFL; 4246 4247 sigAct.sa_sigaction = signalHandler; 4248 // Handle SIGSEGV on alternate signal stack if 4249 // not using stack banging 4250 if (!UseStackBanging && sig == SIGSEGV) { 4251 sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK; 4252 // Interruptible i/o requires SA_RESTART cleared so EINTR 4253 // is returned instead of restarting system calls 4254 } else if (sig == os::Solaris::SIGinterrupt()) { 4255 sigemptyset(&sigAct.sa_mask); 4256 sigAct.sa_handler = NULL; 4257 sigAct.sa_flags = SA_SIGINFO; 4258 sigAct.sa_sigaction = sigINTRHandler; 4259 } else { 4260 sigAct.sa_flags = SA_SIGINFO | SA_RESTART; 4261 } 4262 os::Solaris::set_our_sigflags(sig, sigAct.sa_flags); 4263 4264 sigaction(sig, &sigAct, &oldAct); 4265 4266 void* oldhand2 = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 4267 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 4268 assert(oldhand2 == oldhand, "no concurrent signal handler installation"); 4269} 4270 4271 4272#define DO_SIGNAL_CHECK(sig) \ 4273 if (!sigismember(&check_signal_done, sig)) \ 4274 os::Solaris::check_signal_handler(sig) 4275 4276// This method is a periodic task to check for misbehaving JNI applications 4277// under CheckJNI, we can add any periodic checks here 4278 4279void os::run_periodic_checks() { 4280 // A big source of grief is hijacking virt. addr 0x0 on Solaris, 4281 // thereby preventing a NULL checks. 4282 if(!check_addr0_done) check_addr0_done = check_addr0(tty); 4283 4284 if (check_signals == false) return; 4285 4286 // SEGV and BUS if overridden could potentially prevent 4287 // generation of hs*.log in the event of a crash, debugging 4288 // such a case can be very challenging, so we absolutely 4289 // check for the following for a good measure: 4290 DO_SIGNAL_CHECK(SIGSEGV); 4291 DO_SIGNAL_CHECK(SIGILL); 4292 DO_SIGNAL_CHECK(SIGFPE); 4293 DO_SIGNAL_CHECK(SIGBUS); 4294 DO_SIGNAL_CHECK(SIGPIPE); 4295 DO_SIGNAL_CHECK(SIGXFSZ); 4296 4297 // ReduceSignalUsage allows the user to override these handlers 4298 // see comments at the very top and jvm_solaris.h 4299 if (!ReduceSignalUsage) { 4300 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL); 4301 DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL); 4302 DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL); 4303 DO_SIGNAL_CHECK(BREAK_SIGNAL); 4304 } 4305 4306 // See comments above for using JVM1/JVM2 and UseAltSigs 4307 DO_SIGNAL_CHECK(os::Solaris::SIGinterrupt()); 4308 DO_SIGNAL_CHECK(os::Solaris::SIGasync()); 4309 4310} 4311 4312typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *); 4313 4314static os_sigaction_t os_sigaction = NULL; 4315 4316void os::Solaris::check_signal_handler(int sig) { 4317 char buf[O_BUFLEN]; 4318 address jvmHandler = NULL; 4319 4320 struct sigaction act; 4321 if (os_sigaction == NULL) { 4322 // only trust the default sigaction, in case it has been interposed 4323 os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction"); 4324 if (os_sigaction == NULL) return; 4325 } 4326 4327 os_sigaction(sig, (struct sigaction*)NULL, &act); 4328 4329 address thisHandler = (act.sa_flags & SA_SIGINFO) 4330 ? CAST_FROM_FN_PTR(address, act.sa_sigaction) 4331 : CAST_FROM_FN_PTR(address, act.sa_handler) ; 4332 4333 4334 switch(sig) { 4335 case SIGSEGV: 4336 case SIGBUS: 4337 case SIGFPE: 4338 case SIGPIPE: 4339 case SIGXFSZ: 4340 case SIGILL: 4341 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler); 4342 break; 4343 4344 case SHUTDOWN1_SIGNAL: 4345 case SHUTDOWN2_SIGNAL: 4346 case SHUTDOWN3_SIGNAL: 4347 case BREAK_SIGNAL: 4348 jvmHandler = (address)user_handler(); 4349 break; 4350 4351 default: 4352 int intrsig = os::Solaris::SIGinterrupt(); 4353 int asynsig = os::Solaris::SIGasync(); 4354 4355 if (sig == intrsig) { 4356 jvmHandler = CAST_FROM_FN_PTR(address, sigINTRHandler); 4357 } else if (sig == asynsig) { 4358 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler); 4359 } else { 4360 return; 4361 } 4362 break; 4363 } 4364 4365 4366 if (thisHandler != jvmHandler) { 4367 tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN)); 4368 tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN)); 4369 tty->print_cr(" found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN)); 4370 // No need to check this sig any longer 4371 sigaddset(&check_signal_done, sig); 4372 } else if(os::Solaris::get_our_sigflags(sig) != 0 && act.sa_flags != os::Solaris::get_our_sigflags(sig)) { 4373 tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN)); 4374 tty->print("expected:" PTR32_FORMAT, os::Solaris::get_our_sigflags(sig)); 4375 tty->print_cr(" found:" PTR32_FORMAT, act.sa_flags); 4376 // No need to check this sig any longer 4377 sigaddset(&check_signal_done, sig); 4378 } 4379 4380 // Print all the signal handler state 4381 if (sigismember(&check_signal_done, sig)) { 4382 print_signal_handlers(tty, buf, O_BUFLEN); 4383 } 4384 4385} 4386 4387void os::Solaris::install_signal_handlers() { 4388 bool libjsigdone = false; 4389 signal_handlers_are_installed = true; 4390 4391 // signal-chaining 4392 typedef void (*signal_setting_t)(); 4393 signal_setting_t begin_signal_setting = NULL; 4394 signal_setting_t end_signal_setting = NULL; 4395 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 4396 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting")); 4397 if (begin_signal_setting != NULL) { 4398 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 4399 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting")); 4400 get_signal_action = CAST_TO_FN_PTR(get_signal_t, 4401 dlsym(RTLD_DEFAULT, "JVM_get_signal_action")); 4402 get_libjsig_version = CAST_TO_FN_PTR(version_getting_t, 4403 dlsym(RTLD_DEFAULT, "JVM_get_libjsig_version")); 4404 libjsig_is_loaded = true; 4405 if (os::Solaris::get_libjsig_version != NULL) { 4406 libjsigversion = (*os::Solaris::get_libjsig_version)(); 4407 } 4408 assert(UseSignalChaining, "should enable signal-chaining"); 4409 } 4410 if (libjsig_is_loaded) { 4411 // Tell libjsig jvm is setting signal handlers 4412 (*begin_signal_setting)(); 4413 } 4414 4415 set_signal_handler(SIGSEGV, true, true); 4416 set_signal_handler(SIGPIPE, true, true); 4417 set_signal_handler(SIGXFSZ, true, true); 4418 set_signal_handler(SIGBUS, true, true); 4419 set_signal_handler(SIGILL, true, true); 4420 set_signal_handler(SIGFPE, true, true); 4421 4422 4423 if (os::Solaris::SIGinterrupt() > OLDMAXSIGNUM || os::Solaris::SIGasync() > OLDMAXSIGNUM) { 4424 4425 // Pre-1.4.1 Libjsig limited to signal chaining signals <= 32 so 4426 // can not register overridable signals which might be > 32 4427 if (libjsig_is_loaded && libjsigversion <= JSIG_VERSION_1_4_1) { 4428 // Tell libjsig jvm has finished setting signal handlers 4429 (*end_signal_setting)(); 4430 libjsigdone = true; 4431 } 4432 } 4433 4434 // Never ok to chain our SIGinterrupt 4435 set_signal_handler(os::Solaris::SIGinterrupt(), true, false); 4436 set_signal_handler(os::Solaris::SIGasync(), true, true); 4437 4438 if (libjsig_is_loaded && !libjsigdone) { 4439 // Tell libjsig jvm finishes setting signal handlers 4440 (*end_signal_setting)(); 4441 } 4442 4443 // We don't activate signal checker if libjsig is in place, we trust ourselves 4444 // and if UserSignalHandler is installed all bets are off 4445 if (CheckJNICalls) { 4446 if (libjsig_is_loaded) { 4447 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled"); 4448 check_signals = false; 4449 } 4450 if (AllowUserSignalHandlers) { 4451 tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled"); 4452 check_signals = false; 4453 } 4454 } 4455} 4456 4457 4458void report_error(const char* file_name, int line_no, const char* title, const char* format, ...); 4459 4460const char * signames[] = { 4461 "SIG0", 4462 "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP", 4463 "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS", 4464 "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM", 4465 "SIGUSR1", "SIGUSR2", "SIGCLD", "SIGPWR", "SIGWINCH", 4466 "SIGURG", "SIGPOLL", "SIGSTOP", "SIGTSTP", "SIGCONT", 4467 "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU", 4468 "SIGXFSZ", "SIGWAITING", "SIGLWP", "SIGFREEZE", "SIGTHAW", 4469 "SIGCANCEL", "SIGLOST" 4470}; 4471 4472const char* os::exception_name(int exception_code, char* buf, size_t size) { 4473 if (0 < exception_code && exception_code <= SIGRTMAX) { 4474 // signal 4475 if (exception_code < sizeof(signames)/sizeof(const char*)) { 4476 jio_snprintf(buf, size, "%s", signames[exception_code]); 4477 } else { 4478 jio_snprintf(buf, size, "SIG%d", exception_code); 4479 } 4480 return buf; 4481 } else { 4482 return NULL; 4483 } 4484} 4485 4486// (Static) wrappers for the new libthread API 4487int_fnP_thread_t_iP_uP_stack_tP_gregset_t os::Solaris::_thr_getstate; 4488int_fnP_thread_t_i_gregset_t os::Solaris::_thr_setstate; 4489int_fnP_thread_t_i os::Solaris::_thr_setmutator; 4490int_fnP_thread_t os::Solaris::_thr_suspend_mutator; 4491int_fnP_thread_t os::Solaris::_thr_continue_mutator; 4492 4493// (Static) wrapper for getisax(2) call. 4494os::Solaris::getisax_func_t os::Solaris::_getisax = 0; 4495 4496// (Static) wrappers for the liblgrp API 4497os::Solaris::lgrp_home_func_t os::Solaris::_lgrp_home; 4498os::Solaris::lgrp_init_func_t os::Solaris::_lgrp_init; 4499os::Solaris::lgrp_fini_func_t os::Solaris::_lgrp_fini; 4500os::Solaris::lgrp_root_func_t os::Solaris::_lgrp_root; 4501os::Solaris::lgrp_children_func_t os::Solaris::_lgrp_children; 4502os::Solaris::lgrp_resources_func_t os::Solaris::_lgrp_resources; 4503os::Solaris::lgrp_nlgrps_func_t os::Solaris::_lgrp_nlgrps; 4504os::Solaris::lgrp_cookie_stale_func_t os::Solaris::_lgrp_cookie_stale; 4505os::Solaris::lgrp_cookie_t os::Solaris::_lgrp_cookie = 0; 4506 4507// (Static) wrapper for meminfo() call. 4508os::Solaris::meminfo_func_t os::Solaris::_meminfo = 0; 4509 4510static address resolve_symbol_lazy(const char* name) { 4511 address addr = (address) dlsym(RTLD_DEFAULT, name); 4512 if(addr == NULL) { 4513 // RTLD_DEFAULT was not defined on some early versions of 2.5.1 4514 addr = (address) dlsym(RTLD_NEXT, name); 4515 } 4516 return addr; 4517} 4518 4519static address resolve_symbol(const char* name) { 4520 address addr = resolve_symbol_lazy(name); 4521 if(addr == NULL) { 4522 fatal(dlerror()); 4523 } 4524 return addr; 4525} 4526 4527 4528 4529// isT2_libthread() 4530// 4531// Routine to determine if we are currently using the new T2 libthread. 4532// 4533// We determine if we are using T2 by reading /proc/self/lstatus and 4534// looking for a thread with the ASLWP bit set. If we find this status 4535// bit set, we must assume that we are NOT using T2. The T2 team 4536// has approved this algorithm. 4537// 4538// We need to determine if we are running with the new T2 libthread 4539// since setting native thread priorities is handled differently 4540// when using this library. All threads created using T2 are bound 4541// threads. Calling thr_setprio is meaningless in this case. 4542// 4543bool isT2_libthread() { 4544 static prheader_t * lwpArray = NULL; 4545 static int lwpSize = 0; 4546 static int lwpFile = -1; 4547 lwpstatus_t * that; 4548 char lwpName [128]; 4549 bool isT2 = false; 4550 4551#define ADR(x) ((uintptr_t)(x)) 4552#define LWPINDEX(ary,ix) ((lwpstatus_t *)(((ary)->pr_entsize * (ix)) + (ADR((ary) + 1)))) 4553 4554 lwpFile = open("/proc/self/lstatus", O_RDONLY, 0); 4555 if (lwpFile < 0) { 4556 if (ThreadPriorityVerbose) warning ("Couldn't open /proc/self/lstatus\n"); 4557 return false; 4558 } 4559 lwpSize = 16*1024; 4560 for (;;) { 4561 lseek (lwpFile, 0, SEEK_SET); 4562 lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize); 4563 if (read(lwpFile, lwpArray, lwpSize) < 0) { 4564 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n"); 4565 break; 4566 } 4567 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) { 4568 // We got a good snapshot - now iterate over the list. 4569 int aslwpcount = 0; 4570 for (int i = 0; i < lwpArray->pr_nent; i++ ) { 4571 that = LWPINDEX(lwpArray,i); 4572 if (that->pr_flags & PR_ASLWP) { 4573 aslwpcount++; 4574 } 4575 } 4576 if (aslwpcount == 0) isT2 = true; 4577 break; 4578 } 4579 lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize; 4580 FREE_C_HEAP_ARRAY(char, lwpArray); // retry. 4581 } 4582 4583 FREE_C_HEAP_ARRAY(char, lwpArray); 4584 close (lwpFile); 4585 if (ThreadPriorityVerbose) { 4586 if (isT2) tty->print_cr("We are running with a T2 libthread\n"); 4587 else tty->print_cr("We are not running with a T2 libthread\n"); 4588 } 4589 return isT2; 4590} 4591 4592 4593void os::Solaris::libthread_init() { 4594 address func = (address)dlsym(RTLD_DEFAULT, "_thr_suspend_allmutators"); 4595 4596 // Determine if we are running with the new T2 libthread 4597 os::Solaris::set_T2_libthread(isT2_libthread()); 4598 4599 lwp_priocntl_init(); 4600 4601 // RTLD_DEFAULT was not defined on some early versions of 5.5.1 4602 if(func == NULL) { 4603 func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators"); 4604 // Guarantee that this VM is running on an new enough OS (5.6 or 4605 // later) that it will have a new enough libthread.so. 4606 guarantee(func != NULL, "libthread.so is too old."); 4607 } 4608 4609 // Initialize the new libthread getstate API wrappers 4610 func = resolve_symbol("thr_getstate"); 4611 os::Solaris::set_thr_getstate(CAST_TO_FN_PTR(int_fnP_thread_t_iP_uP_stack_tP_gregset_t, func)); 4612 4613 func = resolve_symbol("thr_setstate"); 4614 os::Solaris::set_thr_setstate(CAST_TO_FN_PTR(int_fnP_thread_t_i_gregset_t, func)); 4615 4616 func = resolve_symbol("thr_setmutator"); 4617 os::Solaris::set_thr_setmutator(CAST_TO_FN_PTR(int_fnP_thread_t_i, func)); 4618 4619 func = resolve_symbol("thr_suspend_mutator"); 4620 os::Solaris::set_thr_suspend_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func)); 4621 4622 func = resolve_symbol("thr_continue_mutator"); 4623 os::Solaris::set_thr_continue_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func)); 4624 4625 int size; 4626 void (*handler_info_func)(address *, int *); 4627 handler_info_func = CAST_TO_FN_PTR(void (*)(address *, int *), resolve_symbol("thr_sighndlrinfo")); 4628 handler_info_func(&handler_start, &size); 4629 handler_end = handler_start + size; 4630} 4631 4632 4633int_fnP_mutex_tP os::Solaris::_mutex_lock; 4634int_fnP_mutex_tP os::Solaris::_mutex_trylock; 4635int_fnP_mutex_tP os::Solaris::_mutex_unlock; 4636int_fnP_mutex_tP_i_vP os::Solaris::_mutex_init; 4637int_fnP_mutex_tP os::Solaris::_mutex_destroy; 4638int os::Solaris::_mutex_scope = USYNC_THREAD; 4639 4640int_fnP_cond_tP_mutex_tP_timestruc_tP os::Solaris::_cond_timedwait; 4641int_fnP_cond_tP_mutex_tP os::Solaris::_cond_wait; 4642int_fnP_cond_tP os::Solaris::_cond_signal; 4643int_fnP_cond_tP os::Solaris::_cond_broadcast; 4644int_fnP_cond_tP_i_vP os::Solaris::_cond_init; 4645int_fnP_cond_tP os::Solaris::_cond_destroy; 4646int os::Solaris::_cond_scope = USYNC_THREAD; 4647 4648void os::Solaris::synchronization_init() { 4649 if(UseLWPSynchronization) { 4650 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock"))); 4651 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock"))); 4652 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock"))); 4653 os::Solaris::set_mutex_init(lwp_mutex_init); 4654 os::Solaris::set_mutex_destroy(lwp_mutex_destroy); 4655 os::Solaris::set_mutex_scope(USYNC_THREAD); 4656 4657 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("_lwp_cond_timedwait"))); 4658 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("_lwp_cond_wait"))); 4659 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal"))); 4660 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast"))); 4661 os::Solaris::set_cond_init(lwp_cond_init); 4662 os::Solaris::set_cond_destroy(lwp_cond_destroy); 4663 os::Solaris::set_cond_scope(USYNC_THREAD); 4664 } 4665 else { 4666 os::Solaris::set_mutex_scope(USYNC_THREAD); 4667 os::Solaris::set_cond_scope(USYNC_THREAD); 4668 4669 if(UsePthreads) { 4670 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock"))); 4671 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock"))); 4672 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock"))); 4673 os::Solaris::set_mutex_init(pthread_mutex_default_init); 4674 os::Solaris::set_mutex_destroy(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_destroy"))); 4675 4676 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("pthread_cond_timedwait"))); 4677 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait"))); 4678 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal"))); 4679 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast"))); 4680 os::Solaris::set_cond_init(pthread_cond_default_init); 4681 os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy"))); 4682 } 4683 else { 4684 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock"))); 4685 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock"))); 4686 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock"))); 4687 os::Solaris::set_mutex_init(::mutex_init); 4688 os::Solaris::set_mutex_destroy(::mutex_destroy); 4689 4690 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("cond_timedwait"))); 4691 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("cond_wait"))); 4692 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_signal"))); 4693 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_broadcast"))); 4694 os::Solaris::set_cond_init(::cond_init); 4695 os::Solaris::set_cond_destroy(::cond_destroy); 4696 } 4697 } 4698} 4699 4700bool os::Solaris::liblgrp_init() { 4701 void *handle = dlopen("liblgrp.so.1", RTLD_LAZY); 4702 if (handle != NULL) { 4703 os::Solaris::set_lgrp_home(CAST_TO_FN_PTR(lgrp_home_func_t, dlsym(handle, "lgrp_home"))); 4704 os::Solaris::set_lgrp_init(CAST_TO_FN_PTR(lgrp_init_func_t, dlsym(handle, "lgrp_init"))); 4705 os::Solaris::set_lgrp_fini(CAST_TO_FN_PTR(lgrp_fini_func_t, dlsym(handle, "lgrp_fini"))); 4706 os::Solaris::set_lgrp_root(CAST_TO_FN_PTR(lgrp_root_func_t, dlsym(handle, "lgrp_root"))); 4707 os::Solaris::set_lgrp_children(CAST_TO_FN_PTR(lgrp_children_func_t, dlsym(handle, "lgrp_children"))); 4708 os::Solaris::set_lgrp_resources(CAST_TO_FN_PTR(lgrp_resources_func_t, dlsym(handle, "lgrp_resources"))); 4709 os::Solaris::set_lgrp_nlgrps(CAST_TO_FN_PTR(lgrp_nlgrps_func_t, dlsym(handle, "lgrp_nlgrps"))); 4710 os::Solaris::set_lgrp_cookie_stale(CAST_TO_FN_PTR(lgrp_cookie_stale_func_t, 4711 dlsym(handle, "lgrp_cookie_stale"))); 4712 4713 lgrp_cookie_t c = lgrp_init(LGRP_VIEW_CALLER); 4714 set_lgrp_cookie(c); 4715 return true; 4716 } 4717 return false; 4718} 4719 4720void os::Solaris::misc_sym_init() { 4721 address func; 4722 4723 // getisax 4724 func = resolve_symbol_lazy("getisax"); 4725 if (func != NULL) { 4726 os::Solaris::_getisax = CAST_TO_FN_PTR(getisax_func_t, func); 4727 } 4728 4729 // meminfo 4730 func = resolve_symbol_lazy("meminfo"); 4731 if (func != NULL) { 4732 os::Solaris::set_meminfo(CAST_TO_FN_PTR(meminfo_func_t, func)); 4733 } 4734} 4735 4736uint_t os::Solaris::getisax(uint32_t* array, uint_t n) { 4737 assert(_getisax != NULL, "_getisax not set"); 4738 return _getisax(array, n); 4739} 4740 4741// Symbol doesn't exist in Solaris 8 pset.h 4742#ifndef PS_MYID 4743#define PS_MYID -3 4744#endif 4745 4746// int pset_getloadavg(psetid_t pset, double loadavg[], int nelem); 4747typedef long (*pset_getloadavg_type)(psetid_t pset, double loadavg[], int nelem); 4748static pset_getloadavg_type pset_getloadavg_ptr = NULL; 4749 4750void init_pset_getloadavg_ptr(void) { 4751 pset_getloadavg_ptr = 4752 (pset_getloadavg_type)dlsym(RTLD_DEFAULT, "pset_getloadavg"); 4753 if (PrintMiscellaneous && Verbose && pset_getloadavg_ptr == NULL) { 4754 warning("pset_getloadavg function not found"); 4755 } 4756} 4757 4758int os::Solaris::_dev_zero_fd = -1; 4759 4760// this is called _before_ the global arguments have been parsed 4761void os::init(void) { 4762 _initial_pid = getpid(); 4763 4764 max_hrtime = first_hrtime = gethrtime(); 4765 4766 init_random(1234567); 4767 4768 page_size = sysconf(_SC_PAGESIZE); 4769 if (page_size == -1) 4770 fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)", 4771 strerror(errno))); 4772 init_page_sizes((size_t) page_size); 4773 4774 Solaris::initialize_system_info(); 4775 4776 // Initialize misc. symbols as soon as possible, so we can use them 4777 // if we need them. 4778 Solaris::misc_sym_init(); 4779 4780 int fd = open("/dev/zero", O_RDWR); 4781 if (fd < 0) { 4782 fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno))); 4783 } else { 4784 Solaris::set_dev_zero_fd(fd); 4785 4786 // Close on exec, child won't inherit. 4787 fcntl(fd, F_SETFD, FD_CLOEXEC); 4788 } 4789 4790 clock_tics_per_sec = CLK_TCK; 4791 4792 // check if dladdr1() exists; dladdr1 can provide more information than 4793 // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9 4794 // and is available on linker patches for 5.7 and 5.8. 4795 // libdl.so must have been loaded, this call is just an entry lookup 4796 void * hdl = dlopen("libdl.so", RTLD_NOW); 4797 if (hdl) 4798 dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1")); 4799 4800 // (Solaris only) this switches to calls that actually do locking. 4801 ThreadCritical::initialize(); 4802 4803 main_thread = thr_self(); 4804 4805 // Constant minimum stack size allowed. It must be at least 4806 // the minimum of what the OS supports (thr_min_stack()), and 4807 // enough to allow the thread to get to user bytecode execution. 4808 Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed); 4809 // If the pagesize of the VM is greater than 8K determine the appropriate 4810 // number of initial guard pages. The user can change this with the 4811 // command line arguments, if needed. 4812 if (vm_page_size() > 8*K) { 4813 StackYellowPages = 1; 4814 StackRedPages = 1; 4815 StackShadowPages = round_to((StackShadowPages*8*K), vm_page_size()) / vm_page_size(); 4816 } 4817} 4818 4819// To install functions for atexit system call 4820extern "C" { 4821 static void perfMemory_exit_helper() { 4822 perfMemory_exit(); 4823 } 4824} 4825 4826// this is called _after_ the global arguments have been parsed 4827jint os::init_2(void) { 4828 // try to enable extended file IO ASAP, see 6431278 4829 os::Solaris::try_enable_extended_io(); 4830 4831 // Allocate a single page and mark it as readable for safepoint polling. Also 4832 // use this first mmap call to check support for MAP_ALIGN. 4833 address polling_page = (address)Solaris::mmap_chunk((char*)page_size, 4834 page_size, 4835 MAP_PRIVATE | MAP_ALIGN, 4836 PROT_READ); 4837 if (polling_page == NULL) { 4838 has_map_align = false; 4839 polling_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE, 4840 PROT_READ); 4841 } 4842 4843 os::set_polling_page(polling_page); 4844 4845#ifndef PRODUCT 4846 if( Verbose && PrintMiscellaneous ) 4847 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page); 4848#endif 4849 4850 if (!UseMembar) { 4851 address mem_serialize_page = (address)Solaris::mmap_chunk( NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE ); 4852 guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page"); 4853 os::set_memory_serialize_page( mem_serialize_page ); 4854 4855#ifndef PRODUCT 4856 if(Verbose && PrintMiscellaneous) 4857 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page); 4858#endif 4859} 4860 4861 FLAG_SET_DEFAULT(UseLargePages, os::large_page_init()); 4862 4863 // Check minimum allowable stack size for thread creation and to initialize 4864 // the java system classes, including StackOverflowError - depends on page 4865 // size. Add a page for compiler2 recursion in main thread. 4866 // Add in BytesPerWord times page size to account for VM stack during 4867 // class initialization depending on 32 or 64 bit VM. 4868 guarantee((Solaris::min_stack_allowed >= 4869 (StackYellowPages+StackRedPages+StackShadowPages+BytesPerWord 4870 COMPILER2_PRESENT(+1)) * page_size), 4871 "need to increase Solaris::min_stack_allowed on this platform"); 4872 4873 size_t threadStackSizeInBytes = ThreadStackSize * K; 4874 if (threadStackSizeInBytes != 0 && 4875 threadStackSizeInBytes < Solaris::min_stack_allowed) { 4876 tty->print_cr("\nThe stack size specified is too small, Specify at least %dk", 4877 Solaris::min_stack_allowed/K); 4878 return JNI_ERR; 4879 } 4880 4881 // For 64kbps there will be a 64kb page size, which makes 4882 // the usable default stack size quite a bit less. Increase the 4883 // stack for 64kb (or any > than 8kb) pages, this increases 4884 // virtual memory fragmentation (since we're not creating the 4885 // stack on a power of 2 boundary. The real fix for this 4886 // should be to fix the guard page mechanism. 4887 4888 if (vm_page_size() > 8*K) { 4889 threadStackSizeInBytes = (threadStackSizeInBytes != 0) 4890 ? threadStackSizeInBytes + 4891 ((StackYellowPages + StackRedPages) * vm_page_size()) 4892 : 0; 4893 ThreadStackSize = threadStackSizeInBytes/K; 4894 } 4895 4896 // Make the stack size a multiple of the page size so that 4897 // the yellow/red zones can be guarded. 4898 JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, 4899 vm_page_size())); 4900 4901 Solaris::libthread_init(); 4902 4903 if (UseNUMA) { 4904 if (!Solaris::liblgrp_init()) { 4905 UseNUMA = false; 4906 } else { 4907 size_t lgrp_limit = os::numa_get_groups_num(); 4908 int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit); 4909 size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit); 4910 FREE_C_HEAP_ARRAY(int, lgrp_ids); 4911 if (lgrp_num < 2) { 4912 // There's only one locality group, disable NUMA. 4913 UseNUMA = false; 4914 } 4915 } 4916 if (!UseNUMA && ForceNUMA) { 4917 UseNUMA = true; 4918 } 4919 } 4920 4921 Solaris::signal_sets_init(); 4922 Solaris::init_signal_mem(); 4923 Solaris::install_signal_handlers(); 4924 4925 if (libjsigversion < JSIG_VERSION_1_4_1) { 4926 Maxlibjsigsigs = OLDMAXSIGNUM; 4927 } 4928 4929 // initialize synchronization primitives to use either thread or 4930 // lwp synchronization (controlled by UseLWPSynchronization) 4931 Solaris::synchronization_init(); 4932 4933 if (MaxFDLimit) { 4934 // set the number of file descriptors to max. print out error 4935 // if getrlimit/setrlimit fails but continue regardless. 4936 struct rlimit nbr_files; 4937 int status = getrlimit(RLIMIT_NOFILE, &nbr_files); 4938 if (status != 0) { 4939 if (PrintMiscellaneous && (Verbose || WizardMode)) 4940 perror("os::init_2 getrlimit failed"); 4941 } else { 4942 nbr_files.rlim_cur = nbr_files.rlim_max; 4943 status = setrlimit(RLIMIT_NOFILE, &nbr_files); 4944 if (status != 0) { 4945 if (PrintMiscellaneous && (Verbose || WizardMode)) 4946 perror("os::init_2 setrlimit failed"); 4947 } 4948 } 4949 } 4950 4951 // Initialize HPI. 4952 jint hpi_result = hpi::initialize(); 4953 if (hpi_result != JNI_OK) { 4954 tty->print_cr("There was an error trying to initialize the HPI library."); 4955 return hpi_result; 4956 } 4957 4958 // Calculate theoretical max. size of Threads to guard gainst 4959 // artifical out-of-memory situations, where all available address- 4960 // space has been reserved by thread stacks. Default stack size is 1Mb. 4961 size_t pre_thread_stack_size = (JavaThread::stack_size_at_create()) ? 4962 JavaThread::stack_size_at_create() : (1*K*K); 4963 assert(pre_thread_stack_size != 0, "Must have a stack"); 4964 // Solaris has a maximum of 4Gb of user programs. Calculate the thread limit when 4965 // we should start doing Virtual Memory banging. Currently when the threads will 4966 // have used all but 200Mb of space. 4967 size_t max_address_space = ((unsigned int)4 * K * K * K) - (200 * K * K); 4968 Solaris::_os_thread_limit = max_address_space / pre_thread_stack_size; 4969 4970 // at-exit methods are called in the reverse order of their registration. 4971 // In Solaris 7 and earlier, atexit functions are called on return from 4972 // main or as a result of a call to exit(3C). There can be only 32 of 4973 // these functions registered and atexit() does not set errno. In Solaris 4974 // 8 and later, there is no limit to the number of functions registered 4975 // and atexit() sets errno. In addition, in Solaris 8 and later, atexit 4976 // functions are called upon dlclose(3DL) in addition to return from main 4977 // and exit(3C). 4978 4979 if (PerfAllowAtExitRegistration) { 4980 // only register atexit functions if PerfAllowAtExitRegistration is set. 4981 // atexit functions can be delayed until process exit time, which 4982 // can be problematic for embedded VM situations. Embedded VMs should 4983 // call DestroyJavaVM() to assure that VM resources are released. 4984 4985 // note: perfMemory_exit_helper atexit function may be removed in 4986 // the future if the appropriate cleanup code can be added to the 4987 // VM_Exit VMOperation's doit method. 4988 if (atexit(perfMemory_exit_helper) != 0) { 4989 warning("os::init2 atexit(perfMemory_exit_helper) failed"); 4990 } 4991 } 4992 4993 // Init pset_loadavg function pointer 4994 init_pset_getloadavg_ptr(); 4995 4996 return JNI_OK; 4997} 4998 4999 5000// Mark the polling page as unreadable 5001void os::make_polling_page_unreadable(void) { 5002 if( mprotect((char *)_polling_page, page_size, PROT_NONE) != 0 ) 5003 fatal("Could not disable polling page"); 5004}; 5005 5006// Mark the polling page as readable 5007void os::make_polling_page_readable(void) { 5008 if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 ) 5009 fatal("Could not enable polling page"); 5010}; 5011 5012// OS interface. 5013 5014int os::stat(const char *path, struct stat *sbuf) { 5015 char pathbuf[MAX_PATH]; 5016 if (strlen(path) > MAX_PATH - 1) { 5017 errno = ENAMETOOLONG; 5018 return -1; 5019 } 5020 hpi::native_path(strcpy(pathbuf, path)); 5021 return ::stat(pathbuf, sbuf); 5022} 5023 5024 5025bool os::check_heap(bool force) { return true; } 5026 5027typedef int (*vsnprintf_t)(char* buf, size_t count, const char* fmt, va_list argptr); 5028static vsnprintf_t sol_vsnprintf = NULL; 5029 5030int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr) { 5031 if (!sol_vsnprintf) { 5032 //search for the named symbol in the objects that were loaded after libjvm 5033 void* where = RTLD_NEXT; 5034 if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL) 5035 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf")); 5036 if (!sol_vsnprintf){ 5037 //search for the named symbol in the objects that were loaded before libjvm 5038 where = RTLD_DEFAULT; 5039 if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL) 5040 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf")); 5041 assert(sol_vsnprintf != NULL, "vsnprintf not found"); 5042 } 5043 } 5044 return (*sol_vsnprintf)(buf, count, fmt, argptr); 5045} 5046 5047 5048// Is a (classpath) directory empty? 5049bool os::dir_is_empty(const char* path) { 5050 DIR *dir = NULL; 5051 struct dirent *ptr; 5052 5053 dir = opendir(path); 5054 if (dir == NULL) return true; 5055 5056 /* Scan the directory */ 5057 bool result = true; 5058 char buf[sizeof(struct dirent) + MAX_PATH]; 5059 struct dirent *dbuf = (struct dirent *) buf; 5060 while (result && (ptr = readdir(dir, dbuf)) != NULL) { 5061 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) { 5062 result = false; 5063 } 5064 } 5065 closedir(dir); 5066 return result; 5067} 5068 5069// create binary file, rewriting existing file if required 5070int os::create_binary_file(const char* path, bool rewrite_existing) { 5071 int oflags = O_WRONLY | O_CREAT; 5072 if (!rewrite_existing) { 5073 oflags |= O_EXCL; 5074 } 5075 return ::open64(path, oflags, S_IREAD | S_IWRITE); 5076} 5077 5078// return current position of file pointer 5079jlong os::current_file_offset(int fd) { 5080 return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR); 5081} 5082 5083// move file pointer to the specified offset 5084jlong os::seek_to_file_offset(int fd, jlong offset) { 5085 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET); 5086} 5087 5088// Map a block of memory. 5089char* os::map_memory(int fd, const char* file_name, size_t file_offset, 5090 char *addr, size_t bytes, bool read_only, 5091 bool allow_exec) { 5092 int prot; 5093 int flags; 5094 5095 if (read_only) { 5096 prot = PROT_READ; 5097 flags = MAP_SHARED; 5098 } else { 5099 prot = PROT_READ | PROT_WRITE; 5100 flags = MAP_PRIVATE; 5101 } 5102 5103 if (allow_exec) { 5104 prot |= PROT_EXEC; 5105 } 5106 5107 if (addr != NULL) { 5108 flags |= MAP_FIXED; 5109 } 5110 5111 char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags, 5112 fd, file_offset); 5113 if (mapped_address == MAP_FAILED) { 5114 return NULL; 5115 } 5116 return mapped_address; 5117} 5118 5119 5120// Remap a block of memory. 5121char* os::remap_memory(int fd, const char* file_name, size_t file_offset, 5122 char *addr, size_t bytes, bool read_only, 5123 bool allow_exec) { 5124 // same as map_memory() on this OS 5125 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 5126 allow_exec); 5127} 5128 5129 5130// Unmap a block of memory. 5131bool os::unmap_memory(char* addr, size_t bytes) { 5132 return munmap(addr, bytes) == 0; 5133} 5134 5135void os::pause() { 5136 char filename[MAX_PATH]; 5137 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 5138 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 5139 } else { 5140 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 5141 } 5142 5143 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 5144 if (fd != -1) { 5145 struct stat buf; 5146 close(fd); 5147 while (::stat(filename, &buf) == 0) { 5148 (void)::poll(NULL, 0, 100); 5149 } 5150 } else { 5151 jio_fprintf(stderr, 5152 "Could not open pause file '%s', continuing immediately.\n", filename); 5153 } 5154} 5155 5156#ifndef PRODUCT 5157#ifdef INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS 5158// Turn this on if you need to trace synch operations. 5159// Set RECORD_SYNCH_LIMIT to a large-enough value, 5160// and call record_synch_enable and record_synch_disable 5161// around the computation of interest. 5162 5163void record_synch(char* name, bool returning); // defined below 5164 5165class RecordSynch { 5166 char* _name; 5167 public: 5168 RecordSynch(char* name) :_name(name) 5169 { record_synch(_name, false); } 5170 ~RecordSynch() { record_synch(_name, true); } 5171}; 5172 5173#define CHECK_SYNCH_OP(ret, name, params, args, inner) \ 5174extern "C" ret name params { \ 5175 typedef ret name##_t params; \ 5176 static name##_t* implem = NULL; \ 5177 static int callcount = 0; \ 5178 if (implem == NULL) { \ 5179 implem = (name##_t*) dlsym(RTLD_NEXT, #name); \ 5180 if (implem == NULL) fatal(dlerror()); \ 5181 } \ 5182 ++callcount; \ 5183 RecordSynch _rs(#name); \ 5184 inner; \ 5185 return implem args; \ 5186} 5187// in dbx, examine callcounts this way: 5188// for n in $(eval whereis callcount | awk '{print $2}'); do print $n; done 5189 5190#define CHECK_POINTER_OK(p) \ 5191 (Universe::perm_gen() == NULL || !Universe::is_reserved_heap((oop)(p))) 5192#define CHECK_MU \ 5193 if (!CHECK_POINTER_OK(mu)) fatal("Mutex must be in C heap only."); 5194#define CHECK_CV \ 5195 if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only."); 5196#define CHECK_P(p) \ 5197 if (!CHECK_POINTER_OK(p)) fatal(false, "Pointer must be in C heap only."); 5198 5199#define CHECK_MUTEX(mutex_op) \ 5200CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU); 5201 5202CHECK_MUTEX( mutex_lock) 5203CHECK_MUTEX( _mutex_lock) 5204CHECK_MUTEX( mutex_unlock) 5205CHECK_MUTEX(_mutex_unlock) 5206CHECK_MUTEX( mutex_trylock) 5207CHECK_MUTEX(_mutex_trylock) 5208 5209#define CHECK_COND(cond_op) \ 5210CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU;CHECK_CV); 5211 5212CHECK_COND( cond_wait); 5213CHECK_COND(_cond_wait); 5214CHECK_COND(_cond_wait_cancel); 5215 5216#define CHECK_COND2(cond_op) \ 5217CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU;CHECK_CV); 5218 5219CHECK_COND2( cond_timedwait); 5220CHECK_COND2(_cond_timedwait); 5221CHECK_COND2(_cond_timedwait_cancel); 5222 5223// do the _lwp_* versions too 5224#define mutex_t lwp_mutex_t 5225#define cond_t lwp_cond_t 5226CHECK_MUTEX( _lwp_mutex_lock) 5227CHECK_MUTEX( _lwp_mutex_unlock) 5228CHECK_MUTEX( _lwp_mutex_trylock) 5229CHECK_MUTEX( __lwp_mutex_lock) 5230CHECK_MUTEX( __lwp_mutex_unlock) 5231CHECK_MUTEX( __lwp_mutex_trylock) 5232CHECK_MUTEX(___lwp_mutex_lock) 5233CHECK_MUTEX(___lwp_mutex_unlock) 5234 5235CHECK_COND( _lwp_cond_wait); 5236CHECK_COND( __lwp_cond_wait); 5237CHECK_COND(___lwp_cond_wait); 5238 5239CHECK_COND2( _lwp_cond_timedwait); 5240CHECK_COND2( __lwp_cond_timedwait); 5241#undef mutex_t 5242#undef cond_t 5243 5244CHECK_SYNCH_OP(int, _lwp_suspend2, (int lwp, int *n), (lwp, n), 0); 5245CHECK_SYNCH_OP(int,__lwp_suspend2, (int lwp, int *n), (lwp, n), 0); 5246CHECK_SYNCH_OP(int, _lwp_kill, (int lwp, int n), (lwp, n), 0); 5247CHECK_SYNCH_OP(int,__lwp_kill, (int lwp, int n), (lwp, n), 0); 5248CHECK_SYNCH_OP(int, _lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p)); 5249CHECK_SYNCH_OP(int,__lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p)); 5250CHECK_SYNCH_OP(int, _lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV); 5251CHECK_SYNCH_OP(int,__lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV); 5252 5253 5254// recording machinery: 5255 5256enum { RECORD_SYNCH_LIMIT = 200 }; 5257char* record_synch_name[RECORD_SYNCH_LIMIT]; 5258void* record_synch_arg0ptr[RECORD_SYNCH_LIMIT]; 5259bool record_synch_returning[RECORD_SYNCH_LIMIT]; 5260thread_t record_synch_thread[RECORD_SYNCH_LIMIT]; 5261int record_synch_count = 0; 5262bool record_synch_enabled = false; 5263 5264// in dbx, examine recorded data this way: 5265// for n in name arg0ptr returning thread; do print record_synch_$n[0..record_synch_count-1]; done 5266 5267void record_synch(char* name, bool returning) { 5268 if (record_synch_enabled) { 5269 if (record_synch_count < RECORD_SYNCH_LIMIT) { 5270 record_synch_name[record_synch_count] = name; 5271 record_synch_returning[record_synch_count] = returning; 5272 record_synch_thread[record_synch_count] = thr_self(); 5273 record_synch_arg0ptr[record_synch_count] = &name; 5274 record_synch_count++; 5275 } 5276 // put more checking code here: 5277 // ... 5278 } 5279} 5280 5281void record_synch_enable() { 5282 // start collecting trace data, if not already doing so 5283 if (!record_synch_enabled) record_synch_count = 0; 5284 record_synch_enabled = true; 5285} 5286 5287void record_synch_disable() { 5288 // stop collecting trace data 5289 record_synch_enabled = false; 5290} 5291 5292#endif // INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS 5293#endif // PRODUCT 5294 5295const intptr_t thr_time_off = (intptr_t)(&((prusage_t *)(NULL))->pr_utime); 5296const intptr_t thr_time_size = (intptr_t)(&((prusage_t *)(NULL))->pr_ttime) - 5297 (intptr_t)(&((prusage_t *)(NULL))->pr_utime); 5298 5299 5300// JVMTI & JVM monitoring and management support 5301// The thread_cpu_time() and current_thread_cpu_time() are only 5302// supported if is_thread_cpu_time_supported() returns true. 5303// They are not supported on Solaris T1. 5304 5305// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 5306// are used by JVM M&M and JVMTI to get user+sys or user CPU time 5307// of a thread. 5308// 5309// current_thread_cpu_time() and thread_cpu_time(Thread *) 5310// returns the fast estimate available on the platform. 5311 5312// hrtime_t gethrvtime() return value includes 5313// user time but does not include system time 5314jlong os::current_thread_cpu_time() { 5315 return (jlong) gethrvtime(); 5316} 5317 5318jlong os::thread_cpu_time(Thread *thread) { 5319 // return user level CPU time only to be consistent with 5320 // what current_thread_cpu_time returns. 5321 // thread_cpu_time_info() must be changed if this changes 5322 return os::thread_cpu_time(thread, false /* user time only */); 5323} 5324 5325jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 5326 if (user_sys_cpu_time) { 5327 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 5328 } else { 5329 return os::current_thread_cpu_time(); 5330 } 5331} 5332 5333jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) { 5334 char proc_name[64]; 5335 int count; 5336 prusage_t prusage; 5337 jlong lwp_time; 5338 int fd; 5339 5340 sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage", 5341 getpid(), 5342 thread->osthread()->lwp_id()); 5343 fd = open(proc_name, O_RDONLY); 5344 if ( fd == -1 ) return -1; 5345 5346 do { 5347 count = pread(fd, 5348 (void *)&prusage.pr_utime, 5349 thr_time_size, 5350 thr_time_off); 5351 } while (count < 0 && errno == EINTR); 5352 close(fd); 5353 if ( count < 0 ) return -1; 5354 5355 if (user_sys_cpu_time) { 5356 // user + system CPU time 5357 lwp_time = (((jlong)prusage.pr_stime.tv_sec + 5358 (jlong)prusage.pr_utime.tv_sec) * (jlong)1000000000) + 5359 (jlong)prusage.pr_stime.tv_nsec + 5360 (jlong)prusage.pr_utime.tv_nsec; 5361 } else { 5362 // user level CPU time only 5363 lwp_time = ((jlong)prusage.pr_utime.tv_sec * (jlong)1000000000) + 5364 (jlong)prusage.pr_utime.tv_nsec; 5365 } 5366 5367 return(lwp_time); 5368} 5369 5370void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 5371 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 5372 info_ptr->may_skip_backward = false; // elapsed time not wall time 5373 info_ptr->may_skip_forward = false; // elapsed time not wall time 5374 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned 5375} 5376 5377void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 5378 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 5379 info_ptr->may_skip_backward = false; // elapsed time not wall time 5380 info_ptr->may_skip_forward = false; // elapsed time not wall time 5381 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned 5382} 5383 5384bool os::is_thread_cpu_time_supported() { 5385 if ( os::Solaris::T2_libthread() || UseBoundThreads ) { 5386 return true; 5387 } else { 5388 return false; 5389 } 5390} 5391 5392// System loadavg support. Returns -1 if load average cannot be obtained. 5393// Return the load average for our processor set if the primitive exists 5394// (Solaris 9 and later). Otherwise just return system wide loadavg. 5395int os::loadavg(double loadavg[], int nelem) { 5396 if (pset_getloadavg_ptr != NULL) { 5397 return (*pset_getloadavg_ptr)(PS_MYID, loadavg, nelem); 5398 } else { 5399 return ::getloadavg(loadavg, nelem); 5400 } 5401} 5402 5403//--------------------------------------------------------------------------------- 5404#ifndef PRODUCT 5405 5406static address same_page(address x, address y) { 5407 intptr_t page_bits = -os::vm_page_size(); 5408 if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits)) 5409 return x; 5410 else if (x > y) 5411 return (address)(intptr_t(y) | ~page_bits) + 1; 5412 else 5413 return (address)(intptr_t(y) & page_bits); 5414} 5415 5416bool os::find(address addr) { 5417 Dl_info dlinfo; 5418 memset(&dlinfo, 0, sizeof(dlinfo)); 5419 if (dladdr(addr, &dlinfo)) { 5420#ifdef _LP64 5421 tty->print("0x%016lx: ", addr); 5422#else 5423 tty->print("0x%08x: ", addr); 5424#endif 5425 if (dlinfo.dli_sname != NULL) 5426 tty->print("%s+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr); 5427 else if (dlinfo.dli_fname) 5428 tty->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase); 5429 else 5430 tty->print("<absolute address>"); 5431 if (dlinfo.dli_fname) tty->print(" in %s", dlinfo.dli_fname); 5432#ifdef _LP64 5433 if (dlinfo.dli_fbase) tty->print(" at 0x%016lx", dlinfo.dli_fbase); 5434#else 5435 if (dlinfo.dli_fbase) tty->print(" at 0x%08x", dlinfo.dli_fbase); 5436#endif 5437 tty->cr(); 5438 5439 if (Verbose) { 5440 // decode some bytes around the PC 5441 address begin = same_page(addr-40, addr); 5442 address end = same_page(addr+40, addr); 5443 address lowest = (address) dlinfo.dli_sname; 5444 if (!lowest) lowest = (address) dlinfo.dli_fbase; 5445 if (begin < lowest) begin = lowest; 5446 Dl_info dlinfo2; 5447 if (dladdr(end, &dlinfo2) && dlinfo2.dli_saddr != dlinfo.dli_saddr 5448 && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) 5449 end = (address) dlinfo2.dli_saddr; 5450 Disassembler::decode(begin, end); 5451 } 5452 return true; 5453 } 5454 return false; 5455} 5456 5457#endif 5458 5459 5460// Following function has been added to support HotSparc's libjvm.so running 5461// under Solaris production JDK 1.2.2 / 1.3.0. These came from 5462// src/solaris/hpi/native_threads in the EVM codebase. 5463// 5464// NOTE: This is no longer needed in the 1.3.1 and 1.4 production release 5465// libraries and should thus be removed. We will leave it behind for a while 5466// until we no longer want to able to run on top of 1.3.0 Solaris production 5467// JDK. See 4341971. 5468 5469#define STACK_SLACK 0x800 5470 5471extern "C" { 5472 intptr_t sysThreadAvailableStackWithSlack() { 5473 stack_t st; 5474 intptr_t retval, stack_top; 5475 retval = thr_stksegment(&st); 5476 assert(retval == 0, "incorrect return value from thr_stksegment"); 5477 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned"); 5478 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned"); 5479 stack_top=(intptr_t)st.ss_sp-st.ss_size; 5480 return ((intptr_t)&stack_top - stack_top - STACK_SLACK); 5481 } 5482} 5483 5484// Just to get the Kernel build to link on solaris for testing. 5485 5486extern "C" { 5487class ASGCT_CallTrace; 5488void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) 5489 KERNEL_RETURN; 5490} 5491 5492 5493// ObjectMonitor park-unpark infrastructure ... 5494// 5495// We implement Solaris and Linux PlatformEvents with the 5496// obvious condvar-mutex-flag triple. 5497// Another alternative that works quite well is pipes: 5498// Each PlatformEvent consists of a pipe-pair. 5499// The thread associated with the PlatformEvent 5500// calls park(), which reads from the input end of the pipe. 5501// Unpark() writes into the other end of the pipe. 5502// The write-side of the pipe must be set NDELAY. 5503// Unfortunately pipes consume a large # of handles. 5504// Native solaris lwp_park() and lwp_unpark() work nicely, too. 5505// Using pipes for the 1st few threads might be workable, however. 5506// 5507// park() is permitted to return spuriously. 5508// Callers of park() should wrap the call to park() in 5509// an appropriate loop. A litmus test for the correct 5510// usage of park is the following: if park() were modified 5511// to immediately return 0 your code should still work, 5512// albeit degenerating to a spin loop. 5513// 5514// An interesting optimization for park() is to use a trylock() 5515// to attempt to acquire the mutex. If the trylock() fails 5516// then we know that a concurrent unpark() operation is in-progress. 5517// in that case the park() code could simply set _count to 0 5518// and return immediately. The subsequent park() operation *might* 5519// return immediately. That's harmless as the caller of park() is 5520// expected to loop. By using trylock() we will have avoided a 5521// avoided a context switch caused by contention on the per-thread mutex. 5522// 5523// TODO-FIXME: 5524// 1. Reconcile Doug's JSR166 j.u.c park-unpark with the 5525// objectmonitor implementation. 5526// 2. Collapse the JSR166 parker event, and the 5527// objectmonitor ParkEvent into a single "Event" construct. 5528// 3. In park() and unpark() add: 5529// assert (Thread::current() == AssociatedWith). 5530// 4. add spurious wakeup injection on a -XX:EarlyParkReturn=N switch. 5531// 1-out-of-N park() operations will return immediately. 5532// 5533// _Event transitions in park() 5534// -1 => -1 : illegal 5535// 1 => 0 : pass - return immediately 5536// 0 => -1 : block 5537// 5538// _Event serves as a restricted-range semaphore. 5539// 5540// Another possible encoding of _Event would be with 5541// explicit "PARKED" == 01b and "SIGNALED" == 10b bits. 5542// 5543// TODO-FIXME: add DTRACE probes for: 5544// 1. Tx parks 5545// 2. Ty unparks Tx 5546// 3. Tx resumes from park 5547 5548 5549// value determined through experimentation 5550#define ROUNDINGFIX 11 5551 5552// utility to compute the abstime argument to timedwait. 5553// TODO-FIXME: switch from compute_abstime() to unpackTime(). 5554 5555static timestruc_t* compute_abstime(timestruc_t* abstime, jlong millis) { 5556 // millis is the relative timeout time 5557 // abstime will be the absolute timeout time 5558 if (millis < 0) millis = 0; 5559 struct timeval now; 5560 int status = gettimeofday(&now, NULL); 5561 assert(status == 0, "gettimeofday"); 5562 jlong seconds = millis / 1000; 5563 jlong max_wait_period; 5564 5565 if (UseLWPSynchronization) { 5566 // forward port of fix for 4275818 (not sleeping long enough) 5567 // There was a bug in Solaris 6, 7 and pre-patch 5 of 8 where 5568 // _lwp_cond_timedwait() used a round_down algorithm rather 5569 // than a round_up. For millis less than our roundfactor 5570 // it rounded down to 0 which doesn't meet the spec. 5571 // For millis > roundfactor we may return a bit sooner, but 5572 // since we can not accurately identify the patch level and 5573 // this has already been fixed in Solaris 9 and 8 we will 5574 // leave it alone rather than always rounding down. 5575 5576 if (millis > 0 && millis < ROUNDINGFIX) millis = ROUNDINGFIX; 5577 // It appears that when we go directly through Solaris _lwp_cond_timedwait() 5578 // the acceptable max time threshold is smaller than for libthread on 2.5.1 and 2.6 5579 max_wait_period = 21000000; 5580 } else { 5581 max_wait_period = 50000000; 5582 } 5583 millis %= 1000; 5584 if (seconds > max_wait_period) { // see man cond_timedwait(3T) 5585 seconds = max_wait_period; 5586 } 5587 abstime->tv_sec = now.tv_sec + seconds; 5588 long usec = now.tv_usec + millis * 1000; 5589 if (usec >= 1000000) { 5590 abstime->tv_sec += 1; 5591 usec -= 1000000; 5592 } 5593 abstime->tv_nsec = usec * 1000; 5594 return abstime; 5595} 5596 5597// Test-and-clear _Event, always leaves _Event set to 0, returns immediately. 5598// Conceptually TryPark() should be equivalent to park(0). 5599 5600int os::PlatformEvent::TryPark() { 5601 for (;;) { 5602 const int v = _Event ; 5603 guarantee ((v == 0) || (v == 1), "invariant") ; 5604 if (Atomic::cmpxchg (0, &_Event, v) == v) return v ; 5605 } 5606} 5607 5608void os::PlatformEvent::park() { // AKA: down() 5609 // Invariant: Only the thread associated with the Event/PlatformEvent 5610 // may call park(). 5611 int v ; 5612 for (;;) { 5613 v = _Event ; 5614 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 5615 } 5616 guarantee (v >= 0, "invariant") ; 5617 if (v == 0) { 5618 // Do this the hard way by blocking ... 5619 // See http://monaco.sfbay/detail.jsf?cr=5094058. 5620 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking. 5621 // Only for SPARC >= V8PlusA 5622#if defined(__sparc) && defined(COMPILER2) 5623 if (ClearFPUAtPark) { _mark_fpu_nosave() ; } 5624#endif 5625 int status = os::Solaris::mutex_lock(_mutex); 5626 assert_status(status == 0, status, "mutex_lock"); 5627 guarantee (_nParked == 0, "invariant") ; 5628 ++ _nParked ; 5629 while (_Event < 0) { 5630 // for some reason, under 2.7 lwp_cond_wait() may return ETIME ... 5631 // Treat this the same as if the wait was interrupted 5632 // With usr/lib/lwp going to kernel, always handle ETIME 5633 status = os::Solaris::cond_wait(_cond, _mutex); 5634 if (status == ETIME) status = EINTR ; 5635 assert_status(status == 0 || status == EINTR, status, "cond_wait"); 5636 } 5637 -- _nParked ; 5638 _Event = 0 ; 5639 status = os::Solaris::mutex_unlock(_mutex); 5640 assert_status(status == 0, status, "mutex_unlock"); 5641 } 5642} 5643 5644int os::PlatformEvent::park(jlong millis) { 5645 guarantee (_nParked == 0, "invariant") ; 5646 int v ; 5647 for (;;) { 5648 v = _Event ; 5649 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 5650 } 5651 guarantee (v >= 0, "invariant") ; 5652 if (v != 0) return OS_OK ; 5653 5654 int ret = OS_TIMEOUT; 5655 timestruc_t abst; 5656 compute_abstime (&abst, millis); 5657 5658 // See http://monaco.sfbay/detail.jsf?cr=5094058. 5659 // For Solaris SPARC set fprs.FEF=0 prior to parking. 5660 // Only for SPARC >= V8PlusA 5661#if defined(__sparc) && defined(COMPILER2) 5662 if (ClearFPUAtPark) { _mark_fpu_nosave() ; } 5663#endif 5664 int status = os::Solaris::mutex_lock(_mutex); 5665 assert_status(status == 0, status, "mutex_lock"); 5666 guarantee (_nParked == 0, "invariant") ; 5667 ++ _nParked ; 5668 while (_Event < 0) { 5669 int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst); 5670 assert_status(status == 0 || status == EINTR || 5671 status == ETIME || status == ETIMEDOUT, 5672 status, "cond_timedwait"); 5673 if (!FilterSpuriousWakeups) break ; // previous semantics 5674 if (status == ETIME || status == ETIMEDOUT) break ; 5675 // We consume and ignore EINTR and spurious wakeups. 5676 } 5677 -- _nParked ; 5678 if (_Event >= 0) ret = OS_OK ; 5679 _Event = 0 ; 5680 status = os::Solaris::mutex_unlock(_mutex); 5681 assert_status(status == 0, status, "mutex_unlock"); 5682 return ret; 5683} 5684 5685void os::PlatformEvent::unpark() { 5686 int v, AnyWaiters; 5687 5688 // Increment _Event. 5689 // Another acceptable implementation would be to simply swap 1 5690 // into _Event: 5691 // if (Swap (&_Event, 1) < 0) { 5692 // mutex_lock (_mutex) ; AnyWaiters = nParked; mutex_unlock (_mutex) ; 5693 // if (AnyWaiters) cond_signal (_cond) ; 5694 // } 5695 5696 for (;;) { 5697 v = _Event ; 5698 if (v > 0) { 5699 // The LD of _Event could have reordered or be satisfied 5700 // by a read-aside from this processor's write buffer. 5701 // To avoid problems execute a barrier and then 5702 // ratify the value. A degenerate CAS() would also work. 5703 // Viz., CAS (v+0, &_Event, v) == v). 5704 OrderAccess::fence() ; 5705 if (_Event == v) return ; 5706 continue ; 5707 } 5708 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ; 5709 } 5710 5711 // If the thread associated with the event was parked, wake it. 5712 if (v < 0) { 5713 int status ; 5714 // Wait for the thread assoc with the PlatformEvent to vacate. 5715 status = os::Solaris::mutex_lock(_mutex); 5716 assert_status(status == 0, status, "mutex_lock"); 5717 AnyWaiters = _nParked ; 5718 status = os::Solaris::mutex_unlock(_mutex); 5719 assert_status(status == 0, status, "mutex_unlock"); 5720 guarantee (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ; 5721 if (AnyWaiters != 0) { 5722 // We intentional signal *after* dropping the lock 5723 // to avoid a common class of futile wakeups. 5724 status = os::Solaris::cond_signal(_cond); 5725 assert_status(status == 0, status, "cond_signal"); 5726 } 5727 } 5728} 5729 5730// JSR166 5731// ------------------------------------------------------- 5732 5733/* 5734 * The solaris and linux implementations of park/unpark are fairly 5735 * conservative for now, but can be improved. They currently use a 5736 * mutex/condvar pair, plus _counter. 5737 * Park decrements _counter if > 0, else does a condvar wait. Unpark 5738 * sets count to 1 and signals condvar. Only one thread ever waits 5739 * on the condvar. Contention seen when trying to park implies that someone 5740 * is unparking you, so don't wait. And spurious returns are fine, so there 5741 * is no need to track notifications. 5742 */ 5743 5744#define NANOSECS_PER_SEC 1000000000 5745#define NANOSECS_PER_MILLISEC 1000000 5746#define MAX_SECS 100000000 5747 5748/* 5749 * This code is common to linux and solaris and will be moved to a 5750 * common place in dolphin. 5751 * 5752 * The passed in time value is either a relative time in nanoseconds 5753 * or an absolute time in milliseconds. Either way it has to be unpacked 5754 * into suitable seconds and nanoseconds components and stored in the 5755 * given timespec structure. 5756 * Given time is a 64-bit value and the time_t used in the timespec is only 5757 * a signed-32-bit value (except on 64-bit Linux) we have to watch for 5758 * overflow if times way in the future are given. Further on Solaris versions 5759 * prior to 10 there is a restriction (see cond_timedwait) that the specified 5760 * number of seconds, in abstime, is less than current_time + 100,000,000. 5761 * As it will be 28 years before "now + 100000000" will overflow we can 5762 * ignore overflow and just impose a hard-limit on seconds using the value 5763 * of "now + 100,000,000". This places a limit on the timeout of about 3.17 5764 * years from "now". 5765 */ 5766static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) { 5767 assert (time > 0, "convertTime"); 5768 5769 struct timeval now; 5770 int status = gettimeofday(&now, NULL); 5771 assert(status == 0, "gettimeofday"); 5772 5773 time_t max_secs = now.tv_sec + MAX_SECS; 5774 5775 if (isAbsolute) { 5776 jlong secs = time / 1000; 5777 if (secs > max_secs) { 5778 absTime->tv_sec = max_secs; 5779 } 5780 else { 5781 absTime->tv_sec = secs; 5782 } 5783 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC; 5784 } 5785 else { 5786 jlong secs = time / NANOSECS_PER_SEC; 5787 if (secs >= MAX_SECS) { 5788 absTime->tv_sec = max_secs; 5789 absTime->tv_nsec = 0; 5790 } 5791 else { 5792 absTime->tv_sec = now.tv_sec + secs; 5793 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000; 5794 if (absTime->tv_nsec >= NANOSECS_PER_SEC) { 5795 absTime->tv_nsec -= NANOSECS_PER_SEC; 5796 ++absTime->tv_sec; // note: this must be <= max_secs 5797 } 5798 } 5799 } 5800 assert(absTime->tv_sec >= 0, "tv_sec < 0"); 5801 assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs"); 5802 assert(absTime->tv_nsec >= 0, "tv_nsec < 0"); 5803 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec"); 5804} 5805 5806void Parker::park(bool isAbsolute, jlong time) { 5807 5808 // Optional fast-path check: 5809 // Return immediately if a permit is available. 5810 if (_counter > 0) { 5811 _counter = 0 ; 5812 OrderAccess::fence(); 5813 return ; 5814 } 5815 5816 // Optional fast-exit: Check interrupt before trying to wait 5817 Thread* thread = Thread::current(); 5818 assert(thread->is_Java_thread(), "Must be JavaThread"); 5819 JavaThread *jt = (JavaThread *)thread; 5820 if (Thread::is_interrupted(thread, false)) { 5821 return; 5822 } 5823 5824 // First, demultiplex/decode time arguments 5825 timespec absTime; 5826 if (time < 0) { // don't wait at all 5827 return; 5828 } 5829 if (time > 0) { 5830 // Warning: this code might be exposed to the old Solaris time 5831 // round-down bugs. Grep "roundingFix" for details. 5832 unpackTime(&absTime, isAbsolute, time); 5833 } 5834 5835 // Enter safepoint region 5836 // Beware of deadlocks such as 6317397. 5837 // The per-thread Parker:: _mutex is a classic leaf-lock. 5838 // In particular a thread must never block on the Threads_lock while 5839 // holding the Parker:: mutex. If safepoints are pending both the 5840 // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock. 5841 ThreadBlockInVM tbivm(jt); 5842 5843 // Don't wait if cannot get lock since interference arises from 5844 // unblocking. Also. check interrupt before trying wait 5845 if (Thread::is_interrupted(thread, false) || 5846 os::Solaris::mutex_trylock(_mutex) != 0) { 5847 return; 5848 } 5849 5850 int status ; 5851 5852 if (_counter > 0) { // no wait needed 5853 _counter = 0; 5854 status = os::Solaris::mutex_unlock(_mutex); 5855 assert (status == 0, "invariant") ; 5856 OrderAccess::fence(); 5857 return; 5858 } 5859 5860#ifdef ASSERT 5861 // Don't catch signals while blocked; let the running threads have the signals. 5862 // (This allows a debugger to break into the running thread.) 5863 sigset_t oldsigs; 5864 sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals(); 5865 thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs); 5866#endif 5867 5868 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 5869 jt->set_suspend_equivalent(); 5870 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 5871 5872 // Do this the hard way by blocking ... 5873 // See http://monaco.sfbay/detail.jsf?cr=5094058. 5874 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking. 5875 // Only for SPARC >= V8PlusA 5876#if defined(__sparc) && defined(COMPILER2) 5877 if (ClearFPUAtPark) { _mark_fpu_nosave() ; } 5878#endif 5879 5880 if (time == 0) { 5881 status = os::Solaris::cond_wait (_cond, _mutex) ; 5882 } else { 5883 status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime); 5884 } 5885 // Note that an untimed cond_wait() can sometimes return ETIME on older 5886 // versions of the Solaris. 5887 assert_status(status == 0 || status == EINTR || 5888 status == ETIME || status == ETIMEDOUT, 5889 status, "cond_timedwait"); 5890 5891#ifdef ASSERT 5892 thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL); 5893#endif 5894 _counter = 0 ; 5895 status = os::Solaris::mutex_unlock(_mutex); 5896 assert_status(status == 0, status, "mutex_unlock") ; 5897 5898 // If externally suspended while waiting, re-suspend 5899 if (jt->handle_special_suspend_equivalent_condition()) { 5900 jt->java_suspend_self(); 5901 } 5902 5903 OrderAccess::fence(); 5904} 5905 5906void Parker::unpark() { 5907 int s, status ; 5908 status = os::Solaris::mutex_lock (_mutex) ; 5909 assert (status == 0, "invariant") ; 5910 s = _counter; 5911 _counter = 1; 5912 status = os::Solaris::mutex_unlock (_mutex) ; 5913 assert (status == 0, "invariant") ; 5914 5915 if (s < 1) { 5916 status = os::Solaris::cond_signal (_cond) ; 5917 assert (status == 0, "invariant") ; 5918 } 5919} 5920 5921extern char** environ; 5922 5923// Run the specified command in a separate process. Return its exit value, 5924// or -1 on failure (e.g. can't fork a new process). 5925// Unlike system(), this function can be called from signal handler. It 5926// doesn't block SIGINT et al. 5927int os::fork_and_exec(char* cmd) { 5928 char * argv[4]; 5929 argv[0] = (char *)"sh"; 5930 argv[1] = (char *)"-c"; 5931 argv[2] = cmd; 5932 argv[3] = NULL; 5933 5934 // fork is async-safe, fork1 is not so can't use in signal handler 5935 pid_t pid; 5936 Thread* t = ThreadLocalStorage::get_thread_slow(); 5937 if (t != NULL && t->is_inside_signal_handler()) { 5938 pid = fork(); 5939 } else { 5940 pid = fork1(); 5941 } 5942 5943 if (pid < 0) { 5944 // fork failed 5945 warning("fork failed: %s", strerror(errno)); 5946 return -1; 5947 5948 } else if (pid == 0) { 5949 // child process 5950 5951 // try to be consistent with system(), which uses "/usr/bin/sh" on Solaris 5952 execve("/usr/bin/sh", argv, environ); 5953 5954 // execve failed 5955 _exit(-1); 5956 5957 } else { 5958 // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't 5959 // care about the actual exit code, for now. 5960 5961 int status; 5962 5963 // Wait for the child process to exit. This returns immediately if 5964 // the child has already exited. */ 5965 while (waitpid(pid, &status, 0) < 0) { 5966 switch (errno) { 5967 case ECHILD: return 0; 5968 case EINTR: break; 5969 default: return -1; 5970 } 5971 } 5972 5973 if (WIFEXITED(status)) { 5974 // The child exited normally; get its exit code. 5975 return WEXITSTATUS(status); 5976 } else if (WIFSIGNALED(status)) { 5977 // The child exited because of a signal 5978 // The best value to return is 0x80 + signal number, 5979 // because that is what all Unix shells do, and because 5980 // it allows callers to distinguish between process exit and 5981 // process death by signal. 5982 return 0x80 + WTERMSIG(status); 5983 } else { 5984 // Unknown exit code; pass it through 5985 return status; 5986 } 5987 } 5988} 5989