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