annotate src/os/solaris/vm/os_solaris.cpp @ 1999:2c8e1acf0433

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