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