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