annotate src/os/solaris/vm/os_solaris.cpp @ 477:24fda36852ce

6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE Summary: Make reguard_stack change access to RW, not execute and use os::protect_memory with the new parameter when change needed to X. Reviewed-by: acorn, jcoomes
author coleenp
date Wed, 10 Dec 2008 15:14:29 -0800
parents 85f1b9537f70
children 8a25d96bcf08
rev   line source
duke@0 1 /*
xdono@196 2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
duke@0 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@0 4 *
duke@0 5 * This code is free software; you can redistribute it and/or modify it
duke@0 6 * under the terms of the GNU General Public License version 2 only, as
duke@0 7 * published by the Free Software Foundation.
duke@0 8 *
duke@0 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@0 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@0 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@0 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@0 13 * accompanied this code).
duke@0 14 *
duke@0 15 * You should have received a copy of the GNU General Public License version
duke@0 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@0 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@0 18 *
duke@0 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@0 20 * CA 95054 USA or visit www.sun.com if you need additional information or
duke@0 21 * have any questions.
duke@0 22 *
duke@0 23 */
duke@0 24
duke@0 25 // do not include precompiled header file
duke@0 26 # include "incls/_os_solaris.cpp.incl"
duke@0 27
duke@0 28 // put OS-includes here
duke@0 29 # include <dlfcn.h>
duke@0 30 # include <errno.h>
duke@0 31 # include <link.h>
duke@0 32 # include <poll.h>
duke@0 33 # include <pthread.h>
duke@0 34 # include <pwd.h>
duke@0 35 # include <schedctl.h>
duke@0 36 # include <setjmp.h>
duke@0 37 # include <signal.h>
duke@0 38 # include <stdio.h>
duke@0 39 # include <alloca.h>
duke@0 40 # include <sys/filio.h>
duke@0 41 # include <sys/ipc.h>
duke@0 42 # include <sys/lwp.h>
duke@0 43 # include <sys/machelf.h> // for elf Sym structure used by dladdr1
duke@0 44 # include <sys/mman.h>
duke@0 45 # include <sys/processor.h>
duke@0 46 # include <sys/procset.h>
duke@0 47 # include <sys/pset.h>
duke@0 48 # include <sys/resource.h>
duke@0 49 # include <sys/shm.h>
duke@0 50 # include <sys/socket.h>
duke@0 51 # include <sys/stat.h>
duke@0 52 # include <sys/systeminfo.h>
duke@0 53 # include <sys/time.h>
duke@0 54 # include <sys/times.h>
duke@0 55 # include <sys/types.h>
duke@0 56 # include <sys/wait.h>
duke@0 57 # include <sys/utsname.h>
duke@0 58 # include <thread.h>
duke@0 59 # include <unistd.h>
duke@0 60 # include <sys/priocntl.h>
duke@0 61 # include <sys/rtpriocntl.h>
duke@0 62 # include <sys/tspriocntl.h>
duke@0 63 # include <sys/iapriocntl.h>
duke@0 64 # include <sys/loadavg.h>
duke@0 65 # include <string.h>
duke@0 66
duke@0 67 # define _STRUCTURED_PROC 1 // this gets us the new structured proc interfaces of 5.6 & later
duke@0 68 # include <sys/procfs.h> // see comment in <sys/procfs.h>
duke@0 69
duke@0 70 #define MAX_PATH (2 * K)
duke@0 71
duke@0 72 // for timer info max values which include all bits
duke@0 73 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
duke@0 74
duke@0 75 #ifdef _GNU_SOURCE
duke@0 76 // See bug #6514594
duke@0 77 extern "C" int madvise(caddr_t, size_t, int);
duke@0 78 extern "C" int memcntl(caddr_t addr, size_t len, int cmd, caddr_t arg,
duke@0 79 int attr, int mask);
duke@0 80 #endif //_GNU_SOURCE
duke@0 81
duke@0 82 /*
duke@0 83 MPSS Changes Start.
duke@0 84 The JVM binary needs to be built and run on pre-Solaris 9
duke@0 85 systems, but the constants needed by MPSS are only in Solaris 9
duke@0 86 header files. They are textually replicated here to allow
duke@0 87 building on earlier systems. Once building on Solaris 8 is
duke@0 88 no longer a requirement, these #defines can be replaced by ordinary
duke@0 89 system .h inclusion.
duke@0 90
duke@0 91 In earlier versions of the JDK and Solaris, we used ISM for large pages.
duke@0 92 But ISM requires shared memory to achieve this and thus has many caveats.
duke@0 93 MPSS is a fully transparent and is a cleaner way to get large pages.
duke@0 94 Although we still require keeping ISM for backward compatiblitiy as well as
duke@0 95 giving the opportunity to use large pages on older systems it is
duke@0 96 recommended that MPSS be used for Solaris 9 and above.
duke@0 97
duke@0 98 */
duke@0 99
duke@0 100 #ifndef MC_HAT_ADVISE
duke@0 101
duke@0 102 struct memcntl_mha {
duke@0 103 uint_t mha_cmd; /* command(s) */
duke@0 104 uint_t mha_flags;
duke@0 105 size_t mha_pagesize;
duke@0 106 };
duke@0 107 #define MC_HAT_ADVISE 7 /* advise hat map size */
duke@0 108 #define MHA_MAPSIZE_VA 0x1 /* set preferred page size */
duke@0 109 #define MAP_ALIGN 0x200 /* addr specifies alignment */
duke@0 110
duke@0 111 #endif
duke@0 112 // MPSS Changes End.
duke@0 113
duke@0 114
duke@0 115 // Here are some liblgrp types from sys/lgrp_user.h to be able to
duke@0 116 // compile on older systems without this header file.
duke@0 117
duke@0 118 #ifndef MADV_ACCESS_LWP
duke@0 119 # define MADV_ACCESS_LWP 7 /* next LWP to access heavily */
duke@0 120 #endif
duke@0 121 #ifndef MADV_ACCESS_MANY
duke@0 122 # define MADV_ACCESS_MANY 8 /* many processes to access heavily */
duke@0 123 #endif
duke@0 124
iveresov@144 125 #ifndef LGRP_RSRC_CPU
iveresov@144 126 # define LGRP_RSRC_CPU 0 /* CPU resources */
iveresov@144 127 #endif
iveresov@144 128 #ifndef LGRP_RSRC_MEM
iveresov@144 129 # define LGRP_RSRC_MEM 1 /* memory resources */
iveresov@144 130 #endif
iveresov@144 131
duke@0 132 // Some more macros from sys/mman.h that are not present in Solaris 8.
duke@0 133
duke@0 134 #ifndef MAX_MEMINFO_CNT
duke@0 135 /*
duke@0 136 * info_req request type definitions for meminfo
duke@0 137 * request types starting with MEMINFO_V are used for Virtual addresses
duke@0 138 * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical
duke@0 139 * addresses
duke@0 140 */
duke@0 141 # define MEMINFO_SHIFT 16
duke@0 142 # define MEMINFO_MASK (0xFF << MEMINFO_SHIFT)
duke@0 143 # define MEMINFO_VPHYSICAL (0x01 << MEMINFO_SHIFT) /* get physical addr */
duke@0 144 # define MEMINFO_VLGRP (0x02 << MEMINFO_SHIFT) /* get lgroup */
duke@0 145 # define MEMINFO_VPAGESIZE (0x03 << MEMINFO_SHIFT) /* size of phys page */
duke@0 146 # define MEMINFO_VREPLCNT (0x04 << MEMINFO_SHIFT) /* no. of replica */
duke@0 147 # define MEMINFO_VREPL (0x05 << MEMINFO_SHIFT) /* physical replica */
duke@0 148 # define MEMINFO_VREPL_LGRP (0x06 << MEMINFO_SHIFT) /* lgrp of replica */
duke@0 149 # define MEMINFO_PLGRP (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */
duke@0 150
duke@0 151 /* maximum number of addresses meminfo() can process at a time */
duke@0 152 # define MAX_MEMINFO_CNT 256
duke@0 153
duke@0 154 /* maximum number of request types */
duke@0 155 # define MAX_MEMINFO_REQ 31
duke@0 156 #endif
duke@0 157
duke@0 158 // see thr_setprio(3T) for the basis of these numbers
duke@0 159 #define MinimumPriority 0
duke@0 160 #define NormalPriority 64
duke@0 161 #define MaximumPriority 127
duke@0 162
duke@0 163 // Values for ThreadPriorityPolicy == 1
duke@0 164 int prio_policy1[MaxPriority+1] = { -99999, 0, 16, 32, 48, 64,
duke@0 165 80, 96, 112, 124, 127 };
duke@0 166
duke@0 167 // System parameters used internally
duke@0 168 static clock_t clock_tics_per_sec = 100;
duke@0 169
duke@0 170 // For diagnostics to print a message once. see run_periodic_checks
duke@0 171 static bool check_addr0_done = false;
duke@0 172 static sigset_t check_signal_done;
duke@0 173 static bool check_signals = true;
duke@0 174
duke@0 175 address os::Solaris::handler_start; // start pc of thr_sighndlrinfo
duke@0 176 address os::Solaris::handler_end; // end pc of thr_sighndlrinfo
duke@0 177
duke@0 178 address os::Solaris::_main_stack_base = NULL; // 4352906 workaround
duke@0 179
duke@0 180
duke@0 181 // "default" initializers for missing libc APIs
duke@0 182 extern "C" {
duke@0 183 static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
duke@0 184 static int lwp_mutex_destroy(mutex_t *mx) { return 0; }
duke@0 185
duke@0 186 static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
duke@0 187 static int lwp_cond_destroy(cond_t *cv) { return 0; }
duke@0 188 }
duke@0 189
duke@0 190 // "default" initializers for pthread-based synchronization
duke@0 191 extern "C" {
duke@0 192 static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
duke@0 193 static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
duke@0 194 }
duke@0 195
duke@0 196 // Thread Local Storage
duke@0 197 // This is common to all Solaris platforms so it is defined here,
duke@0 198 // in this common file.
duke@0 199 // The declarations are in the os_cpu threadLS*.hpp files.
duke@0 200 //
duke@0 201 // Static member initialization for TLS
duke@0 202 Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};
duke@0 203
duke@0 204 #ifndef PRODUCT
duke@0 205 #define _PCT(n,d) ((100.0*(double)(n))/(double)(d))
duke@0 206
duke@0 207 int ThreadLocalStorage::_tcacheHit = 0;
duke@0 208 int ThreadLocalStorage::_tcacheMiss = 0;
duke@0 209
duke@0 210 void ThreadLocalStorage::print_statistics() {
duke@0 211 int total = _tcacheMiss+_tcacheHit;
duke@0 212 tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",
duke@0 213 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));
duke@0 214 }
duke@0 215 #undef _PCT
duke@0 216 #endif // PRODUCT
duke@0 217
duke@0 218 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,
duke@0 219 int index) {
duke@0 220 Thread *thread = get_thread_slow();
duke@0 221 if (thread != NULL) {
duke@0 222 address sp = os::current_stack_pointer();
duke@0 223 guarantee(thread->_stack_base == NULL ||
duke@0 224 (sp <= thread->_stack_base &&
duke@0 225 sp >= thread->_stack_base - thread->_stack_size) ||
duke@0 226 is_error_reported(),
duke@0 227 "sp must be inside of selected thread stack");
duke@0 228
duke@0 229 thread->_self_raw_id = raw_id; // mark for quick retrieval
duke@0 230 _get_thread_cache[ index ] = thread;
duke@0 231 }
duke@0 232 return thread;
duke@0 233 }
duke@0 234
duke@0 235
duke@0 236 static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0};
duke@0 237 #define NO_CACHED_THREAD ((Thread*)all_zero)
duke@0 238
duke@0 239 void ThreadLocalStorage::pd_set_thread(Thread* thread) {
duke@0 240
duke@0 241 // Store the new value before updating the cache to prevent a race
duke@0 242 // between get_thread_via_cache_slowly() and this store operation.
duke@0 243 os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);
duke@0 244
duke@0 245 // Update thread cache with new thread if setting on thread create,
duke@0 246 // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit.
duke@0 247 uintptr_t raw = pd_raw_thread_id();
duke@0 248 int ix = pd_cache_index(raw);
duke@0 249 _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread;
duke@0 250 }
duke@0 251
duke@0 252 void ThreadLocalStorage::pd_init() {
duke@0 253 for (int i = 0; i < _pd_cache_size; i++) {
duke@0 254 _get_thread_cache[i] = NO_CACHED_THREAD;
duke@0 255 }
duke@0 256 }
duke@0 257
duke@0 258 // Invalidate all the caches (happens to be the same as pd_init).
duke@0 259 void ThreadLocalStorage::pd_invalidate_all() { pd_init(); }
duke@0 260
duke@0 261 #undef NO_CACHED_THREAD
duke@0 262
duke@0 263 // END Thread Local Storage
duke@0 264
duke@0 265 static inline size_t adjust_stack_size(address base, size_t size) {
duke@0 266 if ((ssize_t)size < 0) {
duke@0 267 // 4759953: Compensate for ridiculous stack size.
duke@0 268 size = max_intx;
duke@0 269 }
duke@0 270 if (size > (size_t)base) {
duke@0 271 // 4812466: Make sure size doesn't allow the stack to wrap the address space.
duke@0 272 size = (size_t)base;
duke@0 273 }
duke@0 274 return size;
duke@0 275 }
duke@0 276
duke@0 277 static inline stack_t get_stack_info() {
duke@0 278 stack_t st;
duke@0 279 int retval = thr_stksegment(&st);
duke@0 280 st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);
duke@0 281 assert(retval == 0, "incorrect return value from thr_stksegment");
duke@0 282 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
duke@0 283 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
duke@0 284 return st;
duke@0 285 }
duke@0 286
duke@0 287 address os::current_stack_base() {
duke@0 288 int r = thr_main() ;
duke@0 289 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
duke@0 290 bool is_primordial_thread = r;
duke@0 291
duke@0 292 // Workaround 4352906, avoid calls to thr_stksegment by
duke@0 293 // thr_main after the first one (it looks like we trash
duke@0 294 // some data, causing the value for ss_sp to be incorrect).
duke@0 295 if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) {
duke@0 296 stack_t st = get_stack_info();
duke@0 297 if (is_primordial_thread) {
duke@0 298 // cache initial value of stack base
duke@0 299 os::Solaris::_main_stack_base = (address)st.ss_sp;
duke@0 300 }
duke@0 301 return (address)st.ss_sp;
duke@0 302 } else {
duke@0 303 guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");
duke@0 304 return os::Solaris::_main_stack_base;
duke@0 305 }
duke@0 306 }
duke@0 307
duke@0 308 size_t os::current_stack_size() {
duke@0 309 size_t size;
duke@0 310
duke@0 311 int r = thr_main() ;
duke@0 312 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
duke@0 313 if(!r) {
duke@0 314 size = get_stack_info().ss_size;
duke@0 315 } else {
duke@0 316 struct rlimit limits;
duke@0 317 getrlimit(RLIMIT_STACK, &limits);
duke@0 318 size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);
duke@0 319 }
duke@0 320 // base may not be page aligned
duke@0 321 address base = current_stack_base();
duke@0 322 address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());;
duke@0 323 return (size_t)(base - bottom);
duke@0 324 }
duke@0 325
duke@0 326 // interruptible infrastructure
duke@0 327
duke@0 328 // setup_interruptible saves the thread state before going into an
duke@0 329 // interruptible system call.
duke@0 330 // The saved state is used to restore the thread to
duke@0 331 // its former state whether or not an interrupt is received.
duke@0 332 // Used by classloader os::read
duke@0 333 // hpi calls skip this layer and stay in _thread_in_native
duke@0 334
duke@0 335 void os::Solaris::setup_interruptible(JavaThread* thread) {
duke@0 336
duke@0 337 JavaThreadState thread_state = thread->thread_state();
duke@0 338
duke@0 339 assert(thread_state != _thread_blocked, "Coming from the wrong thread");
duke@0 340 assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible");
duke@0 341 OSThread* osthread = thread->osthread();
duke@0 342 osthread->set_saved_interrupt_thread_state(thread_state);
duke@0 343 thread->frame_anchor()->make_walkable(thread);
duke@0 344 ThreadStateTransition::transition(thread, thread_state, _thread_blocked);
duke@0 345 }
duke@0 346
duke@0 347 // Version of setup_interruptible() for threads that are already in
duke@0 348 // _thread_blocked. Used by os_sleep().
duke@0 349 void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) {
duke@0 350 thread->frame_anchor()->make_walkable(thread);
duke@0 351 }
duke@0 352
duke@0 353 JavaThread* os::Solaris::setup_interruptible() {
duke@0 354 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();
duke@0 355 setup_interruptible(thread);
duke@0 356 return thread;
duke@0 357 }
duke@0 358
duke@0 359 void os::Solaris::try_enable_extended_io() {
duke@0 360 typedef int (*enable_extended_FILE_stdio_t)(int, int);
duke@0 361
duke@0 362 if (!UseExtendedFileIO) {
duke@0 363 return;
duke@0 364 }
duke@0 365
duke@0 366 enable_extended_FILE_stdio_t enabler =
duke@0 367 (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,
duke@0 368 "enable_extended_FILE_stdio");
duke@0 369 if (enabler) {
duke@0 370 enabler(-1, -1);
duke@0 371 }
duke@0 372 }
duke@0 373
duke@0 374
duke@0 375 #ifdef ASSERT
duke@0 376
duke@0 377 JavaThread* os::Solaris::setup_interruptible_native() {
duke@0 378 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();
duke@0 379 JavaThreadState thread_state = thread->thread_state();
duke@0 380 assert(thread_state == _thread_in_native, "Assumed thread_in_native");
duke@0 381 return thread;
duke@0 382 }
duke@0 383
duke@0 384 void os::Solaris::cleanup_interruptible_native(JavaThread* thread) {
duke@0 385 JavaThreadState thread_state = thread->thread_state();
duke@0 386 assert(thread_state == _thread_in_native, "Assumed thread_in_native");
duke@0 387 }
duke@0 388 #endif
duke@0 389
duke@0 390 // cleanup_interruptible reverses the effects of setup_interruptible
duke@0 391 // setup_interruptible_already_blocked() does not need any cleanup.
duke@0 392
duke@0 393 void os::Solaris::cleanup_interruptible(JavaThread* thread) {
duke@0 394 OSThread* osthread = thread->osthread();
duke@0 395
duke@0 396 ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state());
duke@0 397 }
duke@0 398
duke@0 399 // I/O interruption related counters called in _INTERRUPTIBLE
duke@0 400
duke@0 401 void os::Solaris::bump_interrupted_before_count() {
duke@0 402 RuntimeService::record_interrupted_before_count();
duke@0 403 }
duke@0 404
duke@0 405 void os::Solaris::bump_interrupted_during_count() {
duke@0 406 RuntimeService::record_interrupted_during_count();
duke@0 407 }
duke@0 408
duke@0 409 static int _processors_online = 0;
duke@0 410
duke@0 411 jint os::Solaris::_os_thread_limit = 0;
duke@0 412 volatile jint os::Solaris::_os_thread_count = 0;
duke@0 413
duke@0 414 julong os::available_memory() {
duke@0 415 return Solaris::available_memory();
duke@0 416 }
duke@0 417
duke@0 418 julong os::Solaris::available_memory() {
duke@0 419 return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();
duke@0 420 }
duke@0 421
duke@0 422 julong os::Solaris::_physical_memory = 0;
duke@0 423
duke@0 424 julong os::physical_memory() {
duke@0 425 return Solaris::physical_memory();
duke@0 426 }
duke@0 427
duke@0 428 julong os::allocatable_physical_memory(julong size) {
duke@0 429 #ifdef _LP64
duke@0 430 return size;
duke@0 431 #else
duke@0 432 julong result = MIN2(size, (julong)3835*M);
duke@0 433 if (!is_allocatable(result)) {
duke@0 434 // Memory allocations will be aligned but the alignment
duke@0 435 // is not known at this point. Alignments will
duke@0 436 // be at most to LargePageSizeInBytes. Protect
duke@0 437 // allocations from alignments up to illegal
duke@0 438 // values. If at this point 2G is illegal.
duke@0 439 julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes;
duke@0 440 result = MIN2(size, reasonable_size);
duke@0 441 }
duke@0 442 return result;
duke@0 443 #endif
duke@0 444 }
duke@0 445
duke@0 446 static hrtime_t first_hrtime = 0;
duke@0 447 static const hrtime_t hrtime_hz = 1000*1000*1000;
duke@0 448 const int LOCK_BUSY = 1;
duke@0 449 const int LOCK_FREE = 0;
duke@0 450 const int LOCK_INVALID = -1;
duke@0 451 static volatile hrtime_t max_hrtime = 0;
duke@0 452 static volatile int max_hrtime_lock = LOCK_FREE; // Update counter with LSB as lock-in-progress
duke@0 453
duke@0 454
duke@0 455 void os::Solaris::initialize_system_info() {
duke@0 456 _processor_count = sysconf(_SC_NPROCESSORS_CONF);
duke@0 457 _processors_online = sysconf (_SC_NPROCESSORS_ONLN);
duke@0 458 _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);
duke@0 459 }
duke@0 460
duke@0 461 int os::active_processor_count() {
duke@0 462 int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
duke@0 463 pid_t pid = getpid();
duke@0 464 psetid_t pset = PS_NONE;
xlu@387 465 // Are we running in a processor set or is there any processor set around?
duke@0 466 if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {
xlu@387 467 uint_t pset_cpus;
xlu@387 468 // Query the number of cpus available to us.
xlu@387 469 if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {
xlu@387 470 assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");
xlu@387 471 _processors_online = pset_cpus;
xlu@387 472 return pset_cpus;
duke@0 473 }
duke@0 474 }
duke@0 475 // Otherwise return number of online cpus
duke@0 476 return online_cpus;
duke@0 477 }
duke@0 478
duke@0 479 static bool find_processors_in_pset(psetid_t pset,
duke@0 480 processorid_t** id_array,
duke@0 481 uint_t* id_length) {
duke@0 482 bool result = false;
duke@0 483 // Find the number of processors in the processor set.
duke@0 484 if (pset_info(pset, NULL, id_length, NULL) == 0) {
duke@0 485 // Make up an array to hold their ids.
duke@0 486 *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
duke@0 487 // Fill in the array with their processor ids.
duke@0 488 if (pset_info(pset, NULL, id_length, *id_array) == 0) {
duke@0 489 result = true;
duke@0 490 }
duke@0 491 }
duke@0 492 return result;
duke@0 493 }
duke@0 494
duke@0 495 // Callers of find_processors_online() must tolerate imprecise results --
duke@0 496 // the system configuration can change asynchronously because of DR
duke@0 497 // or explicit psradm operations.
duke@0 498 //
duke@0 499 // We also need to take care that the loop (below) terminates as the
duke@0 500 // number of processors online can change between the _SC_NPROCESSORS_ONLN
duke@0 501 // request and the loop that builds the list of processor ids. Unfortunately
duke@0 502 // there's no reliable way to determine the maximum valid processor id,
duke@0 503 // so we use a manifest constant, MAX_PROCESSOR_ID, instead. See p_online
duke@0 504 // man pages, which claim the processor id set is "sparse, but
duke@0 505 // not too sparse". MAX_PROCESSOR_ID is used to ensure that we eventually
duke@0 506 // exit the loop.
duke@0 507 //
duke@0 508 // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's
duke@0 509 // not available on S8.0.
duke@0 510
duke@0 511 static bool find_processors_online(processorid_t** id_array,
duke@0 512 uint* id_length) {
duke@0 513 const processorid_t MAX_PROCESSOR_ID = 100000 ;
duke@0 514 // Find the number of processors online.
duke@0 515 *id_length = sysconf(_SC_NPROCESSORS_ONLN);
duke@0 516 // Make up an array to hold their ids.
duke@0 517 *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
duke@0 518 // Processors need not be numbered consecutively.
duke@0 519 long found = 0;
duke@0 520 processorid_t next = 0;
duke@0 521 while (found < *id_length && next < MAX_PROCESSOR_ID) {
duke@0 522 processor_info_t info;
duke@0 523 if (processor_info(next, &info) == 0) {
duke@0 524 // NB, PI_NOINTR processors are effectively online ...
duke@0 525 if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {
duke@0 526 (*id_array)[found] = next;
duke@0 527 found += 1;
duke@0 528 }
duke@0 529 }
duke@0 530 next += 1;
duke@0 531 }
duke@0 532 if (found < *id_length) {
duke@0 533 // The loop above didn't identify the expected number of processors.
duke@0 534 // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)
duke@0 535 // and re-running the loop, above, but there's no guarantee of progress
duke@0 536 // if the system configuration is in flux. Instead, we just return what
duke@0 537 // we've got. Note that in the worst case find_processors_online() could
duke@0 538 // return an empty set. (As a fall-back in the case of the empty set we
duke@0 539 // could just return the ID of the current processor).
duke@0 540 *id_length = found ;
duke@0 541 }
duke@0 542
duke@0 543 return true;
duke@0 544 }
duke@0 545
duke@0 546 static bool assign_distribution(processorid_t* id_array,
duke@0 547 uint id_length,
duke@0 548 uint* distribution,
duke@0 549 uint distribution_length) {
duke@0 550 // We assume we can assign processorid_t's to uint's.
duke@0 551 assert(sizeof(processorid_t) == sizeof(uint),
duke@0 552 "can't convert processorid_t to uint");
duke@0 553 // Quick check to see if we won't succeed.
duke@0 554 if (id_length < distribution_length) {
duke@0 555 return false;
duke@0 556 }
duke@0 557 // Assign processor ids to the distribution.
duke@0 558 // Try to shuffle processors to distribute work across boards,
duke@0 559 // assuming 4 processors per board.
duke@0 560 const uint processors_per_board = ProcessDistributionStride;
duke@0 561 // Find the maximum processor id.
duke@0 562 processorid_t max_id = 0;
duke@0 563 for (uint m = 0; m < id_length; m += 1) {
duke@0 564 max_id = MAX2(max_id, id_array[m]);
duke@0 565 }
duke@0 566 // The next id, to limit loops.
duke@0 567 const processorid_t limit_id = max_id + 1;
duke@0 568 // Make up markers for available processors.
duke@0 569 bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id);
duke@0 570 for (uint c = 0; c < limit_id; c += 1) {
duke@0 571 available_id[c] = false;
duke@0 572 }
duke@0 573 for (uint a = 0; a < id_length; a += 1) {
duke@0 574 available_id[id_array[a]] = true;
duke@0 575 }
duke@0 576 // Step by "boards", then by "slot", copying to "assigned".
duke@0 577 // NEEDS_CLEANUP: The assignment of processors should be stateful,
duke@0 578 // remembering which processors have been assigned by
duke@0 579 // previous calls, etc., so as to distribute several
duke@0 580 // independent calls of this method. What we'd like is
duke@0 581 // It would be nice to have an API that let us ask
duke@0 582 // how many processes are bound to a processor,
duke@0 583 // but we don't have that, either.
duke@0 584 // In the short term, "board" is static so that
duke@0 585 // subsequent distributions don't all start at board 0.
duke@0 586 static uint board = 0;
duke@0 587 uint assigned = 0;
duke@0 588 // Until we've found enough processors ....
duke@0 589 while (assigned < distribution_length) {
duke@0 590 // ... find the next available processor in the board.
duke@0 591 for (uint slot = 0; slot < processors_per_board; slot += 1) {
duke@0 592 uint try_id = board * processors_per_board + slot;
duke@0 593 if ((try_id < limit_id) && (available_id[try_id] == true)) {
duke@0 594 distribution[assigned] = try_id;
duke@0 595 available_id[try_id] = false;
duke@0 596 assigned += 1;
duke@0 597 break;
duke@0 598 }
duke@0 599 }
duke@0 600 board += 1;
duke@0 601 if (board * processors_per_board + 0 >= limit_id) {
duke@0 602 board = 0;
duke@0 603 }
duke@0 604 }
duke@0 605 if (available_id != NULL) {
duke@0 606 FREE_C_HEAP_ARRAY(bool, available_id);
duke@0 607 }
duke@0 608 return true;
duke@0 609 }
duke@0 610
duke@0 611 bool os::distribute_processes(uint length, uint* distribution) {
duke@0 612 bool result = false;
duke@0 613 // Find the processor id's of all the available CPUs.
duke@0 614 processorid_t* id_array = NULL;
duke@0 615 uint id_length = 0;
duke@0 616 // There are some races between querying information and using it,
duke@0 617 // since processor sets can change dynamically.
duke@0 618 psetid_t pset = PS_NONE;
duke@0 619 // Are we running in a processor set?
duke@0 620 if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {
duke@0 621 result = find_processors_in_pset(pset, &id_array, &id_length);
duke@0 622 } else {
duke@0 623 result = find_processors_online(&id_array, &id_length);
duke@0 624 }
duke@0 625 if (result == true) {
duke@0 626 if (id_length >= length) {
duke@0 627 result = assign_distribution(id_array, id_length, distribution, length);
duke@0 628 } else {
duke@0 629 result = false;
duke@0 630 }
duke@0 631 }
duke@0 632 if (id_array != NULL) {
duke@0 633 FREE_C_HEAP_ARRAY(processorid_t, id_array);
duke@0 634 }
duke@0 635 return result;
duke@0 636 }
duke@0 637
duke@0 638 bool os::bind_to_processor(uint processor_id) {
duke@0 639 // We assume that a processorid_t can be stored in a uint.
duke@0 640 assert(sizeof(uint) == sizeof(processorid_t),
duke@0 641 "can't convert uint to processorid_t");
duke@0 642 int bind_result =
duke@0 643 processor_bind(P_LWPID, // bind LWP.
duke@0 644 P_MYID, // bind current LWP.
duke@0 645 (processorid_t) processor_id, // id.
duke@0 646 NULL); // don't return old binding.
duke@0 647 return (bind_result == 0);
duke@0 648 }
duke@0 649
duke@0 650 bool os::getenv(const char* name, char* buffer, int len) {
duke@0 651 char* val = ::getenv( name );
duke@0 652 if ( val == NULL
duke@0 653 || strlen(val) + 1 > len ) {
duke@0 654 if (len > 0) buffer[0] = 0; // return a null string
duke@0 655 return false;
duke@0 656 }
duke@0 657 strcpy( buffer, val );
duke@0 658 return true;
duke@0 659 }
duke@0 660
duke@0 661
duke@0 662 // Return true if user is running as root.
duke@0 663
duke@0 664 bool os::have_special_privileges() {
duke@0 665 static bool init = false;
duke@0 666 static bool privileges = false;
duke@0 667 if (!init) {
duke@0 668 privileges = (getuid() != geteuid()) || (getgid() != getegid());
duke@0 669 init = true;
duke@0 670 }
duke@0 671 return privileges;
duke@0 672 }
duke@0 673
duke@0 674
duke@0 675 static char* get_property(char* name, char* buffer, int buffer_size) {
duke@0 676 if (os::getenv(name, buffer, buffer_size)) {
duke@0 677 return buffer;
duke@0 678 }
duke@0 679 static char empty[] = "";
duke@0 680 return empty;
duke@0 681 }
duke@0 682
duke@0 683
duke@0 684 void os::init_system_properties_values() {
duke@0 685 char arch[12];
duke@0 686 sysinfo(SI_ARCHITECTURE, arch, sizeof(arch));
duke@0 687
duke@0 688 // The next steps are taken in the product version:
duke@0 689 //
duke@0 690 // Obtain the JAVA_HOME value from the location of libjvm[_g].so.
duke@0 691 // This library should be located at:
duke@0 692 // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so.
duke@0 693 //
duke@0 694 // If "/jre/lib/" appears at the right place in the path, then we
duke@0 695 // assume libjvm[_g].so is installed in a JDK and we use this path.
duke@0 696 //
duke@0 697 // Otherwise exit with message: "Could not create the Java virtual machine."
duke@0 698 //
duke@0 699 // The following extra steps are taken in the debugging version:
duke@0 700 //
duke@0 701 // If "/jre/lib/" does NOT appear at the right place in the path
duke@0 702 // instead of exit check for $JAVA_HOME environment variable.
duke@0 703 //
duke@0 704 // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,
duke@0 705 // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so
duke@0 706 // it looks like libjvm[_g].so is installed there
duke@0 707 // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so.
duke@0 708 //
duke@0 709 // Otherwise exit.
duke@0 710 //
duke@0 711 // Important note: if the location of libjvm.so changes this
duke@0 712 // code needs to be changed accordingly.
duke@0 713
duke@0 714 // The next few definitions allow the code to be verbatim:
duke@0 715 #define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))
duke@0 716 #define free(p) FREE_C_HEAP_ARRAY(char, p)
duke@0 717 #define getenv(n) ::getenv(n)
duke@0 718
duke@0 719 #define EXTENSIONS_DIR "/lib/ext"
duke@0 720 #define ENDORSED_DIR "/lib/endorsed"
duke@0 721 #define COMMON_DIR "/usr/jdk/packages"
duke@0 722
duke@0 723 {
duke@0 724 /* sysclasspath, java_home, dll_dir */
duke@0 725 {
duke@0 726 char *home_path;
duke@0 727 char *dll_path;
duke@0 728 char *pslash;
duke@0 729 char buf[MAXPATHLEN];
duke@0 730 os::jvm_path(buf, sizeof(buf));
duke@0 731
duke@0 732 // Found the full path to libjvm.so.
duke@0 733 // Now cut the path to <java_home>/jre if we can.
duke@0 734 *(strrchr(buf, '/')) = '\0'; /* get rid of /libjvm.so */
duke@0 735 pslash = strrchr(buf, '/');
duke@0 736 if (pslash != NULL)
duke@0 737 *pslash = '\0'; /* get rid of /{client|server|hotspot} */
duke@0 738 dll_path = malloc(strlen(buf) + 1);
duke@0 739 if (dll_path == NULL)
duke@0 740 return;
duke@0 741 strcpy(dll_path, buf);
duke@0 742 Arguments::set_dll_dir(dll_path);
duke@0 743
duke@0 744 if (pslash != NULL) {
duke@0 745 pslash = strrchr(buf, '/');
duke@0 746 if (pslash != NULL) {
duke@0 747 *pslash = '\0'; /* get rid of /<arch> */
duke@0 748 pslash = strrchr(buf, '/');
duke@0 749 if (pslash != NULL)
duke@0 750 *pslash = '\0'; /* get rid of /lib */
duke@0 751 }
duke@0 752 }
duke@0 753
duke@0 754 home_path = malloc(strlen(buf) + 1);
duke@0 755 if (home_path == NULL)
duke@0 756 return;
duke@0 757 strcpy(home_path, buf);
duke@0 758 Arguments::set_java_home(home_path);
duke@0 759
duke@0 760 if (!set_boot_path('/', ':'))
duke@0 761 return;
duke@0 762 }
duke@0 763
duke@0 764 /*
duke@0 765 * Where to look for native libraries
duke@0 766 */
duke@0 767 {
duke@0 768 // Use dlinfo() to determine the correct java.library.path.
duke@0 769 //
duke@0 770 // If we're launched by the Java launcher, and the user
duke@0 771 // does not set java.library.path explicitly on the commandline,
duke@0 772 // the Java launcher sets LD_LIBRARY_PATH for us and unsets
duke@0 773 // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64. In this case
duke@0 774 // dlinfo returns LD_LIBRARY_PATH + crle settings (including
duke@0 775 // /usr/lib), which is exactly what we want.
duke@0 776 //
duke@0 777 // If the user does set java.library.path, it completely
duke@0 778 // overwrites this setting, and always has.
duke@0 779 //
duke@0 780 // If we're not launched by the Java launcher, we may
duke@0 781 // get here with any/all of the LD_LIBRARY_PATH[_32|64]
duke@0 782 // settings. Again, dlinfo does exactly what we want.
duke@0 783
duke@0 784 Dl_serinfo _info, *info = &_info;
duke@0 785 Dl_serpath *path;
duke@0 786 char* library_path;
duke@0 787 char *common_path;
duke@0 788 int i;
duke@0 789
duke@0 790 // determine search path count and required buffer size
duke@0 791 if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {
duke@0 792 vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());
duke@0 793 }
duke@0 794
duke@0 795 // allocate new buffer and initialize
duke@0 796 info = (Dl_serinfo*)malloc(_info.dls_size);
duke@0 797 if (info == NULL) {
duke@0 798 vm_exit_out_of_memory(_info.dls_size,
duke@0 799 "init_system_properties_values info");
duke@0 800 }
duke@0 801 info->dls_size = _info.dls_size;
duke@0 802 info->dls_cnt = _info.dls_cnt;
duke@0 803
duke@0 804 // obtain search path information
duke@0 805 if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {
duke@0 806 free(info);
duke@0 807 vm_exit_during_initialization("dlinfo SERINFO request", dlerror());
duke@0 808 }
duke@0 809
duke@0 810 path = &info->dls_serpath[0];
duke@0 811
duke@0 812 // Note: Due to a legacy implementation, most of the library path
duke@0 813 // is set in the launcher. This was to accomodate linking restrictions
duke@0 814 // on legacy Solaris implementations (which are no longer supported).
duke@0 815 // Eventually, all the library path setting will be done here.
duke@0 816 //
duke@0 817 // However, to prevent the proliferation of improperly built native
duke@0 818 // libraries, the new path component /usr/jdk/packages is added here.
duke@0 819
duke@0 820 // Determine the actual CPU architecture.
duke@0 821 char cpu_arch[12];
duke@0 822 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
duke@0 823 #ifdef _LP64
duke@0 824 // If we are a 64-bit vm, perform the following translations:
duke@0 825 // sparc -> sparcv9
duke@0 826 // i386 -> amd64
duke@0 827 if (strcmp(cpu_arch, "sparc") == 0)
duke@0 828 strcat(cpu_arch, "v9");
duke@0 829 else if (strcmp(cpu_arch, "i386") == 0)
duke@0 830 strcpy(cpu_arch, "amd64");
duke@0 831 #endif
duke@0 832
duke@0 833 // Construct the invariant part of ld_library_path. Note that the
duke@0 834 // space for the colon and the trailing null are provided by the
duke@0 835 // nulls included by the sizeof operator.
duke@0 836 size_t bufsize = sizeof(COMMON_DIR) + sizeof("/lib/") + strlen(cpu_arch);
duke@0 837 common_path = malloc(bufsize);
duke@0 838 if (common_path == NULL) {
duke@0 839 free(info);
duke@0 840 vm_exit_out_of_memory(bufsize,
duke@0 841 "init_system_properties_values common_path");
duke@0 842 }
duke@0 843 sprintf(common_path, COMMON_DIR "/lib/%s", cpu_arch);
duke@0 844
duke@0 845 // struct size is more than sufficient for the path components obtained
duke@0 846 // through the dlinfo() call, so only add additional space for the path
duke@0 847 // components explicitly added here.
duke@0 848 bufsize = info->dls_size + strlen(common_path);
duke@0 849 library_path = malloc(bufsize);
duke@0 850 if (library_path == NULL) {
duke@0 851 free(info);
duke@0 852 free(common_path);
duke@0 853 vm_exit_out_of_memory(bufsize,
duke@0 854 "init_system_properties_values library_path");
duke@0 855 }
duke@0 856 library_path[0] = '\0';
duke@0 857
duke@0 858 // Construct the desired Java library path from the linker's library
duke@0 859 // search path.
duke@0 860 //
duke@0 861 // For compatibility, it is optimal that we insert the additional path
duke@0 862 // components specific to the Java VM after those components specified
duke@0 863 // in LD_LIBRARY_PATH (if any) but before those added by the ld.so
duke@0 864 // infrastructure.
duke@0 865 if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it
duke@0 866 strcpy(library_path, common_path);
duke@0 867 } else {
duke@0 868 int inserted = 0;
duke@0 869 for (i = 0; i < info->dls_cnt; i++, path++) {
duke@0 870 uint_t flags = path->dls_flags & LA_SER_MASK;
duke@0 871 if (((flags & LA_SER_LIBPATH) == 0) && !inserted) {
duke@0 872 strcat(library_path, common_path);
duke@0 873 strcat(library_path, os::path_separator());
duke@0 874 inserted = 1;
duke@0 875 }
duke@0 876 strcat(library_path, path->dls_name);
duke@0 877 strcat(library_path, os::path_separator());
duke@0 878 }
duke@0 879 // eliminate trailing path separator
duke@0 880 library_path[strlen(library_path)-1] = '\0';
duke@0 881 }
duke@0 882
duke@0 883 // happens before argument parsing - can't use a trace flag
duke@0 884 // tty->print_raw("init_system_properties_values: native lib path: ");
duke@0 885 // tty->print_raw_cr(library_path);
duke@0 886
duke@0 887 // callee copies into its own buffer
duke@0 888 Arguments::set_library_path(library_path);
duke@0 889
duke@0 890 free(common_path);
duke@0 891 free(library_path);
duke@0 892 free(info);
duke@0 893 }
duke@0 894
duke@0 895 /*
duke@0 896 * Extensions directories.
duke@0 897 *
duke@0 898 * Note that the space for the colon and the trailing null are provided
duke@0 899 * by the nulls included by the sizeof operator (so actually one byte more
duke@0 900 * than necessary is allocated).
duke@0 901 */
duke@0 902 {
duke@0 903 char *buf = (char *) malloc(strlen(Arguments::get_java_home()) +
duke@0 904 sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) +
duke@0 905 sizeof(EXTENSIONS_DIR));
duke@0 906 sprintf(buf, "%s" EXTENSIONS_DIR ":" COMMON_DIR EXTENSIONS_DIR,
duke@0 907 Arguments::get_java_home());
duke@0 908 Arguments::set_ext_dirs(buf);
duke@0 909 }
duke@0 910
duke@0 911 /* Endorsed standards default directory. */
duke@0 912 {
duke@0 913 char * buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR));
duke@0 914 sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home());
duke@0 915 Arguments::set_endorsed_dirs(buf);
duke@0 916 }
duke@0 917 }
duke@0 918
duke@0 919 #undef malloc
duke@0 920 #undef free
duke@0 921 #undef getenv
duke@0 922 #undef EXTENSIONS_DIR
duke@0 923 #undef ENDORSED_DIR
duke@0 924 #undef COMMON_DIR
duke@0 925
duke@0 926 }
duke@0 927
duke@0 928 void os::breakpoint() {
duke@0 929 BREAKPOINT;
duke@0 930 }
duke@0 931
duke@0 932 bool os::obsolete_option(const JavaVMOption *option)
duke@0 933 {
duke@0 934 if (!strncmp(option->optionString, "-Xt", 3)) {
duke@0 935 return true;
duke@0 936 } else if (!strncmp(option->optionString, "-Xtm", 4)) {
duke@0 937 return true;
duke@0 938 } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) {
duke@0 939 return true;
duke@0 940 } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) {
duke@0 941 return true;
duke@0 942 }
duke@0 943 return false;
duke@0 944 }
duke@0 945
duke@0 946 bool os::Solaris::valid_stack_address(Thread* thread, address sp) {
duke@0 947 address stackStart = (address)thread->stack_base();
duke@0 948 address stackEnd = (address)(stackStart - (address)thread->stack_size());
duke@0 949 if (sp < stackStart && sp >= stackEnd ) return true;
duke@0 950 return false;
duke@0 951 }
duke@0 952
duke@0 953 extern "C" void breakpoint() {
duke@0 954 // use debugger to set breakpoint here
duke@0 955 }
duke@0 956
duke@0 957 // Returns an estimate of the current stack pointer. Result must be guaranteed to
duke@0 958 // point into the calling threads stack, and be no lower than the current stack
duke@0 959 // pointer.
duke@0 960 address os::current_stack_pointer() {
duke@0 961 volatile int dummy;
duke@0 962 address sp = (address)&dummy + 8; // %%%% need to confirm if this is right
duke@0 963 return sp;
duke@0 964 }
duke@0 965
duke@0 966 static thread_t main_thread;
duke@0 967
duke@0 968 // Thread start routine for all new Java threads
duke@0 969 extern "C" void* java_start(void* thread_addr) {
duke@0 970 // Try to randomize the cache line index of hot stack frames.
duke@0 971 // This helps when threads of the same stack traces evict each other's
duke@0 972 // cache lines. The threads can be either from the same JVM instance, or
duke@0 973 // from different JVM instances. The benefit is especially true for
duke@0 974 // processors with hyperthreading technology.
duke@0 975 static int counter = 0;
duke@0 976 int pid = os::current_process_id();
duke@0 977 alloca(((pid ^ counter++) & 7) * 128);
duke@0 978
duke@0 979 int prio;
duke@0 980 Thread* thread = (Thread*)thread_addr;
duke@0 981 OSThread* osthr = thread->osthread();
duke@0 982
duke@0 983 osthr->set_lwp_id( _lwp_self() ); // Store lwp in case we are bound
duke@0 984 thread->_schedctl = (void *) schedctl_init () ;
duke@0 985
duke@0 986 if (UseNUMA) {
duke@0 987 int lgrp_id = os::numa_get_group_id();
duke@0 988 if (lgrp_id != -1) {
duke@0 989 thread->set_lgrp_id(lgrp_id);
duke@0 990 }
duke@0 991 }
duke@0 992
duke@0 993 // If the creator called set priority before we started,
duke@0 994 // we need to call set priority now that we have an lwp.
duke@0 995 // Get the priority from libthread and set the priority
duke@0 996 // for the new Solaris lwp.
duke@0 997 if ( osthr->thread_id() != -1 ) {
duke@0 998 if ( UseThreadPriorities ) {
duke@0 999 thr_getprio(osthr->thread_id(), &prio);
duke@0 1000 if (ThreadPriorityVerbose) {
duke@0 1001 tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT ", setting priority: %d\n",
duke@0 1002 osthr->thread_id(), osthr->lwp_id(), prio );
duke@0 1003 }
duke@0 1004 os::set_native_priority(thread, prio);
duke@0 1005 }
duke@0 1006 } else if (ThreadPriorityVerbose) {
duke@0 1007 warning("Can't set priority in _start routine, thread id hasn't been set\n");
duke@0 1008 }
duke@0 1009
duke@0 1010 assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
duke@0 1011
duke@0 1012 // initialize signal mask for this thread
duke@0 1013 os::Solaris::hotspot_sigmask(thread);
duke@0 1014
duke@0 1015 thread->run();
duke@0 1016
duke@0 1017 // One less thread is executing
duke@0 1018 // When the VMThread gets here, the main thread may have already exited
duke@0 1019 // which frees the CodeHeap containing the Atomic::dec code
duke@0 1020 if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {
duke@0 1021 Atomic::dec(&os::Solaris::_os_thread_count);
duke@0 1022 }
duke@0 1023
duke@0 1024 if (UseDetachedThreads) {
duke@0 1025 thr_exit(NULL);
duke@0 1026 ShouldNotReachHere();
duke@0 1027 }
duke@0 1028 return NULL;
duke@0 1029 }
duke@0 1030
duke@0 1031 static OSThread* create_os_thread(Thread* thread, thread_t thread_id) {
duke@0 1032 // Allocate the OSThread object
duke@0 1033 OSThread* osthread = new OSThread(NULL, NULL);
duke@0 1034 if (osthread == NULL) return NULL;
duke@0 1035
duke@0 1036 // Store info on the Solaris thread into the OSThread
duke@0 1037 osthread->set_thread_id(thread_id);
duke@0 1038 osthread->set_lwp_id(_lwp_self());
duke@0 1039 thread->_schedctl = (void *) schedctl_init () ;
duke@0 1040
duke@0 1041 if (UseNUMA) {
duke@0 1042 int lgrp_id = os::numa_get_group_id();
duke@0 1043 if (lgrp_id != -1) {
duke@0 1044 thread->set_lgrp_id(lgrp_id);
duke@0 1045 }
duke@0 1046 }
duke@0 1047
duke@0 1048 if ( ThreadPriorityVerbose ) {
duke@0 1049 tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n",
duke@0 1050 osthread->thread_id(), osthread->lwp_id() );
duke@0 1051 }
duke@0 1052
duke@0 1053 // Initial thread state is INITIALIZED, not SUSPENDED
duke@0 1054 osthread->set_state(INITIALIZED);
duke@0 1055
duke@0 1056 return osthread;
duke@0 1057 }
duke@0 1058
duke@0 1059 void os::Solaris::hotspot_sigmask(Thread* thread) {
duke@0 1060
duke@0 1061 //Save caller's signal mask
duke@0 1062 sigset_t sigmask;
duke@0 1063 thr_sigsetmask(SIG_SETMASK, NULL, &sigmask);
duke@0 1064 OSThread *osthread = thread->osthread();
duke@0 1065 osthread->set_caller_sigmask(sigmask);
duke@0 1066
duke@0 1067 thr_sigsetmask(SIG_UNBLOCK, os::Solaris::unblocked_signals(), NULL);
duke@0 1068 if (!ReduceSignalUsage) {
duke@0 1069 if (thread->is_VM_thread()) {
duke@0 1070 // Only the VM thread handles BREAK_SIGNAL ...
duke@0 1071 thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL);
duke@0 1072 } else {
duke@0 1073 // ... all other threads block BREAK_SIGNAL
duke@0 1074 assert(!sigismember(vm_signals(), SIGINT), "SIGINT should not be blocked");
duke@0 1075 thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL);
duke@0 1076 }
duke@0 1077 }
duke@0 1078 }
duke@0 1079
duke@0 1080 bool os::create_attached_thread(JavaThread* thread) {
duke@0 1081 #ifdef ASSERT
duke@0 1082 thread->verify_not_published();
duke@0 1083 #endif
duke@0 1084 OSThread* osthread = create_os_thread(thread, thr_self());
duke@0 1085 if (osthread == NULL) {
duke@0 1086 return false;
duke@0 1087 }
duke@0 1088
duke@0 1089 // Initial thread state is RUNNABLE
duke@0 1090 osthread->set_state(RUNNABLE);
duke@0 1091 thread->set_osthread(osthread);
duke@0 1092
duke@0 1093 // initialize signal mask for this thread
duke@0 1094 // and save the caller's signal mask
duke@0 1095 os::Solaris::hotspot_sigmask(thread);
duke@0 1096
duke@0 1097 return true;
duke@0 1098 }
duke@0 1099
duke@0 1100 bool os::create_main_thread(JavaThread* thread) {
duke@0 1101 #ifdef ASSERT
duke@0 1102 thread->verify_not_published();
duke@0 1103 #endif
duke@0 1104 if (_starting_thread == NULL) {
duke@0 1105 _starting_thread = create_os_thread(thread, main_thread);
duke@0 1106 if (_starting_thread == NULL) {
duke@0 1107 return false;
duke@0 1108 }
duke@0 1109 }
duke@0 1110
duke@0 1111 // The primodial thread is runnable from the start
duke@0 1112 _starting_thread->set_state(RUNNABLE);
duke@0 1113
duke@0 1114 thread->set_osthread(_starting_thread);
duke@0 1115
duke@0 1116 // initialize signal mask for this thread
duke@0 1117 // and save the caller's signal mask
duke@0 1118 os::Solaris::hotspot_sigmask(thread);
duke@0 1119
duke@0 1120 return true;
duke@0 1121 }
duke@0 1122
duke@0 1123 // _T2_libthread is true if we believe we are running with the newer
duke@0 1124 // SunSoft lwp/libthread.so (2.8 patch, 2.9 default)
duke@0 1125 bool os::Solaris::_T2_libthread = false;
duke@0 1126
duke@0 1127 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
duke@0 1128 // Allocate the OSThread object
duke@0 1129 OSThread* osthread = new OSThread(NULL, NULL);
duke@0 1130 if (osthread == NULL) {
duke@0 1131 return false;
duke@0 1132 }
duke@0 1133
duke@0 1134 if ( ThreadPriorityVerbose ) {
duke@0 1135 char *thrtyp;
duke@0 1136 switch ( thr_type ) {
duke@0 1137 case vm_thread:
duke@0 1138 thrtyp = (char *)"vm";
duke@0 1139 break;
duke@0 1140 case cgc_thread:
duke@0 1141 thrtyp = (char *)"cgc";
duke@0 1142 break;
duke@0 1143 case pgc_thread:
duke@0 1144 thrtyp = (char *)"pgc";
duke@0 1145 break;
duke@0 1146 case java_thread:
duke@0 1147 thrtyp = (char *)"java";
duke@0 1148 break;
duke@0 1149 case compiler_thread:
duke@0 1150 thrtyp = (char *)"compiler";
duke@0 1151 break;
duke@0 1152 case watcher_thread:
duke@0 1153 thrtyp = (char *)"watcher";
duke@0 1154 break;
duke@0 1155 default:
duke@0 1156 thrtyp = (char *)"unknown";
duke@0 1157 break;
duke@0 1158 }
duke@0 1159 tty->print_cr("In create_thread, creating a %s thread\n", thrtyp);
duke@0 1160 }
duke@0 1161
duke@0 1162 // Calculate stack size if it's not specified by caller.
duke@0 1163 if (stack_size == 0) {
duke@0 1164 // The default stack size 1M (2M for LP64).
duke@0 1165 stack_size = (BytesPerWord >> 2) * K * K;
duke@0 1166
duke@0 1167 switch (thr_type) {
duke@0 1168 case os::java_thread:
duke@0 1169 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
duke@0 1170 if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create();
duke@0 1171 break;
duke@0 1172 case os::compiler_thread:
duke@0 1173 if (CompilerThreadStackSize > 0) {
duke@0 1174 stack_size = (size_t)(CompilerThreadStackSize * K);
duke@0 1175 break;
duke@0 1176 } // else fall through:
duke@0 1177 // use VMThreadStackSize if CompilerThreadStackSize is not defined
duke@0 1178 case os::vm_thread:
duke@0 1179 case os::pgc_thread:
duke@0 1180 case os::cgc_thread:
duke@0 1181 case os::watcher_thread:
duke@0 1182 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
duke@0 1183 break;
duke@0 1184 }
duke@0 1185 }
duke@0 1186 stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed);
duke@0 1187
duke@0 1188 // Initial state is ALLOCATED but not INITIALIZED
duke@0 1189 osthread->set_state(ALLOCATED);
duke@0 1190
duke@0 1191 if (os::Solaris::_os_thread_count > os::Solaris::_os_thread_limit) {
duke@0 1192 // We got lots of threads. Check if we still have some address space left.
duke@0 1193 // Need to be at least 5Mb of unreserved address space. We do check by
duke@0 1194 // trying to reserve some.
duke@0 1195 const size_t VirtualMemoryBangSize = 20*K*K;
duke@0 1196 char* mem = os::reserve_memory(VirtualMemoryBangSize);
duke@0 1197 if (mem == NULL) {
duke@0 1198 delete osthread;
duke@0 1199 return false;
duke@0 1200 } else {
duke@0 1201 // Release the memory again
duke@0 1202 os::release_memory(mem, VirtualMemoryBangSize);
duke@0 1203 }
duke@0 1204 }
duke@0 1205
duke@0 1206 // Setup osthread because the child thread may need it.
duke@0 1207 thread->set_osthread(osthread);
duke@0 1208
duke@0 1209 // Create the Solaris thread
duke@0 1210 // explicit THR_BOUND for T2_libthread case in case
duke@0 1211 // that assumption is not accurate, but our alternate signal stack
duke@0 1212 // handling is based on it which must have bound threads
duke@0 1213 thread_t tid = 0;
duke@0 1214 long flags = (UseDetachedThreads ? THR_DETACHED : 0) | THR_SUSPENDED
duke@0 1215 | ((UseBoundThreads || os::Solaris::T2_libthread() ||
duke@0 1216 (thr_type == vm_thread) ||
duke@0 1217 (thr_type == cgc_thread) ||
duke@0 1218 (thr_type == pgc_thread) ||
duke@0 1219 (thr_type == compiler_thread && BackgroundCompilation)) ?
duke@0 1220 THR_BOUND : 0);
duke@0 1221 int status;
duke@0 1222
duke@0 1223 // 4376845 -- libthread/kernel don't provide enough LWPs to utilize all CPUs.
duke@0 1224 //
duke@0 1225 // On multiprocessors systems, libthread sometimes under-provisions our
duke@0 1226 // process with LWPs. On a 30-way systems, for instance, we could have
duke@0 1227 // 50 user-level threads in ready state and only 2 or 3 LWPs assigned
duke@0 1228 // to our process. This can result in under utilization of PEs.
duke@0 1229 // I suspect the problem is related to libthread's LWP
duke@0 1230 // pool management and to the kernel's SIGBLOCKING "last LWP parked"
duke@0 1231 // upcall policy.
duke@0 1232 //
duke@0 1233 // The following code is palliative -- it attempts to ensure that our
duke@0 1234 // process has sufficient LWPs to take advantage of multiple PEs.
duke@0 1235 // Proper long-term cures include using user-level threads bound to LWPs
duke@0 1236 // (THR_BOUND) or using LWP-based synchronization. Note that there is a
duke@0 1237 // slight timing window with respect to sampling _os_thread_count, but
duke@0 1238 // the race is benign. Also, we should periodically recompute
duke@0 1239 // _processors_online as the min of SC_NPROCESSORS_ONLN and the
duke@0 1240 // the number of PEs in our partition. You might be tempted to use
duke@0 1241 // THR_NEW_LWP here, but I'd recommend against it as that could
duke@0 1242 // result in undesirable growth of the libthread's LWP pool.
duke@0 1243 // The fix below isn't sufficient; for instance, it doesn't take into count
duke@0 1244 // LWPs parked on IO. It does, however, help certain CPU-bound benchmarks.
duke@0 1245 //
duke@0 1246 // Some pathologies this scheme doesn't handle:
duke@0 1247 // * Threads can block, releasing the LWPs. The LWPs can age out.
duke@0 1248 // When a large number of threads become ready again there aren't
duke@0 1249 // enough LWPs available to service them. This can occur when the
duke@0 1250 // number of ready threads oscillates.
duke@0 1251 // * LWPs/Threads park on IO, thus taking the LWP out of circulation.
duke@0 1252 //
duke@0 1253 // Finally, we should call thr_setconcurrency() periodically to refresh
duke@0 1254 // the LWP pool and thwart the LWP age-out mechanism.
duke@0 1255 // The "+3" term provides a little slop -- we want to slightly overprovision.
duke@0 1256
duke@0 1257 if (AdjustConcurrency && os::Solaris::_os_thread_count < (_processors_online+3)) {
duke@0 1258 if (!(flags & THR_BOUND)) {
duke@0 1259 thr_setconcurrency (os::Solaris::_os_thread_count); // avoid starvation
duke@0 1260 }
duke@0 1261 }
duke@0 1262 // Although this doesn't hurt, we should warn of undefined behavior
duke@0 1263 // when using unbound T1 threads with schedctl(). This should never
duke@0 1264 // happen, as the compiler and VM threads are always created bound
duke@0 1265 DEBUG_ONLY(
duke@0 1266 if ((VMThreadHintNoPreempt || CompilerThreadHintNoPreempt) &&
duke@0 1267 (!os::Solaris::T2_libthread() && (!(flags & THR_BOUND))) &&
duke@0 1268 ((thr_type == vm_thread) || (thr_type == cgc_thread) ||
duke@0 1269 (thr_type == pgc_thread) || (thr_type == compiler_thread && BackgroundCompilation))) {
duke@0 1270 warning("schedctl behavior undefined when Compiler/VM/GC Threads are Unbound");
duke@0 1271 }
duke@0 1272 );
duke@0 1273
duke@0 1274
duke@0 1275 // Mark that we don't have an lwp or thread id yet.
duke@0 1276 // In case we attempt to set the priority before the thread starts.
duke@0 1277 osthread->set_lwp_id(-1);
duke@0 1278 osthread->set_thread_id(-1);
duke@0 1279
duke@0 1280 status = thr_create(NULL, stack_size, java_start, thread, flags, &tid);
duke@0 1281 if (status != 0) {
duke@0 1282 if (PrintMiscellaneous && (Verbose || WizardMode)) {
duke@0 1283 perror("os::create_thread");
duke@0 1284 }
duke@0 1285 thread->set_osthread(NULL);
duke@0 1286 // Need to clean up stuff we've allocated so far
duke@0 1287 delete osthread;
duke@0 1288 return false;
duke@0 1289 }
duke@0 1290
duke@0 1291 Atomic::inc(&os::Solaris::_os_thread_count);
duke@0 1292
duke@0 1293 // Store info on the Solaris thread into the OSThread
duke@0 1294 osthread->set_thread_id(tid);
duke@0 1295
duke@0 1296 // Remember that we created this thread so we can set priority on it
duke@0 1297 osthread->set_vm_created();
duke@0 1298
duke@0 1299 // Set the default thread priority otherwise use NormalPriority
duke@0 1300
duke@0 1301 if ( UseThreadPriorities ) {
duke@0 1302 thr_setprio(tid, (DefaultThreadPriority == -1) ?
duke@0 1303 java_to_os_priority[NormPriority] :
duke@0 1304 DefaultThreadPriority);
duke@0 1305 }
duke@0 1306
duke@0 1307 // Initial thread state is INITIALIZED, not SUSPENDED
duke@0 1308 osthread->set_state(INITIALIZED);
duke@0 1309
duke@0 1310 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
duke@0 1311 return true;
duke@0 1312 }
duke@0 1313
duke@0 1314 /* defined for >= Solaris 10. This allows builds on earlier versions
duke@0 1315 * of Solaris to take advantage of the newly reserved Solaris JVM signals
duke@0 1316 * With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2
duke@0 1317 * and -XX:+UseAltSigs does nothing since these should have no conflict
duke@0 1318 */
duke@0 1319 #if !defined(SIGJVM1)
duke@0 1320 #define SIGJVM1 39
duke@0 1321 #define SIGJVM2 40
duke@0 1322 #endif
duke@0 1323
duke@0 1324 debug_only(static bool signal_sets_initialized = false);
duke@0 1325 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
duke@0 1326 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;
duke@0 1327 int os::Solaris::_SIGasync = ASYNC_SIGNAL;
duke@0 1328
duke@0 1329 bool os::Solaris::is_sig_ignored(int sig) {
duke@0 1330 struct sigaction oact;
duke@0 1331 sigaction(sig, (struct sigaction*)NULL, &oact);
duke@0 1332 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
duke@0 1333 : CAST_FROM_FN_PTR(void*, oact.sa_handler);
duke@0 1334 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
duke@0 1335 return true;
duke@0 1336 else
duke@0 1337 return false;
duke@0 1338 }
duke@0 1339
duke@0 1340 // Note: SIGRTMIN is a macro that calls sysconf() so it will
duke@0 1341 // dynamically detect SIGRTMIN value for the system at runtime, not buildtime
duke@0 1342 static bool isJVM1available() {
duke@0 1343 return SIGJVM1 < SIGRTMIN;
duke@0 1344 }
duke@0 1345
duke@0 1346 void os::Solaris::signal_sets_init() {
duke@0 1347 // Should also have an assertion stating we are still single-threaded.
duke@0 1348 assert(!signal_sets_initialized, "Already initialized");
duke@0 1349 // Fill in signals that are necessarily unblocked for all threads in
duke@0 1350 // the VM. Currently, we unblock the following signals:
duke@0 1351 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
duke@0 1352 // by -Xrs (=ReduceSignalUsage));
duke@0 1353 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
duke@0 1354 // other threads. The "ReduceSignalUsage" boolean tells us not to alter
duke@0 1355 // the dispositions or masks wrt these signals.
duke@0 1356 // Programs embedding the VM that want to use the above signals for their
duke@0 1357 // own purposes must, at this time, use the "-Xrs" option to prevent
duke@0 1358 // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
duke@0 1359 // (See bug 4345157, and other related bugs).
duke@0 1360 // In reality, though, unblocking these signals is really a nop, since
duke@0 1361 // these signals are not blocked by default.
duke@0 1362 sigemptyset(&unblocked_sigs);
duke@0 1363 sigemptyset(&allowdebug_blocked_sigs);
duke@0 1364 sigaddset(&unblocked_sigs, SIGILL);
duke@0 1365 sigaddset(&unblocked_sigs, SIGSEGV);
duke@0 1366 sigaddset(&unblocked_sigs, SIGBUS);
duke@0 1367 sigaddset(&unblocked_sigs, SIGFPE);
duke@0 1368
duke@0 1369 if (isJVM1available) {
duke@0 1370 os::Solaris::set_SIGinterrupt(SIGJVM1);
duke@0 1371 os::Solaris::set_SIGasync(SIGJVM2);
duke@0 1372 } else if (UseAltSigs) {
duke@0 1373 os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL);
duke@0 1374 os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL);
duke@0 1375 } else {
duke@0 1376 os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL);
duke@0 1377 os::Solaris::set_SIGasync(ASYNC_SIGNAL);
duke@0 1378 }
duke@0 1379
duke@0 1380 sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt());
duke@0 1381 sigaddset(&unblocked_sigs, os::Solaris::SIGasync());
duke@0 1382
duke@0 1383 if (!ReduceSignalUsage) {
duke@0 1384 if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
duke@0 1385 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
duke@0 1386 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
duke@0 1387 }
duke@0 1388 if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
duke@0 1389 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
duke@0 1390 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
duke@0 1391 }
duke@0 1392 if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
duke@0 1393 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
duke@0 1394 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
duke@0 1395 }
duke@0 1396 }
duke@0 1397 // Fill in signals that are blocked by all but the VM thread.
duke@0 1398 sigemptyset(&vm_sigs);
duke@0 1399 if (!ReduceSignalUsage)
duke@0 1400 sigaddset(&vm_sigs, BREAK_SIGNAL);
duke@0 1401 debug_only(signal_sets_initialized = true);
duke@0 1402
duke@0 1403 // For diagnostics only used in run_periodic_checks
duke@0 1404 sigemptyset(&check_signal_done);
duke@0 1405 }
duke@0 1406
duke@0 1407 // These are signals that are unblocked while a thread is running Java.
duke@0 1408 // (For some reason, they get blocked by default.)
duke@0 1409 sigset_t* os::Solaris::unblocked_signals() {
duke@0 1410 assert(signal_sets_initialized, "Not initialized");
duke@0 1411 return &unblocked_sigs;
duke@0 1412 }
duke@0 1413
duke@0 1414 // These are the signals that are blocked while a (non-VM) thread is
duke@0 1415 // running Java. Only the VM thread handles these signals.
duke@0 1416 sigset_t* os::Solaris::vm_signals() {
duke@0 1417 assert(signal_sets_initialized, "Not initialized");
duke@0 1418 return &vm_sigs;
duke@0 1419 }
duke@0 1420
duke@0 1421 // These are signals that are blocked during cond_wait to allow debugger in
duke@0 1422 sigset_t* os::Solaris::allowdebug_blocked_signals() {
duke@0 1423 assert(signal_sets_initialized, "Not initialized");
duke@0 1424 return &allowdebug_blocked_sigs;
duke@0 1425 }
duke@0 1426
duke@0 1427 // First crack at OS-specific initialization, from inside the new thread.
duke@0 1428 void os::initialize_thread() {
duke@0 1429 int r = thr_main() ;
duke@0 1430 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
duke@0 1431 if (r) {
duke@0 1432 JavaThread* jt = (JavaThread *)Thread::current();
duke@0 1433 assert(jt != NULL,"Sanity check");
duke@0 1434 size_t stack_size;
duke@0 1435 address base = jt->stack_base();
duke@0 1436 if (Arguments::created_by_java_launcher()) {
duke@0 1437 // Use 2MB to allow for Solaris 7 64 bit mode.
duke@0 1438 stack_size = JavaThread::stack_size_at_create() == 0
duke@0 1439 ? 2048*K : JavaThread::stack_size_at_create();
duke@0 1440
duke@0 1441 // There are rare cases when we may have already used more than
duke@0 1442 // the basic stack size allotment before this method is invoked.
duke@0 1443 // Attempt to allow for a normally sized java_stack.
duke@0 1444 size_t current_stack_offset = (size_t)(base - (address)&stack_size);
duke@0 1445 stack_size += ReservedSpace::page_align_size_down(current_stack_offset);
duke@0 1446 } else {
duke@0 1447 // 6269555: If we were not created by a Java launcher, i.e. if we are
duke@0 1448 // running embedded in a native application, treat the primordial thread
duke@0 1449 // as much like a native attached thread as possible. This means using
duke@0 1450 // the current stack size from thr_stksegment(), unless it is too large
duke@0 1451 // to reliably setup guard pages. A reasonable max size is 8MB.
duke@0 1452 size_t current_size = current_stack_size();
duke@0 1453 // This should never happen, but just in case....
duke@0 1454 if (current_size == 0) current_size = 2 * K * K;
duke@0 1455 stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size;
duke@0 1456 }
duke@0 1457 address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());;
duke@0 1458 stack_size = (size_t)(base - bottom);
duke@0 1459
duke@0 1460 assert(stack_size > 0, "Stack size calculation problem");
duke@0 1461
duke@0 1462 if (stack_size > jt->stack_size()) {
duke@0 1463 NOT_PRODUCT(
duke@0 1464 struct rlimit limits;
duke@0 1465 getrlimit(RLIMIT_STACK, &limits);
duke@0 1466 size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur);
duke@0 1467 assert(size >= jt->stack_size(), "Stack size problem in main thread");
duke@0 1468 )
duke@0 1469 tty->print_cr(
duke@0 1470 "Stack size of %d Kb exceeds current limit of %d Kb.\n"
duke@0 1471 "(Stack sizes are rounded up to a multiple of the system page size.)\n"
duke@0 1472 "See limit(1) to increase the stack size limit.",
duke@0 1473 stack_size / K, jt->stack_size() / K);
duke@0 1474 vm_exit(1);
duke@0 1475 }
duke@0 1476 assert(jt->stack_size() >= stack_size,
duke@0 1477 "Attempt to map more stack than was allocated");
duke@0 1478 jt->set_stack_size(stack_size);
duke@0 1479 }
duke@0 1480
duke@0 1481 // 5/22/01: Right now alternate signal stacks do not handle
duke@0 1482 // throwing stack overflow exceptions, see bug 4463178
duke@0 1483 // Until a fix is found for this, T2 will NOT imply alternate signal
duke@0 1484 // stacks.
duke@0 1485 // If using T2 libthread threads, install an alternate signal stack.
duke@0 1486 // Because alternate stacks associate with LWPs on Solaris,
duke@0 1487 // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads
duke@0 1488 // we prefer to explicitly stack bang.
duke@0 1489 // If not using T2 libthread, but using UseBoundThreads any threads
duke@0 1490 // (primordial thread, jni_attachCurrentThread) we do not create,
duke@0 1491 // probably are not bound, therefore they can not have an alternate
duke@0 1492 // signal stack. Since our stack banging code is generated and
duke@0 1493 // is shared across threads, all threads must be bound to allow
duke@0 1494 // using alternate signal stacks. The alternative is to interpose
duke@0 1495 // on _lwp_create to associate an alt sig stack with each LWP,
duke@0 1496 // and this could be a problem when the JVM is embedded.
duke@0 1497 // We would prefer to use alternate signal stacks with T2
duke@0 1498 // Since there is currently no accurate way to detect T2
duke@0 1499 // we do not. Assuming T2 when running T1 causes sig 11s or assertions
duke@0 1500 // on installing alternate signal stacks
duke@0 1501
duke@0 1502
duke@0 1503 // 05/09/03: removed alternate signal stack support for Solaris
duke@0 1504 // The alternate signal stack mechanism is no longer needed to
duke@0 1505 // handle stack overflow. This is now handled by allocating
duke@0 1506 // guard pages (red zone) and stackbanging.
duke@0 1507 // Initially the alternate signal stack mechanism was removed because
duke@0 1508 // it did not work with T1 llibthread. Alternate
duke@0 1509 // signal stacks MUST have all threads bound to lwps. Applications
duke@0 1510 // can create their own threads and attach them without their being
duke@0 1511 // bound under T1. This is frequently the case for the primordial thread.
duke@0 1512 // If we were ever to reenable this mechanism we would need to
duke@0 1513 // use the dynamic check for T2 libthread.
duke@0 1514
duke@0 1515 os::Solaris::init_thread_fpu_state();
duke@0 1516 }
duke@0 1517
duke@0 1518
duke@0 1519
duke@0 1520 // Free Solaris resources related to the OSThread
duke@0 1521 void os::free_thread(OSThread* osthread) {
duke@0 1522 assert(osthread != NULL, "os::free_thread but osthread not set");
duke@0 1523
duke@0 1524
duke@0 1525 // We are told to free resources of the argument thread,
duke@0 1526 // but we can only really operate on the current thread.
duke@0 1527 // The main thread must take the VMThread down synchronously
duke@0 1528 // before the main thread exits and frees up CodeHeap
duke@0 1529 guarantee((Thread::current()->osthread() == osthread
duke@0 1530 || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread");
duke@0 1531 if (Thread::current()->osthread() == osthread) {
duke@0 1532 // Restore caller's signal mask
duke@0 1533 sigset_t sigmask = osthread->caller_sigmask();
duke@0 1534 thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);
duke@0 1535 }
duke@0 1536 delete osthread;
duke@0 1537 }
duke@0 1538
duke@0 1539 void os::pd_start_thread(Thread* thread) {
duke@0 1540 int status = thr_continue(thread->osthread()->thread_id());
duke@0 1541 assert_status(status == 0, status, "thr_continue failed");
duke@0 1542 }
duke@0 1543
duke@0 1544
duke@0 1545 intx os::current_thread_id() {
duke@0 1546 return (intx)thr_self();
duke@0 1547 }
duke@0 1548
duke@0 1549 static pid_t _initial_pid = 0;
duke@0 1550
duke@0 1551 int os::current_process_id() {
duke@0 1552 return (int)(_initial_pid ? _initial_pid : getpid());
duke@0 1553 }
duke@0 1554
duke@0 1555 int os::allocate_thread_local_storage() {
duke@0 1556 // %%% in Win32 this allocates a memory segment pointed to by a
duke@0 1557 // register. Dan Stein can implement a similar feature in
duke@0 1558 // Solaris. Alternatively, the VM can do the same thing
duke@0 1559 // explicitly: malloc some storage and keep the pointer in a
duke@0 1560 // register (which is part of the thread's context) (or keep it
duke@0 1561 // in TLS).
duke@0 1562 // %%% In current versions of Solaris, thr_self and TSD can
duke@0 1563 // be accessed via short sequences of displaced indirections.
duke@0 1564 // The value of thr_self is available as %g7(36).
duke@0 1565 // The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4),
duke@0 1566 // assuming that the current thread already has a value bound to k.
duke@0 1567 // It may be worth experimenting with such access patterns,
duke@0 1568 // and later having the parameters formally exported from a Solaris
duke@0 1569 // interface. I think, however, that it will be faster to
duke@0 1570 // maintain the invariant that %g2 always contains the
duke@0 1571 // JavaThread in Java code, and have stubs simply
duke@0 1572 // treat %g2 as a caller-save register, preserving it in a %lN.
duke@0 1573 thread_key_t tk;
duke@0 1574 if (thr_keycreate( &tk, NULL ) )
duke@0 1575 fatal1("os::allocate_thread_local_storage: thr_keycreate failed (%s)", strerror(errno));
duke@0 1576 return int(tk);
duke@0 1577 }
duke@0 1578
duke@0 1579 void os::free_thread_local_storage(int index) {
duke@0 1580 // %%% don't think we need anything here
duke@0 1581 // if ( pthread_key_delete((pthread_key_t) tk) )
duke@0 1582 // fatal("os::free_thread_local_storage: pthread_key_delete failed");
duke@0 1583 }
duke@0 1584
duke@0 1585 #define SMALLINT 32 // libthread allocate for tsd_common is a version specific
duke@0 1586 // small number - point is NO swap space available
duke@0 1587 void os::thread_local_storage_at_put(int index, void* value) {
duke@0 1588 // %%% this is used only in threadLocalStorage.cpp
duke@0 1589 if (thr_setspecific((thread_key_t)index, value)) {
duke@0 1590 if (errno == ENOMEM) {
duke@0 1591 vm_exit_out_of_memory(SMALLINT, "thr_setspecific: out of swap space");
duke@0 1592 } else {
duke@0 1593 fatal1("os::thread_local_storage_at_put: thr_setspecific failed (%s)", strerror(errno));
duke@0 1594 }
duke@0 1595 } else {
duke@0 1596 ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ;
duke@0 1597 }
duke@0 1598 }
duke@0 1599
duke@0 1600 // This function could be called before TLS is initialized, for example, when
duke@0 1601 // VM receives an async signal or when VM causes a fatal error during
duke@0 1602 // initialization. Return NULL if thr_getspecific() fails.
duke@0 1603 void* os::thread_local_storage_at(int index) {
duke@0 1604 // %%% this is used only in threadLocalStorage.cpp
duke@0 1605 void* r = NULL;
duke@0 1606 return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r;
duke@0 1607 }
duke@0 1608
duke@0 1609
duke@0 1610 const int NANOSECS_PER_MILLISECS = 1000000;
duke@0 1611 // gethrtime can move backwards if read from one cpu and then a different cpu
duke@0 1612 // getTimeNanos is guaranteed to not move backward on Solaris
duke@0 1613 // local spinloop created as faster for a CAS on an int than
duke@0 1614 // a CAS on a 64bit jlong. Also Atomic::cmpxchg for jlong is not
duke@0 1615 // supported on sparc v8 or pre supports_cx8 intel boxes.
duke@0 1616 // oldgetTimeNanos for systems which do not support CAS on 64bit jlong
duke@0 1617 // i.e. sparc v8 and pre supports_cx8 (i486) intel boxes
duke@0 1618 inline hrtime_t oldgetTimeNanos() {
duke@0 1619 int gotlock = LOCK_INVALID;
duke@0 1620 hrtime_t newtime = gethrtime();
duke@0 1621
duke@0 1622 for (;;) {
duke@0 1623 // grab lock for max_hrtime
duke@0 1624 int curlock = max_hrtime_lock;
duke@0 1625 if (curlock & LOCK_BUSY) continue;
duke@0 1626 if (gotlock = Atomic::cmpxchg(LOCK_BUSY, &max_hrtime_lock, LOCK_FREE) != LOCK_FREE) continue;
duke@0 1627 if (newtime > max_hrtime) {
duke@0 1628 max_hrtime = newtime;
duke@0 1629 } else {
duke@0 1630 newtime = max_hrtime;
duke@0 1631 }
duke@0 1632 // release lock
duke@0 1633 max_hrtime_lock = LOCK_FREE;
duke@0 1634 return newtime;
duke@0 1635 }
duke@0 1636 }
duke@0 1637 // gethrtime can move backwards if read from one cpu and then a different cpu
duke@0 1638 // getTimeNanos is guaranteed to not move backward on Solaris
duke@0 1639 inline hrtime_t getTimeNanos() {
duke@0 1640 if (VM_Version::supports_cx8()) {
duke@0 1641 bool retry = false;
duke@0 1642 hrtime_t newtime = gethrtime();
duke@0 1643 hrtime_t oldmaxtime = max_hrtime;
duke@0 1644 hrtime_t retmaxtime = oldmaxtime;
duke@0 1645 while ((newtime > retmaxtime) && (retry == false || retmaxtime != oldmaxtime)) {
duke@0 1646 oldmaxtime = retmaxtime;
duke@0 1647 retmaxtime = Atomic::cmpxchg(newtime, (volatile jlong *)&max_hrtime, oldmaxtime);
duke@0 1648 retry = true;
duke@0 1649 }
duke@0 1650 return (newtime > retmaxtime) ? newtime : retmaxtime;
duke@0 1651 } else {
duke@0 1652 return oldgetTimeNanos();
duke@0 1653 }
duke@0 1654 }
duke@0 1655
duke@0 1656 // Time since start-up in seconds to a fine granularity.
duke@0 1657 // Used by VMSelfDestructTimer and the MemProfiler.
duke@0 1658 double os::elapsedTime() {
duke@0 1659 return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz;
duke@0 1660 }
duke@0 1661
duke@0 1662 jlong os::elapsed_counter() {
duke@0 1663 return (jlong)(getTimeNanos() - first_hrtime);
duke@0 1664 }
duke@0 1665
duke@0 1666 jlong os::elapsed_frequency() {
duke@0 1667 return hrtime_hz;
duke@0 1668 }
duke@0 1669
duke@0 1670 // Return the real, user, and system times in seconds from an
duke@0 1671 // arbitrary fixed point in the past.
duke@0 1672 bool os::getTimesSecs(double* process_real_time,
duke@0 1673 double* process_user_time,
duke@0 1674 double* process_system_time) {
duke@0 1675 struct tms ticks;
duke@0 1676 clock_t real_ticks = times(&ticks);
duke@0 1677
duke@0 1678 if (real_ticks == (clock_t) (-1)) {
duke@0 1679 return false;
duke@0 1680 } else {
duke@0 1681 double ticks_per_second = (double) clock_tics_per_sec;
duke@0 1682 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
duke@0 1683 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
duke@0 1684 // For consistency return the real time from getTimeNanos()
duke@0 1685 // converted to seconds.
duke@0 1686 *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS);
duke@0 1687
duke@0 1688 return true;
duke@0 1689 }
duke@0 1690 }
duke@0 1691
ysr@342 1692 bool os::supports_vtime() { return true; }
ysr@342 1693
ysr@342 1694 bool os::enable_vtime() {
ysr@342 1695 int fd = open("/proc/self/ctl", O_WRONLY);
ysr@342 1696 if (fd == -1)
ysr@342 1697 return false;
ysr@342 1698
ysr@342 1699 long cmd[] = { PCSET, PR_MSACCT };
ysr@342 1700 int res = write(fd, cmd, sizeof(long) * 2);
ysr@342 1701 close(fd);
ysr@342 1702 if (res != sizeof(long) * 2)
ysr@342 1703 return false;
ysr@342 1704
ysr@342 1705 return true;
ysr@342 1706 }
ysr@342 1707
ysr@342 1708 bool os::vtime_enabled() {
ysr@342 1709 int fd = open("/proc/self/status", O_RDONLY);
ysr@342 1710 if (fd == -1)
ysr@342 1711 return false;
ysr@342 1712
ysr@342 1713 pstatus_t status;
ysr@342 1714 int res = read(fd, (void*) &status, sizeof(pstatus_t));
ysr@342 1715 close(fd);
ysr@342 1716 if (res != sizeof(pstatus_t))
ysr@342 1717 return false;
ysr@342 1718
ysr@342 1719 return status.pr_flags & PR_MSACCT;
ysr@342 1720 }
ysr@342 1721
ysr@342 1722 double os::elapsedVTime() {
ysr@342 1723 return (double)gethrvtime() / (double)hrtime_hz;
ysr@342 1724 }
ysr@342 1725
duke@0 1726 // Used internally for comparisons only
duke@0 1727 // getTimeMillis guaranteed to not move backwards on Solaris
duke@0 1728 jlong getTimeMillis() {
duke@0 1729 jlong nanotime = getTimeNanos();
duke@0 1730 return (jlong)(nanotime / NANOSECS_PER_MILLISECS);
duke@0 1731 }
duke@0 1732
sbohne@61 1733 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis
sbohne@61 1734 jlong os::javaTimeMillis() {
duke@0 1735 timeval t;
duke@0 1736 if (gettimeofday( &t, NULL) == -1)
sbohne@61 1737 fatal1("os::javaTimeMillis: gettimeofday (%s)", strerror(errno));
duke@0 1738 return jlong(t.tv_sec) * 1000 + jlong(t.tv_usec) / 1000;
duke@0 1739 }
duke@0 1740
duke@0 1741 jlong os::javaTimeNanos() {
duke@0 1742 return (jlong)getTimeNanos();
duke@0 1743 }
duke@0 1744
duke@0 1745 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
duke@0 1746 info_ptr->max_value = ALL_64_BITS; // gethrtime() uses all 64 bits
duke@0 1747 info_ptr->may_skip_backward = false; // not subject to resetting or drifting
duke@0 1748 info_ptr->may_skip_forward = false; // not subject to resetting or drifting
duke@0 1749 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time
duke@0 1750 }
duke@0 1751
duke@0 1752 char * os::local_time_string(char *buf, size_t buflen) {
duke@0 1753 struct tm t;
duke@0 1754 time_t long_time;
duke@0 1755 time(&long_time);
duke@0 1756 localtime_r(&long_time, &t);
duke@0 1757 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
duke@0 1758 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
duke@0 1759 t.tm_hour, t.tm_min, t.tm_sec);
duke@0 1760 return buf;
duke@0 1761 }
duke@0 1762
duke@0 1763 // Note: os::shutdown() might be called very early during initialization, or
duke@0 1764 // called from signal handler. Before adding something to os::shutdown(), make
duke@0 1765 // sure it is async-safe and can handle partially initialized VM.
duke@0 1766 void os::shutdown() {
duke@0 1767
duke@0 1768 // allow PerfMemory to attempt cleanup of any persistent resources
duke@0 1769 perfMemory_exit();
duke@0 1770
duke@0 1771 // needs to remove object in file system
duke@0 1772 AttachListener::abort();
duke@0 1773
duke@0 1774 // flush buffered output, finish log files
duke@0 1775 ostream_abort();
duke@0 1776
duke@0 1777 // Check for abort hook
duke@0 1778 abort_hook_t abort_hook = Arguments::abort_hook();
duke@0 1779 if (abort_hook != NULL) {
duke@0 1780 abort_hook();
duke@0 1781 }
duke@0 1782 }
duke@0 1783
duke@0 1784 // Note: os::abort() might be called very early during initialization, or
duke@0 1785 // called from signal handler. Before adding something to os::abort(), make
duke@0 1786 // sure it is async-safe and can handle partially initialized VM.
duke@0 1787 void os::abort(bool dump_core) {
duke@0 1788 os::shutdown();
duke@0 1789 if (dump_core) {
duke@0 1790 #ifndef PRODUCT
duke@0 1791 fdStream out(defaultStream::output_fd());
duke@0 1792 out.print_raw("Current thread is ");
duke@0 1793 char buf[16];
duke@0 1794 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
duke@0 1795 out.print_raw_cr(buf);
duke@0 1796 out.print_raw_cr("Dumping core ...");
duke@0 1797 #endif
duke@0 1798 ::abort(); // dump core (for debugging)
duke@0 1799 }
duke@0 1800
duke@0 1801 ::exit(1);
duke@0 1802 }
duke@0 1803
duke@0 1804 // Die immediately, no exit hook, no abort hook, no cleanup.
duke@0 1805 void os::die() {
duke@0 1806 _exit(-1);
duke@0 1807 }
duke@0 1808
duke@0 1809 // unused
duke@0 1810 void os::set_error_file(const char *logfile) {}
duke@0 1811
duke@0 1812 // DLL functions
duke@0 1813
duke@0 1814 const char* os::dll_file_extension() { return ".so"; }
duke@0 1815
duke@0 1816 const char* os::get_temp_directory() { return "/tmp/"; }
duke@0 1817
kamg@242 1818 void os::dll_build_name(
kamg@242 1819 char* buffer, size_t buflen, const char* pname, const char* fname) {
kamg@242 1820 // copied from libhpi
kamg@242 1821 const size_t pnamelen = pname ? strlen(pname) : 0;
kamg@242 1822
kamg@242 1823 /* Quietly truncate on buffer overflow. Should be an error. */
kamg@242 1824 if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
kamg@242 1825 *buffer = '\0';
kamg@242 1826 return;
kamg@242 1827 }
kamg@242 1828
kamg@242 1829 if (pnamelen == 0) {
kamg@242 1830 sprintf(buffer, "lib%s.so", fname);
kamg@242 1831 } else {
kamg@242 1832 sprintf(buffer, "%s/lib%s.so", pname, fname);
kamg@242 1833 }
kamg@242 1834 }
kamg@242 1835
duke@0 1836 const char* os::get_current_directory(char *buf, int buflen) {
duke@0 1837 return getcwd(buf, buflen);
duke@0 1838 }
duke@0 1839
duke@0 1840 // check if addr is inside libjvm[_g].so
duke@0 1841 bool os::address_is_in_vm(address addr) {
duke@0 1842 static address libjvm_base_addr;
duke@0 1843 Dl_info dlinfo;
duke@0 1844
duke@0 1845 if (libjvm_base_addr == NULL) {
duke@0 1846 dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo);
duke@0 1847 libjvm_base_addr = (address)dlinfo.dli_fbase;
duke@0 1848 assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");
duke@0 1849 }
duke@0 1850
duke@0 1851 if (dladdr((void *)addr, &dlinfo)) {
duke@0 1852 if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;
duke@0 1853 }
duke@0 1854
duke@0 1855 return false;
duke@0 1856 }
duke@0 1857
duke@0 1858 typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int);
duke@0 1859 static dladdr1_func_type dladdr1_func = NULL;
duke@0 1860
duke@0 1861 bool os::dll_address_to_function_name(address addr, char *buf,
duke@0 1862 int buflen, int * offset) {
duke@0 1863 Dl_info dlinfo;
duke@0 1864
duke@0 1865 // dladdr1_func was initialized in os::init()
duke@0 1866 if (dladdr1_func){
duke@0 1867 // yes, we have dladdr1
duke@0 1868
duke@0 1869 // Support for dladdr1 is checked at runtime; it may be
duke@0 1870 // available even if the vm is built on a machine that does
duke@0 1871 // not have dladdr1 support. Make sure there is a value for
duke@0 1872 // RTLD_DL_SYMENT.
duke@0 1873 #ifndef RTLD_DL_SYMENT
duke@0 1874 #define RTLD_DL_SYMENT 1
duke@0 1875 #endif
duke@0 1876 Sym * info;
duke@0 1877 if (dladdr1_func((void *)addr, &dlinfo, (void **)&info,
duke@0 1878 RTLD_DL_SYMENT)) {
duke@0 1879 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);
duke@0 1880 if (offset) *offset = addr - (address)dlinfo.dli_saddr;
duke@0 1881
duke@0 1882 // check if the returned symbol really covers addr
duke@0 1883 return ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr);
duke@0 1884 } else {
duke@0 1885 if (buf) buf[0] = '\0';
duke@0 1886 if (offset) *offset = -1;
duke@0 1887 return false;
duke@0 1888 }
duke@0 1889 } else {
duke@0 1890 // no, only dladdr is available
duke@0 1891 if(dladdr((void *)addr, &dlinfo)) {
duke@0 1892 if (buf) jio_snprintf(buf, buflen, dlinfo.dli_sname);
duke@0 1893 if (offset) *offset = addr - (address)dlinfo.dli_saddr;
duke@0 1894 return true;
duke@0 1895 } else {
duke@0 1896 if (buf) buf[0] = '\0';
duke@0 1897 if (offset) *offset = -1;
duke@0 1898 return false;
duke@0 1899 }
duke@0 1900 }
duke@0 1901 }
duke@0 1902
duke@0 1903 bool os::dll_address_to_library_name(address addr, char* buf,
duke@0 1904 int buflen, int* offset) {
duke@0 1905 Dl_info dlinfo;
duke@0 1906
duke@0 1907 if (dladdr((void*)addr, &dlinfo)){
duke@0 1908 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
duke@0 1909 if (offset) *offset = addr - (address)dlinfo.dli_fbase;
duke@0 1910 return true;
duke@0 1911 } else {
duke@0 1912 if (buf) buf[0] = '\0';
duke@0 1913 if (offset) *offset = -1;
duke@0 1914 return false;
duke@0 1915 }
duke@0 1916 }
duke@0 1917
duke@0 1918 // Prints the names and full paths of all opened dynamic libraries
duke@0 1919 // for current process
duke@0 1920 void os::print_dll_info(outputStream * st) {
duke@0 1921 Dl_info dli;
duke@0 1922 void *handle;
duke@0 1923 Link_map *map;
duke@0 1924 Link_map *p;
duke@0 1925
duke@0 1926 st->print_cr("Dynamic libraries:"); st->flush();
duke@0 1927
duke@0 1928 if (!dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli)) {
duke@0 1929 st->print_cr("Error: Cannot print dynamic libraries.");
duke@0 1930 return;
duke@0 1931 }
duke@0 1932 handle = dlopen(dli.dli_fname, RTLD_LAZY);
duke@0 1933 if (handle == NULL) {
duke@0 1934 st->print_cr("Error: Cannot print dynamic libraries.");
duke@0 1935 return;
duke@0 1936 }
duke@0 1937 dlinfo(handle, RTLD_DI_LINKMAP, &map);
duke@0 1938 if (map == NULL) {
duke@0 1939 st->print_cr("Error: Cannot print dynamic libraries.");
duke@0 1940 return;
duke@0 1941 }
duke@0 1942
duke@0 1943 while (map->l_prev != NULL)
duke@0 1944 map = map->l_prev;
duke@0 1945
duke@0 1946 while (map != NULL) {
duke@0 1947 st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);
duke@0 1948 map = map->l_next;
duke@0 1949 }
duke@0 1950
duke@0 1951 dlclose(handle);
duke@0 1952 }
duke@0 1953
duke@0 1954 // Loads .dll/.so and
duke@0 1955 // in case of error it checks if .dll/.so was built for the
duke@0 1956 // same architecture as Hotspot is running on
duke@0 1957
duke@0 1958 void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
duke@0 1959 {
duke@0 1960 void * result= ::dlopen(filename, RTLD_LAZY);
duke@0 1961 if (result != NULL) {
duke@0 1962 // Successful loading
duke@0 1963 return result;
duke@0 1964 }
duke@0 1965
duke@0 1966 Elf32_Ehdr elf_head;
duke@0 1967
duke@0 1968 // Read system error message into ebuf
duke@0 1969 // It may or may not be overwritten below
duke@0 1970 ::strncpy(ebuf, ::dlerror(), ebuflen-1);
duke@0 1971 ebuf[ebuflen-1]='\0';
duke@0 1972 int diag_msg_max_length=ebuflen-strlen(ebuf);
duke@0 1973 char* diag_msg_buf=ebuf+strlen(ebuf);
duke@0 1974
duke@0 1975 if (diag_msg_max_length==0) {
duke@0 1976 // No more space in ebuf for additional diagnostics message
duke@0 1977 return NULL;
duke@0 1978 }
duke@0 1979
duke@0 1980
duke@0 1981 int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);
duke@0 1982
duke@0 1983 if (file_descriptor < 0) {
duke@0 1984 // Can't open library, report dlerror() message
duke@0 1985 return NULL;
duke@0 1986 }
duke@0 1987
duke@0 1988 bool failed_to_read_elf_head=
duke@0 1989 (sizeof(elf_head)!=
duke@0 1990 (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
duke@0 1991
duke@0 1992 ::close(file_descriptor);
duke@0 1993 if (failed_to_read_elf_head) {
duke@0 1994 // file i/o error - report dlerror() msg
duke@0 1995 return NULL;
duke@0 1996 }
duke@0 1997
duke@0 1998 typedef struct {
duke@0 1999 Elf32_Half code; // Actual value as defined in elf.h
duke@0 2000 Elf32_Half compat_class; // Compatibility of archs at VM's sense
duke@0 2001 char elf_class; // 32 or 64 bit
duke@0 2002 char endianess; // MSB or LSB
duke@0 2003 char* name; // String representation
duke@0 2004 } arch_t;
duke@0 2005
duke@0 2006 static const arch_t arch_array[]={
duke@0 2007 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
duke@0 2008 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
duke@0 2009 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
duke@0 2010 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
duke@0 2011 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
duke@0 2012 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
duke@0 2013 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
duke@0 2014 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
duke@0 2015 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"}
duke@0 2016 };
duke@0 2017
duke@0 2018 #if (defined IA32)
duke@0 2019 static Elf32_Half running_arch_code=EM_386;
duke@0 2020 #elif (defined AMD64)
duke@0 2021 static Elf32_Half running_arch_code=EM_X86_64;
duke@0 2022 #elif (defined IA64)
duke@0 2023 static Elf32_Half running_arch_code=EM_IA_64;
duke@0 2024 #elif (defined __sparc) && (defined _LP64)
duke@0 2025 static Elf32_Half running_arch_code=EM_SPARCV9;
duke@0 2026 #elif (defined __sparc) && (!defined _LP64)
duke@0 2027 static Elf32_Half running_arch_code=EM_SPARC;
duke@0 2028 #elif (defined __powerpc64__)
duke@0 2029 static Elf32_Half running_arch_code=EM_PPC64;
duke@0 2030 #elif (defined __powerpc__)
duke@0 2031 static Elf32_Half running_arch_code=EM_PPC;
duke@0 2032 #else
duke@0 2033 #error Method os::dll_load requires that one of following is defined:\
duke@0 2034 IA32, AMD64, IA64, __sparc, __powerpc__
duke@0 2035 #endif
duke@0 2036
duke@0 2037 // Identify compatability class for VM's architecture and library's architecture
duke@0 2038 // Obtain string descriptions for architectures
duke@0 2039
duke@0 2040 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
duke@0 2041 int running_arch_index=-1;
duke@0 2042
duke@0 2043 for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
duke@0 2044 if (running_arch_code == arch_array[i].code) {
duke@0 2045 running_arch_index = i;
duke@0 2046 }
duke@0 2047 if (lib_arch.code == arch_array[i].code) {
duke@0 2048 lib_arch.compat_class = arch_array[i].compat_class;
duke@0 2049 lib_arch.name = arch_array[i].name;
duke@0 2050 }
duke@0 2051 }
duke@0 2052
duke@0 2053 assert(running_arch_index != -1,
duke@0 2054 "Didn't find running architecture code (running_arch_code) in arch_array");
duke@0 2055 if (running_arch_index == -1) {
duke@0 2056 // Even though running architecture detection failed
duke@0 2057 // we may still continue with reporting dlerror() message
duke@0 2058 return NULL;
duke@0 2059 }
duke@0 2060
duke@0 2061 if (lib_arch.endianess != arch_array[running_arch_index].endianess) {
duke@0 2062 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");
duke@0 2063 return NULL;
duke@0 2064 }
duke@0 2065
duke@0 2066 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {
duke@0 2067 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");
duke@0 2068 return NULL;
duke@0 2069 }
duke@0 2070
duke@0 2071 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
duke@0 2072 if ( lib_arch.name!=NULL ) {
duke@0 2073 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
duke@0 2074 " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
duke@0 2075 lib_arch.name, arch_array[running_arch_index].name);
duke@0 2076 } else {
duke@0 2077 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
duke@0 2078 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
duke@0 2079 lib_arch.code,
duke@0 2080 arch_array[running_arch_index].name);
duke@0 2081 }
duke@0 2082 }
duke@0 2083
duke@0 2084 return NULL;
duke@0 2085 }
duke@0 2086
kamg@242 2087 void* os::dll_lookup(void* handle, const char* name) {
kamg@242 2088 return dlsym(handle, name);
kamg@242 2089 }
duke@0 2090
duke@0 2091
duke@0 2092 bool _print_ascii_file(const char* filename, outputStream* st) {
duke@0 2093 int fd = open(filename, O_RDONLY);
duke@0 2094 if (fd == -1) {
duke@0 2095 return false;
duke@0 2096 }
duke@0 2097
duke@0 2098 char buf[32];
duke@0 2099 int bytes;
duke@0 2100 while ((bytes = read(fd, buf, sizeof(buf))) > 0) {
duke@0 2101 st->print_raw(buf, bytes);
duke@0 2102 }
duke@0 2103
duke@0 2104 close(fd);
duke@0 2105
duke@0 2106 return true;
duke@0 2107 }
duke@0 2108
duke@0 2109 void os::print_os_info(outputStream* st) {
duke@0 2110 st->print("OS:");
duke@0 2111
duke@0 2112 if (!_print_ascii_file("/etc/release", st)) {
duke@0 2113 st->print("Solaris");
duke@0 2114 }
duke@0 2115 st->cr();
duke@0 2116
duke@0 2117 // kernel
duke@0 2118 st->print("uname:");
duke@0 2119 struct utsname name;
duke@0 2120 uname(&name);
duke@0 2121 st->print(name.sysname); st->print(" ");
duke@0 2122 st->print(name.release); st->print(" ");
duke@0 2123 st->print(name.version); st->print(" ");
duke@0 2124 st->print(name.machine);
duke@0 2125
duke@0 2126 // libthread
duke@0 2127 if (os::Solaris::T2_libthread()) st->print(" (T2 libthread)");
duke@0 2128 else st->print(" (T1 libthread)");
duke@0 2129 st->cr();
duke@0 2130
duke@0 2131 // rlimit
duke@0 2132 st->print("rlimit:");
duke@0 2133 struct rlimit rlim;
duke@0 2134
duke@0 2135 st->print(" STACK ");
duke@0 2136 getrlimit(RLIMIT_STACK, &rlim);
duke@0 2137 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
duke@0 2138 else st->print("%uk", rlim.rlim_cur >> 10);
duke@0 2139
duke@0 2140 st->print(", CORE ");
duke@0 2141 getrlimit(RLIMIT_CORE, &rlim);
duke@0 2142 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
duke@0 2143 else st->print("%uk", rlim.rlim_cur >> 10);
duke@0 2144
duke@0 2145 st->print(", NOFILE ");
duke@0 2146 getrlimit(RLIMIT_NOFILE, &rlim);
duke@0 2147 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
duke@0 2148 else st->print("%d", rlim.rlim_cur);
duke@0 2149
duke@0 2150 st->print(", AS ");
duke@0 2151 getrlimit(RLIMIT_AS, &rlim);
duke@0 2152 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
duke@0 2153 else st->print("%uk", rlim.rlim_cur >> 10);
duke@0 2154 st->cr();
duke@0 2155
duke@0 2156 // load average
duke@0 2157 st->print("load average:");
duke@0 2158 double loadavg[3];
duke@0 2159 os::loadavg(loadavg, 3);
duke@0 2160 st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
duke@0 2161 st->cr();
duke@0 2162 }
duke@0 2163
duke@0 2164
duke@0 2165 static bool check_addr0(outputStream* st) {
duke@0 2166 jboolean status = false;
duke@0 2167 int fd = open("/proc/self/map",O_RDONLY);
duke@0 2168 if (fd >= 0) {
duke@0 2169 prmap_t p;
duke@0 2170 while(read(fd, &p, sizeof(p)) > 0) {
duke@0 2171 if (p.pr_vaddr == 0x0) {
duke@0 2172 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);
duke@0 2173 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);
duke@0 2174 st->print("Access:");
duke@0 2175 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-");
duke@0 2176 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-");
duke@0 2177 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-");
duke@0 2178 st->cr();
duke@0 2179 status = true;
duke@0 2180 }
duke@0 2181 close(fd);
duke@0 2182 }
duke@0 2183 }
duke@0 2184 return status;
duke@0 2185 }
duke@0 2186
duke@0 2187 void os::print_memory_info(outputStream* st) {
duke@0 2188 st->print("Memory:");
duke@0 2189 st->print(" %dk page", os::vm_page_size()>>10);
duke@0 2190 st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10);
duke@0 2191 st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10);
duke@0 2192 st->cr();
duke@0 2193 (void) check_addr0(st);
duke@0 2194 }
duke@0 2195
duke@0 2196 // Taken from /usr/include/sys/machsig.h Supposed to be architecture specific
duke@0 2197 // but they're the same for all the solaris architectures that we support.
duke@0 2198 const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",
duke@0 2199 "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",
duke@0 2200 "ILL_COPROC", "ILL_BADSTK" };
duke@0 2201
duke@0 2202 const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",
duke@0 2203 "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",
duke@0 2204 "FPE_FLTINV", "FPE_FLTSUB" };
duke@0 2205
duke@0 2206 const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };
duke@0 2207
duke@0 2208 const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };
duke@0 2209
duke@0 2210 void os::print_siginfo(outputStream* st, void* siginfo) {
duke@0 2211 st->print("siginfo:");
duke@0 2212
duke@0 2213 const int buflen = 100;
duke@0 2214 char buf[buflen];
duke@0 2215 siginfo_t *si = (siginfo_t*)siginfo;
duke@0 2216 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
duke@0 2217 char *err = strerror(si->si_errno);
duke@0 2218 if (si->si_errno != 0 && err != NULL) {
duke@0 2219 st->print("si_errno=%s", err);
duke@0 2220 } else {
duke@0 2221 st->print("si_errno=%d", si->si_errno);
duke@0 2222 }
duke@0 2223 const int c = si->si_code;
duke@0 2224 assert(c > 0, "unexpected si_code");
duke@0 2225 switch (si->si_signo) {
duke@0 2226 case SIGILL:
duke@0 2227 st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);
duke@0 2228 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
duke@0 2229 break;
duke@0 2230 case SIGFPE:
duke@0 2231 st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);
duke@0 2232 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
duke@0 2233 break;
duke@0 2234 case SIGSEGV:
duke@0 2235 st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);
duke@0 2236 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
duke@0 2237 break;
duke@0 2238 case SIGBUS:
duke@0 2239 st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);
duke@0 2240 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
duke@0 2241 break;
duke@0 2242 default:
duke@0 2243 st->print(", si_code=%d", si->si_code);
duke@0 2244 // no si_addr
duke@0 2245 }
duke@0 2246
duke@0 2247 if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
duke@0 2248 UseSharedSpaces) {
duke@0 2249 FileMapInfo* mapinfo = FileMapInfo::current_info();
duke@0 2250 if (mapinfo->is_in_shared_space(si->si_addr)) {
duke@0 2251 st->print("\n\nError accessing class data sharing archive." \
duke@0 2252 " Mapped file inaccessible during execution, " \
duke@0 2253 " possible disk/network problem.");
duke@0 2254 }
duke@0 2255 }
duke@0 2256 st->cr();
duke@0 2257 }
duke@0 2258
duke@0 2259 // Moved from whole group, because we need them here for diagnostic
duke@0 2260 // prints.
duke@0 2261 #define OLDMAXSIGNUM 32
duke@0 2262 static int Maxsignum = 0;
duke@0 2263 static int *ourSigFlags = NULL;
duke@0 2264
duke@0 2265 extern "C" void sigINTRHandler(int, siginfo_t*, void*);
duke@0 2266
duke@0 2267 int os::Solaris::get_our_sigflags(int sig) {
duke@0 2268 assert(ourSigFlags!=NULL, "signal data structure not initialized");
duke@0 2269 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
duke@0 2270 return ourSigFlags[sig];
duke@0 2271 }
duke@0 2272
duke@0 2273 void os::Solaris::set_our_sigflags(int sig, int flags) {
duke@0 2274 assert(ourSigFlags!=NULL, "signal data structure not initialized");
duke@0 2275 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
duke@0 2276 ourSigFlags[sig] = flags;
duke@0 2277 }
duke@0 2278
duke@0 2279
duke@0 2280 static const char* get_signal_handler_name(address handler,
duke@0 2281 char* buf, int buflen) {
duke@0 2282 int offset;
duke@0 2283 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
duke@0 2284 if (found) {
duke@0 2285 // skip directory names
duke@0 2286 const char *p1, *p2;
duke@0 2287 p1 = buf;
duke@0 2288 size_t len = strlen(os::file_separator());
duke@0 2289 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
duke@0 2290 jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);
duke@0 2291 } else {
duke@0 2292 jio_snprintf(buf, buflen, PTR_FORMAT, handler);
duke@0 2293 }
duke@0 2294 return buf;
duke@0 2295 }
duke@0 2296
duke@0 2297 static void print_signal_handler(outputStream* st, int sig,
duke@0 2298 char* buf, size_t buflen) {
duke@0 2299 struct sigaction sa;
duke@0 2300
duke@0 2301 sigaction(sig, NULL, &sa);
duke@0 2302
duke@0 2303 st->print("%s: ", os::exception_name(sig, buf, buflen));
duke@0 2304
duke@0 2305 address handler = (sa.sa_flags & SA_SIGINFO)
duke@0 2306 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
duke@0 2307 : CAST_FROM_FN_PTR(address, sa.sa_handler);
duke@0 2308
duke@0 2309 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
duke@0 2310 st->print("SIG_DFL");
duke@0 2311 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
duke@0 2312 st->print("SIG_IGN");
duke@0 2313 } else {
duke@0 2314 st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
duke@0 2315 }
duke@0 2316
duke@0 2317 st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);
duke@0 2318
duke@0 2319 address rh = VMError::get_resetted_sighandler(sig);
duke@0 2320 // May be, handler was resetted by VMError?
duke@0 2321 if(rh != NULL) {
duke@0 2322 handler = rh;
duke@0 2323 sa.sa_flags = VMError::get_resetted_sigflags(sig);
duke@0 2324 }
duke@0 2325
duke@0 2326 st->print(", sa_flags=" PTR32_FORMAT, sa.sa_flags);
duke@0 2327
duke@0 2328 // Check: is it our handler?
duke@0 2329 if(handler == CAST_FROM_FN_PTR(address, signalHandler) ||
duke@0 2330 handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {
duke@0 2331 // It is our signal handler
duke@0 2332 // check for flags
duke@0 2333 if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
duke@0 2334 st->print(
duke@0 2335 ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
duke@0 2336 os::Solaris::get_our_sigflags(sig));
duke@0 2337 }
duke@0 2338 }
duke@0 2339 st->cr();
duke@0 2340 }
duke@0 2341
duke@0 2342 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
duke@0 2343 st->print_cr("Signal Handlers:");
duke@0 2344 print_signal_handler(st, SIGSEGV, buf, buflen);
duke@0 2345 print_signal_handler(st, SIGBUS , buf, buflen);
duke@0 2346 print_signal_handler(st, SIGFPE , buf, buflen);
duke@0 2347 print_signal_handler(st, SIGPIPE, buf, buflen);
duke@0 2348 print_signal_handler(st, SIGXFSZ, buf, buflen);
duke@0 2349 print_signal_handler(st, SIGILL , buf, buflen);
duke@0 2350 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
duke@0 2351 print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);
duke@0 2352 print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
duke@0 2353 print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);
duke@0 2354 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
duke@0 2355 print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);
duke@0 2356 print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);
duke@0 2357 print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);
duke@0 2358 }
duke@0 2359
duke@0 2360 static char saved_jvm_path[MAXPATHLEN] = { 0 };
duke@0 2361
duke@0 2362 // Find the full path to the current module, libjvm.so or libjvm_g.so
duke@0 2363 void os::jvm_path(char *buf, jint buflen) {
duke@0 2364 // Error checking.
duke@0 2365 if (buflen < MAXPATHLEN) {
duke@0 2366 assert(false, "must use a large-enough buffer");
duke@0 2367 buf[0] = '\0';
duke@0 2368 return;
duke@0 2369 }
duke@0 2370 // Lazy resolve the path to current module.
duke@0 2371 if (saved_jvm_path[0] != 0) {
duke@0 2372 strcpy(buf, saved_jvm_path);
duke@0 2373 return;
duke@0 2374 }
duke@0 2375
duke@0 2376 Dl_info dlinfo;
duke@0 2377 int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
duke@0 2378 assert(ret != 0, "cannot locate libjvm");
duke@0 2379 realpath((char *)dlinfo.dli_fname, buf);
duke@0 2380
duke@0 2381 if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) {
duke@0 2382 // Support for the gamma launcher. Typical value for buf is
duke@0 2383 // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at
duke@0 2384 // the right place in the string, then assume we are installed in a JDK and
duke@0 2385 // we're done. Otherwise, check for a JAVA_HOME environment variable and fix
duke@0 2386 // up the path so it looks like libjvm.so is installed there (append a
duke@0 2387 // fake suffix hotspot/libjvm.so).
duke@0 2388 const char *p = buf + strlen(buf) - 1;
duke@0 2389 for (int count = 0; p > buf && count < 5; ++count) {
duke@0 2390 for (--p; p > buf && *p != '/'; --p)
duke@0 2391 /* empty */ ;
duke@0 2392 }
duke@0 2393
duke@0 2394 if (strncmp(p, "/jre/lib/", 9) != 0) {
duke@0 2395 // Look for JAVA_HOME in the environment.
duke@0 2396 char* java_home_var = ::getenv("JAVA_HOME");
duke@0 2397 if (java_home_var != NULL && java_home_var[0] != 0) {
duke@0 2398 char cpu_arch[12];
duke@0 2399 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
duke@0 2400 #ifdef _LP64
duke@0 2401 // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.
duke@0 2402 if (strcmp(cpu_arch, "sparc") == 0) {
duke@0 2403 strcat(cpu_arch, "v9");
duke@0 2404 } else if (strcmp(cpu_arch, "i386") == 0) {
duke@0 2405 strcpy(cpu_arch, "amd64");
duke@0 2406 }
duke@0 2407 #endif
duke@0 2408 // Check the current module name "libjvm.so" or "libjvm_g.so".
duke@0 2409 p = strrchr(buf, '/');
duke@0 2410 assert(strstr(p, "/libjvm") == p, "invalid library name");
duke@0 2411 p = strstr(p, "_g") ? "_g" : "";
duke@0 2412
duke@0 2413 realpath(java_home_var, buf);
duke@0 2414 sprintf(buf + strlen(buf), "/jre/lib/%s", cpu_arch);
duke@0 2415 if (0 == access(buf, F_OK)) {
duke@0 2416 // Use current module name "libjvm[_g].so" instead of
duke@0 2417 // "libjvm"debug_only("_g")".so" since for fastdebug version
duke@0 2418 // we should have "libjvm.so" but debug_only("_g") adds "_g"!
duke@0 2419 // It is used when we are choosing the HPI library's name
duke@0 2420 // "libhpi[_g].so" in hpi::initialize_get_interface().
duke@0 2421 sprintf(buf + strlen(buf), "/hotspot/libjvm%s.so", p);
duke@0 2422 } else {
duke@0 2423 // Go back to path of .so
duke@0 2424 realpath((char *)dlinfo.dli_fname, buf);
duke@0 2425 }
duke@0 2426 }
duke@0 2427 }
duke@0 2428 }
duke@0 2429
duke@0 2430 strcpy(saved_jvm_path, buf);
duke@0 2431 }
duke@0 2432
duke@0 2433
duke@0 2434 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
duke@0 2435 // no prefix required, not even "_"
duke@0 2436 }
duke@0 2437
duke@0 2438
duke@0 2439 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
duke@0 2440 // no suffix required
duke@0 2441 }
duke@0 2442
duke@0 2443
duke@0 2444 // sun.misc.Signal
duke@0 2445
duke@0 2446 extern "C" {
duke@0 2447 static void UserHandler(int sig, void *siginfo, void *context) {
duke@0 2448 // Ctrl-C is pressed during error reporting, likely because the error
duke@0 2449 // handler fails to abort. Let VM die immediately.
duke@0 2450 if (sig == SIGINT && is_error_reported()) {
duke@0 2451 os::die();
duke@0 2452 }
duke@0 2453
duke@0 2454 os::signal_notify(sig);
duke@0 2455 // We do not need to reinstate the signal handler each time...
duke@0 2456 }
duke@0 2457 }
duke@0 2458
duke@0 2459 void* os::user_handler() {
duke@0 2460 return CAST_FROM_FN_PTR(void*, UserHandler);
duke@0 2461 }
duke@0 2462
duke@0 2463 extern "C" {
duke@0 2464 typedef void (*sa_handler_t)(int);
duke@0 2465 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
duke@0 2466 }
duke@0 2467
duke@0 2468 void* os::signal(int signal_number, void* handler) {
duke@0 2469 struct sigaction sigAct, oldSigAct;
duke@0 2470 sigfillset(&(sigAct.sa_mask));
duke@0 2471 sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;
duke@0 2472 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
duke@0 2473
duke@0 2474 if (sigaction(signal_number, &sigAct, &oldSigAct))
duke@0 2475 // -1 means registration failed
duke@0 2476 return (void *)-1;
duke@0 2477
duke@0 2478 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
duke@0 2479 }
duke@0 2480
duke@0 2481 void os::signal_raise(int signal_number) {
duke@0 2482 raise(signal_number);
duke@0 2483 }
duke@0 2484
duke@0 2485 /*
duke@0 2486 * The following code is moved from os.cpp for making this
duke@0 2487 * code platform specific, which it is by its very nature.
duke@0 2488 */
duke@0 2489
duke@0 2490 // a counter for each possible signal value
duke@0 2491 static int Sigexit = 0;
duke@0 2492 static int Maxlibjsigsigs;
duke@0 2493 static jint *pending_signals = NULL;
duke@0 2494 static int *preinstalled_sigs = NULL;
duke@0 2495 static struct sigaction *chainedsigactions = NULL;
duke@0 2496 static sema_t sig_sem;
duke@0 2497 typedef int (*version_getting_t)();
duke@0 2498 version_getting_t os::Solaris::get_libjsig_version = NULL;
duke@0 2499 static int libjsigversion = NULL;
duke@0 2500
duke@0 2501 int os::sigexitnum_pd() {
duke@0 2502 assert(Sigexit > 0, "signal memory not yet initialized");
duke@0 2503 return Sigexit;
duke@0 2504 }
duke@0 2505
duke@0 2506 void os::Solaris::init_signal_mem() {
duke@0 2507 // Initialize signal structures
duke@0 2508 Maxsignum = SIGRTMAX;
duke@0 2509 Sigexit = Maxsignum+1;
duke@0 2510 assert(Maxsignum >0, "Unable to obtain max signal number");
duke@0 2511
duke@0 2512 Maxlibjsigsigs = Maxsignum;
duke@0 2513
duke@0 2514 // pending_signals has one int per signal
duke@0 2515 // The additional signal is for SIGEXIT - exit signal to signal_thread
duke@0 2516 pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1));
duke@0 2517 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
duke@0 2518
duke@0 2519 if (UseSignalChaining) {
duke@0 2520 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
duke@0 2521 * (Maxsignum + 1));
duke@0 2522 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
duke@0 2523 preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1));
duke@0 2524 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
duke@0 2525 }
duke@0 2526 ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ));
duke@0 2527 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
duke@0 2528 }
duke@0 2529
duke@0 2530 void os::signal_init_pd() {
duke@0 2531 int ret;
duke@0 2532
duke@0 2533 ret = ::sema_init(&sig_sem, 0, NULL, NULL);
duke@0 2534 assert(ret == 0, "sema_init() failed");
duke@0 2535 }
duke@0 2536
duke@0 2537 void os::signal_notify(int signal_number) {
duke@0 2538 int ret;
duke@0 2539
duke@0 2540 Atomic::inc(&pending_signals[signal_number]);
duke@0 2541 ret = ::sema_post(&sig_sem);
duke@0 2542 assert(ret == 0, "sema_post() failed");
duke@0 2543 }
duke@0 2544
duke@0 2545 static int check_pending_signals(bool wait_for_signal) {
duke@0 2546 int ret;
duke@0 2547 while (true) {
duke@0 2548 for (int i = 0; i < Sigexit + 1; i++) {
duke@0 2549 jint n = pending_signals[i];
duke@0 2550 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
duke@0 2551 return i;
duke@0 2552 }
duke@0 2553 }
duke@0 2554 if (!wait_for_signal) {
duke@0 2555 return -1;
duke@0 2556 }
duke@0 2557 JavaThread *thread = JavaThread::current();
duke@0 2558 ThreadBlockInVM tbivm(thread);
duke@0 2559
duke@0 2560 bool threadIsSuspended;
duke@0 2561 do {
duke@0 2562 thread->set_suspend_equivalent();
duke@0 2563 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
duke@0 2564 while((ret = ::sema_wait(&sig_sem)) == EINTR)
duke@0 2565 ;
duke@0 2566 assert(ret == 0, "sema_wait() failed");
duke@0 2567
duke@0 2568 // were we externally suspended while we were waiting?
duke@0 2569 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
duke@0 2570 if (threadIsSuspended) {
duke@0 2571 //
duke@0 2572 // The semaphore has been incremented, but while we were waiting
duke@0 2573 // another thread suspended us. We don't want to continue running
duke@0 2574 // while suspended because that would surprise the thread that
duke@0 2575 // suspended us.
duke@0 2576 //
duke@0 2577 ret = ::sema_post(&sig_sem);
duke@0 2578 assert(ret == 0, "sema_post() failed");
duke@0 2579
duke@0 2580 thread->java_suspend_self();
duke@0 2581 }
duke@0 2582 } while (threadIsSuspended);
duke@0 2583 }
duke@0 2584 }
duke@0 2585
duke@0 2586 int os::signal_lookup() {
duke@0 2587 return check_pending_signals(false);
duke@0 2588 }
duke@0 2589
duke@0 2590 int os::signal_wait() {
duke@0 2591 return check_pending_signals(true);
duke@0 2592 }
duke@0 2593
duke@0 2594 ////////////////////////////////////////////////////////////////////////////////
duke@0 2595 // Virtual Memory
duke@0 2596
duke@0 2597 static int page_size = -1;
duke@0 2598
duke@0 2599 // The mmap MAP_ALIGN flag is supported on Solaris 9 and later. init_2() will
duke@0 2600 // clear this var if support is not available.
duke@0 2601 static bool has_map_align = true;
duke@0 2602
duke@0 2603 int os::vm_page_size() {
duke@0 2604 assert(page_size != -1, "must call os::init");
duke@0 2605 return page_size;
duke@0 2606 }
duke@0 2607
duke@0 2608 // Solaris allocates memory by pages.
duke@0 2609 int os::vm_allocation_granularity() {
duke@0 2610 assert(page_size != -1, "must call os::init");
duke@0 2611 return page_size;
duke@0 2612 }
duke@0 2613
duke@0 2614 bool os::commit_memory(char* addr, size_t bytes) {
duke@0 2615 size_t size = bytes;
duke@0 2616 return
duke@0 2617 NULL != Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED,
duke@0 2618 PROT_READ | PROT_WRITE | PROT_EXEC);
duke@0 2619 }
duke@0 2620
duke@0 2621 bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint) {
duke@0 2622 if (commit_memory(addr, bytes)) {
duke@0 2623 if (UseMPSS && alignment_hint > (size_t)vm_page_size()) {
duke@0 2624 // If the large page size has been set and the VM
duke@0 2625 // is using large pages, use the large page size
duke@0 2626 // if it is smaller than the alignment hint. This is
duke@0 2627 // a case where the VM wants to use a larger alignment size
duke@0 2628 // for its own reasons but still want to use large pages
duke@0 2629 // (which is what matters to setting the mpss range.
duke@0 2630 size_t page_size = 0;
duke@0 2631 if (large_page_size() < alignment_hint) {
duke@0 2632 assert(UseLargePages, "Expected to be here for large page use only");
duke@0 2633 page_size = large_page_size();
duke@0 2634 } else {
duke@0 2635 // If the alignment hint is less than the large page
duke@0 2636 // size, the VM wants a particular alignment (thus the hint)
duke@0 2637 // for internal reasons. Try to set the mpss range using
duke@0 2638 // the alignment_hint.
duke@0 2639 page_size = alignment_hint;
duke@0 2640 }
duke@0 2641 // Since this is a hint, ignore any failures.
duke@0 2642 (void)Solaris::set_mpss_range(addr, bytes, page_size);
duke@0 2643 }
duke@0 2644 return true;
duke@0 2645 }
duke@0 2646 return false;
duke@0 2647 }
duke@0 2648
duke@0 2649 // Uncommit the pages in a specified region.
duke@0 2650 void os::free_memory(char* addr, size_t bytes) {
duke@0 2651 if (madvise(addr, bytes, MADV_FREE) < 0) {
duke@0 2652 debug_only(warning("MADV_FREE failed."));
duke@0 2653 return;
duke@0 2654 }
duke@0 2655 }
duke@0 2656
duke@0 2657 // Change the page size in a given range.
duke@0 2658 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
duke@0 2659 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
duke@0 2660 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
duke@0 2661 Solaris::set_mpss_range(addr, bytes, alignment_hint);
duke@0 2662 }
duke@0 2663
duke@0 2664 // Tell the OS to make the range local to the first-touching LWP
iveresov@141 2665 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
duke@0 2666 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
duke@0 2667 if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) {
duke@0 2668 debug_only(warning("MADV_ACCESS_LWP failed."));
duke@0 2669 }
duke@0 2670 }
duke@0 2671
duke@0 2672 // Tell the OS that this range would be accessed from different LWPs.
duke@0 2673 void os::numa_make_global(char *addr, size_t bytes) {
duke@0 2674 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
duke@0 2675 if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) {
duke@0 2676 debug_only(warning("MADV_ACCESS_MANY failed."));
duke@0 2677 }
duke@0 2678 }
duke@0 2679
duke@0 2680 // Get the number of the locality groups.
duke@0 2681 size_t os::numa_get_groups_num() {
duke@0 2682 size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie());
duke@0 2683 return n != -1 ? n : 1;
duke@0 2684 }
duke@0 2685
duke@0 2686 // Get a list of leaf locality groups. A leaf lgroup is group that
duke@0 2687 // doesn't have any children. Typical leaf group is a CPU or a CPU/memory
duke@0 2688 // board. An LWP is assigned to one of these groups upon creation.
duke@0 2689 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
duke@0 2690 if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) {
duke@0 2691 ids[0] = 0;
duke@0 2692 return 1;
duke@0 2693 }
duke@0 2694 int result_size = 0, top = 1, bottom = 0, cur = 0;
duke@0 2695 for (int k = 0; k < size; k++) {
duke@0 2696 int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur],
duke@0 2697 (Solaris::lgrp_id_t*)&ids[top], size - top);
duke@0 2698 if (r == -1) {
duke@0 2699 ids[0] = 0;
duke@0 2700 return 1;
duke@0 2701 }
duke@0 2702 if (!r) {
iveresov@144 2703 // That's a leaf node.
duke@0 2704 assert (bottom <= cur, "Sanity check");
iveresov@144 2705 // Check if the node has memory
iveresov@144 2706 if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur],
iveresov@144 2707 NULL, 0, LGRP_RSRC_MEM) > 0) {
iveresov@144 2708 ids[bottom++] = ids[cur];
iveresov@144 2709 }
duke@0 2710 }
duke@0 2711 top += r;
duke@0 2712 cur++;
duke@0 2713 }
iveresov@268 2714 if (bottom == 0) {
iveresov@268 2715 // Handle a situation, when the OS reports no memory available.
iveresov@268 2716 // Assume UMA architecture.
iveresov@268 2717 ids[0] = 0;
iveresov@268 2718 return 1;
iveresov@268 2719 }
duke@0 2720 return bottom;
duke@0 2721 }
duke@0 2722
ysr@342 2723 // Detect the topology change. Typically happens during CPU plugging-unplugging.
duke@0 2724 bool os::numa_topology_changed() {
duke@0 2725 int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie());
duke@0 2726 if (is_stale != -1 && is_stale) {
duke@0 2727 Solaris::lgrp_fini(Solaris::lgrp_cookie());
duke@0 2728 Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER);
duke@0 2729 assert(c != 0, "Failure to initialize LGRP API");
duke@0 2730 Solaris::set_lgrp_cookie(c);
duke@0 2731 return true;
duke@0 2732 }
duke@0 2733 return false;
duke@0 2734 }
duke@0 2735
duke@0 2736 // Get the group id of the current LWP.
duke@0 2737 int os::numa_get_group_id() {
iveresov@144 2738 int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID);
duke@0 2739 if (lgrp_id == -1) {
duke@0 2740 return 0;
duke@0 2741 }
iveresov@144 2742 const int size = os::numa_get_groups_num();
iveresov@144 2743 int *ids = (int*)alloca(size * sizeof(int));
iveresov@144 2744
iveresov@144 2745 // Get the ids of all lgroups with memory; r is the count.
iveresov@144 2746 int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id,
iveresov@144 2747 (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM);
iveresov@144 2748 if (r <= 0) {
iveresov@144 2749 return 0;
iveresov@144 2750 }
iveresov@144 2751 return ids[os::random() % r];
duke@0 2752 }
duke@0 2753
duke@0 2754 // Request information about the page.
duke@0 2755 bool os::get_page_info(char *start, page_info* info) {
duke@0 2756 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
duke@0 2757 uint64_t addr = (uintptr_t)start;
duke@0 2758 uint64_t outdata[2];
duke@0 2759 uint_t validity = 0;
duke@0 2760
duke@0 2761 if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) {
duke@0 2762 return false;
duke@0 2763 }
duke@0 2764
duke@0 2765 info->size = 0;
duke@0 2766 info->lgrp_id = -1;
duke@0 2767
duke@0 2768 if ((validity & 1) != 0) {
duke@0 2769 if ((validity & 2) != 0) {
duke@0 2770 info->lgrp_id = outdata[0];
duke@0 2771 }
duke@0 2772 if ((validity & 4) != 0) {
duke@0 2773 info->size = outdata[1];
duke@0 2774 }
duke@0 2775 return true;
duke@0 2776 }
duke@0 2777 return false;
duke@0 2778 }
duke@0 2779
duke@0 2780 // Scan the pages from start to end until a page different than
duke@0 2781 // the one described in the info parameter is encountered.
duke@0 2782 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
duke@0 2783 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
duke@0 2784 const size_t types = sizeof(info_types) / sizeof(info_types[0]);
duke@0 2785 uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT];
duke@0 2786 uint_t validity[MAX_MEMINFO_CNT];
duke@0 2787
duke@0 2788 size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size);
duke@0 2789 uint64_t p = (uint64_t)start;
duke@0 2790 while (p < (uint64_t)end) {
duke@0 2791 addrs[0] = p;
duke@0 2792 size_t addrs_count = 1;
duke@0 2793 while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] < (uint64_t)end) {
duke@0 2794 addrs[addrs_count] = addrs[addrs_count - 1] + page_size;
duke@0 2795 addrs_count++;
duke@0 2796 }
duke@0 2797
duke@0 2798 if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) {
duke@0 2799 return NULL;
duke@0 2800 }
duke@0 2801
duke@0 2802 size_t i = 0;
duke@0 2803 for (; i < addrs_count; i++) {
duke@0 2804 if ((validity[i] & 1) != 0) {
duke@0 2805 if ((validity[i] & 4) != 0) {
duke@0 2806 if (outdata[types * i + 1] != page_expected->size) {
duke@0 2807 break;
duke@0 2808 }
duke@0 2809 } else
duke@0 2810 if (page_expected->size != 0) {
duke@0 2811 break;
duke@0 2812 }
duke@0 2813
duke@0 2814 if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) {
duke@0 2815 if (outdata[types * i] != page_expected->lgrp_id) {
duke@0 2816 break;
duke@0 2817 }
duke@0 2818 }
duke@0 2819 } else {
duke@0 2820 return NULL;
duke@0 2821 }
duke@0 2822 }
duke@0 2823
duke@0 2824 if (i != addrs_count) {
duke@0 2825 if ((validity[i] & 2) != 0) {
duke@0 2826 page_found->lgrp_id = outdata[types * i];
duke@0 2827 } else {
duke@0 2828 page_found->lgrp_id = -1;
duke@0 2829 }
duke@0 2830 if ((validity[i] & 4) != 0) {
duke@0 2831 page_found->size = outdata[types * i + 1];
duke@0 2832 } else {
duke@0 2833 page_found->size = 0;
duke@0 2834 }
duke@0 2835 return (char*)addrs[i];
duke@0 2836 }
duke@0 2837
duke@0 2838 p = addrs[addrs_count - 1] + page_size;
duke@0 2839 }
duke@0 2840 return end;
duke@0 2841 }
duke@0 2842
duke@0 2843 bool os::uncommit_memory(char* addr, size_t bytes) {
duke@0 2844 size_t size = bytes;
duke@0 2845 // Map uncommitted pages PROT_NONE so we fail early if we touch an
duke@0 2846 // uncommitted page. Otherwise, the read/write might succeed if we
duke@0 2847 // have enough swap space to back the physical page.
duke@0 2848 return
duke@0 2849 NULL != Solaris::mmap_chunk(addr, size,
duke@0 2850 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE,
duke@0 2851 PROT_NONE);
duke@0 2852 }
duke@0 2853
duke@0 2854 char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) {
duke@0 2855 char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0);
duke@0 2856
duke@0 2857 if (b == MAP_FAILED) {
duke@0 2858 return NULL;
duke@0 2859 }
duke@0 2860 return b;
duke@0 2861 }
duke@0 2862
sbohne@60 2863 char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) {
sbohne@60 2864 char* addr = requested_addr;
sbohne@60 2865 int flags = MAP_PRIVATE | MAP_NORESERVE;
sbohne@60 2866
sbohne@60 2867 assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap");
sbohne@60 2868
sbohne@60 2869 if (fixed) {
sbohne@60 2870 flags |= MAP_FIXED;
sbohne@60 2871 } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) {
duke@0 2872 flags |= MAP_ALIGN;
duke@0 2873 addr = (char*) alignment_hint;
duke@0 2874 }
duke@0 2875
duke@0 2876 // Map uncommitted pages PROT_NONE so we fail early if we touch an
duke@0 2877 // uncommitted page. Otherwise, the read/write might succeed if we
duke@0 2878 // have enough swap space to back the physical page.
sbohne@60 2879 return mmap_chunk(addr, bytes, flags, PROT_NONE);
sbohne@60 2880 }
sbohne@60 2881
sbohne@60 2882 char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
sbohne@60 2883 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL));
duke@0 2884
duke@0 2885 guarantee(requested_addr == NULL || requested_addr == addr,
duke@0 2886 "OS failed to return requested mmap address.");
duke@0 2887 return addr;
duke@0 2888 }
duke@0 2889
duke@0 2890 // Reserve memory at an arbitrary address, only if that area is
duke@0 2891 // available (and not reserved for something else).
duke@0 2892
duke@0 2893 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
duke@0 2894 const int max_tries = 10;
duke@0 2895 char* base[max_tries];
duke@0 2896 size_t size[max_tries];
duke@0 2897
duke@0 2898 // Solaris adds a gap between mmap'ed regions. The size of the gap
duke@0 2899 // is dependent on the requested size and the MMU. Our initial gap
duke@0 2900 // value here is just a guess and will be corrected later.
duke@0 2901 bool had_top_overlap = false;
duke@0 2902 bool have_adjusted_gap = false;
duke@0 2903 size_t gap = 0x400000;
duke@0 2904
duke@0 2905 // Assert only that the size is a multiple of the page size, since
duke@0 2906 // that's all that mmap requires, and since that's all we really know
duke@0 2907 // about at this low abstraction level. If we need higher alignment,
duke@0 2908 // we can either pass an alignment to this method or verify alignment
duke@0 2909 // in one of the methods further up the call chain. See bug 5044738.
duke@0 2910 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
duke@0 2911
sbohne@60 2912 // Since snv_84, Solaris attempts to honor the address hint - see 5003415.
sbohne@60 2913 // Give it a try, if the kernel honors the hint we can return immediately.
sbohne@60 2914 char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false);
sbohne@60 2915 volatile int err = errno;
sbohne@60 2916 if (addr == requested_addr) {
sbohne@60 2917 return addr;
sbohne@60 2918 } else if (addr != NULL) {
sbohne@60 2919 unmap_memory(addr, bytes);
sbohne@60 2920 }
sbohne@60 2921
sbohne@60 2922 if (PrintMiscellaneous && Verbose) {
sbohne@60 2923 char buf[256];
sbohne@60 2924 buf[0] = '\0';
sbohne@60 2925 if (addr == NULL) {
sbohne@60 2926 jio_snprintf(buf, sizeof(buf), ": %s", strerror(err));
sbohne@60 2927 }
sbohne@60 2928 warning("attempt_reserve_memory_at: couldn't reserve %d bytes at "
sbohne@60 2929 PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT
sbohne@60 2930 "%s", bytes, requested_addr, addr, buf);
sbohne@60 2931 }
sbohne@60 2932
sbohne@60 2933 // Address hint method didn't work. Fall back to the old method.
sbohne@60 2934 // In theory, once SNV becomes our oldest supported platform, this
sbohne@60 2935 // code will no longer be needed.
sbohne@60 2936 //
duke@0 2937 // Repeatedly allocate blocks until the block is allocated at the
duke@0 2938 // right spot. Give up after max_tries.
duke@0 2939 int i;
duke@0 2940 for (i = 0; i < max_tries; ++i) {
duke@0 2941 base[i] = reserve_memory(bytes);
duke@0 2942
duke@0 2943 if (base[i] != NULL) {
duke@0 2944 // Is this the block we wanted?
duke@0 2945 if (base[i] == requested_addr) {
duke@0 2946 size[i] = bytes;
duke@0 2947 break;
duke@0 2948 }
duke@0 2949
duke@0 2950 // check that the gap value is right
duke@0 2951 if (had_top_overlap && !have_adjusted_gap) {
duke@0 2952 size_t actual_gap = base[i-1] - base[i] - bytes;
duke@0 2953 if (gap != actual_gap) {
duke@0 2954 // adjust the gap value and retry the last 2 allocations
duke@0 2955 assert(i > 0, "gap adjustment code problem");
duke@0 2956 have_adjusted_gap = true; // adjust the gap only once, just in case
duke@0 2957 gap = actual_gap;
duke@0 2958 if (PrintMiscellaneous && Verbose) {
duke@0 2959 warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap);
duke@0 2960 }
duke@0 2961 unmap_memory(base[i], bytes);
duke@0 2962 unmap_memory(base[i-1], size[i-1]);
duke@0 2963 i-=2;
duke@0 2964 continue;
duke@0 2965 }
duke@0 2966 }
duke@0 2967
duke@0 2968 // Does this overlap the block we wanted? Give back the overlapped
duke@0 2969 // parts and try again.
duke@0 2970 //
duke@0 2971 // There is still a bug in this code: if top_overlap == bytes,
duke@0 2972 // the overlap is offset from requested region by the value of gap.
duke@0 2973 // In this case giving back the overlapped part will not work,
duke@0 2974 // because we'll give back the entire block at base[i] and
duke@0 2975 // therefore the subsequent allocation will not generate a new gap.
duke@0 2976 // This could be fixed with a new algorithm that used larger
duke@0 2977 // or variable size chunks to find the requested region -
duke@0 2978 // but such a change would introduce additional complications.
duke@0 2979 // It's rare enough that the planets align for this bug,
duke@0 2980 // so we'll just wait for a fix for 6204603/5003415 which
duke@0 2981 // will provide a mmap flag to allow us to avoid this business.
duke@0 2982
duke@0 2983 size_t top_overlap = requested_addr + (bytes + gap) - base[i];
duke@0 2984 if (top_overlap >= 0 && top_overlap < bytes) {
duke@0 2985 had_top_overlap = true;
duke@0 2986 unmap_memory(base[i], top_overlap);
duke@0 2987 base[i] += top_overlap;
duke@0 2988 size[i] = bytes - top_overlap;
duke@0 2989 } else {
duke@0 2990 size_t bottom_overlap = base[i] + bytes - requested_addr;
duke@0 2991 if (bottom_overlap >= 0 && bottom_overlap < bytes) {
duke@0 2992 if (PrintMiscellaneous && Verbose && bottom_overlap == 0) {
duke@0 2993 warning("attempt_reserve_memory_at: possible alignment bug");
duke@0 2994 }
duke@0 2995 unmap_memory(requested_addr, bottom_overlap);
duke@0 2996 size[i] = bytes - bottom_overlap;
duke@0 2997 } else {
duke@0 2998 size[i] = bytes;
duke@0 2999 }
duke@0 3000 }
duke@0 3001 }
duke@0 3002 }
duke@0 3003
duke@0 3004 // Give back the unused reserved pieces.
duke@0 3005
duke@0 3006 for (int j = 0; j < i; ++j) {
duke@0 3007 if (base[j] != NULL) {
duke@0 3008 unmap_memory(base[j], size[j]);
duke@0 3009 }
duke@0 3010 }
duke@0 3011
duke@0 3012 return (i < max_tries) ? requested_addr : NULL;
duke@0 3013 }
duke@0 3014
duke@0 3015 bool os::release_memory(char* addr, size_t bytes) {
duke@0 3016 size_t size = bytes;
duke@0 3017 return munmap(addr, size) == 0;
duke@0 3018 }
duke@0 3019
duke@0 3020 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
duke@0 3021 assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()),
duke@0 3022 "addr must be page aligned");
duke@0 3023 int retVal = mprotect(addr, bytes, prot);
duke@0 3024 return retVal == 0;
duke@0 3025 }
duke@0 3026
coleenp@237 3027 // Protect memory (Used to pass readonly pages through
duke@0 3028 // JNI GetArray<type>Elements with empty arrays.)
coleenp@477 3029 // Also, used for serialization page and for compressed oops null pointer
coleenp@477 3030 // checking.
coleenp@237 3031 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
coleenp@237 3032 bool is_committed) {
coleenp@237 3033 unsigned int p = 0;
coleenp@237 3034 switch (prot) {
coleenp@237 3035 case MEM_PROT_NONE: p = PROT_NONE; break;
coleenp@237 3036 case MEM_PROT_READ: p = PROT_READ; break;
coleenp@237 3037 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break;
coleenp@237 3038 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
coleenp@237 3039 default:
coleenp@237 3040 ShouldNotReachHere();
coleenp@237 3041 }
coleenp@237 3042 // is_committed is unused.
coleenp@237 3043 return solaris_mprotect(addr, bytes, p);
duke@0 3044 }
duke@0 3045
duke@0 3046 // guard_memory and unguard_memory only happens within stack guard pages.
duke@0 3047 // Since ISM pertains only to the heap, guard and unguard memory should not
duke@0 3048 /// happen with an ISM region.
duke@0 3049 bool os::guard_memory(char* addr, size_t bytes) {
duke@0 3050 return solaris_mprotect(addr, bytes, PROT_NONE);
duke@0 3051 }
duke@0 3052
duke@0 3053 bool os::unguard_memory(char* addr, size_t bytes) {
coleenp@477 3054 return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE);
duke@0 3055 }
duke@0 3056
duke@0 3057 // Large page support
duke@0 3058
duke@0 3059 // UseLargePages is the master flag to enable/disable large page memory.
duke@0 3060 // UseMPSS and UseISM are supported for compatibility reasons. Their combined
duke@0 3061 // effects can be described in the following table:
duke@0 3062 //
duke@0 3063 // UseLargePages UseMPSS UseISM
duke@0 3064 // false * * => UseLargePages is the master switch, turning
duke@0 3065 // it off will turn off both UseMPSS and
duke@0 3066 // UseISM. VM will not use large page memory
duke@0 3067 // regardless the settings of UseMPSS/UseISM.
duke@0 3068 // true false false => Unless future Solaris provides other
duke@0 3069 // mechanism to use large page memory, this
duke@0 3070 // combination is equivalent to -UseLargePages,
duke@0 3071 // VM will not use large page memory
duke@0 3072 // true true false => JVM will use MPSS for large page memory.
duke@0 3073 // This is the default behavior.
duke@0 3074 // true false true => JVM will use ISM for large page memory.
duke@0 3075 // true true true => JVM will use ISM if it is available.
duke@0 3076 // Otherwise, JVM will fall back to MPSS.
duke@0 3077 // Becaues ISM is now available on all
duke@0 3078 // supported Solaris versions, this combination
duke@0 3079 // is equivalent to +UseISM -UseMPSS.
duke@0 3080
duke@0 3081 typedef int (*getpagesizes_func_type) (size_t[], int);
duke@0 3082 static size_t _large_page_size = 0;
duke@0 3083
duke@0 3084 bool os::Solaris::ism_sanity_check(bool warn, size_t * page_size) {
duke@0 3085 // x86 uses either 2M or 4M page, depending on whether PAE (Physical Address
duke@0 3086 // Extensions) mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. Sparc
duke@0 3087 // can support multiple page sizes.
duke@0 3088
duke@0 3089 // Don't bother to probe page size because getpagesizes() comes with MPSS.
duke@0 3090 // ISM is only recommended on old Solaris where there is no MPSS support.
duke@0 3091 // Simply choose a conservative value as default.
duke@0 3092 *page_size = LargePageSizeInBytes ? LargePageSizeInBytes :
duke@0 3093 SPARC_ONLY(4 * M) IA32_ONLY(4 * M) AMD64_ONLY(2 * M);
duke@0 3094
duke@0 3095 // ISM is available on all supported Solaris versions
duke@0 3096 return true;
duke@0 3097 }
duke@0 3098
duke@0 3099 // Insertion sort for small arrays (descending order).
duke@0 3100 static void insertion_sort_descending(size_t* array, int len) {
duke@0 3101 for (int i = 0; i < len; i++) {
duke@0 3102 size_t val = array[i];
duke@0 3103 for (size_t key = i; key > 0 && array[key - 1] < val; --key) {
duke@0 3104 size_t tmp = array[key];
duke@0 3105 array[key] = array[key - 1];
duke@0 3106 array[key - 1] = tmp;
duke@0 3107 }
duke@0 3108 }
duke@0 3109 }
duke@0 3110
duke@0 3111 bool os::Solaris::mpss_sanity_check(bool warn, size_t * page_size) {
duke@0 3112 getpagesizes_func_type getpagesizes_func =
duke@0 3113 CAST_TO_FN_PTR(getpagesizes_func_type, dlsym(RTLD_DEFAULT, "getpagesizes"));
duke@0 3114 if (getpagesizes_func == NULL) {
duke@0 3115 if (warn) {
duke@0 3116 warning("MPSS is not supported by the operating system.");
duke@0 3117 }
duke@0 3118 return false;
duke@0 3119 }
duke@0 3120
duke@0 3121 const unsigned int usable_count = VM_Version::page_size_count();
duke@0 3122 if (usable_count == 1) {
duke@0 3123 return false;
duke@0 3124 }
duke@0 3125
duke@0 3126 // Fill the array of page sizes.
duke@0 3127 int n = getpagesizes_func(_page_sizes, page_sizes_max);
duke@0 3128 assert(n > 0, "Solaris bug?");
duke@0 3129 if (n == page_sizes_max) {
duke@0 3130 // Add a sentinel value (necessary only if the array was completely filled
duke@0 3131 // since it is static (zeroed at initialization)).
duke@0 3132 _page_sizes[--n] = 0;
duke@0 3133 DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");)
duke@0 3134 }
duke@0 3135 assert(_page_sizes[n] == 0, "missing sentinel");
duke@0 3136
duke@0 3137 if (n == 1) return false; // Only one page size available.
duke@0 3138
duke@0 3139 // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and
duke@0 3140 // select up to usable_count elements. First sort the array, find the first
duke@0 3141 // acceptable value, then copy the usable sizes to the top of the array and
duke@0 3142 // trim the rest. Make sure to include the default page size :-).
duke@0 3143 //
duke@0 3144 // A better policy could get rid of the 4M limit by taking the sizes of the
duke@0 3145 // important VM memory regions (java heap and possibly the code cache) into
duke@0 3146 // account.
duke@0 3147 insertion_sort_descending(_page_sizes, n);
duke@0 3148 const size_t size_limit =
duke@0 3149 FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes;
duke@0 3150 int beg;
duke@0 3151 for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ;
duke@0 3152 const int end = MIN2((int)usable_count, n) - 1;
duke@0 3153 for (int cur = 0; cur < end; ++cur, ++beg) {
duke@0 3154 _page_sizes[cur] = _page_sizes[beg];
duke@0 3155 }
duke@0 3156 _page_sizes[end] = vm_page_size();
duke@0 3157 _page_sizes[end + 1] = 0;
duke@0 3158
duke@0 3159 if (_page_sizes[end] > _page_sizes[end - 1]) {
duke@0 3160 // Default page size is not the smallest; sort again.
duke@0 3161 insertion_sort_descending(_page_sizes, end + 1);
duke@0 3162 }
duke@0 3163 *page_size = _page_sizes[0];
duke@0 3164
duke@0 3165 return true;
duke@0 3166 }
duke@0 3167
duke@0 3168 bool os::large_page_init() {
duke@0 3169 if (!UseLargePages) {
duke@0 3170 UseISM = false;
duke@0 3171 UseMPSS = false;
duke@0 3172 return false;
duke@0 3173 }
duke@0 3174
duke@0 3175 // print a warning if any large page related flag is specified on command line
duke@0 3176 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
duke@0 3177 !FLAG_IS_DEFAULT(UseISM) ||
duke@0 3178 !FLAG_IS_DEFAULT(UseMPSS) ||
duke@0 3179 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
duke@0 3180 UseISM = UseISM &&
duke@0 3181 Solaris::ism_sanity_check(warn_on_failure, &_large_page_size);
duke@0 3182 if (UseISM) {
duke@0 3183 // ISM disables MPSS to be compatible with old JDK behavior
duke@0 3184 UseMPSS = false;
jcoomes@79 3185 _page_sizes[0] = _large_page_size;
jcoomes@79 3186 _page_sizes[1] = vm_page_size();
duke@0 3187 }
duke@0 3188
duke@0 3189 UseMPSS = UseMPSS &&
duke@0 3190 Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size);
duke@0 3191
duke@0 3192 UseLargePages = UseISM || UseMPSS;
duke@0 3193 return UseLargePages;
duke@0 3194 }
duke@0 3195
duke@0 3196 bool os::Solaris::set_mpss_range(caddr_t start, size_t bytes, size_t align) {
duke@0 3197 // Signal to OS that we want large pages for addresses
duke@0 3198 // from addr, addr + bytes
duke@0 3199 struct memcntl_mha mpss_struct;
duke@0 3200 mpss_struct.mha_cmd = MHA_MAPSIZE_VA;
duke@0 3201 mpss_struct.mha_pagesize = align;
duke@0 3202 mpss_struct.mha_flags = 0;
duke@0 3203 if (memcntl(start, bytes, MC_HAT_ADVISE,
duke@0 3204 (caddr_t) &mpss_struct, 0, 0) < 0) {
duke@0 3205 debug_only(warning("Attempt to use MPSS failed."));
duke@0 3206 return false;
duke@0 3207 }
duke@0 3208 return true;
duke@0 3209 }
duke@0 3210
duke@0 3211 char* os::reserve_memory_special(size_t bytes) {
duke@0 3212 assert(UseLargePages && UseISM, "only for ISM large pages");
duke@0 3213
duke@0 3214 size_t size = bytes;
duke@0 3215 char* retAddr = NULL;
duke@0 3216 int shmid;
duke@0 3217 key_t ismKey;
duke@0 3218
duke@0 3219 bool warn_on_failure = UseISM &&
duke@0 3220 (!FLAG_IS_DEFAULT(UseLargePages) ||
duke@0 3221 !FLAG_IS_DEFAULT(UseISM) ||
duke@0 3222 !FLAG_IS_DEFAULT(LargePageSizeInBytes)
duke@0 3223 );
duke@0 3224 char msg[128];
duke@0 3225
duke@0 3226 ismKey = IPC_PRIVATE;
duke@0 3227
duke@0 3228 // Create a large shared memory region to attach to based on size.
duke@0 3229 // Currently, size is the total size of the heap
duke@0 3230 shmid = shmget(ismKey, size, SHM_R | SHM_W | IPC_CREAT);
duke@0 3231 if (shmid == -1){
duke@0 3232 if (warn_on_failure) {
duke@0 3233 jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno);
duke@0 3234 warning(msg);
duke@0 3235 }
duke@0 3236 return NULL;
duke@0 3237 }
duke@0 3238
duke@0 3239 // Attach to the region
duke@0 3240 retAddr = (char *) shmat(shmid, 0, SHM_SHARE_MMU | SHM_R | SHM_W);
duke@0 3241 int err = errno;
duke@0 3242
duke@0 3243 // Remove shmid. If shmat() is successful, the actual shared memory segment
duke@0 3244 // will be deleted when it's detached by shmdt() or when the process
duke@0 3245 // terminates. If shmat() is not successful this will remove the shared
duke@0 3246 // segment immediately.
duke@0 3247 shmctl(shmid, IPC_RMID, NULL);
duke@0 3248
duke@0 3249 if (retAddr == (char *) -1) {
duke@0 3250 if (warn_on_failure) {
duke@0 3251 jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
duke@0 3252 warning(msg);
duke@0 3253 }
duke@0 3254 return NULL;
duke@0 3255 }
duke@0 3256
duke@0 3257 return retAddr;
duke@0 3258 }
duke@0 3259
duke@0 3260 bool os::release_memory_special(char* base, size_t bytes) {
duke@0 3261 // detaching the SHM segment will also delete it, see reserve_memory_special()
duke@0 3262 int rslt = shmdt(base);
duke@0 3263 return rslt == 0;
duke@0 3264 }
duke@0 3265
duke@0 3266 size_t os::large_page_size() {
duke@0 3267 return _large_page_size;
duke@0 3268 }
duke@0 3269
duke@0 3270 // MPSS allows application to commit large page memory on demand; with ISM
duke@0 3271 // the entire memory region must be allocated as shared memory.
duke@0 3272 bool os::can_commit_large_page_memory() {
duke@0 3273 return UseISM ? false : true;
duke@0 3274 }
duke@0 3275
jcoomes@79 3276 bool os::can_execute_large_page_memory() {
jcoomes@79 3277 return UseISM ? false : true;
jcoomes@79 3278 }
jcoomes@79 3279
duke@0 3280 static int os_sleep(jlong millis, bool interruptible) {
duke@0 3281 const jlong limit = INT_MAX;
duke@0 3282 jlong prevtime;
duke@0 3283 int res;
duke@0 3284
duke@0 3285 while (millis > limit) {
duke@0 3286 if ((res = os_sleep(limit, interruptible)) != OS_OK)
duke@0 3287 return res;
duke@0 3288 millis -= limit;
duke@0 3289 }
duke@0 3290
duke@0 3291 // Restart interrupted polls with new parameters until the proper delay
duke@0 3292 // has been completed.
duke@0 3293
duke@0 3294 prevtime = getTimeMillis();
duke@0 3295
duke@0 3296 while (millis > 0) {
duke@0 3297 jlong newtime;
duke@0 3298
duke@0 3299 if (!interruptible) {
duke@0 3300 // Following assert fails for os::yield_all:
duke@0 3301 // assert(!thread->is_Java_thread(), "must not be java thread");
duke@0 3302 res = poll(NULL, 0, millis);
duke@0 3303 } else {
duke@0 3304 JavaThread *jt = JavaThread::current();
duke@0 3305
duke@0 3306 INTERRUPTIBLE_NORESTART_VM_ALWAYS(poll(NULL, 0, millis), res, jt,
duke@0 3307 os::Solaris::clear_interrupted);
duke@0 3308 }
duke@0 3309
duke@0 3310 // INTERRUPTIBLE_NORESTART_VM_ALWAYS returns res == OS_INTRPT for
duke@0 3311 // thread.Interrupt.
duke@0 3312
duke@0 3313 if((res == OS_ERR) && (errno == EINTR)) {
duke@0 3314 newtime = getTimeMillis();
duke@0 3315 assert(newtime >= prevtime, "time moving backwards");
duke@0 3316 /* Doing prevtime and newtime in microseconds doesn't help precision,
duke@0 3317 and trying to round up to avoid lost milliseconds can result in a
duke@0 3318 too-short delay. */
duke@0 3319 millis -= newtime - prevtime;
duke@0 3320 if(millis <= 0)
duke@0 3321 return OS_OK;
duke@0 3322 prevtime = newtime;
duke@0 3323 } else
duke@0 3324 return res;
duke@0 3325 }
duke@0 3326
duke@0 3327 return OS_OK;
duke@0 3328 }
duke@0 3329
duke@0 3330 // Read calls from inside the vm need to perform state transitions
duke@0 3331 size_t os::read(int fd, void *buf, unsigned int nBytes) {
duke@0 3332 INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted);
duke@0 3333 }
duke@0 3334
duke@0 3335 int os::sleep(Thread* thread, jlong millis, bool interruptible) {
duke@0 3336 assert(thread == Thread::current(), "thread consistency check");
duke@0 3337
duke@0 3338 // TODO-FIXME: this should be removed.
duke@0 3339 // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock
duke@0 3340 // situation with a JavaThread being starved out of a lwp. The kernel doesn't seem to generate
duke@0 3341 // a SIGWAITING signal which would enable the threads library to create a new lwp for the starving
duke@0 3342 // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel
duke@0 3343 // is fooled into believing that the system is making progress. In the code below we block the
duke@0 3344 // the watcher thread while safepoint is in progress so that it would not appear as though the
duke@0 3345 // system is making progress.
duke@0 3346 if (!Solaris::T2_libthread() &&
duke@0 3347 thread->is_Watcher_thread() && SafepointSynchronize::is_synchronizing() && !Arguments::has_profile()) {
duke@0 3348 // We now try to acquire the threads lock. Since this lock is held by the VM thread during
duke@0 3349 // the entire safepoint, the watcher thread will line up here during the safepoint.
duke@0 3350 Threads_lock->lock_without_safepoint_check();
duke@0 3351 Threads_lock->unlock();
duke@0 3352 }
duke@0 3353
duke@0 3354 if (thread->is_Java_thread()) {
duke@0 3355 // This is a JavaThread so we honor the _thread_blocked protocol
duke@0 3356 // even for sleeps of 0 milliseconds. This was originally done
duke@0 3357 // as a workaround for bug 4338139. However, now we also do it
duke@0 3358 // to honor the suspend-equivalent protocol.
duke@0 3359
duke@0 3360 JavaThread *jt = (JavaThread *) thread;
duke@0 3361 ThreadBlockInVM tbivm(jt);
duke@0 3362
duke@0 3363 jt->set_suspend_equivalent();
duke@0 3364 // cleared by handle_special_suspend_equivalent_condition() or
duke@0 3365 // java_suspend_self() via check_and_wait_while_suspended()
duke@0 3366
duke@0 3367 int ret_code;
duke@0 3368 if (millis <= 0) {
duke@0 3369 thr_yield();
duke@0 3370 ret_code = 0;
duke@0 3371 } else {
duke@0 3372 // The original sleep() implementation did not create an
duke@0 3373 // OSThreadWaitState helper for sleeps of 0 milliseconds.
duke@0 3374 // I'm preserving that decision for now.
duke@0 3375 OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
duke@0 3376
duke@0 3377 ret_code = os_sleep(millis, interruptible);
duke@0 3378 }
duke@0 3379
duke@0 3380 // were we externally suspended while we were waiting?
duke@0 3381 jt->check_and_wait_while_suspended();
duke@0 3382
duke@0 3383 return ret_code;
duke@0 3384 }
duke@0 3385
duke@0 3386 // non-JavaThread from this point on:
duke@0 3387
duke@0 3388 if (millis <= 0) {
duke@0 3389 thr_yield();
duke@0 3390 return 0;
duke@0 3391 }
duke@0 3392
duke@0 3393 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
duke@0 3394
duke@0 3395 return os_sleep(millis, interruptible);
duke@0 3396 }
duke@0 3397
duke@0 3398 int os::naked_sleep() {
duke@0 3399 // %% make the sleep time an integer flag. for now use 1 millisec.
duke@0 3400 return os_sleep(1, false);
duke@0 3401 }
duke@0 3402
duke@0 3403 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
duke@0 3404 void os::infinite_sleep() {
duke@0 3405 while (true) { // sleep forever ...
duke@0 3406 ::sleep(100); // ... 100 seconds at a time
duke@0 3407 }
duke@0 3408 }
duke@0 3409
duke@0 3410 // Used to convert frequent JVM_Yield() to nops
duke@0 3411 bool os::dont_yield() {
duke@0 3412 if (DontYieldALot) {
duke@0 3413 static hrtime_t last_time = 0;
duke@0 3414 hrtime_t diff = getTimeNanos() - last_time;
duke@0 3415
duke@0 3416 if (diff < DontYieldALotInterval * 1000000)
duke@0 3417 return true;
duke@0 3418
duke@0 3419 last_time += diff;
duke@0 3420
duke@0 3421 return false;
duke@0 3422 }
duke@0 3423 else {
duke@0 3424 return false;
duke@0 3425 }
duke@0 3426 }
duke@0 3427
duke@0 3428 // Caveat: Solaris os::yield() causes a thread-state transition whereas
duke@0 3429 // the linux and win32 implementations do not. This should be checked.
duke@0 3430
duke@0 3431 void os::yield() {
duke@0 3432 // Yields to all threads with same or greater priority
duke@0 3433 os::sleep(Thread::current(), 0, false);
duke@0 3434 }
duke@0 3435
duke@0 3436 // Note that yield semantics are defined by the scheduling class to which
duke@0 3437 // the thread currently belongs. Typically, yield will _not yield to
duke@0 3438 // other equal or higher priority threads that reside on the dispatch queues
duke@0 3439 // of other CPUs.
duke@0 3440
duke@0 3441 os::YieldResult os::NakedYield() { thr_yield(); return os::YIELD_UNKNOWN; }
duke@0 3442
duke@0 3443
duke@0 3444 // On Solaris we found that yield_all doesn't always yield to all other threads.
duke@0 3445 // There have been cases where there is a thread ready to execute but it doesn't
duke@0 3446 // get an lwp as the VM thread continues to spin with sleeps of 1 millisecond.
duke@0 3447 // The 1 millisecond wait doesn't seem long enough for the kernel to issue a
duke@0 3448 // SIGWAITING signal which will cause a new lwp to be created. So we count the
duke@0 3449 // number of times yield_all is called in the one loop and increase the sleep
duke@0 3450 // time after 8 attempts. If this fails too we increase the concurrency level
duke@0 3451 // so that the starving thread would get an lwp
duke@0 3452
duke@0 3453 void os::yield_all(int attempts) {
duke@0 3454 // Yields to all threads, including threads with lower priorities
duke@0 3455 if (attempts == 0) {
duke@0 3456 os::sleep(Thread::current(), 1, false);
duke@0 3457 } else {
duke@0 3458 int iterations = attempts % 30;
duke@0 3459 if (iterations == 0 && !os::Solaris::T2_libthread()) {
duke@0 3460 // thr_setconcurrency and _getconcurrency make sense only under T1.
duke@0 3461 int noofLWPS = thr_getconcurrency();
duke@0 3462 if (noofLWPS < (Threads::number_of_threads() + 2)) {
duke@0 3463 thr_setconcurrency(thr_getconcurrency() + 1);
duke@0 3464 }
duke@0 3465 } else if (iterations < 25) {
duke@0 3466 os::sleep(Thread::current(), 1, false);
duke@0 3467 } else {
duke@0 3468 os::sleep(Thread::current(), 10, false);
duke@0 3469 }
duke@0 3470 }
duke@0 3471 }
duke@0 3472
duke@0 3473 // Called from the tight loops to possibly influence time-sharing heuristics
duke@0 3474 void os::loop_breaker(int attempts) {
duke@0 3475 os::yield_all(attempts);
duke@0 3476 }
duke@0 3477
duke@0 3478
duke@0 3479 // Interface for setting lwp priorities. If we are using T2 libthread,
duke@0 3480 // which forces the use of BoundThreads or we manually set UseBoundThreads,
duke@0 3481 // all of our threads will be assigned to real lwp's. Using the thr_setprio
duke@0 3482 // function is meaningless in this mode so we must adjust the real lwp's priority
duke@0 3483 // The routines below implement the getting and setting of lwp priorities.
duke@0 3484 //
duke@0 3485 // Note: There are three priority scales used on Solaris. Java priotities
duke@0 3486 // which range from 1 to 10, libthread "thr_setprio" scale which range
duke@0 3487 // from 0 to 127, and the current scheduling class of the process we
duke@0 3488 // are running in. This is typically from -60 to +60.
duke@0 3489 // The setting of the lwp priorities in done after a call to thr_setprio
duke@0 3490 // so Java priorities are mapped to libthread priorities and we map from
duke@0 3491 // the latter to lwp priorities. We don't keep priorities stored in
duke@0 3492 // Java priorities since some of our worker threads want to set priorities
duke@0 3493 // higher than all Java threads.
duke@0 3494 //
duke@0 3495 // For related information:
duke@0 3496 // (1) man -s 2 priocntl
duke@0 3497 // (2) man -s 4 priocntl
duke@0 3498 // (3) man dispadmin
duke@0 3499 // = librt.so
duke@0 3500 // = libthread/common/rtsched.c - thrp_setlwpprio().
duke@0 3501 // = ps -cL <pid> ... to validate priority.
duke@0 3502 // = sched_get_priority_min and _max
duke@0 3503 // pthread_create
duke@0 3504 // sched_setparam
duke@0 3505 // pthread_setschedparam
duke@0 3506 //
duke@0 3507 // Assumptions:
duke@0 3508 // + We assume that all threads in the process belong to the same
duke@0 3509 // scheduling class. IE. an homogenous process.
duke@0 3510 // + Must be root or in IA group to change change "interactive" attribute.
duke@0 3511 // Priocntl() will fail silently. The only indication of failure is when
duke@0 3512 // we read-back the value and notice that it hasn't changed.
duke@0 3513 // + Interactive threads enter the runq at the head, non-interactive at the tail.
duke@0 3514 // + For RT, change timeslice as well. Invariant:
duke@0 3515 // constant "priority integral"
duke@0 3516 // Konst == TimeSlice * (60-Priority)
duke@0 3517 // Given a priority, compute appropriate timeslice.
duke@0 3518 // + Higher numerical values have higher priority.
duke@0 3519
duke@0 3520 // sched class attributes
duke@0 3521 typedef struct {
duke@0 3522 int schedPolicy; // classID
duke@0 3523 int maxPrio;
duke@0 3524 int minPrio;
duke@0 3525 } SchedInfo;
duke@0 3526
duke@0 3527
duke@0 3528 static SchedInfo tsLimits, iaLimits, rtLimits;
duke@0 3529
duke@0 3530 #ifdef ASSERT
duke@0 3531 static int ReadBackValidate = 1;
duke@0 3532 #endif
duke@0 3533 static int myClass = 0;
duke@0 3534 static int myMin = 0;
duke@0 3535 static int myMax = 0;
duke@0 3536 static int myCur = 0;
duke@0 3537 static bool priocntl_enable = false;
duke@0 3538
duke@0 3539
duke@0 3540 // Call the version of priocntl suitable for all supported versions
duke@0 3541 // of Solaris. We need to call through this wrapper so that we can
duke@0 3542 // build on Solaris 9 and run on Solaris 8, 9 and 10.
duke@0 3543 //
duke@0 3544 // This code should be removed if we ever stop supporting Solaris 8
duke@0 3545 // and earlier releases.
duke@0 3546
duke@0 3547 static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg);
duke@0 3548 typedef long (*priocntl_type)(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg);
duke@0 3549 static priocntl_type priocntl_ptr = priocntl_stub;
duke@0 3550
duke@0 3551 // Stub to set the value of the real pointer, and then call the real
duke@0 3552 // function.
duke@0 3553
duke@0 3554 static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg) {
duke@0 3555 // Try Solaris 8- name only.
duke@0 3556 priocntl_type tmp = (priocntl_type)dlsym(RTLD_DEFAULT, "__priocntl");
duke@0 3557 guarantee(tmp != NULL, "priocntl function not found.");
duke@0 3558 priocntl_ptr = tmp;
duke@0 3559 return (*priocntl_ptr)(PC_VERSION, idtype, id, cmd, arg);
duke@0 3560 }
duke@0 3561
duke@0 3562
duke@0 3563 // lwp_priocntl_init
duke@0 3564 //
duke@0 3565 // Try to determine the priority scale for our process.
duke@0 3566 //
duke@0 3567 // Return errno or 0 if OK.
duke@0 3568 //
duke@0 3569 static
duke@0 3570 int lwp_priocntl_init ()
duke@0 3571 {
duke@0 3572 int rslt;
duke@0 3573 pcinfo_t ClassInfo;
duke@0 3574 pcparms_t ParmInfo;
duke@0 3575 int i;
duke@0 3576
duke@0 3577 if (!UseThreadPriorities) return 0;
duke@0 3578
duke@0 3579 // We are using Bound threads, we need to determine our priority ranges
duke@0 3580 if (os::Solaris::T2_libthread() || UseBoundThreads) {
duke@0 3581 // If ThreadPriorityPolicy is 1, switch tables
duke@0 3582 if (ThreadPriorityPolicy == 1) {
duke@0 3583 for (i = 0 ; i < MaxPriority+1; i++)
duke@0 3584 os::java_to_os_priority[i] = prio_policy1[i];
duke@0 3585 }
duke@0 3586 }
duke@0 3587 // Not using Bound Threads, set to ThreadPolicy 1
duke@0 3588 else {
duke@0 3589 for ( i = 0 ; i < MaxPriority+1; i++ ) {
duke@0 3590 os::java_to_os_priority[i] = prio_policy1[i];
duke@0 3591 }
duke@0 3592 return 0;
duke@0 3593 }
duke@0 3594
duke@0 3595
duke@0 3596 // Get IDs for a set of well-known scheduling classes.
duke@0 3597 // TODO-FIXME: GETCLINFO returns the current # of classes in the
duke@0 3598 // the system. We should have a loop that iterates over the
duke@0 3599 // classID values, which are known to be "small" integers.
duke@0 3600
duke@0 3601 strcpy(ClassInfo.pc_clname, "TS");
duke@0 3602 ClassInfo.pc_cid = -1;
duke@0 3603 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
duke@0 3604 if (rslt < 0) return errno;
duke@0 3605 assert(ClassInfo.pc_cid != -1, "cid for TS class is -1");
duke@0 3606 tsLimits.schedPolicy = ClassInfo.pc_cid;
duke@0 3607 tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri;
duke@0 3608 tsLimits.minPrio = -tsLimits.maxPrio;
duke@0 3609
duke@0 3610 strcpy(ClassInfo.pc_clname, "IA");
duke@0 3611 ClassInfo.pc_cid = -1;
duke@0 3612 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
duke@0 3613 if (rslt < 0) return errno;
duke@0 3614 assert(ClassInfo.pc_cid != -1, "cid for IA class is -1");
duke@0 3615 iaLimits.schedPolicy = ClassInfo.pc_cid;
duke@0 3616 iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri;
duke@0 3617 iaLimits.minPrio = -iaLimits.maxPrio;
duke@0 3618
duke@0 3619 strcpy(ClassInfo.pc_clname, "RT");
duke@0 3620 ClassInfo.pc_cid = -1;
duke@0 3621 rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
duke@0 3622 if (rslt < 0) return errno;
duke@0 3623 assert(ClassInfo.pc_cid != -1, "cid for RT class is -1");
duke@0 3624 rtLimits.schedPolicy = ClassInfo.pc_cid;
duke@0 3625 rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri;
duke@0 3626 rtLimits.minPrio = 0;
duke@0 3627
duke@0 3628
duke@0 3629 // Query our "current" scheduling class.
duke@0 3630 // This will normally be IA,TS or, rarely, RT.
duke@0 3631 memset (&ParmInfo, 0, sizeof(ParmInfo));
duke@0 3632 ParmInfo.pc_cid = PC_CLNULL;
duke@0 3633 rslt = (*priocntl_ptr) (PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo );
duke@0 3634 if ( rslt < 0 ) return errno;
duke@0 3635 myClass = ParmInfo.pc_cid;
duke@0 3636
duke@0 3637 // We now know our scheduling classId, get specific information
duke@0 3638 // the class.
duke@0 3639 ClassInfo.pc_cid = myClass;
duke@0 3640 ClassInfo.pc_clname[0] = 0;
duke@0 3641 rslt = (*priocntl_ptr) (PC_VERSION, (idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo );
duke@0 3642 if ( rslt < 0 ) return errno;
duke@0 3643
duke@0 3644 if (ThreadPriorityVerbose)
duke@0 3645 tty->print_cr ("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname);
duke@0 3646
duke@0 3647 memset(&ParmInfo, 0, sizeof(pcparms_t));
duke@0 3648 ParmInfo.pc_cid = PC_CLNULL;
duke@0 3649 rslt = (*priocntl_ptr)(PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo);
duke@0 3650 if (rslt < 0) return errno;
duke@0 3651
duke@0 3652 if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
duke@0 3653 myMin = rtLimits.minPrio;
duke@0 3654 myMax = rtLimits.maxPrio;
duke@0 3655 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
duke@0 3656 iaparms_t *iaInfo = (iaparms_t*)ParmInfo.pc_clparms;
duke@0 3657 myMin = iaLimits.minPrio;
duke@0 3658 myMax = iaLimits.maxPrio;
duke@0 3659 myMax = MIN2(myMax, (int)iaInfo->ia_uprilim); // clamp - restrict
duke@0 3660 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
duke@0 3661 tsparms_t *tsInfo = (tsparms_t*)ParmInfo.pc_clparms;
duke@0 3662 myMin = tsLimits.minPrio;
duke@0 3663 myMax = tsLimits.maxPrio;
duke@0 3664 myMax = MIN2(myMax, (int)tsInfo->ts_uprilim); // clamp - restrict
duke@0 3665 } else {
duke@0 3666 // No clue - punt
duke@0 3667 if (ThreadPriorityVerbose)
duke@0 3668 tty->print_cr ("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname);
duke@0 3669 return EINVAL; // no clue, punt
duke@0 3670 }
duke@0 3671
duke@0 3672 if (ThreadPriorityVerbose)
duke@0 3673 tty->print_cr ("Thread priority Range: [%d..%d]\n", myMin, myMax);
duke@0 3674
duke@0 3675 priocntl_enable = true; // Enable changing priorities
duke@0 3676 return 0;
duke@0 3677 }
duke@0 3678
duke@0 3679 #define IAPRI(x) ((iaparms_t *)((x).pc_clparms))
duke@0 3680 #define RTPRI(x) ((rtparms_t *)((x).pc_clparms))
duke@0 3681 #define TSPRI(x) ((tsparms_t *)((x).pc_clparms))
duke@0 3682
duke@0 3683
duke@0 3684 // scale_to_lwp_priority
duke@0 3685 //
duke@0 3686 // Convert from the libthread "thr_setprio" scale to our current
duke@0 3687 // lwp scheduling class scale.
duke@0 3688 //
duke@0 3689 static
duke@0 3690 int scale_to_lwp_priority (int rMin, int rMax, int x)
duke@0 3691 {
duke@0 3692 int v;
duke@0 3693
duke@0 3694 if (x == 127) return rMax; // avoid round-down
duke@0 3695 v = (((x*(rMax-rMin)))/128)+rMin;
duke@0 3696 return v;
duke@0 3697 }
duke@0 3698
duke@0 3699
duke@0 3700 // set_lwp_priority
duke@0 3701 //
duke@0 3702 // Set the priority of the lwp. This call should only be made
duke@0 3703 // when using bound threads (T2 threads are bound by default).
duke@0 3704 //
duke@0 3705 int set_lwp_priority (int ThreadID, int lwpid, int newPrio )
duke@0 3706 {
duke@0 3707 int rslt;
duke@0 3708 int Actual, Expected, prv;
duke@0 3709 pcparms_t ParmInfo; // for GET-SET
duke@0 3710 #ifdef ASSERT
duke@0 3711 pcparms_t ReadBack; // for readback
duke@0 3712 #endif
duke@0 3713
duke@0 3714 // Set priority via PC_GETPARMS, update, PC_SETPARMS
duke@0 3715 // Query current values.
duke@0 3716 // TODO: accelerate this by eliminating the PC_GETPARMS call.
duke@0 3717 // Cache "pcparms_t" in global ParmCache.
duke@0 3718 // TODO: elide set-to-same-value
duke@0 3719
duke@0 3720 // If something went wrong on init, don't change priorities.
duke@0 3721 if ( !priocntl_enable ) {
duke@0 3722 if (ThreadPriorityVerbose)
duke@0 3723 tty->print_cr("Trying to set priority but init failed, ignoring");
duke@0 3724 return EINVAL;
duke@0 3725 }
duke@0 3726
duke@0 3727
duke@0 3728 // If lwp hasn't started yet, just return
duke@0 3729 // the _start routine will call us again.
duke@0 3730 if ( lwpid <= 0 ) {
duke@0 3731 if (ThreadPriorityVerbose) {
duke@0 3732 tty->print_cr ("deferring the set_lwp_priority of thread " INTPTR_FORMAT " to %d, lwpid not set",
duke@0 3733 ThreadID, newPrio);
duke@0 3734 }
duke@0 3735 return 0;
duke@0 3736 }
duke@0 3737
duke@0 3738 if (ThreadPriorityVerbose) {
duke@0 3739 tty->print_cr ("set_lwp_priority(" INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ",
duke@0 3740 ThreadID, lwpid, newPrio);
duke@0 3741 }
duke@0 3742
duke@0 3743 memset(&ParmInfo, 0, sizeof(pcparms_t));
duke@0 3744 ParmInfo.pc_cid = PC_CLNULL;
duke@0 3745 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo);
duke@0 3746 if (rslt < 0) return errno;
duke@0 3747
duke@0 3748 if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
duke@0 3749 rtparms_t *rtInfo = (rtparms_t*)ParmInfo.pc_clparms;