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