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