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