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