Wed, 16 Nov 2011 20:38:24 -0500
7110017: is_headless_jre should be updated to reflect the new location of awt toolkit libraries
Reviewed-by: dholmes, dsamersoff
Contributed-by: Chris Hegarty <chris.hegarty@oracle.com>
1 /*
2 * Copyright (c) 1997, 2011, 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/loadavg.h>
118 # include <string.h>
119 # include <stdio.h>
121 # define _STRUCTURED_PROC 1 // this gets us the new structured proc interfaces of 5.6 & later
122 # include <sys/procfs.h> // see comment in <sys/procfs.h>
124 #define MAX_PATH (2 * K)
126 // for timer info max values which include all bits
127 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
129 #ifdef _GNU_SOURCE
130 // See bug #6514594
131 extern "C" int madvise(caddr_t, size_t, int);
132 extern "C" int memcntl(caddr_t addr, size_t len, int cmd, caddr_t arg,
133 int attr, int mask);
134 #endif //_GNU_SOURCE
136 /*
137 MPSS Changes Start.
138 The JVM binary needs to be built and run on pre-Solaris 9
139 systems, but the constants needed by MPSS are only in Solaris 9
140 header files. They are textually replicated here to allow
141 building on earlier systems. Once building on Solaris 8 is
142 no longer a requirement, these #defines can be replaced by ordinary
143 system .h inclusion.
145 In earlier versions of the JDK and Solaris, we used ISM for large pages.
146 But ISM requires shared memory to achieve this and thus has many caveats.
147 MPSS is a fully transparent and is a cleaner way to get large pages.
148 Although we still require keeping ISM for backward compatiblitiy as well as
149 giving the opportunity to use large pages on older systems it is
150 recommended that MPSS be used for Solaris 9 and above.
152 */
154 #ifndef MC_HAT_ADVISE
156 struct memcntl_mha {
157 uint_t mha_cmd; /* command(s) */
158 uint_t mha_flags;
159 size_t mha_pagesize;
160 };
161 #define MC_HAT_ADVISE 7 /* advise hat map size */
162 #define MHA_MAPSIZE_VA 0x1 /* set preferred page size */
163 #define MAP_ALIGN 0x200 /* addr specifies alignment */
165 #endif
166 // MPSS Changes End.
169 // Here are some liblgrp types from sys/lgrp_user.h to be able to
170 // compile on older systems without this header file.
172 #ifndef MADV_ACCESS_LWP
173 # define MADV_ACCESS_LWP 7 /* next LWP to access heavily */
174 #endif
175 #ifndef MADV_ACCESS_MANY
176 # define MADV_ACCESS_MANY 8 /* many processes to access heavily */
177 #endif
179 #ifndef LGRP_RSRC_CPU
180 # define LGRP_RSRC_CPU 0 /* CPU resources */
181 #endif
182 #ifndef LGRP_RSRC_MEM
183 # define LGRP_RSRC_MEM 1 /* memory resources */
184 #endif
186 // Some more macros from sys/mman.h that are not present in Solaris 8.
188 #ifndef MAX_MEMINFO_CNT
189 /*
190 * info_req request type definitions for meminfo
191 * request types starting with MEMINFO_V are used for Virtual addresses
192 * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical
193 * addresses
194 */
195 # define MEMINFO_SHIFT 16
196 # define MEMINFO_MASK (0xFF << MEMINFO_SHIFT)
197 # define MEMINFO_VPHYSICAL (0x01 << MEMINFO_SHIFT) /* get physical addr */
198 # define MEMINFO_VLGRP (0x02 << MEMINFO_SHIFT) /* get lgroup */
199 # define MEMINFO_VPAGESIZE (0x03 << MEMINFO_SHIFT) /* size of phys page */
200 # define MEMINFO_VREPLCNT (0x04 << MEMINFO_SHIFT) /* no. of replica */
201 # define MEMINFO_VREPL (0x05 << MEMINFO_SHIFT) /* physical replica */
202 # define MEMINFO_VREPL_LGRP (0x06 << MEMINFO_SHIFT) /* lgrp of replica */
203 # define MEMINFO_PLGRP (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */
205 /* maximum number of addresses meminfo() can process at a time */
206 # define MAX_MEMINFO_CNT 256
208 /* maximum number of request types */
209 # define MAX_MEMINFO_REQ 31
210 #endif
212 // see thr_setprio(3T) for the basis of these numbers
213 #define MinimumPriority 0
214 #define NormalPriority 64
215 #define MaximumPriority 127
217 // Values for ThreadPriorityPolicy == 1
218 int prio_policy1[MaxPriority+1] = { -99999, 0, 16, 32, 48, 64,
219 80, 96, 112, 124, 127 };
221 // System parameters used internally
222 static clock_t clock_tics_per_sec = 100;
224 // Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+)
225 static bool enabled_extended_FILE_stdio = false;
227 // For diagnostics to print a message once. see run_periodic_checks
228 static bool check_addr0_done = false;
229 static sigset_t check_signal_done;
230 static bool check_signals = true;
232 address os::Solaris::handler_start; // start pc of thr_sighndlrinfo
233 address os::Solaris::handler_end; // end pc of thr_sighndlrinfo
235 address os::Solaris::_main_stack_base = NULL; // 4352906 workaround
238 // "default" initializers for missing libc APIs
239 extern "C" {
240 static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
241 static int lwp_mutex_destroy(mutex_t *mx) { return 0; }
243 static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
244 static int lwp_cond_destroy(cond_t *cv) { return 0; }
245 }
247 // "default" initializers for pthread-based synchronization
248 extern "C" {
249 static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
250 static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
251 }
253 // Thread Local Storage
254 // This is common to all Solaris platforms so it is defined here,
255 // in this common file.
256 // The declarations are in the os_cpu threadLS*.hpp files.
257 //
258 // Static member initialization for TLS
259 Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};
261 #ifndef PRODUCT
262 #define _PCT(n,d) ((100.0*(double)(n))/(double)(d))
264 int ThreadLocalStorage::_tcacheHit = 0;
265 int ThreadLocalStorage::_tcacheMiss = 0;
267 void ThreadLocalStorage::print_statistics() {
268 int total = _tcacheMiss+_tcacheHit;
269 tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",
270 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));
271 }
272 #undef _PCT
273 #endif // PRODUCT
275 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,
276 int index) {
277 Thread *thread = get_thread_slow();
278 if (thread != NULL) {
279 address sp = os::current_stack_pointer();
280 guarantee(thread->_stack_base == NULL ||
281 (sp <= thread->_stack_base &&
282 sp >= thread->_stack_base - thread->_stack_size) ||
283 is_error_reported(),
284 "sp must be inside of selected thread stack");
286 thread->set_self_raw_id(raw_id); // mark for quick retrieval
287 _get_thread_cache[ index ] = thread;
288 }
289 return thread;
290 }
293 static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0};
294 #define NO_CACHED_THREAD ((Thread*)all_zero)
296 void ThreadLocalStorage::pd_set_thread(Thread* thread) {
298 // Store the new value before updating the cache to prevent a race
299 // between get_thread_via_cache_slowly() and this store operation.
300 os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);
302 // Update thread cache with new thread if setting on thread create,
303 // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit.
304 uintptr_t raw = pd_raw_thread_id();
305 int ix = pd_cache_index(raw);
306 _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread;
307 }
309 void ThreadLocalStorage::pd_init() {
310 for (int i = 0; i < _pd_cache_size; i++) {
311 _get_thread_cache[i] = NO_CACHED_THREAD;
312 }
313 }
315 // Invalidate all the caches (happens to be the same as pd_init).
316 void ThreadLocalStorage::pd_invalidate_all() { pd_init(); }
318 #undef NO_CACHED_THREAD
320 // END Thread Local Storage
322 static inline size_t adjust_stack_size(address base, size_t size) {
323 if ((ssize_t)size < 0) {
324 // 4759953: Compensate for ridiculous stack size.
325 size = max_intx;
326 }
327 if (size > (size_t)base) {
328 // 4812466: Make sure size doesn't allow the stack to wrap the address space.
329 size = (size_t)base;
330 }
331 return size;
332 }
334 static inline stack_t get_stack_info() {
335 stack_t st;
336 int retval = thr_stksegment(&st);
337 st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);
338 assert(retval == 0, "incorrect return value from thr_stksegment");
339 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
340 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
341 return st;
342 }
344 address os::current_stack_base() {
345 int r = thr_main() ;
346 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
347 bool is_primordial_thread = r;
349 // Workaround 4352906, avoid calls to thr_stksegment by
350 // thr_main after the first one (it looks like we trash
351 // some data, causing the value for ss_sp to be incorrect).
352 if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) {
353 stack_t st = get_stack_info();
354 if (is_primordial_thread) {
355 // cache initial value of stack base
356 os::Solaris::_main_stack_base = (address)st.ss_sp;
357 }
358 return (address)st.ss_sp;
359 } else {
360 guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");
361 return os::Solaris::_main_stack_base;
362 }
363 }
365 size_t os::current_stack_size() {
366 size_t size;
368 int r = thr_main() ;
369 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
370 if(!r) {
371 size = get_stack_info().ss_size;
372 } else {
373 struct rlimit limits;
374 getrlimit(RLIMIT_STACK, &limits);
375 size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);
376 }
377 // base may not be page aligned
378 address base = current_stack_base();
379 address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());;
380 return (size_t)(base - bottom);
381 }
383 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
384 return localtime_r(clock, res);
385 }
387 // interruptible infrastructure
389 // setup_interruptible saves the thread state before going into an
390 // interruptible system call.
391 // The saved state is used to restore the thread to
392 // its former state whether or not an interrupt is received.
393 // Used by classloader os::read
394 // os::restartable_read calls skip this layer and stay in _thread_in_native
396 void os::Solaris::setup_interruptible(JavaThread* thread) {
398 JavaThreadState thread_state = thread->thread_state();
400 assert(thread_state != _thread_blocked, "Coming from the wrong thread");
401 assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible");
402 OSThread* osthread = thread->osthread();
403 osthread->set_saved_interrupt_thread_state(thread_state);
404 thread->frame_anchor()->make_walkable(thread);
405 ThreadStateTransition::transition(thread, thread_state, _thread_blocked);
406 }
408 // Version of setup_interruptible() for threads that are already in
409 // _thread_blocked. Used by os_sleep().
410 void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) {
411 thread->frame_anchor()->make_walkable(thread);
412 }
414 JavaThread* os::Solaris::setup_interruptible() {
415 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();
416 setup_interruptible(thread);
417 return thread;
418 }
420 void os::Solaris::try_enable_extended_io() {
421 typedef int (*enable_extended_FILE_stdio_t)(int, int);
423 if (!UseExtendedFileIO) {
424 return;
425 }
427 enable_extended_FILE_stdio_t enabler =
428 (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,
429 "enable_extended_FILE_stdio");
430 if (enabler) {
431 enabler(-1, -1);
432 }
433 }
436 #ifdef ASSERT
438 JavaThread* os::Solaris::setup_interruptible_native() {
439 JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();
440 JavaThreadState thread_state = thread->thread_state();
441 assert(thread_state == _thread_in_native, "Assumed thread_in_native");
442 return thread;
443 }
445 void os::Solaris::cleanup_interruptible_native(JavaThread* thread) {
446 JavaThreadState thread_state = thread->thread_state();
447 assert(thread_state == _thread_in_native, "Assumed thread_in_native");
448 }
449 #endif
451 // cleanup_interruptible reverses the effects of setup_interruptible
452 // setup_interruptible_already_blocked() does not need any cleanup.
454 void os::Solaris::cleanup_interruptible(JavaThread* thread) {
455 OSThread* osthread = thread->osthread();
457 ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state());
458 }
460 // I/O interruption related counters called in _INTERRUPTIBLE
462 void os::Solaris::bump_interrupted_before_count() {
463 RuntimeService::record_interrupted_before_count();
464 }
466 void os::Solaris::bump_interrupted_during_count() {
467 RuntimeService::record_interrupted_during_count();
468 }
470 static int _processors_online = 0;
472 jint os::Solaris::_os_thread_limit = 0;
473 volatile jint os::Solaris::_os_thread_count = 0;
475 julong os::available_memory() {
476 return Solaris::available_memory();
477 }
479 julong os::Solaris::available_memory() {
480 return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();
481 }
483 julong os::Solaris::_physical_memory = 0;
485 julong os::physical_memory() {
486 return Solaris::physical_memory();
487 }
489 julong os::allocatable_physical_memory(julong size) {
490 #ifdef _LP64
491 return size;
492 #else
493 julong result = MIN2(size, (julong)3835*M);
494 if (!is_allocatable(result)) {
495 // Memory allocations will be aligned but the alignment
496 // is not known at this point. Alignments will
497 // be at most to LargePageSizeInBytes. Protect
498 // allocations from alignments up to illegal
499 // values. If at this point 2G is illegal.
500 julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes;
501 result = MIN2(size, reasonable_size);
502 }
503 return result;
504 #endif
505 }
507 static hrtime_t first_hrtime = 0;
508 static const hrtime_t hrtime_hz = 1000*1000*1000;
509 const int LOCK_BUSY = 1;
510 const int LOCK_FREE = 0;
511 const int LOCK_INVALID = -1;
512 static volatile hrtime_t max_hrtime = 0;
513 static volatile int max_hrtime_lock = LOCK_FREE; // Update counter with LSB as lock-in-progress
516 void os::Solaris::initialize_system_info() {
517 set_processor_count(sysconf(_SC_NPROCESSORS_CONF));
518 _processors_online = sysconf (_SC_NPROCESSORS_ONLN);
519 _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);
520 }
522 int os::active_processor_count() {
523 int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
524 pid_t pid = getpid();
525 psetid_t pset = PS_NONE;
526 // Are we running in a processor set or is there any processor set around?
527 if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {
528 uint_t pset_cpus;
529 // Query the number of cpus available to us.
530 if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {
531 assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");
532 _processors_online = pset_cpus;
533 return pset_cpus;
534 }
535 }
536 // Otherwise return number of online cpus
537 return online_cpus;
538 }
540 static bool find_processors_in_pset(psetid_t pset,
541 processorid_t** id_array,
542 uint_t* id_length) {
543 bool result = false;
544 // Find the number of processors in the processor set.
545 if (pset_info(pset, NULL, id_length, NULL) == 0) {
546 // Make up an array to hold their ids.
547 *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
548 // Fill in the array with their processor ids.
549 if (pset_info(pset, NULL, id_length, *id_array) == 0) {
550 result = true;
551 }
552 }
553 return result;
554 }
556 // Callers of find_processors_online() must tolerate imprecise results --
557 // the system configuration can change asynchronously because of DR
558 // or explicit psradm operations.
559 //
560 // We also need to take care that the loop (below) terminates as the
561 // number of processors online can change between the _SC_NPROCESSORS_ONLN
562 // request and the loop that builds the list of processor ids. Unfortunately
563 // there's no reliable way to determine the maximum valid processor id,
564 // so we use a manifest constant, MAX_PROCESSOR_ID, instead. See p_online
565 // man pages, which claim the processor id set is "sparse, but
566 // not too sparse". MAX_PROCESSOR_ID is used to ensure that we eventually
567 // exit the loop.
568 //
569 // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's
570 // not available on S8.0.
572 static bool find_processors_online(processorid_t** id_array,
573 uint* id_length) {
574 const processorid_t MAX_PROCESSOR_ID = 100000 ;
575 // Find the number of processors online.
576 *id_length = sysconf(_SC_NPROCESSORS_ONLN);
577 // Make up an array to hold their ids.
578 *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
579 // Processors need not be numbered consecutively.
580 long found = 0;
581 processorid_t next = 0;
582 while (found < *id_length && next < MAX_PROCESSOR_ID) {
583 processor_info_t info;
584 if (processor_info(next, &info) == 0) {
585 // NB, PI_NOINTR processors are effectively online ...
586 if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {
587 (*id_array)[found] = next;
588 found += 1;
589 }
590 }
591 next += 1;
592 }
593 if (found < *id_length) {
594 // The loop above didn't identify the expected number of processors.
595 // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)
596 // and re-running the loop, above, but there's no guarantee of progress
597 // if the system configuration is in flux. Instead, we just return what
598 // we've got. Note that in the worst case find_processors_online() could
599 // return an empty set. (As a fall-back in the case of the empty set we
600 // could just return the ID of the current processor).
601 *id_length = found ;
602 }
604 return true;
605 }
607 static bool assign_distribution(processorid_t* id_array,
608 uint id_length,
609 uint* distribution,
610 uint distribution_length) {
611 // We assume we can assign processorid_t's to uint's.
612 assert(sizeof(processorid_t) == sizeof(uint),
613 "can't convert processorid_t to uint");
614 // Quick check to see if we won't succeed.
615 if (id_length < distribution_length) {
616 return false;
617 }
618 // Assign processor ids to the distribution.
619 // Try to shuffle processors to distribute work across boards,
620 // assuming 4 processors per board.
621 const uint processors_per_board = ProcessDistributionStride;
622 // Find the maximum processor id.
623 processorid_t max_id = 0;
624 for (uint m = 0; m < id_length; m += 1) {
625 max_id = MAX2(max_id, id_array[m]);
626 }
627 // The next id, to limit loops.
628 const processorid_t limit_id = max_id + 1;
629 // Make up markers for available processors.
630 bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id);
631 for (uint c = 0; c < limit_id; c += 1) {
632 available_id[c] = false;
633 }
634 for (uint a = 0; a < id_length; a += 1) {
635 available_id[id_array[a]] = true;
636 }
637 // Step by "boards", then by "slot", copying to "assigned".
638 // NEEDS_CLEANUP: The assignment of processors should be stateful,
639 // remembering which processors have been assigned by
640 // previous calls, etc., so as to distribute several
641 // independent calls of this method. What we'd like is
642 // It would be nice to have an API that let us ask
643 // how many processes are bound to a processor,
644 // but we don't have that, either.
645 // In the short term, "board" is static so that
646 // subsequent distributions don't all start at board 0.
647 static uint board = 0;
648 uint assigned = 0;
649 // Until we've found enough processors ....
650 while (assigned < distribution_length) {
651 // ... find the next available processor in the board.
652 for (uint slot = 0; slot < processors_per_board; slot += 1) {
653 uint try_id = board * processors_per_board + slot;
654 if ((try_id < limit_id) && (available_id[try_id] == true)) {
655 distribution[assigned] = try_id;
656 available_id[try_id] = false;
657 assigned += 1;
658 break;
659 }
660 }
661 board += 1;
662 if (board * processors_per_board + 0 >= limit_id) {
663 board = 0;
664 }
665 }
666 if (available_id != NULL) {
667 FREE_C_HEAP_ARRAY(bool, available_id);
668 }
669 return true;
670 }
672 void os::set_native_thread_name(const char *name) {
673 // Not yet implemented.
674 return;
675 }
677 bool os::distribute_processes(uint length, uint* distribution) {
678 bool result = false;
679 // Find the processor id's of all the available CPUs.
680 processorid_t* id_array = NULL;
681 uint id_length = 0;
682 // There are some races between querying information and using it,
683 // since processor sets can change dynamically.
684 psetid_t pset = PS_NONE;
685 // Are we running in a processor set?
686 if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {
687 result = find_processors_in_pset(pset, &id_array, &id_length);
688 } else {
689 result = find_processors_online(&id_array, &id_length);
690 }
691 if (result == true) {
692 if (id_length >= length) {
693 result = assign_distribution(id_array, id_length, distribution, length);
694 } else {
695 result = false;
696 }
697 }
698 if (id_array != NULL) {
699 FREE_C_HEAP_ARRAY(processorid_t, id_array);
700 }
701 return result;
702 }
704 bool os::bind_to_processor(uint processor_id) {
705 // We assume that a processorid_t can be stored in a uint.
706 assert(sizeof(uint) == sizeof(processorid_t),
707 "can't convert uint to processorid_t");
708 int bind_result =
709 processor_bind(P_LWPID, // bind LWP.
710 P_MYID, // bind current LWP.
711 (processorid_t) processor_id, // id.
712 NULL); // don't return old binding.
713 return (bind_result == 0);
714 }
716 bool os::getenv(const char* name, char* buffer, int len) {
717 char* val = ::getenv( name );
718 if ( val == NULL
719 || strlen(val) + 1 > len ) {
720 if (len > 0) buffer[0] = 0; // return a null string
721 return false;
722 }
723 strcpy( buffer, val );
724 return true;
725 }
728 // Return true if user is running as root.
730 bool os::have_special_privileges() {
731 static bool init = false;
732 static bool privileges = false;
733 if (!init) {
734 privileges = (getuid() != geteuid()) || (getgid() != getegid());
735 init = true;
736 }
737 return privileges;
738 }
741 void os::init_system_properties_values() {
742 char arch[12];
743 sysinfo(SI_ARCHITECTURE, arch, sizeof(arch));
745 // The next steps are taken in the product version:
746 //
747 // Obtain the JAVA_HOME value from the location of libjvm[_g].so.
748 // This library should be located at:
749 // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so.
750 //
751 // If "/jre/lib/" appears at the right place in the path, then we
752 // assume libjvm[_g].so is installed in a JDK and we use this path.
753 //
754 // Otherwise exit with message: "Could not create the Java virtual machine."
755 //
756 // The following extra steps are taken in the debugging version:
757 //
758 // If "/jre/lib/" does NOT appear at the right place in the path
759 // instead of exit check for $JAVA_HOME environment variable.
760 //
761 // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,
762 // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so
763 // it looks like libjvm[_g].so is installed there
764 // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so.
765 //
766 // Otherwise exit.
767 //
768 // Important note: if the location of libjvm.so changes this
769 // code needs to be changed accordingly.
771 // The next few definitions allow the code to be verbatim:
772 #define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))
773 #define free(p) FREE_C_HEAP_ARRAY(char, p)
774 #define getenv(n) ::getenv(n)
776 #define EXTENSIONS_DIR "/lib/ext"
777 #define ENDORSED_DIR "/lib/endorsed"
778 #define COMMON_DIR "/usr/jdk/packages"
780 {
781 /* sysclasspath, java_home, dll_dir */
782 {
783 char *home_path;
784 char *dll_path;
785 char *pslash;
786 char buf[MAXPATHLEN];
787 os::jvm_path(buf, sizeof(buf));
789 // Found the full path to libjvm.so.
790 // Now cut the path to <java_home>/jre if we can.
791 *(strrchr(buf, '/')) = '\0'; /* get rid of /libjvm.so */
792 pslash = strrchr(buf, '/');
793 if (pslash != NULL)
794 *pslash = '\0'; /* get rid of /{client|server|hotspot} */
795 dll_path = malloc(strlen(buf) + 1);
796 if (dll_path == NULL)
797 return;
798 strcpy(dll_path, buf);
799 Arguments::set_dll_dir(dll_path);
801 if (pslash != NULL) {
802 pslash = strrchr(buf, '/');
803 if (pslash != NULL) {
804 *pslash = '\0'; /* get rid of /<arch> */
805 pslash = strrchr(buf, '/');
806 if (pslash != NULL)
807 *pslash = '\0'; /* get rid of /lib */
808 }
809 }
811 home_path = malloc(strlen(buf) + 1);
812 if (home_path == NULL)
813 return;
814 strcpy(home_path, buf);
815 Arguments::set_java_home(home_path);
817 if (!set_boot_path('/', ':'))
818 return;
819 }
821 /*
822 * Where to look for native libraries
823 */
824 {
825 // Use dlinfo() to determine the correct java.library.path.
826 //
827 // If we're launched by the Java launcher, and the user
828 // does not set java.library.path explicitly on the commandline,
829 // the Java launcher sets LD_LIBRARY_PATH for us and unsets
830 // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64. In this case
831 // dlinfo returns LD_LIBRARY_PATH + crle settings (including
832 // /usr/lib), which is exactly what we want.
833 //
834 // If the user does set java.library.path, it completely
835 // overwrites this setting, and always has.
836 //
837 // If we're not launched by the Java launcher, we may
838 // get here with any/all of the LD_LIBRARY_PATH[_32|64]
839 // settings. Again, dlinfo does exactly what we want.
841 Dl_serinfo _info, *info = &_info;
842 Dl_serpath *path;
843 char* library_path;
844 char *common_path;
845 int i;
847 // determine search path count and required buffer size
848 if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {
849 vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());
850 }
852 // allocate new buffer and initialize
853 info = (Dl_serinfo*)malloc(_info.dls_size);
854 if (info == NULL) {
855 vm_exit_out_of_memory(_info.dls_size,
856 "init_system_properties_values info");
857 }
858 info->dls_size = _info.dls_size;
859 info->dls_cnt = _info.dls_cnt;
861 // obtain search path information
862 if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {
863 free(info);
864 vm_exit_during_initialization("dlinfo SERINFO request", dlerror());
865 }
867 path = &info->dls_serpath[0];
869 // Note: Due to a legacy implementation, most of the library path
870 // is set in the launcher. This was to accomodate linking restrictions
871 // on legacy Solaris implementations (which are no longer supported).
872 // Eventually, all the library path setting will be done here.
873 //
874 // However, to prevent the proliferation of improperly built native
875 // libraries, the new path component /usr/jdk/packages is added here.
877 // Determine the actual CPU architecture.
878 char cpu_arch[12];
879 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
880 #ifdef _LP64
881 // If we are a 64-bit vm, perform the following translations:
882 // sparc -> sparcv9
883 // i386 -> amd64
884 if (strcmp(cpu_arch, "sparc") == 0)
885 strcat(cpu_arch, "v9");
886 else if (strcmp(cpu_arch, "i386") == 0)
887 strcpy(cpu_arch, "amd64");
888 #endif
890 // Construct the invariant part of ld_library_path. Note that the
891 // space for the colon and the trailing null are provided by the
892 // nulls included by the sizeof operator.
893 size_t bufsize = sizeof(COMMON_DIR) + sizeof("/lib/") + strlen(cpu_arch);
894 common_path = malloc(bufsize);
895 if (common_path == NULL) {
896 free(info);
897 vm_exit_out_of_memory(bufsize,
898 "init_system_properties_values common_path");
899 }
900 sprintf(common_path, COMMON_DIR "/lib/%s", cpu_arch);
902 // struct size is more than sufficient for the path components obtained
903 // through the dlinfo() call, so only add additional space for the path
904 // components explicitly added here.
905 bufsize = info->dls_size + strlen(common_path);
906 library_path = malloc(bufsize);
907 if (library_path == NULL) {
908 free(info);
909 free(common_path);
910 vm_exit_out_of_memory(bufsize,
911 "init_system_properties_values library_path");
912 }
913 library_path[0] = '\0';
915 // Construct the desired Java library path from the linker's library
916 // search path.
917 //
918 // For compatibility, it is optimal that we insert the additional path
919 // components specific to the Java VM after those components specified
920 // in LD_LIBRARY_PATH (if any) but before those added by the ld.so
921 // infrastructure.
922 if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it
923 strcpy(library_path, common_path);
924 } else {
925 int inserted = 0;
926 for (i = 0; i < info->dls_cnt; i++, path++) {
927 uint_t flags = path->dls_flags & LA_SER_MASK;
928 if (((flags & LA_SER_LIBPATH) == 0) && !inserted) {
929 strcat(library_path, common_path);
930 strcat(library_path, os::path_separator());
931 inserted = 1;
932 }
933 strcat(library_path, path->dls_name);
934 strcat(library_path, os::path_separator());
935 }
936 // eliminate trailing path separator
937 library_path[strlen(library_path)-1] = '\0';
938 }
940 // happens before argument parsing - can't use a trace flag
941 // tty->print_raw("init_system_properties_values: native lib path: ");
942 // tty->print_raw_cr(library_path);
944 // callee copies into its own buffer
945 Arguments::set_library_path(library_path);
947 free(common_path);
948 free(library_path);
949 free(info);
950 }
952 /*
953 * Extensions directories.
954 *
955 * Note that the space for the colon and the trailing null are provided
956 * by the nulls included by the sizeof operator (so actually one byte more
957 * than necessary is allocated).
958 */
959 {
960 char *buf = (char *) malloc(strlen(Arguments::get_java_home()) +
961 sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) +
962 sizeof(EXTENSIONS_DIR));
963 sprintf(buf, "%s" EXTENSIONS_DIR ":" COMMON_DIR EXTENSIONS_DIR,
964 Arguments::get_java_home());
965 Arguments::set_ext_dirs(buf);
966 }
968 /* Endorsed standards default directory. */
969 {
970 char * buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR));
971 sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home());
972 Arguments::set_endorsed_dirs(buf);
973 }
974 }
976 #undef malloc
977 #undef free
978 #undef getenv
979 #undef EXTENSIONS_DIR
980 #undef ENDORSED_DIR
981 #undef COMMON_DIR
983 }
985 void os::breakpoint() {
986 BREAKPOINT;
987 }
989 bool os::obsolete_option(const JavaVMOption *option)
990 {
991 if (!strncmp(option->optionString, "-Xt", 3)) {
992 return true;
993 } else if (!strncmp(option->optionString, "-Xtm", 4)) {
994 return true;
995 } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) {
996 return true;
997 } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) {
998 return true;
999 }
1000 return false;
1001 }
1003 bool os::Solaris::valid_stack_address(Thread* thread, address sp) {
1004 address stackStart = (address)thread->stack_base();
1005 address stackEnd = (address)(stackStart - (address)thread->stack_size());
1006 if (sp < stackStart && sp >= stackEnd ) return true;
1007 return false;
1008 }
1010 extern "C" void breakpoint() {
1011 // use debugger to set breakpoint here
1012 }
1014 // Returns an estimate of the current stack pointer. Result must be guaranteed to
1015 // point into the calling threads stack, and be no lower than the current stack
1016 // pointer.
1017 address os::current_stack_pointer() {
1018 volatile int dummy;
1019 address sp = (address)&dummy + 8; // %%%% need to confirm if this is right
1020 return sp;
1021 }
1023 static thread_t main_thread;
1025 // Thread start routine for all new Java threads
1026 extern "C" void* java_start(void* thread_addr) {
1027 // Try to randomize the cache line index of hot stack frames.
1028 // This helps when threads of the same stack traces evict each other's
1029 // cache lines. The threads can be either from the same JVM instance, or
1030 // from different JVM instances. The benefit is especially true for
1031 // processors with hyperthreading technology.
1032 static int counter = 0;
1033 int pid = os::current_process_id();
1034 alloca(((pid ^ counter++) & 7) * 128);
1036 int prio;
1037 Thread* thread = (Thread*)thread_addr;
1038 OSThread* osthr = thread->osthread();
1040 osthr->set_lwp_id( _lwp_self() ); // Store lwp in case we are bound
1041 thread->_schedctl = (void *) schedctl_init () ;
1043 if (UseNUMA) {
1044 int lgrp_id = os::numa_get_group_id();
1045 if (lgrp_id != -1) {
1046 thread->set_lgrp_id(lgrp_id);
1047 }
1048 }
1050 // If the creator called set priority before we started,
1051 // we need to call set priority now that we have an lwp.
1052 // Get the priority from libthread and set the priority
1053 // for the new Solaris lwp.
1054 if ( osthr->thread_id() != -1 ) {
1055 if ( UseThreadPriorities ) {
1056 thr_getprio(osthr->thread_id(), &prio);
1057 if (ThreadPriorityVerbose) {
1058 tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is " 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 otherwise use NormalPriority
1358 if ( UseThreadPriorities ) {
1359 thr_setprio(tid, (DefaultThreadPriority == -1) ?
1360 java_to_os_priority[NormPriority] :
1361 DefaultThreadPriority);
1362 }
1364 // Initial thread state is INITIALIZED, not SUSPENDED
1365 osthread->set_state(INITIALIZED);
1367 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
1368 return true;
1369 }
1371 /* defined for >= Solaris 10. This allows builds on earlier versions
1372 * of Solaris to take advantage of the newly reserved Solaris JVM signals
1373 * With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2
1374 * and -XX:+UseAltSigs does nothing since these should have no conflict
1375 */
1376 #if !defined(SIGJVM1)
1377 #define SIGJVM1 39
1378 #define SIGJVM2 40
1379 #endif
1381 debug_only(static bool signal_sets_initialized = false);
1382 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
1383 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;
1384 int os::Solaris::_SIGasync = ASYNC_SIGNAL;
1386 bool os::Solaris::is_sig_ignored(int sig) {
1387 struct sigaction oact;
1388 sigaction(sig, (struct sigaction*)NULL, &oact);
1389 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
1390 : CAST_FROM_FN_PTR(void*, oact.sa_handler);
1391 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
1392 return true;
1393 else
1394 return false;
1395 }
1397 // Note: SIGRTMIN is a macro that calls sysconf() so it will
1398 // dynamically detect SIGRTMIN value for the system at runtime, not buildtime
1399 static bool isJVM1available() {
1400 return SIGJVM1 < SIGRTMIN;
1401 }
1403 void os::Solaris::signal_sets_init() {
1404 // Should also have an assertion stating we are still single-threaded.
1405 assert(!signal_sets_initialized, "Already initialized");
1406 // Fill in signals that are necessarily unblocked for all threads in
1407 // the VM. Currently, we unblock the following signals:
1408 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
1409 // by -Xrs (=ReduceSignalUsage));
1410 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
1411 // other threads. The "ReduceSignalUsage" boolean tells us not to alter
1412 // the dispositions or masks wrt these signals.
1413 // Programs embedding the VM that want to use the above signals for their
1414 // own purposes must, at this time, use the "-Xrs" option to prevent
1415 // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
1416 // (See bug 4345157, and other related bugs).
1417 // In reality, though, unblocking these signals is really a nop, since
1418 // these signals are not blocked by default.
1419 sigemptyset(&unblocked_sigs);
1420 sigemptyset(&allowdebug_blocked_sigs);
1421 sigaddset(&unblocked_sigs, SIGILL);
1422 sigaddset(&unblocked_sigs, SIGSEGV);
1423 sigaddset(&unblocked_sigs, SIGBUS);
1424 sigaddset(&unblocked_sigs, SIGFPE);
1426 if (isJVM1available) {
1427 os::Solaris::set_SIGinterrupt(SIGJVM1);
1428 os::Solaris::set_SIGasync(SIGJVM2);
1429 } else if (UseAltSigs) {
1430 os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL);
1431 os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL);
1432 } else {
1433 os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL);
1434 os::Solaris::set_SIGasync(ASYNC_SIGNAL);
1435 }
1437 sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt());
1438 sigaddset(&unblocked_sigs, os::Solaris::SIGasync());
1440 if (!ReduceSignalUsage) {
1441 if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
1442 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
1443 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
1444 }
1445 if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
1446 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
1447 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
1448 }
1449 if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
1450 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
1451 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
1452 }
1453 }
1454 // Fill in signals that are blocked by all but the VM thread.
1455 sigemptyset(&vm_sigs);
1456 if (!ReduceSignalUsage)
1457 sigaddset(&vm_sigs, BREAK_SIGNAL);
1458 debug_only(signal_sets_initialized = true);
1460 // For diagnostics only used in run_periodic_checks
1461 sigemptyset(&check_signal_done);
1462 }
1464 // These are signals that are unblocked while a thread is running Java.
1465 // (For some reason, they get blocked by default.)
1466 sigset_t* os::Solaris::unblocked_signals() {
1467 assert(signal_sets_initialized, "Not initialized");
1468 return &unblocked_sigs;
1469 }
1471 // These are the signals that are blocked while a (non-VM) thread is
1472 // running Java. Only the VM thread handles these signals.
1473 sigset_t* os::Solaris::vm_signals() {
1474 assert(signal_sets_initialized, "Not initialized");
1475 return &vm_sigs;
1476 }
1478 // These are signals that are blocked during cond_wait to allow debugger in
1479 sigset_t* os::Solaris::allowdebug_blocked_signals() {
1480 assert(signal_sets_initialized, "Not initialized");
1481 return &allowdebug_blocked_sigs;
1482 }
1485 void _handle_uncaught_cxx_exception() {
1486 VMError err("An uncaught C++ exception");
1487 err.report_and_die();
1488 }
1491 // First crack at OS-specific initialization, from inside the new thread.
1492 void os::initialize_thread() {
1493 int r = thr_main() ;
1494 guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
1495 if (r) {
1496 JavaThread* jt = (JavaThread *)Thread::current();
1497 assert(jt != NULL,"Sanity check");
1498 size_t stack_size;
1499 address base = jt->stack_base();
1500 if (Arguments::created_by_java_launcher()) {
1501 // Use 2MB to allow for Solaris 7 64 bit mode.
1502 stack_size = JavaThread::stack_size_at_create() == 0
1503 ? 2048*K : JavaThread::stack_size_at_create();
1505 // There are rare cases when we may have already used more than
1506 // the basic stack size allotment before this method is invoked.
1507 // Attempt to allow for a normally sized java_stack.
1508 size_t current_stack_offset = (size_t)(base - (address)&stack_size);
1509 stack_size += ReservedSpace::page_align_size_down(current_stack_offset);
1510 } else {
1511 // 6269555: If we were not created by a Java launcher, i.e. if we are
1512 // running embedded in a native application, treat the primordial thread
1513 // as much like a native attached thread as possible. This means using
1514 // the current stack size from thr_stksegment(), unless it is too large
1515 // to reliably setup guard pages. A reasonable max size is 8MB.
1516 size_t current_size = current_stack_size();
1517 // This should never happen, but just in case....
1518 if (current_size == 0) current_size = 2 * K * K;
1519 stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size;
1520 }
1521 address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());;
1522 stack_size = (size_t)(base - bottom);
1524 assert(stack_size > 0, "Stack size calculation problem");
1526 if (stack_size > jt->stack_size()) {
1527 NOT_PRODUCT(
1528 struct rlimit limits;
1529 getrlimit(RLIMIT_STACK, &limits);
1530 size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur);
1531 assert(size >= jt->stack_size(), "Stack size problem in main thread");
1532 )
1533 tty->print_cr(
1534 "Stack size of %d Kb exceeds current limit of %d Kb.\n"
1535 "(Stack sizes are rounded up to a multiple of the system page size.)\n"
1536 "See limit(1) to increase the stack size limit.",
1537 stack_size / K, jt->stack_size() / K);
1538 vm_exit(1);
1539 }
1540 assert(jt->stack_size() >= stack_size,
1541 "Attempt to map more stack than was allocated");
1542 jt->set_stack_size(stack_size);
1543 }
1545 // 5/22/01: Right now alternate signal stacks do not handle
1546 // throwing stack overflow exceptions, see bug 4463178
1547 // Until a fix is found for this, T2 will NOT imply alternate signal
1548 // stacks.
1549 // If using T2 libthread threads, install an alternate signal stack.
1550 // Because alternate stacks associate with LWPs on Solaris,
1551 // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads
1552 // we prefer to explicitly stack bang.
1553 // If not using T2 libthread, but using UseBoundThreads any threads
1554 // (primordial thread, jni_attachCurrentThread) we do not create,
1555 // probably are not bound, therefore they can not have an alternate
1556 // signal stack. Since our stack banging code is generated and
1557 // is shared across threads, all threads must be bound to allow
1558 // using alternate signal stacks. The alternative is to interpose
1559 // on _lwp_create to associate an alt sig stack with each LWP,
1560 // and this could be a problem when the JVM is embedded.
1561 // We would prefer to use alternate signal stacks with T2
1562 // Since there is currently no accurate way to detect T2
1563 // we do not. Assuming T2 when running T1 causes sig 11s or assertions
1564 // on installing alternate signal stacks
1567 // 05/09/03: removed alternate signal stack support for Solaris
1568 // The alternate signal stack mechanism is no longer needed to
1569 // handle stack overflow. This is now handled by allocating
1570 // guard pages (red zone) and stackbanging.
1571 // Initially the alternate signal stack mechanism was removed because
1572 // it did not work with T1 llibthread. Alternate
1573 // signal stacks MUST have all threads bound to lwps. Applications
1574 // can create their own threads and attach them without their being
1575 // bound under T1. This is frequently the case for the primordial thread.
1576 // If we were ever to reenable this mechanism we would need to
1577 // use the dynamic check for T2 libthread.
1579 os::Solaris::init_thread_fpu_state();
1580 std::set_terminate(_handle_uncaught_cxx_exception);
1581 }
1585 // Free Solaris resources related to the OSThread
1586 void os::free_thread(OSThread* osthread) {
1587 assert(osthread != NULL, "os::free_thread but osthread not set");
1590 // We are told to free resources of the argument thread,
1591 // but we can only really operate on the current thread.
1592 // The main thread must take the VMThread down synchronously
1593 // before the main thread exits and frees up CodeHeap
1594 guarantee((Thread::current()->osthread() == osthread
1595 || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread");
1596 if (Thread::current()->osthread() == osthread) {
1597 // Restore caller's signal mask
1598 sigset_t sigmask = osthread->caller_sigmask();
1599 thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);
1600 }
1601 delete osthread;
1602 }
1604 void os::pd_start_thread(Thread* thread) {
1605 int status = thr_continue(thread->osthread()->thread_id());
1606 assert_status(status == 0, status, "thr_continue failed");
1607 }
1610 intx os::current_thread_id() {
1611 return (intx)thr_self();
1612 }
1614 static pid_t _initial_pid = 0;
1616 int os::current_process_id() {
1617 return (int)(_initial_pid ? _initial_pid : getpid());
1618 }
1620 int os::allocate_thread_local_storage() {
1621 // %%% in Win32 this allocates a memory segment pointed to by a
1622 // register. Dan Stein can implement a similar feature in
1623 // Solaris. Alternatively, the VM can do the same thing
1624 // explicitly: malloc some storage and keep the pointer in a
1625 // register (which is part of the thread's context) (or keep it
1626 // in TLS).
1627 // %%% In current versions of Solaris, thr_self and TSD can
1628 // be accessed via short sequences of displaced indirections.
1629 // The value of thr_self is available as %g7(36).
1630 // The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4),
1631 // assuming that the current thread already has a value bound to k.
1632 // It may be worth experimenting with such access patterns,
1633 // and later having the parameters formally exported from a Solaris
1634 // interface. I think, however, that it will be faster to
1635 // maintain the invariant that %g2 always contains the
1636 // JavaThread in Java code, and have stubs simply
1637 // treat %g2 as a caller-save register, preserving it in a %lN.
1638 thread_key_t tk;
1639 if (thr_keycreate( &tk, NULL ) )
1640 fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed "
1641 "(%s)", strerror(errno)));
1642 return int(tk);
1643 }
1645 void os::free_thread_local_storage(int index) {
1646 // %%% don't think we need anything here
1647 // if ( pthread_key_delete((pthread_key_t) tk) )
1648 // fatal("os::free_thread_local_storage: pthread_key_delete failed");
1649 }
1651 #define SMALLINT 32 // libthread allocate for tsd_common is a version specific
1652 // small number - point is NO swap space available
1653 void os::thread_local_storage_at_put(int index, void* value) {
1654 // %%% this is used only in threadLocalStorage.cpp
1655 if (thr_setspecific((thread_key_t)index, value)) {
1656 if (errno == ENOMEM) {
1657 vm_exit_out_of_memory(SMALLINT, "thr_setspecific: out of swap space");
1658 } else {
1659 fatal(err_msg("os::thread_local_storage_at_put: thr_setspecific failed "
1660 "(%s)", strerror(errno)));
1661 }
1662 } else {
1663 ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ;
1664 }
1665 }
1667 // This function could be called before TLS is initialized, for example, when
1668 // VM receives an async signal or when VM causes a fatal error during
1669 // initialization. Return NULL if thr_getspecific() fails.
1670 void* os::thread_local_storage_at(int index) {
1671 // %%% this is used only in threadLocalStorage.cpp
1672 void* r = NULL;
1673 return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r;
1674 }
1677 const int NANOSECS_PER_MILLISECS = 1000000;
1678 // gethrtime can move backwards if read from one cpu and then a different cpu
1679 // getTimeNanos is guaranteed to not move backward on Solaris
1680 // local spinloop created as faster for a CAS on an int than
1681 // a CAS on a 64bit jlong. Also Atomic::cmpxchg for jlong is not
1682 // supported on sparc v8 or pre supports_cx8 intel boxes.
1683 // oldgetTimeNanos for systems which do not support CAS on 64bit jlong
1684 // i.e. sparc v8 and pre supports_cx8 (i486) intel boxes
1685 inline hrtime_t oldgetTimeNanos() {
1686 int gotlock = LOCK_INVALID;
1687 hrtime_t newtime = gethrtime();
1689 for (;;) {
1690 // grab lock for max_hrtime
1691 int curlock = max_hrtime_lock;
1692 if (curlock & LOCK_BUSY) continue;
1693 if (gotlock = Atomic::cmpxchg(LOCK_BUSY, &max_hrtime_lock, LOCK_FREE) != LOCK_FREE) continue;
1694 if (newtime > max_hrtime) {
1695 max_hrtime = newtime;
1696 } else {
1697 newtime = max_hrtime;
1698 }
1699 // release lock
1700 max_hrtime_lock = LOCK_FREE;
1701 return newtime;
1702 }
1703 }
1704 // gethrtime can move backwards if read from one cpu and then a different cpu
1705 // getTimeNanos is guaranteed to not move backward on Solaris
1706 inline hrtime_t getTimeNanos() {
1707 if (VM_Version::supports_cx8()) {
1708 const hrtime_t now = gethrtime();
1709 // Use atomic long load since 32-bit x86 uses 2 registers to keep long.
1710 const hrtime_t prev = Atomic::load((volatile jlong*)&max_hrtime);
1711 if (now <= prev) return prev; // same or retrograde time;
1712 const hrtime_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&max_hrtime, prev);
1713 assert(obsv >= prev, "invariant"); // Monotonicity
1714 // If the CAS succeeded then we're done and return "now".
1715 // If the CAS failed and the observed value "obs" is >= now then
1716 // we should return "obs". If the CAS failed and now > obs > prv then
1717 // some other thread raced this thread and installed a new value, in which case
1718 // we could either (a) retry the entire operation, (b) retry trying to install now
1719 // or (c) just return obs. We use (c). No loop is required although in some cases
1720 // we might discard a higher "now" value in deference to a slightly lower but freshly
1721 // installed obs value. That's entirely benign -- it admits no new orderings compared
1722 // to (a) or (b) -- and greatly reduces coherence traffic.
1723 // We might also condition (c) on the magnitude of the delta between obs and now.
1724 // Avoiding excessive CAS operations to hot RW locations is critical.
1725 // See http://blogs.sun.com/dave/entry/cas_and_cache_trivia_invalidate
1726 return (prev == obsv) ? now : obsv ;
1727 } else {
1728 return oldgetTimeNanos();
1729 }
1730 }
1732 // Time since start-up in seconds to a fine granularity.
1733 // Used by VMSelfDestructTimer and the MemProfiler.
1734 double os::elapsedTime() {
1735 return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz;
1736 }
1738 jlong os::elapsed_counter() {
1739 return (jlong)(getTimeNanos() - first_hrtime);
1740 }
1742 jlong os::elapsed_frequency() {
1743 return hrtime_hz;
1744 }
1746 // Return the real, user, and system times in seconds from an
1747 // arbitrary fixed point in the past.
1748 bool os::getTimesSecs(double* process_real_time,
1749 double* process_user_time,
1750 double* process_system_time) {
1751 struct tms ticks;
1752 clock_t real_ticks = times(&ticks);
1754 if (real_ticks == (clock_t) (-1)) {
1755 return false;
1756 } else {
1757 double ticks_per_second = (double) clock_tics_per_sec;
1758 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1759 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1760 // For consistency return the real time from getTimeNanos()
1761 // converted to seconds.
1762 *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS);
1764 return true;
1765 }
1766 }
1768 bool os::supports_vtime() { return true; }
1770 bool os::enable_vtime() {
1771 int fd = ::open("/proc/self/ctl", O_WRONLY);
1772 if (fd == -1)
1773 return false;
1775 long cmd[] = { PCSET, PR_MSACCT };
1776 int res = ::write(fd, cmd, sizeof(long) * 2);
1777 ::close(fd);
1778 if (res != sizeof(long) * 2)
1779 return false;
1781 return true;
1782 }
1784 bool os::vtime_enabled() {
1785 int fd = ::open("/proc/self/status", O_RDONLY);
1786 if (fd == -1)
1787 return false;
1789 pstatus_t status;
1790 int res = os::read(fd, (void*) &status, sizeof(pstatus_t));
1791 ::close(fd);
1792 if (res != sizeof(pstatus_t))
1793 return false;
1795 return status.pr_flags & PR_MSACCT;
1796 }
1798 double os::elapsedVTime() {
1799 return (double)gethrvtime() / (double)hrtime_hz;
1800 }
1802 // Used internally for comparisons only
1803 // getTimeMillis guaranteed to not move backwards on Solaris
1804 jlong getTimeMillis() {
1805 jlong nanotime = getTimeNanos();
1806 return (jlong)(nanotime / NANOSECS_PER_MILLISECS);
1807 }
1809 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis
1810 jlong os::javaTimeMillis() {
1811 timeval t;
1812 if (gettimeofday( &t, NULL) == -1)
1813 fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno)));
1814 return jlong(t.tv_sec) * 1000 + jlong(t.tv_usec) / 1000;
1815 }
1817 jlong os::javaTimeNanos() {
1818 return (jlong)getTimeNanos();
1819 }
1821 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1822 info_ptr->max_value = ALL_64_BITS; // gethrtime() uses all 64 bits
1823 info_ptr->may_skip_backward = false; // not subject to resetting or drifting
1824 info_ptr->may_skip_forward = false; // not subject to resetting or drifting
1825 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time
1826 }
1828 char * os::local_time_string(char *buf, size_t buflen) {
1829 struct tm t;
1830 time_t long_time;
1831 time(&long_time);
1832 localtime_r(&long_time, &t);
1833 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1834 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1835 t.tm_hour, t.tm_min, t.tm_sec);
1836 return buf;
1837 }
1839 // Note: os::shutdown() might be called very early during initialization, or
1840 // called from signal handler. Before adding something to os::shutdown(), make
1841 // sure it is async-safe and can handle partially initialized VM.
1842 void os::shutdown() {
1844 // allow PerfMemory to attempt cleanup of any persistent resources
1845 perfMemory_exit();
1847 // needs to remove object in file system
1848 AttachListener::abort();
1850 // flush buffered output, finish log files
1851 ostream_abort();
1853 // Check for abort hook
1854 abort_hook_t abort_hook = Arguments::abort_hook();
1855 if (abort_hook != NULL) {
1856 abort_hook();
1857 }
1858 }
1860 // Note: os::abort() might be called very early during initialization, or
1861 // called from signal handler. Before adding something to os::abort(), make
1862 // sure it is async-safe and can handle partially initialized VM.
1863 void os::abort(bool dump_core) {
1864 os::shutdown();
1865 if (dump_core) {
1866 #ifndef PRODUCT
1867 fdStream out(defaultStream::output_fd());
1868 out.print_raw("Current thread is ");
1869 char buf[16];
1870 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1871 out.print_raw_cr(buf);
1872 out.print_raw_cr("Dumping core ...");
1873 #endif
1874 ::abort(); // dump core (for debugging)
1875 }
1877 ::exit(1);
1878 }
1880 // Die immediately, no exit hook, no abort hook, no cleanup.
1881 void os::die() {
1882 _exit(-1);
1883 }
1885 // unused
1886 void os::set_error_file(const char *logfile) {}
1888 // DLL functions
1890 const char* os::dll_file_extension() { return ".so"; }
1892 // This must be hard coded because it's the system's temporary
1893 // directory not the java application's temp directory, ala java.io.tmpdir.
1894 const char* os::get_temp_directory() { return "/tmp"; }
1896 static bool file_exists(const char* filename) {
1897 struct stat statbuf;
1898 if (filename == NULL || strlen(filename) == 0) {
1899 return false;
1900 }
1901 return os::stat(filename, &statbuf) == 0;
1902 }
1904 void os::dll_build_name(char* buffer, size_t buflen,
1905 const char* pname, const char* fname) {
1906 const size_t pnamelen = pname ? strlen(pname) : 0;
1908 // Quietly truncate on buffer overflow. Should be an error.
1909 if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1910 *buffer = '\0';
1911 return;
1912 }
1914 if (pnamelen == 0) {
1915 snprintf(buffer, buflen, "lib%s.so", fname);
1916 } else if (strchr(pname, *os::path_separator()) != NULL) {
1917 int n;
1918 char** pelements = split_path(pname, &n);
1919 for (int i = 0 ; i < n ; i++) {
1920 // really shouldn't be NULL but what the heck, check can't hurt
1921 if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1922 continue; // skip the empty path values
1923 }
1924 snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1925 if (file_exists(buffer)) {
1926 break;
1927 }
1928 }
1929 // release the storage
1930 for (int i = 0 ; i < n ; i++) {
1931 if (pelements[i] != NULL) {
1932 FREE_C_HEAP_ARRAY(char, pelements[i]);
1933 }
1934 }
1935 if (pelements != NULL) {
1936 FREE_C_HEAP_ARRAY(char*, pelements);
1937 }
1938 } else {
1939 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1940 }
1941 }
1943 const char* os::get_current_directory(char *buf, int buflen) {
1944 return getcwd(buf, buflen);
1945 }
1947 // check if addr is inside libjvm[_g].so
1948 bool os::address_is_in_vm(address addr) {
1949 static address libjvm_base_addr;
1950 Dl_info dlinfo;
1952 if (libjvm_base_addr == NULL) {
1953 dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo);
1954 libjvm_base_addr = (address)dlinfo.dli_fbase;
1955 assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");
1956 }
1958 if (dladdr((void *)addr, &dlinfo)) {
1959 if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;
1960 }
1962 return false;
1963 }
1965 typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int);
1966 static dladdr1_func_type dladdr1_func = NULL;
1968 bool os::dll_address_to_function_name(address addr, char *buf,
1969 int buflen, int * offset) {
1970 Dl_info dlinfo;
1972 // dladdr1_func was initialized in os::init()
1973 if (dladdr1_func){
1974 // yes, we have dladdr1
1976 // Support for dladdr1 is checked at runtime; it may be
1977 // available even if the vm is built on a machine that does
1978 // not have dladdr1 support. Make sure there is a value for
1979 // RTLD_DL_SYMENT.
1980 #ifndef RTLD_DL_SYMENT
1981 #define RTLD_DL_SYMENT 1
1982 #endif
1983 #ifdef _LP64
1984 Elf64_Sym * info;
1985 #else
1986 Elf32_Sym * info;
1987 #endif
1988 if (dladdr1_func((void *)addr, &dlinfo, (void **)&info,
1989 RTLD_DL_SYMENT)) {
1990 if ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr) {
1991 if (buf != NULL) {
1992 if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen))
1993 jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);
1994 }
1995 if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
1996 return true;
1997 }
1998 }
1999 if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) {
2000 if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
2001 dlinfo.dli_fname, buf, buflen, offset) == Decoder::no_error) {
2002 return true;
2003 }
2004 }
2005 if (buf != NULL) buf[0] = '\0';
2006 if (offset != NULL) *offset = -1;
2007 return false;
2008 } else {
2009 // no, only dladdr is available
2010 if (dladdr((void *)addr, &dlinfo)) {
2011 if (buf != NULL) {
2012 if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen))
2013 jio_snprintf(buf, buflen, dlinfo.dli_sname);
2014 }
2015 if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
2016 return true;
2017 } else if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) {
2018 if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
2019 dlinfo.dli_fname, buf, buflen, offset) == Decoder::no_error) {
2020 return true;
2021 }
2022 }
2023 if (buf != NULL) buf[0] = '\0';
2024 if (offset != NULL) *offset = -1;
2025 return false;
2026 }
2027 }
2029 bool os::dll_address_to_library_name(address addr, char* buf,
2030 int buflen, int* offset) {
2031 Dl_info dlinfo;
2033 if (dladdr((void*)addr, &dlinfo)){
2034 if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
2035 if (offset) *offset = addr - (address)dlinfo.dli_fbase;
2036 return true;
2037 } else {
2038 if (buf) buf[0] = '\0';
2039 if (offset) *offset = -1;
2040 return false;
2041 }
2042 }
2044 // Prints the names and full paths of all opened dynamic libraries
2045 // for current process
2046 void os::print_dll_info(outputStream * st) {
2047 Dl_info dli;
2048 void *handle;
2049 Link_map *map;
2050 Link_map *p;
2052 st->print_cr("Dynamic libraries:"); st->flush();
2054 if (!dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli)) {
2055 st->print_cr("Error: Cannot print dynamic libraries.");
2056 return;
2057 }
2058 handle = dlopen(dli.dli_fname, RTLD_LAZY);
2059 if (handle == NULL) {
2060 st->print_cr("Error: Cannot print dynamic libraries.");
2061 return;
2062 }
2063 dlinfo(handle, RTLD_DI_LINKMAP, &map);
2064 if (map == NULL) {
2065 st->print_cr("Error: Cannot print dynamic libraries.");
2066 return;
2067 }
2069 while (map->l_prev != NULL)
2070 map = map->l_prev;
2072 while (map != NULL) {
2073 st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);
2074 map = map->l_next;
2075 }
2077 dlclose(handle);
2078 }
2080 // Loads .dll/.so and
2081 // in case of error it checks if .dll/.so was built for the
2082 // same architecture as Hotspot is running on
2084 void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
2085 {
2086 void * result= ::dlopen(filename, RTLD_LAZY);
2087 if (result != NULL) {
2088 // Successful loading
2089 return result;
2090 }
2092 Elf32_Ehdr elf_head;
2094 // Read system error message into ebuf
2095 // It may or may not be overwritten below
2096 ::strncpy(ebuf, ::dlerror(), ebuflen-1);
2097 ebuf[ebuflen-1]='\0';
2098 int diag_msg_max_length=ebuflen-strlen(ebuf);
2099 char* diag_msg_buf=ebuf+strlen(ebuf);
2101 if (diag_msg_max_length==0) {
2102 // No more space in ebuf for additional diagnostics message
2103 return NULL;
2104 }
2107 int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);
2109 if (file_descriptor < 0) {
2110 // Can't open library, report dlerror() message
2111 return NULL;
2112 }
2114 bool failed_to_read_elf_head=
2115 (sizeof(elf_head)!=
2116 (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
2118 ::close(file_descriptor);
2119 if (failed_to_read_elf_head) {
2120 // file i/o error - report dlerror() msg
2121 return NULL;
2122 }
2124 typedef struct {
2125 Elf32_Half code; // Actual value as defined in elf.h
2126 Elf32_Half compat_class; // Compatibility of archs at VM's sense
2127 char elf_class; // 32 or 64 bit
2128 char endianess; // MSB or LSB
2129 char* name; // String representation
2130 } arch_t;
2132 static const arch_t arch_array[]={
2133 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
2134 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
2135 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
2136 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
2137 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
2138 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
2139 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
2140 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
2141 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
2142 {EM_ARM, EM_ARM, ELFCLASS32, ELFDATA2LSB, (char*)"ARM 32"}
2143 };
2145 #if (defined IA32)
2146 static Elf32_Half running_arch_code=EM_386;
2147 #elif (defined AMD64)
2148 static Elf32_Half running_arch_code=EM_X86_64;
2149 #elif (defined IA64)
2150 static Elf32_Half running_arch_code=EM_IA_64;
2151 #elif (defined __sparc) && (defined _LP64)
2152 static Elf32_Half running_arch_code=EM_SPARCV9;
2153 #elif (defined __sparc) && (!defined _LP64)
2154 static Elf32_Half running_arch_code=EM_SPARC;
2155 #elif (defined __powerpc64__)
2156 static Elf32_Half running_arch_code=EM_PPC64;
2157 #elif (defined __powerpc__)
2158 static Elf32_Half running_arch_code=EM_PPC;
2159 #elif (defined ARM)
2160 static Elf32_Half running_arch_code=EM_ARM;
2161 #else
2162 #error Method os::dll_load requires that one of following is defined:\
2163 IA32, AMD64, IA64, __sparc, __powerpc__, ARM, ARM
2164 #endif
2166 // Identify compatability class for VM's architecture and library's architecture
2167 // Obtain string descriptions for architectures
2169 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
2170 int running_arch_index=-1;
2172 for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
2173 if (running_arch_code == arch_array[i].code) {
2174 running_arch_index = i;
2175 }
2176 if (lib_arch.code == arch_array[i].code) {
2177 lib_arch.compat_class = arch_array[i].compat_class;
2178 lib_arch.name = arch_array[i].name;
2179 }
2180 }
2182 assert(running_arch_index != -1,
2183 "Didn't find running architecture code (running_arch_code) in arch_array");
2184 if (running_arch_index == -1) {
2185 // Even though running architecture detection failed
2186 // we may still continue with reporting dlerror() message
2187 return NULL;
2188 }
2190 if (lib_arch.endianess != arch_array[running_arch_index].endianess) {
2191 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");
2192 return NULL;
2193 }
2195 if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {
2196 ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");
2197 return NULL;
2198 }
2200 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
2201 if ( lib_arch.name!=NULL ) {
2202 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
2203 " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
2204 lib_arch.name, arch_array[running_arch_index].name);
2205 } else {
2206 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
2207 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
2208 lib_arch.code,
2209 arch_array[running_arch_index].name);
2210 }
2211 }
2213 return NULL;
2214 }
2216 void* os::dll_lookup(void* handle, const char* name) {
2217 return dlsym(handle, name);
2218 }
2220 int os::stat(const char *path, struct stat *sbuf) {
2221 char pathbuf[MAX_PATH];
2222 if (strlen(path) > MAX_PATH - 1) {
2223 errno = ENAMETOOLONG;
2224 return -1;
2225 }
2226 os::native_path(strcpy(pathbuf, path));
2227 return ::stat(pathbuf, sbuf);
2228 }
2230 static bool _print_ascii_file(const char* filename, outputStream* st) {
2231 int fd = ::open(filename, O_RDONLY);
2232 if (fd == -1) {
2233 return false;
2234 }
2236 char buf[32];
2237 int bytes;
2238 while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) {
2239 st->print_raw(buf, bytes);
2240 }
2242 ::close(fd);
2244 return true;
2245 }
2247 void os::print_os_info(outputStream* st) {
2248 st->print("OS:");
2250 if (!_print_ascii_file("/etc/release", st)) {
2251 st->print("Solaris");
2252 }
2253 st->cr();
2255 // kernel
2256 st->print("uname:");
2257 struct utsname name;
2258 uname(&name);
2259 st->print(name.sysname); st->print(" ");
2260 st->print(name.release); st->print(" ");
2261 st->print(name.version); st->print(" ");
2262 st->print(name.machine);
2264 // libthread
2265 if (os::Solaris::T2_libthread()) st->print(" (T2 libthread)");
2266 else st->print(" (T1 libthread)");
2267 st->cr();
2269 // rlimit
2270 st->print("rlimit:");
2271 struct rlimit rlim;
2273 st->print(" STACK ");
2274 getrlimit(RLIMIT_STACK, &rlim);
2275 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2276 else st->print("%uk", rlim.rlim_cur >> 10);
2278 st->print(", CORE ");
2279 getrlimit(RLIMIT_CORE, &rlim);
2280 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2281 else st->print("%uk", rlim.rlim_cur >> 10);
2283 st->print(", NOFILE ");
2284 getrlimit(RLIMIT_NOFILE, &rlim);
2285 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2286 else st->print("%d", rlim.rlim_cur);
2288 st->print(", AS ");
2289 getrlimit(RLIMIT_AS, &rlim);
2290 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2291 else st->print("%uk", rlim.rlim_cur >> 10);
2292 st->cr();
2294 // load average
2295 st->print("load average:");
2296 double loadavg[3];
2297 os::loadavg(loadavg, 3);
2298 st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
2299 st->cr();
2300 }
2303 static bool check_addr0(outputStream* st) {
2304 jboolean status = false;
2305 int fd = ::open("/proc/self/map",O_RDONLY);
2306 if (fd >= 0) {
2307 prmap_t p;
2308 while(::read(fd, &p, sizeof(p)) > 0) {
2309 if (p.pr_vaddr == 0x0) {
2310 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);
2311 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);
2312 st->print("Access:");
2313 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-");
2314 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-");
2315 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-");
2316 st->cr();
2317 status = true;
2318 }
2319 ::close(fd);
2320 }
2321 }
2322 return status;
2323 }
2325 void os::pd_print_cpu_info(outputStream* st) {
2326 // Nothing to do for now.
2327 }
2329 void os::print_memory_info(outputStream* st) {
2330 st->print("Memory:");
2331 st->print(" %dk page", os::vm_page_size()>>10);
2332 st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10);
2333 st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10);
2334 st->cr();
2335 (void) check_addr0(st);
2336 }
2338 // Taken from /usr/include/sys/machsig.h Supposed to be architecture specific
2339 // but they're the same for all the solaris architectures that we support.
2340 const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",
2341 "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",
2342 "ILL_COPROC", "ILL_BADSTK" };
2344 const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",
2345 "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",
2346 "FPE_FLTINV", "FPE_FLTSUB" };
2348 const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };
2350 const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };
2352 void os::print_siginfo(outputStream* st, void* siginfo) {
2353 st->print("siginfo:");
2355 const int buflen = 100;
2356 char buf[buflen];
2357 siginfo_t *si = (siginfo_t*)siginfo;
2358 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
2359 char *err = strerror(si->si_errno);
2360 if (si->si_errno != 0 && err != NULL) {
2361 st->print("si_errno=%s", err);
2362 } else {
2363 st->print("si_errno=%d", si->si_errno);
2364 }
2365 const int c = si->si_code;
2366 assert(c > 0, "unexpected si_code");
2367 switch (si->si_signo) {
2368 case SIGILL:
2369 st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);
2370 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2371 break;
2372 case SIGFPE:
2373 st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);
2374 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2375 break;
2376 case SIGSEGV:
2377 st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);
2378 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2379 break;
2380 case SIGBUS:
2381 st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);
2382 st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2383 break;
2384 default:
2385 st->print(", si_code=%d", si->si_code);
2386 // no si_addr
2387 }
2389 if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
2390 UseSharedSpaces) {
2391 FileMapInfo* mapinfo = FileMapInfo::current_info();
2392 if (mapinfo->is_in_shared_space(si->si_addr)) {
2393 st->print("\n\nError accessing class data sharing archive." \
2394 " Mapped file inaccessible during execution, " \
2395 " possible disk/network problem.");
2396 }
2397 }
2398 st->cr();
2399 }
2401 // Moved from whole group, because we need them here for diagnostic
2402 // prints.
2403 #define OLDMAXSIGNUM 32
2404 static int Maxsignum = 0;
2405 static int *ourSigFlags = NULL;
2407 extern "C" void sigINTRHandler(int, siginfo_t*, void*);
2409 int os::Solaris::get_our_sigflags(int sig) {
2410 assert(ourSigFlags!=NULL, "signal data structure not initialized");
2411 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2412 return ourSigFlags[sig];
2413 }
2415 void os::Solaris::set_our_sigflags(int sig, int flags) {
2416 assert(ourSigFlags!=NULL, "signal data structure not initialized");
2417 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2418 ourSigFlags[sig] = flags;
2419 }
2422 static const char* get_signal_handler_name(address handler,
2423 char* buf, int buflen) {
2424 int offset;
2425 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
2426 if (found) {
2427 // skip directory names
2428 const char *p1, *p2;
2429 p1 = buf;
2430 size_t len = strlen(os::file_separator());
2431 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
2432 jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);
2433 } else {
2434 jio_snprintf(buf, buflen, PTR_FORMAT, handler);
2435 }
2436 return buf;
2437 }
2439 static void print_signal_handler(outputStream* st, int sig,
2440 char* buf, size_t buflen) {
2441 struct sigaction sa;
2443 sigaction(sig, NULL, &sa);
2445 st->print("%s: ", os::exception_name(sig, buf, buflen));
2447 address handler = (sa.sa_flags & SA_SIGINFO)
2448 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
2449 : CAST_FROM_FN_PTR(address, sa.sa_handler);
2451 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
2452 st->print("SIG_DFL");
2453 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
2454 st->print("SIG_IGN");
2455 } else {
2456 st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
2457 }
2459 st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);
2461 address rh = VMError::get_resetted_sighandler(sig);
2462 // May be, handler was resetted by VMError?
2463 if(rh != NULL) {
2464 handler = rh;
2465 sa.sa_flags = VMError::get_resetted_sigflags(sig);
2466 }
2468 st->print(", sa_flags=" PTR32_FORMAT, sa.sa_flags);
2470 // Check: is it our handler?
2471 if(handler == CAST_FROM_FN_PTR(address, signalHandler) ||
2472 handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {
2473 // It is our signal handler
2474 // check for flags
2475 if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
2476 st->print(
2477 ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
2478 os::Solaris::get_our_sigflags(sig));
2479 }
2480 }
2481 st->cr();
2482 }
2484 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2485 st->print_cr("Signal Handlers:");
2486 print_signal_handler(st, SIGSEGV, buf, buflen);
2487 print_signal_handler(st, SIGBUS , buf, buflen);
2488 print_signal_handler(st, SIGFPE , buf, buflen);
2489 print_signal_handler(st, SIGPIPE, buf, buflen);
2490 print_signal_handler(st, SIGXFSZ, buf, buflen);
2491 print_signal_handler(st, SIGILL , buf, buflen);
2492 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
2493 print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);
2494 print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
2495 print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);
2496 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
2497 print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);
2498 print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);
2499 print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);
2500 }
2502 static char saved_jvm_path[MAXPATHLEN] = { 0 };
2504 // Find the full path to the current module, libjvm.so or libjvm_g.so
2505 void os::jvm_path(char *buf, jint buflen) {
2506 // Error checking.
2507 if (buflen < MAXPATHLEN) {
2508 assert(false, "must use a large-enough buffer");
2509 buf[0] = '\0';
2510 return;
2511 }
2512 // Lazy resolve the path to current module.
2513 if (saved_jvm_path[0] != 0) {
2514 strcpy(buf, saved_jvm_path);
2515 return;
2516 }
2518 Dl_info dlinfo;
2519 int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
2520 assert(ret != 0, "cannot locate libjvm");
2521 realpath((char *)dlinfo.dli_fname, buf);
2523 if (Arguments::created_by_gamma_launcher()) {
2524 // Support for the gamma launcher. Typical value for buf is
2525 // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so". If "/jre/lib/" appears at
2526 // the right place in the string, then assume we are installed in a JDK and
2527 // we're done. Otherwise, check for a JAVA_HOME environment variable and fix
2528 // up the path so it looks like libjvm.so is installed there (append a
2529 // fake suffix hotspot/libjvm.so).
2530 const char *p = buf + strlen(buf) - 1;
2531 for (int count = 0; p > buf && count < 5; ++count) {
2532 for (--p; p > buf && *p != '/'; --p)
2533 /* empty */ ;
2534 }
2536 if (strncmp(p, "/jre/lib/", 9) != 0) {
2537 // Look for JAVA_HOME in the environment.
2538 char* java_home_var = ::getenv("JAVA_HOME");
2539 if (java_home_var != NULL && java_home_var[0] != 0) {
2540 char cpu_arch[12];
2541 char* jrelib_p;
2542 int len;
2543 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
2544 #ifdef _LP64
2545 // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.
2546 if (strcmp(cpu_arch, "sparc") == 0) {
2547 strcat(cpu_arch, "v9");
2548 } else if (strcmp(cpu_arch, "i386") == 0) {
2549 strcpy(cpu_arch, "amd64");
2550 }
2551 #endif
2552 // Check the current module name "libjvm.so" or "libjvm_g.so".
2553 p = strrchr(buf, '/');
2554 assert(strstr(p, "/libjvm") == p, "invalid library name");
2555 p = strstr(p, "_g") ? "_g" : "";
2557 realpath(java_home_var, buf);
2558 // determine if this is a legacy image or modules image
2559 // modules image doesn't have "jre" subdirectory
2560 len = strlen(buf);
2561 jrelib_p = buf + len;
2562 snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch);
2563 if (0 != access(buf, F_OK)) {
2564 snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch);
2565 }
2567 if (0 == access(buf, F_OK)) {
2568 // Use current module name "libjvm[_g].so" instead of
2569 // "libjvm"debug_only("_g")".so" since for fastdebug version
2570 // we should have "libjvm.so" but debug_only("_g") adds "_g"!
2571 len = strlen(buf);
2572 snprintf(buf + len, buflen-len, "/hotspot/libjvm%s.so", p);
2573 } else {
2574 // Go back to path of .so
2575 realpath((char *)dlinfo.dli_fname, buf);
2576 }
2577 }
2578 }
2579 }
2581 strcpy(saved_jvm_path, buf);
2582 }
2585 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
2586 // no prefix required, not even "_"
2587 }
2590 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
2591 // no suffix required
2592 }
2594 // This method is a copy of JDK's sysGetLastErrorString
2595 // from src/solaris/hpi/src/system_md.c
2597 size_t os::lasterror(char *buf, size_t len) {
2599 if (errno == 0) return 0;
2601 const char *s = ::strerror(errno);
2602 size_t n = ::strlen(s);
2603 if (n >= len) {
2604 n = len - 1;
2605 }
2606 ::strncpy(buf, s, n);
2607 buf[n] = '\0';
2608 return n;
2609 }
2612 // sun.misc.Signal
2614 extern "C" {
2615 static void UserHandler(int sig, void *siginfo, void *context) {
2616 // Ctrl-C is pressed during error reporting, likely because the error
2617 // handler fails to abort. Let VM die immediately.
2618 if (sig == SIGINT && is_error_reported()) {
2619 os::die();
2620 }
2622 os::signal_notify(sig);
2623 // We do not need to reinstate the signal handler each time...
2624 }
2625 }
2627 void* os::user_handler() {
2628 return CAST_FROM_FN_PTR(void*, UserHandler);
2629 }
2631 extern "C" {
2632 typedef void (*sa_handler_t)(int);
2633 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
2634 }
2636 void* os::signal(int signal_number, void* handler) {
2637 struct sigaction sigAct, oldSigAct;
2638 sigfillset(&(sigAct.sa_mask));
2639 sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;
2640 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
2642 if (sigaction(signal_number, &sigAct, &oldSigAct))
2643 // -1 means registration failed
2644 return (void *)-1;
2646 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
2647 }
2649 void os::signal_raise(int signal_number) {
2650 raise(signal_number);
2651 }
2653 /*
2654 * The following code is moved from os.cpp for making this
2655 * code platform specific, which it is by its very nature.
2656 */
2658 // a counter for each possible signal value
2659 static int Sigexit = 0;
2660 static int Maxlibjsigsigs;
2661 static jint *pending_signals = NULL;
2662 static int *preinstalled_sigs = NULL;
2663 static struct sigaction *chainedsigactions = NULL;
2664 static sema_t sig_sem;
2665 typedef int (*version_getting_t)();
2666 version_getting_t os::Solaris::get_libjsig_version = NULL;
2667 static int libjsigversion = NULL;
2669 int os::sigexitnum_pd() {
2670 assert(Sigexit > 0, "signal memory not yet initialized");
2671 return Sigexit;
2672 }
2674 void os::Solaris::init_signal_mem() {
2675 // Initialize signal structures
2676 Maxsignum = SIGRTMAX;
2677 Sigexit = Maxsignum+1;
2678 assert(Maxsignum >0, "Unable to obtain max signal number");
2680 Maxlibjsigsigs = Maxsignum;
2682 // pending_signals has one int per signal
2683 // The additional signal is for SIGEXIT - exit signal to signal_thread
2684 pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1));
2685 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
2687 if (UseSignalChaining) {
2688 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
2689 * (Maxsignum + 1));
2690 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
2691 preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1));
2692 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
2693 }
2694 ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ));
2695 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
2696 }
2698 void os::signal_init_pd() {
2699 int ret;
2701 ret = ::sema_init(&sig_sem, 0, NULL, NULL);
2702 assert(ret == 0, "sema_init() failed");
2703 }
2705 void os::signal_notify(int signal_number) {
2706 int ret;
2708 Atomic::inc(&pending_signals[signal_number]);
2709 ret = ::sema_post(&sig_sem);
2710 assert(ret == 0, "sema_post() failed");
2711 }
2713 static int check_pending_signals(bool wait_for_signal) {
2714 int ret;
2715 while (true) {
2716 for (int i = 0; i < Sigexit + 1; i++) {
2717 jint n = pending_signals[i];
2718 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2719 return i;
2720 }
2721 }
2722 if (!wait_for_signal) {
2723 return -1;
2724 }
2725 JavaThread *thread = JavaThread::current();
2726 ThreadBlockInVM tbivm(thread);
2728 bool threadIsSuspended;
2729 do {
2730 thread->set_suspend_equivalent();
2731 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2732 while((ret = ::sema_wait(&sig_sem)) == EINTR)
2733 ;
2734 assert(ret == 0, "sema_wait() failed");
2736 // were we externally suspended while we were waiting?
2737 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2738 if (threadIsSuspended) {
2739 //
2740 // The semaphore has been incremented, but while we were waiting
2741 // another thread suspended us. We don't want to continue running
2742 // while suspended because that would surprise the thread that
2743 // suspended us.
2744 //
2745 ret = ::sema_post(&sig_sem);
2746 assert(ret == 0, "sema_post() failed");
2748 thread->java_suspend_self();
2749 }
2750 } while (threadIsSuspended);
2751 }
2752 }
2754 int os::signal_lookup() {
2755 return check_pending_signals(false);
2756 }
2758 int os::signal_wait() {
2759 return check_pending_signals(true);
2760 }
2762 ////////////////////////////////////////////////////////////////////////////////
2763 // Virtual Memory
2765 static int page_size = -1;
2767 // The mmap MAP_ALIGN flag is supported on Solaris 9 and later. init_2() will
2768 // clear this var if support is not available.
2769 static bool has_map_align = true;
2771 int os::vm_page_size() {
2772 assert(page_size != -1, "must call os::init");
2773 return page_size;
2774 }
2776 // Solaris allocates memory by pages.
2777 int os::vm_allocation_granularity() {
2778 assert(page_size != -1, "must call os::init");
2779 return page_size;
2780 }
2782 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
2783 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
2784 size_t size = bytes;
2785 char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
2786 if (res != NULL) {
2787 if (UseNUMAInterleaving) {
2788 numa_make_global(addr, bytes);
2789 }
2790 return true;
2791 }
2792 return false;
2793 }
2795 bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint,
2796 bool exec) {
2797 if (commit_memory(addr, bytes, exec)) {
2798 if (UseMPSS && alignment_hint > (size_t)vm_page_size()) {
2799 // If the large page size has been set and the VM
2800 // is using large pages, use the large page size
2801 // if it is smaller than the alignment hint. This is
2802 // a case where the VM wants to use a larger alignment size
2803 // for its own reasons but still want to use large pages
2804 // (which is what matters to setting the mpss range.
2805 size_t page_size = 0;
2806 if (large_page_size() < alignment_hint) {
2807 assert(UseLargePages, "Expected to be here for large page use only");
2808 page_size = large_page_size();
2809 } else {
2810 // If the alignment hint is less than the large page
2811 // size, the VM wants a particular alignment (thus the hint)
2812 // for internal reasons. Try to set the mpss range using
2813 // the alignment_hint.
2814 page_size = alignment_hint;
2815 }
2816 // Since this is a hint, ignore any failures.
2817 (void)Solaris::set_mpss_range(addr, bytes, page_size);
2818 }
2819 return true;
2820 }
2821 return false;
2822 }
2824 // Uncommit the pages in a specified region.
2825 void os::free_memory(char* addr, size_t bytes) {
2826 if (madvise(addr, bytes, MADV_FREE) < 0) {
2827 debug_only(warning("MADV_FREE failed."));
2828 return;
2829 }
2830 }
2832 bool os::create_stack_guard_pages(char* addr, size_t size) {
2833 return os::commit_memory(addr, size);
2834 }
2836 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2837 return os::uncommit_memory(addr, size);
2838 }
2840 // Change the page size in a given range.
2841 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2842 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
2843 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
2844 if (UseLargePages && UseMPSS) {
2845 Solaris::set_mpss_range(addr, bytes, alignment_hint);
2846 }
2847 }
2849 // Tell the OS to make the range local to the first-touching LWP
2850 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2851 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2852 if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) {
2853 debug_only(warning("MADV_ACCESS_LWP failed."));
2854 }
2855 }
2857 // Tell the OS that this range would be accessed from different LWPs.
2858 void os::numa_make_global(char *addr, size_t bytes) {
2859 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2860 if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) {
2861 debug_only(warning("MADV_ACCESS_MANY failed."));
2862 }
2863 }
2865 // Get the number of the locality groups.
2866 size_t os::numa_get_groups_num() {
2867 size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie());
2868 return n != -1 ? n : 1;
2869 }
2871 // Get a list of leaf locality groups. A leaf lgroup is group that
2872 // doesn't have any children. Typical leaf group is a CPU or a CPU/memory
2873 // board. An LWP is assigned to one of these groups upon creation.
2874 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2875 if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) {
2876 ids[0] = 0;
2877 return 1;
2878 }
2879 int result_size = 0, top = 1, bottom = 0, cur = 0;
2880 for (int k = 0; k < size; k++) {
2881 int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur],
2882 (Solaris::lgrp_id_t*)&ids[top], size - top);
2883 if (r == -1) {
2884 ids[0] = 0;
2885 return 1;
2886 }
2887 if (!r) {
2888 // That's a leaf node.
2889 assert (bottom <= cur, "Sanity check");
2890 // Check if the node has memory
2891 if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur],
2892 NULL, 0, LGRP_RSRC_MEM) > 0) {
2893 ids[bottom++] = ids[cur];
2894 }
2895 }
2896 top += r;
2897 cur++;
2898 }
2899 if (bottom == 0) {
2900 // Handle a situation, when the OS reports no memory available.
2901 // Assume UMA architecture.
2902 ids[0] = 0;
2903 return 1;
2904 }
2905 return bottom;
2906 }
2908 // Detect the topology change. Typically happens during CPU plugging-unplugging.
2909 bool os::numa_topology_changed() {
2910 int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie());
2911 if (is_stale != -1 && is_stale) {
2912 Solaris::lgrp_fini(Solaris::lgrp_cookie());
2913 Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER);
2914 assert(c != 0, "Failure to initialize LGRP API");
2915 Solaris::set_lgrp_cookie(c);
2916 return true;
2917 }
2918 return false;
2919 }
2921 // Get the group id of the current LWP.
2922 int os::numa_get_group_id() {
2923 int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID);
2924 if (lgrp_id == -1) {
2925 return 0;
2926 }
2927 const int size = os::numa_get_groups_num();
2928 int *ids = (int*)alloca(size * sizeof(int));
2930 // Get the ids of all lgroups with memory; r is the count.
2931 int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id,
2932 (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM);
2933 if (r <= 0) {
2934 return 0;
2935 }
2936 return ids[os::random() % r];
2937 }
2939 // Request information about the page.
2940 bool os::get_page_info(char *start, page_info* info) {
2941 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2942 uint64_t addr = (uintptr_t)start;
2943 uint64_t outdata[2];
2944 uint_t validity = 0;
2946 if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) {
2947 return false;
2948 }
2950 info->size = 0;
2951 info->lgrp_id = -1;
2953 if ((validity & 1) != 0) {
2954 if ((validity & 2) != 0) {
2955 info->lgrp_id = outdata[0];
2956 }
2957 if ((validity & 4) != 0) {
2958 info->size = outdata[1];
2959 }
2960 return true;
2961 }
2962 return false;
2963 }
2965 // Scan the pages from start to end until a page different than
2966 // the one described in the info parameter is encountered.
2967 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2968 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2969 const size_t types = sizeof(info_types) / sizeof(info_types[0]);
2970 uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT];
2971 uint_t validity[MAX_MEMINFO_CNT];
2973 size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size);
2974 uint64_t p = (uint64_t)start;
2975 while (p < (uint64_t)end) {
2976 addrs[0] = p;
2977 size_t addrs_count = 1;
2978 while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] < (uint64_t)end) {
2979 addrs[addrs_count] = addrs[addrs_count - 1] + page_size;
2980 addrs_count++;
2981 }
2983 if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) {
2984 return NULL;
2985 }
2987 size_t i = 0;
2988 for (; i < addrs_count; i++) {
2989 if ((validity[i] & 1) != 0) {
2990 if ((validity[i] & 4) != 0) {
2991 if (outdata[types * i + 1] != page_expected->size) {
2992 break;
2993 }
2994 } else
2995 if (page_expected->size != 0) {
2996 break;
2997 }
2999 if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) {
3000 if (outdata[types * i] != page_expected->lgrp_id) {
3001 break;
3002 }
3003 }
3004 } else {
3005 return NULL;
3006 }
3007 }
3009 if (i != addrs_count) {
3010 if ((validity[i] & 2) != 0) {
3011 page_found->lgrp_id = outdata[types * i];
3012 } else {
3013 page_found->lgrp_id = -1;
3014 }
3015 if ((validity[i] & 4) != 0) {
3016 page_found->size = outdata[types * i + 1];
3017 } else {
3018 page_found->size = 0;
3019 }
3020 return (char*)addrs[i];
3021 }
3023 p = addrs[addrs_count - 1] + page_size;
3024 }
3025 return end;
3026 }
3028 bool os::uncommit_memory(char* addr, size_t bytes) {
3029 size_t size = bytes;
3030 // Map uncommitted pages PROT_NONE so we fail early if we touch an
3031 // uncommitted page. Otherwise, the read/write might succeed if we
3032 // have enough swap space to back the physical page.
3033 return
3034 NULL != Solaris::mmap_chunk(addr, size,
3035 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE,
3036 PROT_NONE);
3037 }
3039 char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) {
3040 char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0);
3042 if (b == MAP_FAILED) {
3043 return NULL;
3044 }
3045 return b;
3046 }
3048 char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) {
3049 char* addr = requested_addr;
3050 int flags = MAP_PRIVATE | MAP_NORESERVE;
3052 assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap");
3054 if (fixed) {
3055 flags |= MAP_FIXED;
3056 } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) {
3057 flags |= MAP_ALIGN;
3058 addr = (char*) alignment_hint;
3059 }
3061 // Map uncommitted pages PROT_NONE so we fail early if we touch an
3062 // uncommitted page. Otherwise, the read/write might succeed if we
3063 // have enough swap space to back the physical page.
3064 return mmap_chunk(addr, bytes, flags, PROT_NONE);
3065 }
3067 char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
3068 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL));
3070 guarantee(requested_addr == NULL || requested_addr == addr,
3071 "OS failed to return requested mmap address.");
3072 return addr;
3073 }
3075 // Reserve memory at an arbitrary address, only if that area is
3076 // available (and not reserved for something else).
3078 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3079 const int max_tries = 10;
3080 char* base[max_tries];
3081 size_t size[max_tries];
3083 // Solaris adds a gap between mmap'ed regions. The size of the gap
3084 // is dependent on the requested size and the MMU. Our initial gap
3085 // value here is just a guess and will be corrected later.
3086 bool had_top_overlap = false;
3087 bool have_adjusted_gap = false;
3088 size_t gap = 0x400000;
3090 // Assert only that the size is a multiple of the page size, since
3091 // that's all that mmap requires, and since that's all we really know
3092 // about at this low abstraction level. If we need higher alignment,
3093 // we can either pass an alignment to this method or verify alignment
3094 // in one of the methods further up the call chain. See bug 5044738.
3095 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
3097 // Since snv_84, Solaris attempts to honor the address hint - see 5003415.
3098 // Give it a try, if the kernel honors the hint we can return immediately.
3099 char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false);
3100 volatile int err = errno;
3101 if (addr == requested_addr) {
3102 return addr;
3103 } else if (addr != NULL) {
3104 unmap_memory(addr, bytes);
3105 }
3107 if (PrintMiscellaneous && Verbose) {
3108 char buf[256];
3109 buf[0] = '\0';
3110 if (addr == NULL) {
3111 jio_snprintf(buf, sizeof(buf), ": %s", strerror(err));
3112 }
3113 warning("attempt_reserve_memory_at: couldn't reserve " SIZE_FORMAT " bytes at "
3114 PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT
3115 "%s", bytes, requested_addr, addr, buf);
3116 }
3118 // Address hint method didn't work. Fall back to the old method.
3119 // In theory, once SNV becomes our oldest supported platform, this
3120 // code will no longer be needed.
3121 //
3122 // Repeatedly allocate blocks until the block is allocated at the
3123 // right spot. Give up after max_tries.
3124 int i;
3125 for (i = 0; i < max_tries; ++i) {
3126 base[i] = reserve_memory(bytes);
3128 if (base[i] != NULL) {
3129 // Is this the block we wanted?
3130 if (base[i] == requested_addr) {
3131 size[i] = bytes;
3132 break;
3133 }
3135 // check that the gap value is right
3136 if (had_top_overlap && !have_adjusted_gap) {
3137 size_t actual_gap = base[i-1] - base[i] - bytes;
3138 if (gap != actual_gap) {
3139 // adjust the gap value and retry the last 2 allocations
3140 assert(i > 0, "gap adjustment code problem");
3141 have_adjusted_gap = true; // adjust the gap only once, just in case
3142 gap = actual_gap;
3143 if (PrintMiscellaneous && Verbose) {
3144 warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap);
3145 }
3146 unmap_memory(base[i], bytes);
3147 unmap_memory(base[i-1], size[i-1]);
3148 i-=2;
3149 continue;
3150 }
3151 }
3153 // Does this overlap the block we wanted? Give back the overlapped
3154 // parts and try again.
3155 //
3156 // There is still a bug in this code: if top_overlap == bytes,
3157 // the overlap is offset from requested region by the value of gap.
3158 // In this case giving back the overlapped part will not work,
3159 // because we'll give back the entire block at base[i] and
3160 // therefore the subsequent allocation will not generate a new gap.
3161 // This could be fixed with a new algorithm that used larger
3162 // or variable size chunks to find the requested region -
3163 // but such a change would introduce additional complications.
3164 // It's rare enough that the planets align for this bug,
3165 // so we'll just wait for a fix for 6204603/5003415 which
3166 // will provide a mmap flag to allow us to avoid this business.
3168 size_t top_overlap = requested_addr + (bytes + gap) - base[i];
3169 if (top_overlap >= 0 && top_overlap < bytes) {
3170 had_top_overlap = true;
3171 unmap_memory(base[i], top_overlap);
3172 base[i] += top_overlap;
3173 size[i] = bytes - top_overlap;
3174 } else {
3175 size_t bottom_overlap = base[i] + bytes - requested_addr;
3176 if (bottom_overlap >= 0 && bottom_overlap < bytes) {
3177 if (PrintMiscellaneous && Verbose && bottom_overlap == 0) {
3178 warning("attempt_reserve_memory_at: possible alignment bug");
3179 }
3180 unmap_memory(requested_addr, bottom_overlap);
3181 size[i] = bytes - bottom_overlap;
3182 } else {
3183 size[i] = bytes;
3184 }
3185 }
3186 }
3187 }
3189 // Give back the unused reserved pieces.
3191 for (int j = 0; j < i; ++j) {
3192 if (base[j] != NULL) {
3193 unmap_memory(base[j], size[j]);
3194 }
3195 }
3197 return (i < max_tries) ? requested_addr : NULL;
3198 }
3200 bool os::release_memory(char* addr, size_t bytes) {
3201 size_t size = bytes;
3202 return munmap(addr, size) == 0;
3203 }
3205 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
3206 assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()),
3207 "addr must be page aligned");
3208 int retVal = mprotect(addr, bytes, prot);
3209 return retVal == 0;
3210 }
3212 // Protect memory (Used to pass readonly pages through
3213 // JNI GetArray<type>Elements with empty arrays.)
3214 // Also, used for serialization page and for compressed oops null pointer
3215 // checking.
3216 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3217 bool is_committed) {
3218 unsigned int p = 0;
3219 switch (prot) {
3220 case MEM_PROT_NONE: p = PROT_NONE; break;
3221 case MEM_PROT_READ: p = PROT_READ; break;
3222 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break;
3223 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
3224 default:
3225 ShouldNotReachHere();
3226 }
3227 // is_committed is unused.
3228 return solaris_mprotect(addr, bytes, p);
3229 }
3231 // guard_memory and unguard_memory only happens within stack guard pages.
3232 // Since ISM pertains only to the heap, guard and unguard memory should not
3233 /// happen with an ISM region.
3234 bool os::guard_memory(char* addr, size_t bytes) {
3235 return solaris_mprotect(addr, bytes, PROT_NONE);
3236 }
3238 bool os::unguard_memory(char* addr, size_t bytes) {
3239 return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE);
3240 }
3242 // Large page support
3244 // UseLargePages is the master flag to enable/disable large page memory.
3245 // UseMPSS and UseISM are supported for compatibility reasons. Their combined
3246 // effects can be described in the following table:
3247 //
3248 // UseLargePages UseMPSS UseISM
3249 // false * * => UseLargePages is the master switch, turning
3250 // it off will turn off both UseMPSS and
3251 // UseISM. VM will not use large page memory
3252 // regardless the settings of UseMPSS/UseISM.
3253 // true false false => Unless future Solaris provides other
3254 // mechanism to use large page memory, this
3255 // combination is equivalent to -UseLargePages,
3256 // VM will not use large page memory
3257 // true true false => JVM will use MPSS for large page memory.
3258 // This is the default behavior.
3259 // true false true => JVM will use ISM for large page memory.
3260 // true true true => JVM will use ISM if it is available.
3261 // Otherwise, JVM will fall back to MPSS.
3262 // Becaues ISM is now available on all
3263 // supported Solaris versions, this combination
3264 // is equivalent to +UseISM -UseMPSS.
3266 static size_t _large_page_size = 0;
3268 bool os::Solaris::ism_sanity_check(bool warn, size_t * page_size) {
3269 // x86 uses either 2M or 4M page, depending on whether PAE (Physical Address
3270 // Extensions) mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. Sparc
3271 // can support multiple page sizes.
3273 // Don't bother to probe page size because getpagesizes() comes with MPSS.
3274 // ISM is only recommended on old Solaris where there is no MPSS support.
3275 // Simply choose a conservative value as default.
3276 *page_size = LargePageSizeInBytes ? LargePageSizeInBytes :
3277 SPARC_ONLY(4 * M) IA32_ONLY(4 * M) AMD64_ONLY(2 * M)
3278 ARM_ONLY(2 * M);
3280 // ISM is available on all supported Solaris versions
3281 return true;
3282 }
3284 // Insertion sort for small arrays (descending order).
3285 static void insertion_sort_descending(size_t* array, int len) {
3286 for (int i = 0; i < len; i++) {
3287 size_t val = array[i];
3288 for (size_t key = i; key > 0 && array[key - 1] < val; --key) {
3289 size_t tmp = array[key];
3290 array[key] = array[key - 1];
3291 array[key - 1] = tmp;
3292 }
3293 }
3294 }
3296 bool os::Solaris::mpss_sanity_check(bool warn, size_t * page_size) {
3297 const unsigned int usable_count = VM_Version::page_size_count();
3298 if (usable_count == 1) {
3299 return false;
3300 }
3302 // Find the right getpagesizes interface. When solaris 11 is the minimum
3303 // build platform, getpagesizes() (without the '2') can be called directly.
3304 typedef int (*gps_t)(size_t[], int);
3305 gps_t gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes2"));
3306 if (gps_func == NULL) {
3307 gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes"));
3308 if (gps_func == NULL) {
3309 if (warn) {
3310 warning("MPSS is not supported by the operating system.");
3311 }
3312 return false;
3313 }
3314 }
3316 // Fill the array of page sizes.
3317 int n = (*gps_func)(_page_sizes, page_sizes_max);
3318 assert(n > 0, "Solaris bug?");
3320 if (n == page_sizes_max) {
3321 // Add a sentinel value (necessary only if the array was completely filled
3322 // since it is static (zeroed at initialization)).
3323 _page_sizes[--n] = 0;
3324 DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");)
3325 }
3326 assert(_page_sizes[n] == 0, "missing sentinel");
3327 trace_page_sizes("available page sizes", _page_sizes, n);
3329 if (n == 1) return false; // Only one page size available.
3331 // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and
3332 // select up to usable_count elements. First sort the array, find the first
3333 // acceptable value, then copy the usable sizes to the top of the array and
3334 // trim the rest. Make sure to include the default page size :-).
3335 //
3336 // A better policy could get rid of the 4M limit by taking the sizes of the
3337 // important VM memory regions (java heap and possibly the code cache) into
3338 // account.
3339 insertion_sort_descending(_page_sizes, n);
3340 const size_t size_limit =
3341 FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes;
3342 int beg;
3343 for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ;
3344 const int end = MIN2((int)usable_count, n) - 1;
3345 for (int cur = 0; cur < end; ++cur, ++beg) {
3346 _page_sizes[cur] = _page_sizes[beg];
3347 }
3348 _page_sizes[end] = vm_page_size();
3349 _page_sizes[end + 1] = 0;
3351 if (_page_sizes[end] > _page_sizes[end - 1]) {
3352 // Default page size is not the smallest; sort again.
3353 insertion_sort_descending(_page_sizes, end + 1);
3354 }
3355 *page_size = _page_sizes[0];
3357 trace_page_sizes("usable page sizes", _page_sizes, end + 1);
3358 return true;
3359 }
3361 void os::large_page_init() {
3362 if (!UseLargePages) {
3363 UseISM = false;
3364 UseMPSS = false;
3365 return;
3366 }
3368 // print a warning if any large page related flag is specified on command line
3369 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
3370 !FLAG_IS_DEFAULT(UseISM) ||
3371 !FLAG_IS_DEFAULT(UseMPSS) ||
3372 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3373 UseISM = UseISM &&
3374 Solaris::ism_sanity_check(warn_on_failure, &_large_page_size);
3375 if (UseISM) {
3376 // ISM disables MPSS to be compatible with old JDK behavior
3377 UseMPSS = false;
3378 _page_sizes[0] = _large_page_size;
3379 _page_sizes[1] = vm_page_size();
3380 }
3382 UseMPSS = UseMPSS &&
3383 Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size);
3385 UseLargePages = UseISM || UseMPSS;
3386 }
3388 bool os::Solaris::set_mpss_range(caddr_t start, size_t bytes, size_t align) {
3389 // Signal to OS that we want large pages for addresses
3390 // from addr, addr + bytes
3391 struct memcntl_mha mpss_struct;
3392 mpss_struct.mha_cmd = MHA_MAPSIZE_VA;
3393 mpss_struct.mha_pagesize = align;
3394 mpss_struct.mha_flags = 0;
3395 if (memcntl(start, bytes, MC_HAT_ADVISE,
3396 (caddr_t) &mpss_struct, 0, 0) < 0) {
3397 debug_only(warning("Attempt to use MPSS failed."));
3398 return false;
3399 }
3400 return true;
3401 }
3403 char* os::reserve_memory_special(size_t size, char* addr, bool exec) {
3404 // "exec" is passed in but not used. Creating the shared image for
3405 // the code cache doesn't have an SHM_X executable permission to check.
3406 assert(UseLargePages && UseISM, "only for ISM large pages");
3408 char* retAddr = NULL;
3409 int shmid;
3410 key_t ismKey;
3412 bool warn_on_failure = UseISM &&
3413 (!FLAG_IS_DEFAULT(UseLargePages) ||
3414 !FLAG_IS_DEFAULT(UseISM) ||
3415 !FLAG_IS_DEFAULT(LargePageSizeInBytes)
3416 );
3417 char msg[128];
3419 ismKey = IPC_PRIVATE;
3421 // Create a large shared memory region to attach to based on size.
3422 // Currently, size is the total size of the heap
3423 shmid = shmget(ismKey, size, SHM_R | SHM_W | IPC_CREAT);
3424 if (shmid == -1){
3425 if (warn_on_failure) {
3426 jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno);
3427 warning(msg);
3428 }
3429 return NULL;
3430 }
3432 // Attach to the region
3433 retAddr = (char *) shmat(shmid, 0, SHM_SHARE_MMU | SHM_R | SHM_W);
3434 int err = errno;
3436 // Remove shmid. If shmat() is successful, the actual shared memory segment
3437 // will be deleted when it's detached by shmdt() or when the process
3438 // terminates. If shmat() is not successful this will remove the shared
3439 // segment immediately.
3440 shmctl(shmid, IPC_RMID, NULL);
3442 if (retAddr == (char *) -1) {
3443 if (warn_on_failure) {
3444 jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
3445 warning(msg);
3446 }
3447 return NULL;
3448 }
3449 if ((retAddr != NULL) && UseNUMAInterleaving) {
3450 numa_make_global(retAddr, size);
3451 }
3452 return retAddr;
3453 }
3455 bool os::release_memory_special(char* base, size_t bytes) {
3456 // detaching the SHM segment will also delete it, see reserve_memory_special()
3457 int rslt = shmdt(base);
3458 return rslt == 0;
3459 }
3461 size_t os::large_page_size() {
3462 return _large_page_size;
3463 }
3465 // MPSS allows application to commit large page memory on demand; with ISM
3466 // the entire memory region must be allocated as shared memory.
3467 bool os::can_commit_large_page_memory() {
3468 return UseISM ? false : true;
3469 }
3471 bool os::can_execute_large_page_memory() {
3472 return UseISM ? false : true;
3473 }
3475 static int os_sleep(jlong millis, bool interruptible) {
3476 const jlong limit = INT_MAX;
3477 jlong prevtime;
3478 int res;
3480 while (millis > limit) {
3481 if ((res = os_sleep(limit, interruptible)) != OS_OK)
3482 return res;
3483 millis -= limit;
3484 }
3486 // Restart interrupted polls with new parameters until the proper delay
3487 // has been completed.
3489 prevtime = getTimeMillis();
3491 while (millis > 0) {
3492 jlong newtime;
3494 if (!interruptible) {
3495 // Following assert fails for os::yield_all:
3496 // assert(!thread->is_Java_thread(), "must not be java thread");
3497 res = poll(NULL, 0, millis);
3498 } else {
3499 JavaThread *jt = JavaThread::current();
3501 INTERRUPTIBLE_NORESTART_VM_ALWAYS(poll(NULL, 0, millis), res, jt,
3502 os::Solaris::clear_interrupted);
3503 }
3505 // INTERRUPTIBLE_NORESTART_VM_ALWAYS returns res == OS_INTRPT for
3506 // thread.Interrupt.
3508 // See c/r 6751923. Poll can return 0 before time
3509 // has elapsed if time is set via clock_settime (as NTP does).
3510 // res == 0 if poll timed out (see man poll RETURN VALUES)
3511 // using the logic below checks that we really did
3512 // sleep at least "millis" if not we'll sleep again.
3513 if( ( res == 0 ) || ((res == OS_ERR) && (errno == EINTR))) {
3514 newtime = getTimeMillis();
3515 assert(newtime >= prevtime, "time moving backwards");
3516 /* Doing prevtime and newtime in microseconds doesn't help precision,
3517 and trying to round up to avoid lost milliseconds can result in a
3518 too-short delay. */
3519 millis -= newtime - prevtime;
3520 if(millis <= 0)
3521 return OS_OK;
3522 prevtime = newtime;
3523 } else
3524 return res;
3525 }
3527 return OS_OK;
3528 }
3530 // Read calls from inside the vm need to perform state transitions
3531 size_t os::read(int fd, void *buf, unsigned int nBytes) {
3532 INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted);
3533 }
3535 size_t os::restartable_read(int fd, void *buf, unsigned int nBytes) {
3536 INTERRUPTIBLE_RETURN_INT(::read(fd, buf, nBytes), os::Solaris::clear_interrupted);
3537 }
3539 int os::sleep(Thread* thread, jlong millis, bool interruptible) {
3540 assert(thread == Thread::current(), "thread consistency check");
3542 // TODO-FIXME: this should be removed.
3543 // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock
3544 // situation with a JavaThread being starved out of a lwp. The kernel doesn't seem to generate
3545 // a SIGWAITING signal which would enable the threads library to create a new lwp for the starving
3546 // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel
3547 // is fooled into believing that the system is making progress. In the code below we block the
3548 // the watcher thread while safepoint is in progress so that it would not appear as though the
3549 // system is making progress.
3550 if (!Solaris::T2_libthread() &&
3551 thread->is_Watcher_thread() && SafepointSynchronize::is_synchronizing() && !Arguments::has_profile()) {
3552 // We now try to acquire the threads lock. Since this lock is held by the VM thread during
3553 // the entire safepoint, the watcher thread will line up here during the safepoint.
3554 Threads_lock->lock_without_safepoint_check();
3555 Threads_lock->unlock();
3556 }
3558 if (thread->is_Java_thread()) {
3559 // This is a JavaThread so we honor the _thread_blocked protocol
3560 // even for sleeps of 0 milliseconds. This was originally done
3561 // as a workaround for bug 4338139. However, now we also do it
3562 // to honor the suspend-equivalent protocol.
3564 JavaThread *jt = (JavaThread *) thread;
3565 ThreadBlockInVM tbivm(jt);
3567 jt->set_suspend_equivalent();
3568 // cleared by handle_special_suspend_equivalent_condition() or
3569 // java_suspend_self() via check_and_wait_while_suspended()
3571 int ret_code;
3572 if (millis <= 0) {
3573 thr_yield();
3574 ret_code = 0;
3575 } else {
3576 // The original sleep() implementation did not create an
3577 // OSThreadWaitState helper for sleeps of 0 milliseconds.
3578 // I'm preserving that decision for now.
3579 OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
3581 ret_code = os_sleep(millis, interruptible);
3582 }
3584 // were we externally suspended while we were waiting?
3585 jt->check_and_wait_while_suspended();
3587 return ret_code;
3588 }
3590 // non-JavaThread from this point on:
3592 if (millis <= 0) {
3593 thr_yield();
3594 return 0;
3595 }
3597 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
3599 return os_sleep(millis, interruptible);
3600 }
3602 int os::naked_sleep() {
3603 // %% make the sleep time an integer flag. for now use 1 millisec.
3604 return os_sleep(1, false);
3605 }
3607 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3608 void os::infinite_sleep() {
3609 while (true) { // sleep forever ...
3610 ::sleep(100); // ... 100 seconds at a time
3611 }
3612 }
3614 // Used to convert frequent JVM_Yield() to nops
3615 bool os::dont_yield() {
3616 if (DontYieldALot) {
3617 static hrtime_t last_time = 0;
3618 hrtime_t diff = getTimeNanos() - last_time;
3620 if (diff < DontYieldALotInterval * 1000000)
3621 return true;
3623 last_time += diff;
3625 return false;
3626 }
3627 else {
3628 return false;
3629 }
3630 }
3632 // Caveat: Solaris os::yield() causes a thread-state transition whereas
3633 // the linux and win32 implementations do not. This should be checked.
3635 void os::yield() {
3636 // Yields to all threads with same or greater priority
3637 os::sleep(Thread::current(), 0, false);
3638 }
3640 // Note that yield semantics are defined by the scheduling class to which
3641 // the thread currently belongs. Typically, yield will _not yield to
3642 // other equal or higher priority threads that reside on the dispatch queues
3643 // of other CPUs.
3645 os::YieldResult os::NakedYield() { thr_yield(); return os::YIELD_UNKNOWN; }
3648 // On Solaris we found that yield_all doesn't always yield to all other threads.
3649 // There have been cases where there is a thread ready to execute but it doesn't
3650 // get an lwp as the VM thread continues to spin with sleeps of 1 millisecond.
3651 // The 1 millisecond wait doesn't seem long enough for the kernel to issue a
3652 // SIGWAITING signal which will cause a new lwp to be created. So we count the
3653 // number of times yield_all is called in the one loop and increase the sleep
3654 // time after 8 attempts. If this fails too we increase the concurrency level
3655 // so that the starving thread would get an lwp
3657 void os::yield_all(int attempts) {
3658 // Yields to all threads, including threads with lower priorities
3659 if (attempts == 0) {
3660 os::sleep(Thread::current(), 1, false);
3661 } else {
3662 int iterations = attempts % 30;
3663 if (iterations == 0 && !os::Solaris::T2_libthread()) {
3664 // thr_setconcurrency and _getconcurrency make sense only under T1.
3665 int noofLWPS = thr_getconcurrency();
3666 if (noofLWPS < (Threads::number_of_threads() + 2)) {
3667 thr_setconcurrency(thr_getconcurrency() + 1);
3668 }
3669 } else if (iterations < 25) {
3670 os::sleep(Thread::current(), 1, false);
3671 } else {
3672 os::sleep(Thread::current(), 10, false);
3673 }
3674 }
3675 }
3677 // Called from the tight loops to possibly influence time-sharing heuristics
3678 void os::loop_breaker(int attempts) {
3679 os::yield_all(attempts);
3680 }
3683 // Interface for setting lwp priorities. If we are using T2 libthread,
3684 // which forces the use of BoundThreads or we manually set UseBoundThreads,
3685 // all of our threads will be assigned to real lwp's. Using the thr_setprio
3686 // function is meaningless in this mode so we must adjust the real lwp's priority
3687 // The routines below implement the getting and setting of lwp priorities.
3688 //
3689 // Note: There are three priority scales used on Solaris. Java priotities
3690 // which range from 1 to 10, libthread "thr_setprio" scale which range
3691 // from 0 to 127, and the current scheduling class of the process we
3692 // are running in. This is typically from -60 to +60.
3693 // The setting of the lwp priorities in done after a call to thr_setprio
3694 // so Java priorities are mapped to libthread priorities and we map from
3695 // the latter to lwp priorities. We don't keep priorities stored in
3696 // Java priorities since some of our worker threads want to set priorities
3697 // higher than all Java threads.
3698 //
3699 // For related information:
3700 // (1) man -s 2 priocntl
3701 // (2) man -s 4 priocntl
3702 // (3) man dispadmin
3703 // = librt.so
3704 // = libthread/common/rtsched.c - thrp_setlwpprio().
3705 // = ps -cL <pid> ... to validate priority.
3706 // = sched_get_priority_min and _max
3707 // pthread_create
3708 // sched_setparam
3709 // pthread_setschedparam
3710 //
3711 // Assumptions:
3712 // + We assume that all threads in the process belong to the same
3713 // scheduling class. IE. an homogenous process.
3714 // + Must be root or in IA group to change change "interactive" attribute.
3715 // Priocntl() will fail silently. The only indication of failure is when
3716 // we read-back the value and notice that it hasn't changed.
3717 // + Interactive threads enter the runq at the head, non-interactive at the tail.
3718 // + For RT, change timeslice as well. Invariant:
3719 // constant "priority integral"
3720 // Konst == TimeSlice * (60-Priority)
3721 // Given a priority, compute appropriate timeslice.
3722 // + Higher numerical values have higher priority.
3724 // sched class attributes
3725 typedef struct {
3726 int schedPolicy; // classID
3727 int maxPrio;
3728 int minPrio;
3729 } SchedInfo;
3732 static SchedInfo tsLimits, iaLimits, rtLimits;
3734 #ifdef ASSERT
3735 static int ReadBackValidate = 1;
3736 #endif
3737 static int myClass = 0;
3738 static int myMin = 0;
3739 static int myMax = 0;
3740 static int myCur = 0;
3741 static bool priocntl_enable = false;
3744 // Call the version of priocntl suitable for all supported versions
3745 // of Solaris. We need to call through this wrapper so that we can
3746 // build on Solaris 9 and run on Solaris 8, 9 and 10.
3747 //
3748 // This code should be removed if we ever stop supporting Solaris 8
3749 // and earlier releases.
3751 static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg);
3752 typedef long (*priocntl_type)(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg);
3753 static priocntl_type priocntl_ptr = priocntl_stub;
3755 // Stub to set the value of the real pointer, and then call the real
3756 // function.
3758 static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg) {
3759 // Try Solaris 8- name only.
3760 priocntl_type tmp = (priocntl_type)dlsym(RTLD_DEFAULT, "__priocntl");
3761 guarantee(tmp != NULL, "priocntl function not found.");
3762 priocntl_ptr = tmp;
3763 return (*priocntl_ptr)(PC_VERSION, idtype, id, cmd, arg);
3764 }
3767 // lwp_priocntl_init
3768 //
3769 // Try to determine the priority scale for our process.
3770 //
3771 // Return errno or 0 if OK.
3772 //
3773 static
3774 int lwp_priocntl_init ()
3775 {
3776 int rslt;
3777 pcinfo_t ClassInfo;
3778 pcparms_t ParmInfo;
3779 int i;
3781 if (!UseThreadPriorities) return 0;
3783 // We are using Bound threads, we need to determine our priority ranges
3784 if (os::Solaris::T2_libthread() || UseBoundThreads) {
3785 // If ThreadPriorityPolicy is 1, switch tables
3786 if (ThreadPriorityPolicy == 1) {
3787 for (i = 0 ; i < MaxPriority+1; i++)
3788 os::java_to_os_priority[i] = prio_policy1[i];
3789 }
3790 }
3791 // Not using Bound Threads, set to ThreadPolicy 1
3792 else {
3793 for ( i = 0 ; i < MaxPriority+1; i++ ) {
3794 os::java_to_os_priority[i] = prio_policy1[i];
3795 }
3796 return 0;
3797 }
3800 // Get IDs for a set of well-known scheduling classes.
3801 // TODO-FIXME: GETCLINFO returns the current # of classes in the
3802 // the system. We should have a loop that iterates over the
3803 // classID values, which are known to be "small" integers.
3805 strcpy(ClassInfo.pc_clname, "TS");
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 TS class is -1");
3810 tsLimits.schedPolicy = ClassInfo.pc_cid;
3811 tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri;
3812 tsLimits.minPrio = -tsLimits.maxPrio;
3814 strcpy(ClassInfo.pc_clname, "IA");
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 IA class is -1");
3819 iaLimits.schedPolicy = ClassInfo.pc_cid;
3820 iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri;
3821 iaLimits.minPrio = -iaLimits.maxPrio;
3823 strcpy(ClassInfo.pc_clname, "RT");
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 RT class is -1");
3828 rtLimits.schedPolicy = ClassInfo.pc_cid;
3829 rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri;
3830 rtLimits.minPrio = 0;
3833 // Query our "current" scheduling class.
3834 // This will normally be IA,TS or, rarely, RT.
3835 memset (&ParmInfo, 0, sizeof(ParmInfo));
3836 ParmInfo.pc_cid = PC_CLNULL;
3837 rslt = (*priocntl_ptr) (PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo );
3838 if ( rslt < 0 ) return errno;
3839 myClass = ParmInfo.pc_cid;
3841 // We now know our scheduling classId, get specific information
3842 // the class.
3843 ClassInfo.pc_cid = myClass;
3844 ClassInfo.pc_clname[0] = 0;
3845 rslt = (*priocntl_ptr) (PC_VERSION, (idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo );
3846 if ( rslt < 0 ) return errno;
3848 if (ThreadPriorityVerbose)
3849 tty->print_cr ("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname);
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 {
3870 // No clue - punt
3871 if (ThreadPriorityVerbose)
3872 tty->print_cr ("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname);
3873 return EINVAL; // no clue, punt
3874 }
3876 if (ThreadPriorityVerbose)
3877 tty->print_cr ("Thread priority Range: [%d..%d]\n", myMin, myMax);
3879 priocntl_enable = true; // Enable changing priorities
3880 return 0;
3881 }
3883 #define IAPRI(x) ((iaparms_t *)((x).pc_clparms))
3884 #define RTPRI(x) ((rtparms_t *)((x).pc_clparms))
3885 #define TSPRI(x) ((tsparms_t *)((x).pc_clparms))
3888 // scale_to_lwp_priority
3889 //
3890 // Convert from the libthread "thr_setprio" scale to our current
3891 // lwp scheduling class scale.
3892 //
3893 static
3894 int scale_to_lwp_priority (int rMin, int rMax, int x)
3895 {
3896 int v;
3898 if (x == 127) return rMax; // avoid round-down
3899 v = (((x*(rMax-rMin)))/128)+rMin;
3900 return v;
3901 }
3904 // set_lwp_priority
3905 //
3906 // Set the priority of the lwp. This call should only be made
3907 // when using bound threads (T2 threads are bound by default).
3908 //
3909 int set_lwp_priority (int ThreadID, int lwpid, int newPrio )
3910 {
3911 int rslt;
3912 int Actual, Expected, prv;
3913 pcparms_t ParmInfo; // for GET-SET
3914 #ifdef ASSERT
3915 pcparms_t ReadBack; // for readback
3916 #endif
3918 // Set priority via PC_GETPARMS, update, PC_SETPARMS
3919 // Query current values.
3920 // TODO: accelerate this by eliminating the PC_GETPARMS call.
3921 // Cache "pcparms_t" in global ParmCache.
3922 // TODO: elide set-to-same-value
3924 // If something went wrong on init, don't change priorities.
3925 if ( !priocntl_enable ) {
3926 if (ThreadPriorityVerbose)
3927 tty->print_cr("Trying to set priority but init failed, ignoring");
3928 return EINVAL;
3929 }
3932 // If lwp hasn't started yet, just return
3933 // the _start routine will call us again.
3934 if ( lwpid <= 0 ) {
3935 if (ThreadPriorityVerbose) {
3936 tty->print_cr ("deferring the set_lwp_priority of thread " INTPTR_FORMAT " to %d, lwpid not set",
3937 ThreadID, newPrio);
3938 }
3939 return 0;
3940 }
3942 if (ThreadPriorityVerbose) {
3943 tty->print_cr ("set_lwp_priority(" INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ",
3944 ThreadID, lwpid, newPrio);
3945 }
3947 memset(&ParmInfo, 0, sizeof(pcparms_t));
3948 ParmInfo.pc_cid = PC_CLNULL;
3949 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo);
3950 if (rslt < 0) return errno;
3952 if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3953 rtparms_t *rtInfo = (rtparms_t*)ParmInfo.pc_clparms;
3954 rtInfo->rt_pri = scale_to_lwp_priority (rtLimits.minPrio, rtLimits.maxPrio, newPrio);
3955 rtInfo->rt_tqsecs = RT_NOCHANGE;
3956 rtInfo->rt_tqnsecs = RT_NOCHANGE;
3957 if (ThreadPriorityVerbose) {
3958 tty->print_cr("RT: %d->%d\n", newPrio, rtInfo->rt_pri);
3959 }
3960 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3961 iaparms_t *iaInfo = (iaparms_t*)ParmInfo.pc_clparms;
3962 int maxClamped = MIN2(iaLimits.maxPrio, (int)iaInfo->ia_uprilim);
3963 iaInfo->ia_upri = scale_to_lwp_priority(iaLimits.minPrio, maxClamped, newPrio);
3964 iaInfo->ia_uprilim = IA_NOCHANGE;
3965 iaInfo->ia_mode = IA_NOCHANGE;
3966 if (ThreadPriorityVerbose) {
3967 tty->print_cr ("IA: [%d...%d] %d->%d\n",
3968 iaLimits.minPrio, maxClamped, newPrio, iaInfo->ia_upri);
3969 }
3970 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3971 tsparms_t *tsInfo = (tsparms_t*)ParmInfo.pc_clparms;
3972 int maxClamped = MIN2(tsLimits.maxPrio, (int)tsInfo->ts_uprilim);
3973 prv = tsInfo->ts_upri;
3974 tsInfo->ts_upri = scale_to_lwp_priority(tsLimits.minPrio, maxClamped, newPrio);
3975 tsInfo->ts_uprilim = IA_NOCHANGE;
3976 if (ThreadPriorityVerbose) {
3977 tty->print_cr ("TS: %d [%d...%d] %d->%d\n",
3978 prv, tsLimits.minPrio, maxClamped, newPrio, tsInfo->ts_upri);
3979 }
3980 if (prv == tsInfo->ts_upri) return 0;
3981 } else {
3982 if ( ThreadPriorityVerbose ) {
3983 tty->print_cr ("Unknown scheduling class\n");
3984 }
3985 return EINVAL; // no clue, punt
3986 }
3988 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_SETPARMS, (caddr_t)&ParmInfo);
3989 if (ThreadPriorityVerbose && rslt) {
3990 tty->print_cr ("PC_SETPARMS ->%d %d\n", rslt, errno);
3991 }
3992 if (rslt < 0) return errno;
3994 #ifdef ASSERT
3995 // Sanity check: read back what we just attempted to set.
3996 // In theory it could have changed in the interim ...
3997 //
3998 // The priocntl system call is tricky.
3999 // Sometimes it'll validate the priority value argument and
4000 // return EINVAL if unhappy. At other times it fails silently.
4001 // Readbacks are prudent.
4003 if (!ReadBackValidate) return 0;
4005 memset(&ReadBack, 0, sizeof(pcparms_t));
4006 ReadBack.pc_cid = PC_CLNULL;
4007 rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ReadBack);
4008 assert(rslt >= 0, "priocntl failed");
4009 Actual = Expected = 0xBAD;
4010 assert(ParmInfo.pc_cid == ReadBack.pc_cid, "cid's don't match");
4011 if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
4012 Actual = RTPRI(ReadBack)->rt_pri;
4013 Expected = RTPRI(ParmInfo)->rt_pri;
4014 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
4015 Actual = IAPRI(ReadBack)->ia_upri;
4016 Expected = IAPRI(ParmInfo)->ia_upri;
4017 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
4018 Actual = TSPRI(ReadBack)->ts_upri;
4019 Expected = TSPRI(ParmInfo)->ts_upri;
4020 } else {
4021 if ( ThreadPriorityVerbose ) {
4022 tty->print_cr("set_lwp_priority: unexpected class in readback: %d\n", ParmInfo.pc_cid);
4023 }
4024 }
4026 if (Actual != Expected) {
4027 if ( ThreadPriorityVerbose ) {
4028 tty->print_cr ("set_lwp_priority(%d %d) Class=%d: actual=%d vs expected=%d\n",
4029 lwpid, newPrio, ReadBack.pc_cid, Actual, Expected);
4030 }
4031 }
4032 #endif
4034 return 0;
4035 }
4039 // Solaris only gives access to 128 real priorities at a time,
4040 // so we expand Java's ten to fill this range. This would be better
4041 // if we dynamically adjusted relative priorities.
4042 //
4043 // The ThreadPriorityPolicy option allows us to select 2 different
4044 // priority scales.
4045 //
4046 // ThreadPriorityPolicy=0
4047 // Since the Solaris' default priority is MaximumPriority, we do not
4048 // set a priority lower than Max unless a priority lower than
4049 // NormPriority is requested.
4050 //
4051 // ThreadPriorityPolicy=1
4052 // This mode causes the priority table to get filled with
4053 // linear values. NormPriority get's mapped to 50% of the
4054 // Maximum priority an so on. This will cause VM threads
4055 // to get unfair treatment against other Solaris processes
4056 // which do not explicitly alter their thread priorities.
4057 //
4060 int os::java_to_os_priority[MaxPriority + 1] = {
4061 -99999, // 0 Entry should never be used
4063 0, // 1 MinPriority
4064 32, // 2
4065 64, // 3
4067 96, // 4
4068 127, // 5 NormPriority
4069 127, // 6
4071 127, // 7
4072 127, // 8
4073 127, // 9 NearMaxPriority
4075 127 // 10 MaxPriority
4076 };
4079 OSReturn os::set_native_priority(Thread* thread, int newpri) {
4080 assert(newpri >= MinimumPriority && newpri <= MaximumPriority, "bad priority mapping");
4081 if ( !UseThreadPriorities ) return OS_OK;
4082 int status = thr_setprio(thread->osthread()->thread_id(), newpri);
4083 if ( os::Solaris::T2_libthread() || (UseBoundThreads && thread->osthread()->is_vm_created()) )
4084 status |= (set_lwp_priority (thread->osthread()->thread_id(),
4085 thread->osthread()->lwp_id(), newpri ));
4086 return (status == 0) ? OS_OK : OS_ERR;
4087 }
4090 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
4091 int p;
4092 if ( !UseThreadPriorities ) {
4093 *priority_ptr = NormalPriority;
4094 return OS_OK;
4095 }
4096 int status = thr_getprio(thread->osthread()->thread_id(), &p);
4097 if (status != 0) {
4098 return OS_ERR;
4099 }
4100 *priority_ptr = p;
4101 return OS_OK;
4102 }
4105 // Hint to the underlying OS that a task switch would not be good.
4106 // Void return because it's a hint and can fail.
4107 void os::hint_no_preempt() {
4108 schedctl_start(schedctl_init());
4109 }
4111 void os::interrupt(Thread* thread) {
4112 assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer");
4114 OSThread* osthread = thread->osthread();
4116 int isInterrupted = osthread->interrupted();
4117 if (!isInterrupted) {
4118 osthread->set_interrupted(true);
4119 OrderAccess::fence();
4120 // os::sleep() is implemented with either poll (NULL,0,timeout) or
4121 // by parking on _SleepEvent. If the former, thr_kill will unwedge
4122 // the sleeper by SIGINTR, otherwise the unpark() will wake the sleeper.
4123 ParkEvent * const slp = thread->_SleepEvent ;
4124 if (slp != NULL) slp->unpark() ;
4125 }
4127 // For JSR166: unpark after setting status but before thr_kill -dl
4128 if (thread->is_Java_thread()) {
4129 ((JavaThread*)thread)->parker()->unpark();
4130 }
4132 // Handle interruptible wait() ...
4133 ParkEvent * const ev = thread->_ParkEvent ;
4134 if (ev != NULL) ev->unpark() ;
4136 // When events are used everywhere for os::sleep, then this thr_kill
4137 // will only be needed if UseVMInterruptibleIO is true.
4139 if (!isInterrupted) {
4140 int status = thr_kill(osthread->thread_id(), os::Solaris::SIGinterrupt());
4141 assert_status(status == 0, status, "thr_kill");
4143 // Bump thread interruption counter
4144 RuntimeService::record_thread_interrupt_signaled_count();
4145 }
4146 }
4149 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
4150 assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer");
4152 OSThread* osthread = thread->osthread();
4154 bool res = osthread->interrupted();
4156 // NOTE that since there is no "lock" around these two operations,
4157 // there is the possibility that the interrupted flag will be
4158 // "false" but that the interrupt event will be set. This is
4159 // intentional. The effect of this is that Object.wait() will appear
4160 // to have a spurious wakeup, which is not harmful, and the
4161 // possibility is so rare that it is not worth the added complexity
4162 // to add yet another lock. It has also been recommended not to put
4163 // the interrupted flag into the os::Solaris::Event structure,
4164 // because it hides the issue.
4165 if (res && clear_interrupted) {
4166 osthread->set_interrupted(false);
4167 }
4168 return res;
4169 }
4172 void os::print_statistics() {
4173 }
4175 int os::message_box(const char* title, const char* message) {
4176 int i;
4177 fdStream err(defaultStream::error_fd());
4178 for (i = 0; i < 78; i++) err.print_raw("=");
4179 err.cr();
4180 err.print_raw_cr(title);
4181 for (i = 0; i < 78; i++) err.print_raw("-");
4182 err.cr();
4183 err.print_raw_cr(message);
4184 for (i = 0; i < 78; i++) err.print_raw("=");
4185 err.cr();
4187 char buf[16];
4188 // Prevent process from exiting upon "read error" without consuming all CPU
4189 while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
4191 return buf[0] == 'y' || buf[0] == 'Y';
4192 }
4194 // A lightweight implementation that does not suspend the target thread and
4195 // thus returns only a hint. Used for profiling only!
4196 ExtendedPC os::get_thread_pc(Thread* thread) {
4197 // Make sure that it is called by the watcher and the Threads lock is owned.
4198 assert(Thread::current()->is_Watcher_thread(), "Must be watcher and own Threads_lock");
4199 // For now, is only used to profile the VM Thread
4200 assert(thread->is_VM_thread(), "Can only be called for VMThread");
4201 ExtendedPC epc;
4203 GetThreadPC_Callback cb(ProfileVM_lock);
4204 OSThread *osthread = thread->osthread();
4205 const int time_to_wait = 400; // 400ms wait for initial response
4206 int status = cb.interrupt(thread, time_to_wait);
4208 if (cb.is_done() ) {
4209 epc = cb.addr();
4210 } else {
4211 DEBUG_ONLY(tty->print_cr("Failed to get pc for thread: %d got %d status",
4212 osthread->thread_id(), status););
4213 // epc is already NULL
4214 }
4215 return epc;
4216 }
4219 // This does not do anything on Solaris. This is basically a hook for being
4220 // able to use structured exception handling (thread-local exception filters) on, e.g., Win32.
4221 void os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread) {
4222 f(value, method, args, thread);
4223 }
4225 // This routine may be used by user applications as a "hook" to catch signals.
4226 // The user-defined signal handler must pass unrecognized signals to this
4227 // routine, and if it returns true (non-zero), then the signal handler must
4228 // return immediately. If the flag "abort_if_unrecognized" is true, then this
4229 // routine will never retun false (zero), but instead will execute a VM panic
4230 // routine kill the process.
4231 //
4232 // If this routine returns false, it is OK to call it again. This allows
4233 // the user-defined signal handler to perform checks either before or after
4234 // the VM performs its own checks. Naturally, the user code would be making
4235 // a serious error if it tried to handle an exception (such as a null check
4236 // or breakpoint) that the VM was generating for its own correct operation.
4237 //
4238 // This routine may recognize any of the following kinds of signals:
4239 // SIGBUS, SIGSEGV, SIGILL, SIGFPE, BREAK_SIGNAL, SIGPIPE, SIGXFSZ,
4240 // os::Solaris::SIGasync
4241 // It should be consulted by handlers for any of those signals.
4242 // It explicitly does not recognize os::Solaris::SIGinterrupt
4243 //
4244 // The caller of this routine must pass in the three arguments supplied
4245 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
4246 // field of the structure passed to sigaction(). This routine assumes that
4247 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
4248 //
4249 // Note that the VM will print warnings if it detects conflicting signal
4250 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
4251 //
4252 extern "C" JNIEXPORT int
4253 JVM_handle_solaris_signal(int signo, siginfo_t* siginfo, void* ucontext,
4254 int abort_if_unrecognized);
4257 void signalHandler(int sig, siginfo_t* info, void* ucVoid) {
4258 JVM_handle_solaris_signal(sig, info, ucVoid, true);
4259 }
4261 /* Do not delete - if guarantee is ever removed, a signal handler (even empty)
4262 is needed to provoke threads blocked on IO to return an EINTR
4263 Note: this explicitly does NOT call JVM_handle_solaris_signal and
4264 does NOT participate in signal chaining due to requirement for
4265 NOT setting SA_RESTART to make EINTR work. */
4266 extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) {
4267 if (UseSignalChaining) {
4268 struct sigaction *actp = os::Solaris::get_chained_signal_action(sig);
4269 if (actp && actp->sa_handler) {
4270 vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs");
4271 }
4272 }
4273 }
4275 // This boolean allows users to forward their own non-matching signals
4276 // to JVM_handle_solaris_signal, harmlessly.
4277 bool os::Solaris::signal_handlers_are_installed = false;
4279 // For signal-chaining
4280 bool os::Solaris::libjsig_is_loaded = false;
4281 typedef struct sigaction *(*get_signal_t)(int);
4282 get_signal_t os::Solaris::get_signal_action = NULL;
4284 struct sigaction* os::Solaris::get_chained_signal_action(int sig) {
4285 struct sigaction *actp = NULL;
4287 if ((libjsig_is_loaded) && (sig <= Maxlibjsigsigs)) {
4288 // Retrieve the old signal handler from libjsig
4289 actp = (*get_signal_action)(sig);
4290 }
4291 if (actp == NULL) {
4292 // Retrieve the preinstalled signal handler from jvm
4293 actp = get_preinstalled_handler(sig);
4294 }
4296 return actp;
4297 }
4299 static bool call_chained_handler(struct sigaction *actp, int sig,
4300 siginfo_t *siginfo, void *context) {
4301 // Call the old signal handler
4302 if (actp->sa_handler == SIG_DFL) {
4303 // It's more reasonable to let jvm treat it as an unexpected exception
4304 // instead of taking the default action.
4305 return false;
4306 } else if (actp->sa_handler != SIG_IGN) {
4307 if ((actp->sa_flags & SA_NODEFER) == 0) {
4308 // automaticlly block the signal
4309 sigaddset(&(actp->sa_mask), sig);
4310 }
4312 sa_handler_t hand;
4313 sa_sigaction_t sa;
4314 bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
4315 // retrieve the chained handler
4316 if (siginfo_flag_set) {
4317 sa = actp->sa_sigaction;
4318 } else {
4319 hand = actp->sa_handler;
4320 }
4322 if ((actp->sa_flags & SA_RESETHAND) != 0) {
4323 actp->sa_handler = SIG_DFL;
4324 }
4326 // try to honor the signal mask
4327 sigset_t oset;
4328 thr_sigsetmask(SIG_SETMASK, &(actp->sa_mask), &oset);
4330 // call into the chained handler
4331 if (siginfo_flag_set) {
4332 (*sa)(sig, siginfo, context);
4333 } else {
4334 (*hand)(sig);
4335 }
4337 // restore the signal mask
4338 thr_sigsetmask(SIG_SETMASK, &oset, 0);
4339 }
4340 // Tell jvm's signal handler the signal is taken care of.
4341 return true;
4342 }
4344 bool os::Solaris::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4345 bool chained = false;
4346 // signal-chaining
4347 if (UseSignalChaining) {
4348 struct sigaction *actp = get_chained_signal_action(sig);
4349 if (actp != NULL) {
4350 chained = call_chained_handler(actp, sig, siginfo, context);
4351 }
4352 }
4353 return chained;
4354 }
4356 struct sigaction* os::Solaris::get_preinstalled_handler(int sig) {
4357 assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized");
4358 if (preinstalled_sigs[sig] != 0) {
4359 return &chainedsigactions[sig];
4360 }
4361 return NULL;
4362 }
4364 void os::Solaris::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
4366 assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range");
4367 assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized");
4368 chainedsigactions[sig] = oldAct;
4369 preinstalled_sigs[sig] = 1;
4370 }
4372 void os::Solaris::set_signal_handler(int sig, bool set_installed, bool oktochain) {
4373 // Check for overwrite.
4374 struct sigaction oldAct;
4375 sigaction(sig, (struct sigaction*)NULL, &oldAct);
4376 void* oldhand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
4377 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
4378 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
4379 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
4380 oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) {
4381 if (AllowUserSignalHandlers || !set_installed) {
4382 // Do not overwrite; user takes responsibility to forward to us.
4383 return;
4384 } else if (UseSignalChaining) {
4385 if (oktochain) {
4386 // save the old handler in jvm
4387 save_preinstalled_handler(sig, oldAct);
4388 } else {
4389 vm_exit_during_initialization("Signal chaining not allowed for VM interrupt signal, try -XX:+UseAltSigs.");
4390 }
4391 // libjsig also interposes the sigaction() call below and saves the
4392 // old sigaction on it own.
4393 } else {
4394 fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
4395 "%#lx for signal %d.", (long)oldhand, sig));
4396 }
4397 }
4399 struct sigaction sigAct;
4400 sigfillset(&(sigAct.sa_mask));
4401 sigAct.sa_handler = SIG_DFL;
4403 sigAct.sa_sigaction = signalHandler;
4404 // Handle SIGSEGV on alternate signal stack if
4405 // not using stack banging
4406 if (!UseStackBanging && sig == SIGSEGV) {
4407 sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
4408 // Interruptible i/o requires SA_RESTART cleared so EINTR
4409 // is returned instead of restarting system calls
4410 } else if (sig == os::Solaris::SIGinterrupt()) {
4411 sigemptyset(&sigAct.sa_mask);
4412 sigAct.sa_handler = NULL;
4413 sigAct.sa_flags = SA_SIGINFO;
4414 sigAct.sa_sigaction = sigINTRHandler;
4415 } else {
4416 sigAct.sa_flags = SA_SIGINFO | SA_RESTART;
4417 }
4418 os::Solaris::set_our_sigflags(sig, sigAct.sa_flags);
4420 sigaction(sig, &sigAct, &oldAct);
4422 void* oldhand2 = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
4423 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
4424 assert(oldhand2 == oldhand, "no concurrent signal handler installation");
4425 }
4428 #define DO_SIGNAL_CHECK(sig) \
4429 if (!sigismember(&check_signal_done, sig)) \
4430 os::Solaris::check_signal_handler(sig)
4432 // This method is a periodic task to check for misbehaving JNI applications
4433 // under CheckJNI, we can add any periodic checks here
4435 void os::run_periodic_checks() {
4436 // A big source of grief is hijacking virt. addr 0x0 on Solaris,
4437 // thereby preventing a NULL checks.
4438 if(!check_addr0_done) check_addr0_done = check_addr0(tty);
4440 if (check_signals == false) return;
4442 // SEGV and BUS if overridden could potentially prevent
4443 // generation of hs*.log in the event of a crash, debugging
4444 // such a case can be very challenging, so we absolutely
4445 // check for the following for a good measure:
4446 DO_SIGNAL_CHECK(SIGSEGV);
4447 DO_SIGNAL_CHECK(SIGILL);
4448 DO_SIGNAL_CHECK(SIGFPE);
4449 DO_SIGNAL_CHECK(SIGBUS);
4450 DO_SIGNAL_CHECK(SIGPIPE);
4451 DO_SIGNAL_CHECK(SIGXFSZ);
4453 // ReduceSignalUsage allows the user to override these handlers
4454 // see comments at the very top and jvm_solaris.h
4455 if (!ReduceSignalUsage) {
4456 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
4457 DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
4458 DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
4459 DO_SIGNAL_CHECK(BREAK_SIGNAL);
4460 }
4462 // See comments above for using JVM1/JVM2 and UseAltSigs
4463 DO_SIGNAL_CHECK(os::Solaris::SIGinterrupt());
4464 DO_SIGNAL_CHECK(os::Solaris::SIGasync());
4466 }
4468 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
4470 static os_sigaction_t os_sigaction = NULL;
4472 void os::Solaris::check_signal_handler(int sig) {
4473 char buf[O_BUFLEN];
4474 address jvmHandler = NULL;
4476 struct sigaction act;
4477 if (os_sigaction == NULL) {
4478 // only trust the default sigaction, in case it has been interposed
4479 os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
4480 if (os_sigaction == NULL) return;
4481 }
4483 os_sigaction(sig, (struct sigaction*)NULL, &act);
4485 address thisHandler = (act.sa_flags & SA_SIGINFO)
4486 ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
4487 : CAST_FROM_FN_PTR(address, act.sa_handler) ;
4490 switch(sig) {
4491 case SIGSEGV:
4492 case SIGBUS:
4493 case SIGFPE:
4494 case SIGPIPE:
4495 case SIGXFSZ:
4496 case SIGILL:
4497 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4498 break;
4500 case SHUTDOWN1_SIGNAL:
4501 case SHUTDOWN2_SIGNAL:
4502 case SHUTDOWN3_SIGNAL:
4503 case BREAK_SIGNAL:
4504 jvmHandler = (address)user_handler();
4505 break;
4507 default:
4508 int intrsig = os::Solaris::SIGinterrupt();
4509 int asynsig = os::Solaris::SIGasync();
4511 if (sig == intrsig) {
4512 jvmHandler = CAST_FROM_FN_PTR(address, sigINTRHandler);
4513 } else if (sig == asynsig) {
4514 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4515 } else {
4516 return;
4517 }
4518 break;
4519 }
4522 if (thisHandler != jvmHandler) {
4523 tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
4524 tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
4525 tty->print_cr(" found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
4526 // No need to check this sig any longer
4527 sigaddset(&check_signal_done, sig);
4528 } else if(os::Solaris::get_our_sigflags(sig) != 0 && act.sa_flags != os::Solaris::get_our_sigflags(sig)) {
4529 tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
4530 tty->print("expected:" PTR32_FORMAT, os::Solaris::get_our_sigflags(sig));
4531 tty->print_cr(" found:" PTR32_FORMAT, act.sa_flags);
4532 // No need to check this sig any longer
4533 sigaddset(&check_signal_done, sig);
4534 }
4536 // Print all the signal handler state
4537 if (sigismember(&check_signal_done, sig)) {
4538 print_signal_handlers(tty, buf, O_BUFLEN);
4539 }
4541 }
4543 void os::Solaris::install_signal_handlers() {
4544 bool libjsigdone = false;
4545 signal_handlers_are_installed = true;
4547 // signal-chaining
4548 typedef void (*signal_setting_t)();
4549 signal_setting_t begin_signal_setting = NULL;
4550 signal_setting_t end_signal_setting = NULL;
4551 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4552 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
4553 if (begin_signal_setting != NULL) {
4554 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4555 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
4556 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
4557 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
4558 get_libjsig_version = CAST_TO_FN_PTR(version_getting_t,
4559 dlsym(RTLD_DEFAULT, "JVM_get_libjsig_version"));
4560 libjsig_is_loaded = true;
4561 if (os::Solaris::get_libjsig_version != NULL) {
4562 libjsigversion = (*os::Solaris::get_libjsig_version)();
4563 }
4564 assert(UseSignalChaining, "should enable signal-chaining");
4565 }
4566 if (libjsig_is_loaded) {
4567 // Tell libjsig jvm is setting signal handlers
4568 (*begin_signal_setting)();
4569 }
4571 set_signal_handler(SIGSEGV, true, true);
4572 set_signal_handler(SIGPIPE, true, true);
4573 set_signal_handler(SIGXFSZ, true, true);
4574 set_signal_handler(SIGBUS, true, true);
4575 set_signal_handler(SIGILL, true, true);
4576 set_signal_handler(SIGFPE, true, true);
4579 if (os::Solaris::SIGinterrupt() > OLDMAXSIGNUM || os::Solaris::SIGasync() > OLDMAXSIGNUM) {
4581 // Pre-1.4.1 Libjsig limited to signal chaining signals <= 32 so
4582 // can not register overridable signals which might be > 32
4583 if (libjsig_is_loaded && libjsigversion <= JSIG_VERSION_1_4_1) {
4584 // Tell libjsig jvm has finished setting signal handlers
4585 (*end_signal_setting)();
4586 libjsigdone = true;
4587 }
4588 }
4590 // Never ok to chain our SIGinterrupt
4591 set_signal_handler(os::Solaris::SIGinterrupt(), true, false);
4592 set_signal_handler(os::Solaris::SIGasync(), true, true);
4594 if (libjsig_is_loaded && !libjsigdone) {
4595 // Tell libjsig jvm finishes setting signal handlers
4596 (*end_signal_setting)();
4597 }
4599 // We don't activate signal checker if libjsig is in place, we trust ourselves
4600 // and if UserSignalHandler is installed all bets are off.
4601 // Log that signal checking is off only if -verbose:jni is specified.
4602 if (CheckJNICalls) {
4603 if (libjsig_is_loaded) {
4604 if (PrintJNIResolving) {
4605 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
4606 }
4607 check_signals = false;
4608 }
4609 if (AllowUserSignalHandlers) {
4610 if (PrintJNIResolving) {
4611 tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
4612 }
4613 check_signals = false;
4614 }
4615 }
4616 }
4619 void report_error(const char* file_name, int line_no, const char* title, const char* format, ...);
4621 const char * signames[] = {
4622 "SIG0",
4623 "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP",
4624 "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS",
4625 "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM",
4626 "SIGUSR1", "SIGUSR2", "SIGCLD", "SIGPWR", "SIGWINCH",
4627 "SIGURG", "SIGPOLL", "SIGSTOP", "SIGTSTP", "SIGCONT",
4628 "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU",
4629 "SIGXFSZ", "SIGWAITING", "SIGLWP", "SIGFREEZE", "SIGTHAW",
4630 "SIGCANCEL", "SIGLOST"
4631 };
4633 const char* os::exception_name(int exception_code, char* buf, size_t size) {
4634 if (0 < exception_code && exception_code <= SIGRTMAX) {
4635 // signal
4636 if (exception_code < sizeof(signames)/sizeof(const char*)) {
4637 jio_snprintf(buf, size, "%s", signames[exception_code]);
4638 } else {
4639 jio_snprintf(buf, size, "SIG%d", exception_code);
4640 }
4641 return buf;
4642 } else {
4643 return NULL;
4644 }
4645 }
4647 // (Static) wrappers for the new libthread API
4648 int_fnP_thread_t_iP_uP_stack_tP_gregset_t os::Solaris::_thr_getstate;
4649 int_fnP_thread_t_i_gregset_t os::Solaris::_thr_setstate;
4650 int_fnP_thread_t_i os::Solaris::_thr_setmutator;
4651 int_fnP_thread_t os::Solaris::_thr_suspend_mutator;
4652 int_fnP_thread_t os::Solaris::_thr_continue_mutator;
4654 // (Static) wrapper for getisax(2) call.
4655 os::Solaris::getisax_func_t os::Solaris::_getisax = 0;
4657 // (Static) wrappers for the liblgrp API
4658 os::Solaris::lgrp_home_func_t os::Solaris::_lgrp_home;
4659 os::Solaris::lgrp_init_func_t os::Solaris::_lgrp_init;
4660 os::Solaris::lgrp_fini_func_t os::Solaris::_lgrp_fini;
4661 os::Solaris::lgrp_root_func_t os::Solaris::_lgrp_root;
4662 os::Solaris::lgrp_children_func_t os::Solaris::_lgrp_children;
4663 os::Solaris::lgrp_resources_func_t os::Solaris::_lgrp_resources;
4664 os::Solaris::lgrp_nlgrps_func_t os::Solaris::_lgrp_nlgrps;
4665 os::Solaris::lgrp_cookie_stale_func_t os::Solaris::_lgrp_cookie_stale;
4666 os::Solaris::lgrp_cookie_t os::Solaris::_lgrp_cookie = 0;
4668 // (Static) wrapper for meminfo() call.
4669 os::Solaris::meminfo_func_t os::Solaris::_meminfo = 0;
4671 static address resolve_symbol_lazy(const char* name) {
4672 address addr = (address) dlsym(RTLD_DEFAULT, name);
4673 if(addr == NULL) {
4674 // RTLD_DEFAULT was not defined on some early versions of 2.5.1
4675 addr = (address) dlsym(RTLD_NEXT, name);
4676 }
4677 return addr;
4678 }
4680 static address resolve_symbol(const char* name) {
4681 address addr = resolve_symbol_lazy(name);
4682 if(addr == NULL) {
4683 fatal(dlerror());
4684 }
4685 return addr;
4686 }
4690 // isT2_libthread()
4691 //
4692 // Routine to determine if we are currently using the new T2 libthread.
4693 //
4694 // We determine if we are using T2 by reading /proc/self/lstatus and
4695 // looking for a thread with the ASLWP bit set. If we find this status
4696 // bit set, we must assume that we are NOT using T2. The T2 team
4697 // has approved this algorithm.
4698 //
4699 // We need to determine if we are running with the new T2 libthread
4700 // since setting native thread priorities is handled differently
4701 // when using this library. All threads created using T2 are bound
4702 // threads. Calling thr_setprio is meaningless in this case.
4703 //
4704 bool isT2_libthread() {
4705 static prheader_t * lwpArray = NULL;
4706 static int lwpSize = 0;
4707 static int lwpFile = -1;
4708 lwpstatus_t * that;
4709 char lwpName [128];
4710 bool isT2 = false;
4712 #define ADR(x) ((uintptr_t)(x))
4713 #define LWPINDEX(ary,ix) ((lwpstatus_t *)(((ary)->pr_entsize * (ix)) + (ADR((ary) + 1))))
4715 lwpFile = ::open("/proc/self/lstatus", O_RDONLY, 0);
4716 if (lwpFile < 0) {
4717 if (ThreadPriorityVerbose) warning ("Couldn't open /proc/self/lstatus\n");
4718 return false;
4719 }
4720 lwpSize = 16*1024;
4721 for (;;) {
4722 ::lseek64 (lwpFile, 0, SEEK_SET);
4723 lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize);
4724 if (::read(lwpFile, lwpArray, lwpSize) < 0) {
4725 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n");
4726 break;
4727 }
4728 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) {
4729 // We got a good snapshot - now iterate over the list.
4730 int aslwpcount = 0;
4731 for (int i = 0; i < lwpArray->pr_nent; i++ ) {
4732 that = LWPINDEX(lwpArray,i);
4733 if (that->pr_flags & PR_ASLWP) {
4734 aslwpcount++;
4735 }
4736 }
4737 if (aslwpcount == 0) isT2 = true;
4738 break;
4739 }
4740 lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize;
4741 FREE_C_HEAP_ARRAY(char, lwpArray); // retry.
4742 }
4744 FREE_C_HEAP_ARRAY(char, lwpArray);
4745 ::close (lwpFile);
4746 if (ThreadPriorityVerbose) {
4747 if (isT2) tty->print_cr("We are running with a T2 libthread\n");
4748 else tty->print_cr("We are not running with a T2 libthread\n");
4749 }
4750 return isT2;
4751 }
4754 void os::Solaris::libthread_init() {
4755 address func = (address)dlsym(RTLD_DEFAULT, "_thr_suspend_allmutators");
4757 // Determine if we are running with the new T2 libthread
4758 os::Solaris::set_T2_libthread(isT2_libthread());
4760 lwp_priocntl_init();
4762 // RTLD_DEFAULT was not defined on some early versions of 5.5.1
4763 if(func == NULL) {
4764 func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators");
4765 // Guarantee that this VM is running on an new enough OS (5.6 or
4766 // later) that it will have a new enough libthread.so.
4767 guarantee(func != NULL, "libthread.so is too old.");
4768 }
4770 // Initialize the new libthread getstate API wrappers
4771 func = resolve_symbol("thr_getstate");
4772 os::Solaris::set_thr_getstate(CAST_TO_FN_PTR(int_fnP_thread_t_iP_uP_stack_tP_gregset_t, func));
4774 func = resolve_symbol("thr_setstate");
4775 os::Solaris::set_thr_setstate(CAST_TO_FN_PTR(int_fnP_thread_t_i_gregset_t, func));
4777 func = resolve_symbol("thr_setmutator");
4778 os::Solaris::set_thr_setmutator(CAST_TO_FN_PTR(int_fnP_thread_t_i, func));
4780 func = resolve_symbol("thr_suspend_mutator");
4781 os::Solaris::set_thr_suspend_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func));
4783 func = resolve_symbol("thr_continue_mutator");
4784 os::Solaris::set_thr_continue_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func));
4786 int size;
4787 void (*handler_info_func)(address *, int *);
4788 handler_info_func = CAST_TO_FN_PTR(void (*)(address *, int *), resolve_symbol("thr_sighndlrinfo"));
4789 handler_info_func(&handler_start, &size);
4790 handler_end = handler_start + size;
4791 }
4794 int_fnP_mutex_tP os::Solaris::_mutex_lock;
4795 int_fnP_mutex_tP os::Solaris::_mutex_trylock;
4796 int_fnP_mutex_tP os::Solaris::_mutex_unlock;
4797 int_fnP_mutex_tP_i_vP os::Solaris::_mutex_init;
4798 int_fnP_mutex_tP os::Solaris::_mutex_destroy;
4799 int os::Solaris::_mutex_scope = USYNC_THREAD;
4801 int_fnP_cond_tP_mutex_tP_timestruc_tP os::Solaris::_cond_timedwait;
4802 int_fnP_cond_tP_mutex_tP os::Solaris::_cond_wait;
4803 int_fnP_cond_tP os::Solaris::_cond_signal;
4804 int_fnP_cond_tP os::Solaris::_cond_broadcast;
4805 int_fnP_cond_tP_i_vP os::Solaris::_cond_init;
4806 int_fnP_cond_tP os::Solaris::_cond_destroy;
4807 int os::Solaris::_cond_scope = USYNC_THREAD;
4809 void os::Solaris::synchronization_init() {
4810 if(UseLWPSynchronization) {
4811 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock")));
4812 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock")));
4813 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock")));
4814 os::Solaris::set_mutex_init(lwp_mutex_init);
4815 os::Solaris::set_mutex_destroy(lwp_mutex_destroy);
4816 os::Solaris::set_mutex_scope(USYNC_THREAD);
4818 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("_lwp_cond_timedwait")));
4819 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("_lwp_cond_wait")));
4820 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal")));
4821 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast")));
4822 os::Solaris::set_cond_init(lwp_cond_init);
4823 os::Solaris::set_cond_destroy(lwp_cond_destroy);
4824 os::Solaris::set_cond_scope(USYNC_THREAD);
4825 }
4826 else {
4827 os::Solaris::set_mutex_scope(USYNC_THREAD);
4828 os::Solaris::set_cond_scope(USYNC_THREAD);
4830 if(UsePthreads) {
4831 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock")));
4832 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock")));
4833 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock")));
4834 os::Solaris::set_mutex_init(pthread_mutex_default_init);
4835 os::Solaris::set_mutex_destroy(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_destroy")));
4837 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("pthread_cond_timedwait")));
4838 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait")));
4839 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal")));
4840 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast")));
4841 os::Solaris::set_cond_init(pthread_cond_default_init);
4842 os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy")));
4843 }
4844 else {
4845 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock")));
4846 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock")));
4847 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock")));
4848 os::Solaris::set_mutex_init(::mutex_init);
4849 os::Solaris::set_mutex_destroy(::mutex_destroy);
4851 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("cond_timedwait")));
4852 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("cond_wait")));
4853 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_signal")));
4854 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_broadcast")));
4855 os::Solaris::set_cond_init(::cond_init);
4856 os::Solaris::set_cond_destroy(::cond_destroy);
4857 }
4858 }
4859 }
4861 bool os::Solaris::liblgrp_init() {
4862 void *handle = dlopen("liblgrp.so.1", RTLD_LAZY);
4863 if (handle != NULL) {
4864 os::Solaris::set_lgrp_home(CAST_TO_FN_PTR(lgrp_home_func_t, dlsym(handle, "lgrp_home")));
4865 os::Solaris::set_lgrp_init(CAST_TO_FN_PTR(lgrp_init_func_t, dlsym(handle, "lgrp_init")));
4866 os::Solaris::set_lgrp_fini(CAST_TO_FN_PTR(lgrp_fini_func_t, dlsym(handle, "lgrp_fini")));
4867 os::Solaris::set_lgrp_root(CAST_TO_FN_PTR(lgrp_root_func_t, dlsym(handle, "lgrp_root")));
4868 os::Solaris::set_lgrp_children(CAST_TO_FN_PTR(lgrp_children_func_t, dlsym(handle, "lgrp_children")));
4869 os::Solaris::set_lgrp_resources(CAST_TO_FN_PTR(lgrp_resources_func_t, dlsym(handle, "lgrp_resources")));
4870 os::Solaris::set_lgrp_nlgrps(CAST_TO_FN_PTR(lgrp_nlgrps_func_t, dlsym(handle, "lgrp_nlgrps")));
4871 os::Solaris::set_lgrp_cookie_stale(CAST_TO_FN_PTR(lgrp_cookie_stale_func_t,
4872 dlsym(handle, "lgrp_cookie_stale")));
4874 lgrp_cookie_t c = lgrp_init(LGRP_VIEW_CALLER);
4875 set_lgrp_cookie(c);
4876 return true;
4877 }
4878 return false;
4879 }
4881 void os::Solaris::misc_sym_init() {
4882 address func;
4884 // getisax
4885 func = resolve_symbol_lazy("getisax");
4886 if (func != NULL) {
4887 os::Solaris::_getisax = CAST_TO_FN_PTR(getisax_func_t, func);
4888 }
4890 // meminfo
4891 func = resolve_symbol_lazy("meminfo");
4892 if (func != NULL) {
4893 os::Solaris::set_meminfo(CAST_TO_FN_PTR(meminfo_func_t, func));
4894 }
4895 }
4897 uint_t os::Solaris::getisax(uint32_t* array, uint_t n) {
4898 assert(_getisax != NULL, "_getisax not set");
4899 return _getisax(array, n);
4900 }
4902 // Symbol doesn't exist in Solaris 8 pset.h
4903 #ifndef PS_MYID
4904 #define PS_MYID -3
4905 #endif
4907 // int pset_getloadavg(psetid_t pset, double loadavg[], int nelem);
4908 typedef long (*pset_getloadavg_type)(psetid_t pset, double loadavg[], int nelem);
4909 static pset_getloadavg_type pset_getloadavg_ptr = NULL;
4911 void init_pset_getloadavg_ptr(void) {
4912 pset_getloadavg_ptr =
4913 (pset_getloadavg_type)dlsym(RTLD_DEFAULT, "pset_getloadavg");
4914 if (PrintMiscellaneous && Verbose && pset_getloadavg_ptr == NULL) {
4915 warning("pset_getloadavg function not found");
4916 }
4917 }
4919 int os::Solaris::_dev_zero_fd = -1;
4921 // this is called _before_ the global arguments have been parsed
4922 void os::init(void) {
4923 _initial_pid = getpid();
4925 max_hrtime = first_hrtime = gethrtime();
4927 init_random(1234567);
4929 page_size = sysconf(_SC_PAGESIZE);
4930 if (page_size == -1)
4931 fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)",
4932 strerror(errno)));
4933 init_page_sizes((size_t) page_size);
4935 Solaris::initialize_system_info();
4937 // Initialize misc. symbols as soon as possible, so we can use them
4938 // if we need them.
4939 Solaris::misc_sym_init();
4941 int fd = ::open("/dev/zero", O_RDWR);
4942 if (fd < 0) {
4943 fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno)));
4944 } else {
4945 Solaris::set_dev_zero_fd(fd);
4947 // Close on exec, child won't inherit.
4948 fcntl(fd, F_SETFD, FD_CLOEXEC);
4949 }
4951 clock_tics_per_sec = CLK_TCK;
4953 // check if dladdr1() exists; dladdr1 can provide more information than
4954 // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9
4955 // and is available on linker patches for 5.7 and 5.8.
4956 // libdl.so must have been loaded, this call is just an entry lookup
4957 void * hdl = dlopen("libdl.so", RTLD_NOW);
4958 if (hdl)
4959 dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1"));
4961 // (Solaris only) this switches to calls that actually do locking.
4962 ThreadCritical::initialize();
4964 main_thread = thr_self();
4966 // Constant minimum stack size allowed. It must be at least
4967 // the minimum of what the OS supports (thr_min_stack()), and
4968 // enough to allow the thread to get to user bytecode execution.
4969 Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed);
4970 // If the pagesize of the VM is greater than 8K determine the appropriate
4971 // number of initial guard pages. The user can change this with the
4972 // command line arguments, if needed.
4973 if (vm_page_size() > 8*K) {
4974 StackYellowPages = 1;
4975 StackRedPages = 1;
4976 StackShadowPages = round_to((StackShadowPages*8*K), vm_page_size()) / vm_page_size();
4977 }
4978 }
4980 // To install functions for atexit system call
4981 extern "C" {
4982 static void perfMemory_exit_helper() {
4983 perfMemory_exit();
4984 }
4985 }
4987 // this is called _after_ the global arguments have been parsed
4988 jint os::init_2(void) {
4989 // try to enable extended file IO ASAP, see 6431278
4990 os::Solaris::try_enable_extended_io();
4992 // Allocate a single page and mark it as readable for safepoint polling. Also
4993 // use this first mmap call to check support for MAP_ALIGN.
4994 address polling_page = (address)Solaris::mmap_chunk((char*)page_size,
4995 page_size,
4996 MAP_PRIVATE | MAP_ALIGN,
4997 PROT_READ);
4998 if (polling_page == NULL) {
4999 has_map_align = false;
5000 polling_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE,
5001 PROT_READ);
5002 }
5004 os::set_polling_page(polling_page);
5006 #ifndef PRODUCT
5007 if( Verbose && PrintMiscellaneous )
5008 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
5009 #endif
5011 if (!UseMembar) {
5012 address mem_serialize_page = (address)Solaris::mmap_chunk( NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE );
5013 guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page");
5014 os::set_memory_serialize_page( mem_serialize_page );
5016 #ifndef PRODUCT
5017 if(Verbose && PrintMiscellaneous)
5018 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
5019 #endif
5020 }
5022 os::large_page_init();
5024 // Check minimum allowable stack size for thread creation and to initialize
5025 // the java system classes, including StackOverflowError - depends on page
5026 // size. Add a page for compiler2 recursion in main thread.
5027 // Add in 2*BytesPerWord times page size to account for VM stack during
5028 // class initialization depending on 32 or 64 bit VM.
5029 os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed,
5030 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
5031 2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size);
5033 size_t threadStackSizeInBytes = ThreadStackSize * K;
5034 if (threadStackSizeInBytes != 0 &&
5035 threadStackSizeInBytes < os::Solaris::min_stack_allowed) {
5036 tty->print_cr("\nThe stack size specified is too small, Specify at least %dk",
5037 os::Solaris::min_stack_allowed/K);
5038 return JNI_ERR;
5039 }
5041 // For 64kbps there will be a 64kb page size, which makes
5042 // the usable default stack size quite a bit less. Increase the
5043 // stack for 64kb (or any > than 8kb) pages, this increases
5044 // virtual memory fragmentation (since we're not creating the
5045 // stack on a power of 2 boundary. The real fix for this
5046 // should be to fix the guard page mechanism.
5048 if (vm_page_size() > 8*K) {
5049 threadStackSizeInBytes = (threadStackSizeInBytes != 0)
5050 ? threadStackSizeInBytes +
5051 ((StackYellowPages + StackRedPages) * vm_page_size())
5052 : 0;
5053 ThreadStackSize = threadStackSizeInBytes/K;
5054 }
5056 // Make the stack size a multiple of the page size so that
5057 // the yellow/red zones can be guarded.
5058 JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
5059 vm_page_size()));
5061 Solaris::libthread_init();
5063 if (UseNUMA) {
5064 if (!Solaris::liblgrp_init()) {
5065 UseNUMA = false;
5066 } else {
5067 size_t lgrp_limit = os::numa_get_groups_num();
5068 int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit);
5069 size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit);
5070 FREE_C_HEAP_ARRAY(int, lgrp_ids);
5071 if (lgrp_num < 2) {
5072 // There's only one locality group, disable NUMA.
5073 UseNUMA = false;
5074 }
5075 }
5076 // ISM is not compatible with the NUMA allocator - it always allocates
5077 // pages round-robin across the lgroups.
5078 if (UseNUMA && UseLargePages && UseISM) {
5079 if (!FLAG_IS_DEFAULT(UseNUMA)) {
5080 if (FLAG_IS_DEFAULT(UseLargePages) && FLAG_IS_DEFAULT(UseISM)) {
5081 UseLargePages = false;
5082 } else {
5083 warning("UseNUMA is not compatible with ISM large pages, disabling NUMA allocator");
5084 UseNUMA = false;
5085 }
5086 } else {
5087 UseNUMA = false;
5088 }
5089 }
5090 if (!UseNUMA && ForceNUMA) {
5091 UseNUMA = true;
5092 }
5093 }
5095 Solaris::signal_sets_init();
5096 Solaris::init_signal_mem();
5097 Solaris::install_signal_handlers();
5099 if (libjsigversion < JSIG_VERSION_1_4_1) {
5100 Maxlibjsigsigs = OLDMAXSIGNUM;
5101 }
5103 // initialize synchronization primitives to use either thread or
5104 // lwp synchronization (controlled by UseLWPSynchronization)
5105 Solaris::synchronization_init();
5107 if (MaxFDLimit) {
5108 // set the number of file descriptors to max. print out error
5109 // if getrlimit/setrlimit fails but continue regardless.
5110 struct rlimit nbr_files;
5111 int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
5112 if (status != 0) {
5113 if (PrintMiscellaneous && (Verbose || WizardMode))
5114 perror("os::init_2 getrlimit failed");
5115 } else {
5116 nbr_files.rlim_cur = nbr_files.rlim_max;
5117 status = setrlimit(RLIMIT_NOFILE, &nbr_files);
5118 if (status != 0) {
5119 if (PrintMiscellaneous && (Verbose || WizardMode))
5120 perror("os::init_2 setrlimit failed");
5121 }
5122 }
5123 }
5125 // Calculate theoretical max. size of Threads to guard gainst
5126 // artifical out-of-memory situations, where all available address-
5127 // space has been reserved by thread stacks. Default stack size is 1Mb.
5128 size_t pre_thread_stack_size = (JavaThread::stack_size_at_create()) ?
5129 JavaThread::stack_size_at_create() : (1*K*K);
5130 assert(pre_thread_stack_size != 0, "Must have a stack");
5131 // Solaris has a maximum of 4Gb of user programs. Calculate the thread limit when
5132 // we should start doing Virtual Memory banging. Currently when the threads will
5133 // have used all but 200Mb of space.
5134 size_t max_address_space = ((unsigned int)4 * K * K * K) - (200 * K * K);
5135 Solaris::_os_thread_limit = max_address_space / pre_thread_stack_size;
5137 // at-exit methods are called in the reverse order of their registration.
5138 // In Solaris 7 and earlier, atexit functions are called on return from
5139 // main or as a result of a call to exit(3C). There can be only 32 of
5140 // these functions registered and atexit() does not set errno. In Solaris
5141 // 8 and later, there is no limit to the number of functions registered
5142 // and atexit() sets errno. In addition, in Solaris 8 and later, atexit
5143 // functions are called upon dlclose(3DL) in addition to return from main
5144 // and exit(3C).
5146 if (PerfAllowAtExitRegistration) {
5147 // only register atexit functions if PerfAllowAtExitRegistration is set.
5148 // atexit functions can be delayed until process exit time, which
5149 // can be problematic for embedded VM situations. Embedded VMs should
5150 // call DestroyJavaVM() to assure that VM resources are released.
5152 // note: perfMemory_exit_helper atexit function may be removed in
5153 // the future if the appropriate cleanup code can be added to the
5154 // VM_Exit VMOperation's doit method.
5155 if (atexit(perfMemory_exit_helper) != 0) {
5156 warning("os::init2 atexit(perfMemory_exit_helper) failed");
5157 }
5158 }
5160 // Init pset_loadavg function pointer
5161 init_pset_getloadavg_ptr();
5163 return JNI_OK;
5164 }
5166 void os::init_3(void) {
5167 return;
5168 }
5170 // Mark the polling page as unreadable
5171 void os::make_polling_page_unreadable(void) {
5172 if( mprotect((char *)_polling_page, page_size, PROT_NONE) != 0 )
5173 fatal("Could not disable polling page");
5174 };
5176 // Mark the polling page as readable
5177 void os::make_polling_page_readable(void) {
5178 if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 )
5179 fatal("Could not enable polling page");
5180 };
5182 // OS interface.
5184 bool os::check_heap(bool force) { return true; }
5186 typedef int (*vsnprintf_t)(char* buf, size_t count, const char* fmt, va_list argptr);
5187 static vsnprintf_t sol_vsnprintf = NULL;
5189 int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr) {
5190 if (!sol_vsnprintf) {
5191 //search for the named symbol in the objects that were loaded after libjvm
5192 void* where = RTLD_NEXT;
5193 if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL)
5194 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf"));
5195 if (!sol_vsnprintf){
5196 //search for the named symbol in the objects that were loaded before libjvm
5197 where = RTLD_DEFAULT;
5198 if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL)
5199 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf"));
5200 assert(sol_vsnprintf != NULL, "vsnprintf not found");
5201 }
5202 }
5203 return (*sol_vsnprintf)(buf, count, fmt, argptr);
5204 }
5207 // Is a (classpath) directory empty?
5208 bool os::dir_is_empty(const char* path) {
5209 DIR *dir = NULL;
5210 struct dirent *ptr;
5212 dir = opendir(path);
5213 if (dir == NULL) return true;
5215 /* Scan the directory */
5216 bool result = true;
5217 char buf[sizeof(struct dirent) + MAX_PATH];
5218 struct dirent *dbuf = (struct dirent *) buf;
5219 while (result && (ptr = readdir(dir, dbuf)) != NULL) {
5220 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
5221 result = false;
5222 }
5223 }
5224 closedir(dir);
5225 return result;
5226 }
5228 // This code originates from JDK's sysOpen and open64_w
5229 // from src/solaris/hpi/src/system_md.c
5231 #ifndef O_DELETE
5232 #define O_DELETE 0x10000
5233 #endif
5235 // Open a file. Unlink the file immediately after open returns
5236 // if the specified oflag has the O_DELETE flag set.
5237 // O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
5239 int os::open(const char *path, int oflag, int mode) {
5240 if (strlen(path) > MAX_PATH - 1) {
5241 errno = ENAMETOOLONG;
5242 return -1;
5243 }
5244 int fd;
5245 int o_delete = (oflag & O_DELETE);
5246 oflag = oflag & ~O_DELETE;
5248 fd = ::open64(path, oflag, mode);
5249 if (fd == -1) return -1;
5251 //If the open succeeded, the file might still be a directory
5252 {
5253 struct stat64 buf64;
5254 int ret = ::fstat64(fd, &buf64);
5255 int st_mode = buf64.st_mode;
5257 if (ret != -1) {
5258 if ((st_mode & S_IFMT) == S_IFDIR) {
5259 errno = EISDIR;
5260 ::close(fd);
5261 return -1;
5262 }
5263 } else {
5264 ::close(fd);
5265 return -1;
5266 }
5267 }
5268 /*
5269 * 32-bit Solaris systems suffer from:
5270 *
5271 * - an historical default soft limit of 256 per-process file
5272 * descriptors that is too low for many Java programs.
5273 *
5274 * - a design flaw where file descriptors created using stdio
5275 * fopen must be less than 256, _even_ when the first limit above
5276 * has been raised. This can cause calls to fopen (but not calls to
5277 * open, for example) to fail mysteriously, perhaps in 3rd party
5278 * native code (although the JDK itself uses fopen). One can hardly
5279 * criticize them for using this most standard of all functions.
5280 *
5281 * We attempt to make everything work anyways by:
5282 *
5283 * - raising the soft limit on per-process file descriptors beyond
5284 * 256
5285 *
5286 * - As of Solaris 10u4, we can request that Solaris raise the 256
5287 * stdio fopen limit by calling function enable_extended_FILE_stdio.
5288 * This is done in init_2 and recorded in enabled_extended_FILE_stdio
5289 *
5290 * - If we are stuck on an old (pre 10u4) Solaris system, we can
5291 * workaround the bug by remapping non-stdio file descriptors below
5292 * 256 to ones beyond 256, which is done below.
5293 *
5294 * See:
5295 * 1085341: 32-bit stdio routines should support file descriptors >255
5296 * 6533291: Work around 32-bit Solaris stdio limit of 256 open files
5297 * 6431278: Netbeans crash on 32 bit Solaris: need to call
5298 * enable_extended_FILE_stdio() in VM initialisation
5299 * Giri Mandalika's blog
5300 * http://technopark02.blogspot.com/2005_05_01_archive.html
5301 */
5302 #ifndef _LP64
5303 if ((!enabled_extended_FILE_stdio) && fd < 256) {
5304 int newfd = ::fcntl(fd, F_DUPFD, 256);
5305 if (newfd != -1) {
5306 ::close(fd);
5307 fd = newfd;
5308 }
5309 }
5310 #endif // 32-bit Solaris
5311 /*
5312 * All file descriptors that are opened in the JVM and not
5313 * specifically destined for a subprocess should have the
5314 * close-on-exec flag set. If we don't set it, then careless 3rd
5315 * party native code might fork and exec without closing all
5316 * appropriate file descriptors (e.g. as we do in closeDescriptors in
5317 * UNIXProcess.c), and this in turn might:
5318 *
5319 * - cause end-of-file to fail to be detected on some file
5320 * descriptors, resulting in mysterious hangs, or
5321 *
5322 * - might cause an fopen in the subprocess to fail on a system
5323 * suffering from bug 1085341.
5324 *
5325 * (Yes, the default setting of the close-on-exec flag is a Unix
5326 * design flaw)
5327 *
5328 * See:
5329 * 1085341: 32-bit stdio routines should support file descriptors >255
5330 * 4843136: (process) pipe file descriptor from Runtime.exec not being closed
5331 * 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
5332 */
5333 #ifdef FD_CLOEXEC
5334 {
5335 int flags = ::fcntl(fd, F_GETFD);
5336 if (flags != -1)
5337 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
5338 }
5339 #endif
5341 if (o_delete != 0) {
5342 ::unlink(path);
5343 }
5344 return fd;
5345 }
5347 // create binary file, rewriting existing file if required
5348 int os::create_binary_file(const char* path, bool rewrite_existing) {
5349 int oflags = O_WRONLY | O_CREAT;
5350 if (!rewrite_existing) {
5351 oflags |= O_EXCL;
5352 }
5353 return ::open64(path, oflags, S_IREAD | S_IWRITE);
5354 }
5356 // return current position of file pointer
5357 jlong os::current_file_offset(int fd) {
5358 return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
5359 }
5361 // move file pointer to the specified offset
5362 jlong os::seek_to_file_offset(int fd, jlong offset) {
5363 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
5364 }
5366 jlong os::lseek(int fd, jlong offset, int whence) {
5367 return (jlong) ::lseek64(fd, offset, whence);
5368 }
5370 char * os::native_path(char *path) {
5371 return path;
5372 }
5374 int os::ftruncate(int fd, jlong length) {
5375 return ::ftruncate64(fd, length);
5376 }
5378 int os::fsync(int fd) {
5379 RESTARTABLE_RETURN_INT(::fsync(fd));
5380 }
5382 int os::available(int fd, jlong *bytes) {
5383 jlong cur, end;
5384 int mode;
5385 struct stat64 buf64;
5387 if (::fstat64(fd, &buf64) >= 0) {
5388 mode = buf64.st_mode;
5389 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
5390 /*
5391 * XXX: is the following call interruptible? If so, this might
5392 * need to go through the INTERRUPT_IO() wrapper as for other
5393 * blocking, interruptible calls in this file.
5394 */
5395 int n,ioctl_return;
5397 INTERRUPTIBLE(::ioctl(fd, FIONREAD, &n),ioctl_return,os::Solaris::clear_interrupted);
5398 if (ioctl_return>= 0) {
5399 *bytes = n;
5400 return 1;
5401 }
5402 }
5403 }
5404 if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
5405 return 0;
5406 } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
5407 return 0;
5408 } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
5409 return 0;
5410 }
5411 *bytes = end - cur;
5412 return 1;
5413 }
5415 // Map a block of memory.
5416 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
5417 char *addr, size_t bytes, bool read_only,
5418 bool allow_exec) {
5419 int prot;
5420 int flags;
5422 if (read_only) {
5423 prot = PROT_READ;
5424 flags = MAP_SHARED;
5425 } else {
5426 prot = PROT_READ | PROT_WRITE;
5427 flags = MAP_PRIVATE;
5428 }
5430 if (allow_exec) {
5431 prot |= PROT_EXEC;
5432 }
5434 if (addr != NULL) {
5435 flags |= MAP_FIXED;
5436 }
5438 char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags,
5439 fd, file_offset);
5440 if (mapped_address == MAP_FAILED) {
5441 return NULL;
5442 }
5443 return mapped_address;
5444 }
5447 // Remap a block of memory.
5448 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
5449 char *addr, size_t bytes, bool read_only,
5450 bool allow_exec) {
5451 // same as map_memory() on this OS
5452 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
5453 allow_exec);
5454 }
5457 // Unmap a block of memory.
5458 bool os::unmap_memory(char* addr, size_t bytes) {
5459 return munmap(addr, bytes) == 0;
5460 }
5462 void os::pause() {
5463 char filename[MAX_PATH];
5464 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
5465 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
5466 } else {
5467 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
5468 }
5470 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
5471 if (fd != -1) {
5472 struct stat buf;
5473 ::close(fd);
5474 while (::stat(filename, &buf) == 0) {
5475 (void)::poll(NULL, 0, 100);
5476 }
5477 } else {
5478 jio_fprintf(stderr,
5479 "Could not open pause file '%s', continuing immediately.\n", filename);
5480 }
5481 }
5483 #ifndef PRODUCT
5484 #ifdef INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5485 // Turn this on if you need to trace synch operations.
5486 // Set RECORD_SYNCH_LIMIT to a large-enough value,
5487 // and call record_synch_enable and record_synch_disable
5488 // around the computation of interest.
5490 void record_synch(char* name, bool returning); // defined below
5492 class RecordSynch {
5493 char* _name;
5494 public:
5495 RecordSynch(char* name) :_name(name)
5496 { record_synch(_name, false); }
5497 ~RecordSynch() { record_synch(_name, true); }
5498 };
5500 #define CHECK_SYNCH_OP(ret, name, params, args, inner) \
5501 extern "C" ret name params { \
5502 typedef ret name##_t params; \
5503 static name##_t* implem = NULL; \
5504 static int callcount = 0; \
5505 if (implem == NULL) { \
5506 implem = (name##_t*) dlsym(RTLD_NEXT, #name); \
5507 if (implem == NULL) fatal(dlerror()); \
5508 } \
5509 ++callcount; \
5510 RecordSynch _rs(#name); \
5511 inner; \
5512 return implem args; \
5513 }
5514 // in dbx, examine callcounts this way:
5515 // for n in $(eval whereis callcount | awk '{print $2}'); do print $n; done
5517 #define CHECK_POINTER_OK(p) \
5518 (Universe::perm_gen() == NULL || !Universe::is_reserved_heap((oop)(p)))
5519 #define CHECK_MU \
5520 if (!CHECK_POINTER_OK(mu)) fatal("Mutex must be in C heap only.");
5521 #define CHECK_CV \
5522 if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only.");
5523 #define CHECK_P(p) \
5524 if (!CHECK_POINTER_OK(p)) fatal(false, "Pointer must be in C heap only.");
5526 #define CHECK_MUTEX(mutex_op) \
5527 CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU);
5529 CHECK_MUTEX( mutex_lock)
5530 CHECK_MUTEX( _mutex_lock)
5531 CHECK_MUTEX( mutex_unlock)
5532 CHECK_MUTEX(_mutex_unlock)
5533 CHECK_MUTEX( mutex_trylock)
5534 CHECK_MUTEX(_mutex_trylock)
5536 #define CHECK_COND(cond_op) \
5537 CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU;CHECK_CV);
5539 CHECK_COND( cond_wait);
5540 CHECK_COND(_cond_wait);
5541 CHECK_COND(_cond_wait_cancel);
5543 #define CHECK_COND2(cond_op) \
5544 CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU;CHECK_CV);
5546 CHECK_COND2( cond_timedwait);
5547 CHECK_COND2(_cond_timedwait);
5548 CHECK_COND2(_cond_timedwait_cancel);
5550 // do the _lwp_* versions too
5551 #define mutex_t lwp_mutex_t
5552 #define cond_t lwp_cond_t
5553 CHECK_MUTEX( _lwp_mutex_lock)
5554 CHECK_MUTEX( _lwp_mutex_unlock)
5555 CHECK_MUTEX( _lwp_mutex_trylock)
5556 CHECK_MUTEX( __lwp_mutex_lock)
5557 CHECK_MUTEX( __lwp_mutex_unlock)
5558 CHECK_MUTEX( __lwp_mutex_trylock)
5559 CHECK_MUTEX(___lwp_mutex_lock)
5560 CHECK_MUTEX(___lwp_mutex_unlock)
5562 CHECK_COND( _lwp_cond_wait);
5563 CHECK_COND( __lwp_cond_wait);
5564 CHECK_COND(___lwp_cond_wait);
5566 CHECK_COND2( _lwp_cond_timedwait);
5567 CHECK_COND2( __lwp_cond_timedwait);
5568 #undef mutex_t
5569 #undef cond_t
5571 CHECK_SYNCH_OP(int, _lwp_suspend2, (int lwp, int *n), (lwp, n), 0);
5572 CHECK_SYNCH_OP(int,__lwp_suspend2, (int lwp, int *n), (lwp, n), 0);
5573 CHECK_SYNCH_OP(int, _lwp_kill, (int lwp, int n), (lwp, n), 0);
5574 CHECK_SYNCH_OP(int,__lwp_kill, (int lwp, int n), (lwp, n), 0);
5575 CHECK_SYNCH_OP(int, _lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p));
5576 CHECK_SYNCH_OP(int,__lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p));
5577 CHECK_SYNCH_OP(int, _lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV);
5578 CHECK_SYNCH_OP(int,__lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV);
5581 // recording machinery:
5583 enum { RECORD_SYNCH_LIMIT = 200 };
5584 char* record_synch_name[RECORD_SYNCH_LIMIT];
5585 void* record_synch_arg0ptr[RECORD_SYNCH_LIMIT];
5586 bool record_synch_returning[RECORD_SYNCH_LIMIT];
5587 thread_t record_synch_thread[RECORD_SYNCH_LIMIT];
5588 int record_synch_count = 0;
5589 bool record_synch_enabled = false;
5591 // in dbx, examine recorded data this way:
5592 // for n in name arg0ptr returning thread; do print record_synch_$n[0..record_synch_count-1]; done
5594 void record_synch(char* name, bool returning) {
5595 if (record_synch_enabled) {
5596 if (record_synch_count < RECORD_SYNCH_LIMIT) {
5597 record_synch_name[record_synch_count] = name;
5598 record_synch_returning[record_synch_count] = returning;
5599 record_synch_thread[record_synch_count] = thr_self();
5600 record_synch_arg0ptr[record_synch_count] = &name;
5601 record_synch_count++;
5602 }
5603 // put more checking code here:
5604 // ...
5605 }
5606 }
5608 void record_synch_enable() {
5609 // start collecting trace data, if not already doing so
5610 if (!record_synch_enabled) record_synch_count = 0;
5611 record_synch_enabled = true;
5612 }
5614 void record_synch_disable() {
5615 // stop collecting trace data
5616 record_synch_enabled = false;
5617 }
5619 #endif // INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5620 #endif // PRODUCT
5622 const intptr_t thr_time_off = (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5623 const intptr_t thr_time_size = (intptr_t)(&((prusage_t *)(NULL))->pr_ttime) -
5624 (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5627 // JVMTI & JVM monitoring and management support
5628 // The thread_cpu_time() and current_thread_cpu_time() are only
5629 // supported if is_thread_cpu_time_supported() returns true.
5630 // They are not supported on Solaris T1.
5632 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
5633 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
5634 // of a thread.
5635 //
5636 // current_thread_cpu_time() and thread_cpu_time(Thread *)
5637 // returns the fast estimate available on the platform.
5639 // hrtime_t gethrvtime() return value includes
5640 // user time but does not include system time
5641 jlong os::current_thread_cpu_time() {
5642 return (jlong) gethrvtime();
5643 }
5645 jlong os::thread_cpu_time(Thread *thread) {
5646 // return user level CPU time only to be consistent with
5647 // what current_thread_cpu_time returns.
5648 // thread_cpu_time_info() must be changed if this changes
5649 return os::thread_cpu_time(thread, false /* user time only */);
5650 }
5652 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
5653 if (user_sys_cpu_time) {
5654 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
5655 } else {
5656 return os::current_thread_cpu_time();
5657 }
5658 }
5660 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
5661 char proc_name[64];
5662 int count;
5663 prusage_t prusage;
5664 jlong lwp_time;
5665 int fd;
5667 sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage",
5668 getpid(),
5669 thread->osthread()->lwp_id());
5670 fd = ::open(proc_name, O_RDONLY);
5671 if ( fd == -1 ) return -1;
5673 do {
5674 count = ::pread(fd,
5675 (void *)&prusage.pr_utime,
5676 thr_time_size,
5677 thr_time_off);
5678 } while (count < 0 && errno == EINTR);
5679 ::close(fd);
5680 if ( count < 0 ) return -1;
5682 if (user_sys_cpu_time) {
5683 // user + system CPU time
5684 lwp_time = (((jlong)prusage.pr_stime.tv_sec +
5685 (jlong)prusage.pr_utime.tv_sec) * (jlong)1000000000) +
5686 (jlong)prusage.pr_stime.tv_nsec +
5687 (jlong)prusage.pr_utime.tv_nsec;
5688 } else {
5689 // user level CPU time only
5690 lwp_time = ((jlong)prusage.pr_utime.tv_sec * (jlong)1000000000) +
5691 (jlong)prusage.pr_utime.tv_nsec;
5692 }
5694 return(lwp_time);
5695 }
5697 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5698 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits
5699 info_ptr->may_skip_backward = false; // elapsed time not wall time
5700 info_ptr->may_skip_forward = false; // elapsed time not wall time
5701 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned
5702 }
5704 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5705 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits
5706 info_ptr->may_skip_backward = false; // elapsed time not wall time
5707 info_ptr->may_skip_forward = false; // elapsed time not wall time
5708 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned
5709 }
5711 bool os::is_thread_cpu_time_supported() {
5712 if ( os::Solaris::T2_libthread() || UseBoundThreads ) {
5713 return true;
5714 } else {
5715 return false;
5716 }
5717 }
5719 // System loadavg support. Returns -1 if load average cannot be obtained.
5720 // Return the load average for our processor set if the primitive exists
5721 // (Solaris 9 and later). Otherwise just return system wide loadavg.
5722 int os::loadavg(double loadavg[], int nelem) {
5723 if (pset_getloadavg_ptr != NULL) {
5724 return (*pset_getloadavg_ptr)(PS_MYID, loadavg, nelem);
5725 } else {
5726 return ::getloadavg(loadavg, nelem);
5727 }
5728 }
5730 //---------------------------------------------------------------------------------
5732 static address same_page(address x, address y) {
5733 intptr_t page_bits = -os::vm_page_size();
5734 if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
5735 return x;
5736 else if (x > y)
5737 return (address)(intptr_t(y) | ~page_bits) + 1;
5738 else
5739 return (address)(intptr_t(y) & page_bits);
5740 }
5742 bool os::find(address addr, outputStream* st) {
5743 Dl_info dlinfo;
5744 memset(&dlinfo, 0, sizeof(dlinfo));
5745 if (dladdr(addr, &dlinfo)) {
5746 #ifdef _LP64
5747 st->print("0x%016lx: ", addr);
5748 #else
5749 st->print("0x%08x: ", addr);
5750 #endif
5751 if (dlinfo.dli_sname != NULL)
5752 st->print("%s+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr);
5753 else if (dlinfo.dli_fname)
5754 st->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase);
5755 else
5756 st->print("<absolute address>");
5757 if (dlinfo.dli_fname) st->print(" in %s", dlinfo.dli_fname);
5758 #ifdef _LP64
5759 if (dlinfo.dli_fbase) st->print(" at 0x%016lx", dlinfo.dli_fbase);
5760 #else
5761 if (dlinfo.dli_fbase) st->print(" at 0x%08x", dlinfo.dli_fbase);
5762 #endif
5763 st->cr();
5765 if (Verbose) {
5766 // decode some bytes around the PC
5767 address begin = same_page(addr-40, addr);
5768 address end = same_page(addr+40, addr);
5769 address lowest = (address) dlinfo.dli_sname;
5770 if (!lowest) lowest = (address) dlinfo.dli_fbase;
5771 if (begin < lowest) begin = lowest;
5772 Dl_info dlinfo2;
5773 if (dladdr(end, &dlinfo2) && dlinfo2.dli_saddr != dlinfo.dli_saddr
5774 && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin)
5775 end = (address) dlinfo2.dli_saddr;
5776 Disassembler::decode(begin, end, st);
5777 }
5778 return true;
5779 }
5780 return false;
5781 }
5783 // Following function has been added to support HotSparc's libjvm.so running
5784 // under Solaris production JDK 1.2.2 / 1.3.0. These came from
5785 // src/solaris/hpi/native_threads in the EVM codebase.
5786 //
5787 // NOTE: This is no longer needed in the 1.3.1 and 1.4 production release
5788 // libraries and should thus be removed. We will leave it behind for a while
5789 // until we no longer want to able to run on top of 1.3.0 Solaris production
5790 // JDK. See 4341971.
5792 #define STACK_SLACK 0x800
5794 extern "C" {
5795 intptr_t sysThreadAvailableStackWithSlack() {
5796 stack_t st;
5797 intptr_t retval, stack_top;
5798 retval = thr_stksegment(&st);
5799 assert(retval == 0, "incorrect return value from thr_stksegment");
5800 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
5801 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
5802 stack_top=(intptr_t)st.ss_sp-st.ss_size;
5803 return ((intptr_t)&stack_top - stack_top - STACK_SLACK);
5804 }
5805 }
5807 // Just to get the Kernel build to link on solaris for testing.
5809 extern "C" {
5810 class ASGCT_CallTrace;
5811 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext)
5812 KERNEL_RETURN;
5813 }
5816 // ObjectMonitor park-unpark infrastructure ...
5817 //
5818 // We implement Solaris and Linux PlatformEvents with the
5819 // obvious condvar-mutex-flag triple.
5820 // Another alternative that works quite well is pipes:
5821 // Each PlatformEvent consists of a pipe-pair.
5822 // The thread associated with the PlatformEvent
5823 // calls park(), which reads from the input end of the pipe.
5824 // Unpark() writes into the other end of the pipe.
5825 // The write-side of the pipe must be set NDELAY.
5826 // Unfortunately pipes consume a large # of handles.
5827 // Native solaris lwp_park() and lwp_unpark() work nicely, too.
5828 // Using pipes for the 1st few threads might be workable, however.
5829 //
5830 // park() is permitted to return spuriously.
5831 // Callers of park() should wrap the call to park() in
5832 // an appropriate loop. A litmus test for the correct
5833 // usage of park is the following: if park() were modified
5834 // to immediately return 0 your code should still work,
5835 // albeit degenerating to a spin loop.
5836 //
5837 // An interesting optimization for park() is to use a trylock()
5838 // to attempt to acquire the mutex. If the trylock() fails
5839 // then we know that a concurrent unpark() operation is in-progress.
5840 // in that case the park() code could simply set _count to 0
5841 // and return immediately. The subsequent park() operation *might*
5842 // return immediately. That's harmless as the caller of park() is
5843 // expected to loop. By using trylock() we will have avoided a
5844 // avoided a context switch caused by contention on the per-thread mutex.
5845 //
5846 // TODO-FIXME:
5847 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the
5848 // objectmonitor implementation.
5849 // 2. Collapse the JSR166 parker event, and the
5850 // objectmonitor ParkEvent into a single "Event" construct.
5851 // 3. In park() and unpark() add:
5852 // assert (Thread::current() == AssociatedWith).
5853 // 4. add spurious wakeup injection on a -XX:EarlyParkReturn=N switch.
5854 // 1-out-of-N park() operations will return immediately.
5855 //
5856 // _Event transitions in park()
5857 // -1 => -1 : illegal
5858 // 1 => 0 : pass - return immediately
5859 // 0 => -1 : block
5860 //
5861 // _Event serves as a restricted-range semaphore.
5862 //
5863 // Another possible encoding of _Event would be with
5864 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5865 //
5866 // TODO-FIXME: add DTRACE probes for:
5867 // 1. Tx parks
5868 // 2. Ty unparks Tx
5869 // 3. Tx resumes from park
5872 // value determined through experimentation
5873 #define ROUNDINGFIX 11
5875 // utility to compute the abstime argument to timedwait.
5876 // TODO-FIXME: switch from compute_abstime() to unpackTime().
5878 static timestruc_t* compute_abstime(timestruc_t* abstime, jlong millis) {
5879 // millis is the relative timeout time
5880 // abstime will be the absolute timeout time
5881 if (millis < 0) millis = 0;
5882 struct timeval now;
5883 int status = gettimeofday(&now, NULL);
5884 assert(status == 0, "gettimeofday");
5885 jlong seconds = millis / 1000;
5886 jlong max_wait_period;
5888 if (UseLWPSynchronization) {
5889 // forward port of fix for 4275818 (not sleeping long enough)
5890 // There was a bug in Solaris 6, 7 and pre-patch 5 of 8 where
5891 // _lwp_cond_timedwait() used a round_down algorithm rather
5892 // than a round_up. For millis less than our roundfactor
5893 // it rounded down to 0 which doesn't meet the spec.
5894 // For millis > roundfactor we may return a bit sooner, but
5895 // since we can not accurately identify the patch level and
5896 // this has already been fixed in Solaris 9 and 8 we will
5897 // leave it alone rather than always rounding down.
5899 if (millis > 0 && millis < ROUNDINGFIX) millis = ROUNDINGFIX;
5900 // It appears that when we go directly through Solaris _lwp_cond_timedwait()
5901 // the acceptable max time threshold is smaller than for libthread on 2.5.1 and 2.6
5902 max_wait_period = 21000000;
5903 } else {
5904 max_wait_period = 50000000;
5905 }
5906 millis %= 1000;
5907 if (seconds > max_wait_period) { // see man cond_timedwait(3T)
5908 seconds = max_wait_period;
5909 }
5910 abstime->tv_sec = now.tv_sec + seconds;
5911 long usec = now.tv_usec + millis * 1000;
5912 if (usec >= 1000000) {
5913 abstime->tv_sec += 1;
5914 usec -= 1000000;
5915 }
5916 abstime->tv_nsec = usec * 1000;
5917 return abstime;
5918 }
5920 // Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
5921 // Conceptually TryPark() should be equivalent to park(0).
5923 int os::PlatformEvent::TryPark() {
5924 for (;;) {
5925 const int v = _Event ;
5926 guarantee ((v == 0) || (v == 1), "invariant") ;
5927 if (Atomic::cmpxchg (0, &_Event, v) == v) return v ;
5928 }
5929 }
5931 void os::PlatformEvent::park() { // AKA: down()
5932 // Invariant: Only the thread associated with the Event/PlatformEvent
5933 // may call park().
5934 int v ;
5935 for (;;) {
5936 v = _Event ;
5937 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
5938 }
5939 guarantee (v >= 0, "invariant") ;
5940 if (v == 0) {
5941 // Do this the hard way by blocking ...
5942 // See http://monaco.sfbay/detail.jsf?cr=5094058.
5943 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
5944 // Only for SPARC >= V8PlusA
5945 #if defined(__sparc) && defined(COMPILER2)
5946 if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
5947 #endif
5948 int status = os::Solaris::mutex_lock(_mutex);
5949 assert_status(status == 0, status, "mutex_lock");
5950 guarantee (_nParked == 0, "invariant") ;
5951 ++ _nParked ;
5952 while (_Event < 0) {
5953 // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
5954 // Treat this the same as if the wait was interrupted
5955 // With usr/lib/lwp going to kernel, always handle ETIME
5956 status = os::Solaris::cond_wait(_cond, _mutex);
5957 if (status == ETIME) status = EINTR ;
5958 assert_status(status == 0 || status == EINTR, status, "cond_wait");
5959 }
5960 -- _nParked ;
5961 _Event = 0 ;
5962 status = os::Solaris::mutex_unlock(_mutex);
5963 assert_status(status == 0, status, "mutex_unlock");
5964 }
5965 }
5967 int os::PlatformEvent::park(jlong millis) {
5968 guarantee (_nParked == 0, "invariant") ;
5969 int v ;
5970 for (;;) {
5971 v = _Event ;
5972 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
5973 }
5974 guarantee (v >= 0, "invariant") ;
5975 if (v != 0) return OS_OK ;
5977 int ret = OS_TIMEOUT;
5978 timestruc_t abst;
5979 compute_abstime (&abst, millis);
5981 // See http://monaco.sfbay/detail.jsf?cr=5094058.
5982 // For Solaris SPARC set fprs.FEF=0 prior to parking.
5983 // Only for SPARC >= V8PlusA
5984 #if defined(__sparc) && defined(COMPILER2)
5985 if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
5986 #endif
5987 int status = os::Solaris::mutex_lock(_mutex);
5988 assert_status(status == 0, status, "mutex_lock");
5989 guarantee (_nParked == 0, "invariant") ;
5990 ++ _nParked ;
5991 while (_Event < 0) {
5992 int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst);
5993 assert_status(status == 0 || status == EINTR ||
5994 status == ETIME || status == ETIMEDOUT,
5995 status, "cond_timedwait");
5996 if (!FilterSpuriousWakeups) break ; // previous semantics
5997 if (status == ETIME || status == ETIMEDOUT) break ;
5998 // We consume and ignore EINTR and spurious wakeups.
5999 }
6000 -- _nParked ;
6001 if (_Event >= 0) ret = OS_OK ;
6002 _Event = 0 ;
6003 status = os::Solaris::mutex_unlock(_mutex);
6004 assert_status(status == 0, status, "mutex_unlock");
6005 return ret;
6006 }
6008 void os::PlatformEvent::unpark() {
6009 int v, AnyWaiters;
6011 // Increment _Event.
6012 // Another acceptable implementation would be to simply swap 1
6013 // into _Event:
6014 // if (Swap (&_Event, 1) < 0) {
6015 // mutex_lock (_mutex) ; AnyWaiters = nParked; mutex_unlock (_mutex) ;
6016 // if (AnyWaiters) cond_signal (_cond) ;
6017 // }
6019 for (;;) {
6020 v = _Event ;
6021 if (v > 0) {
6022 // The LD of _Event could have reordered or be satisfied
6023 // by a read-aside from this processor's write buffer.
6024 // To avoid problems execute a barrier and then
6025 // ratify the value. A degenerate CAS() would also work.
6026 // Viz., CAS (v+0, &_Event, v) == v).
6027 OrderAccess::fence() ;
6028 if (_Event == v) return ;
6029 continue ;
6030 }
6031 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
6032 }
6034 // If the thread associated with the event was parked, wake it.
6035 if (v < 0) {
6036 int status ;
6037 // Wait for the thread assoc with the PlatformEvent to vacate.
6038 status = os::Solaris::mutex_lock(_mutex);
6039 assert_status(status == 0, status, "mutex_lock");
6040 AnyWaiters = _nParked ;
6041 status = os::Solaris::mutex_unlock(_mutex);
6042 assert_status(status == 0, status, "mutex_unlock");
6043 guarantee (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ;
6044 if (AnyWaiters != 0) {
6045 // We intentional signal *after* dropping the lock
6046 // to avoid a common class of futile wakeups.
6047 status = os::Solaris::cond_signal(_cond);
6048 assert_status(status == 0, status, "cond_signal");
6049 }
6050 }
6051 }
6053 // JSR166
6054 // -------------------------------------------------------
6056 /*
6057 * The solaris and linux implementations of park/unpark are fairly
6058 * conservative for now, but can be improved. They currently use a
6059 * mutex/condvar pair, plus _counter.
6060 * Park decrements _counter if > 0, else does a condvar wait. Unpark
6061 * sets count to 1 and signals condvar. Only one thread ever waits
6062 * on the condvar. Contention seen when trying to park implies that someone
6063 * is unparking you, so don't wait. And spurious returns are fine, so there
6064 * is no need to track notifications.
6065 */
6067 #define NANOSECS_PER_SEC 1000000000
6068 #define NANOSECS_PER_MILLISEC 1000000
6069 #define MAX_SECS 100000000
6071 /*
6072 * This code is common to linux and solaris and will be moved to a
6073 * common place in dolphin.
6074 *
6075 * The passed in time value is either a relative time in nanoseconds
6076 * or an absolute time in milliseconds. Either way it has to be unpacked
6077 * into suitable seconds and nanoseconds components and stored in the
6078 * given timespec structure.
6079 * Given time is a 64-bit value and the time_t used in the timespec is only
6080 * a signed-32-bit value (except on 64-bit Linux) we have to watch for
6081 * overflow if times way in the future are given. Further on Solaris versions
6082 * prior to 10 there is a restriction (see cond_timedwait) that the specified
6083 * number of seconds, in abstime, is less than current_time + 100,000,000.
6084 * As it will be 28 years before "now + 100000000" will overflow we can
6085 * ignore overflow and just impose a hard-limit on seconds using the value
6086 * of "now + 100,000,000". This places a limit on the timeout of about 3.17
6087 * years from "now".
6088 */
6089 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
6090 assert (time > 0, "convertTime");
6092 struct timeval now;
6093 int status = gettimeofday(&now, NULL);
6094 assert(status == 0, "gettimeofday");
6096 time_t max_secs = now.tv_sec + MAX_SECS;
6098 if (isAbsolute) {
6099 jlong secs = time / 1000;
6100 if (secs > max_secs) {
6101 absTime->tv_sec = max_secs;
6102 }
6103 else {
6104 absTime->tv_sec = secs;
6105 }
6106 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
6107 }
6108 else {
6109 jlong secs = time / NANOSECS_PER_SEC;
6110 if (secs >= MAX_SECS) {
6111 absTime->tv_sec = max_secs;
6112 absTime->tv_nsec = 0;
6113 }
6114 else {
6115 absTime->tv_sec = now.tv_sec + secs;
6116 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
6117 if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
6118 absTime->tv_nsec -= NANOSECS_PER_SEC;
6119 ++absTime->tv_sec; // note: this must be <= max_secs
6120 }
6121 }
6122 }
6123 assert(absTime->tv_sec >= 0, "tv_sec < 0");
6124 assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
6125 assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
6126 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
6127 }
6129 void Parker::park(bool isAbsolute, jlong time) {
6131 // Optional fast-path check:
6132 // Return immediately if a permit is available.
6133 if (_counter > 0) {
6134 _counter = 0 ;
6135 OrderAccess::fence();
6136 return ;
6137 }
6139 // Optional fast-exit: Check interrupt before trying to wait
6140 Thread* thread = Thread::current();
6141 assert(thread->is_Java_thread(), "Must be JavaThread");
6142 JavaThread *jt = (JavaThread *)thread;
6143 if (Thread::is_interrupted(thread, false)) {
6144 return;
6145 }
6147 // First, demultiplex/decode time arguments
6148 timespec absTime;
6149 if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
6150 return;
6151 }
6152 if (time > 0) {
6153 // Warning: this code might be exposed to the old Solaris time
6154 // round-down bugs. Grep "roundingFix" for details.
6155 unpackTime(&absTime, isAbsolute, time);
6156 }
6158 // Enter safepoint region
6159 // Beware of deadlocks such as 6317397.
6160 // The per-thread Parker:: _mutex is a classic leaf-lock.
6161 // In particular a thread must never block on the Threads_lock while
6162 // holding the Parker:: mutex. If safepoints are pending both the
6163 // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
6164 ThreadBlockInVM tbivm(jt);
6166 // Don't wait if cannot get lock since interference arises from
6167 // unblocking. Also. check interrupt before trying wait
6168 if (Thread::is_interrupted(thread, false) ||
6169 os::Solaris::mutex_trylock(_mutex) != 0) {
6170 return;
6171 }
6173 int status ;
6175 if (_counter > 0) { // no wait needed
6176 _counter = 0;
6177 status = os::Solaris::mutex_unlock(_mutex);
6178 assert (status == 0, "invariant") ;
6179 OrderAccess::fence();
6180 return;
6181 }
6183 #ifdef ASSERT
6184 // Don't catch signals while blocked; let the running threads have the signals.
6185 // (This allows a debugger to break into the running thread.)
6186 sigset_t oldsigs;
6187 sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals();
6188 thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
6189 #endif
6191 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
6192 jt->set_suspend_equivalent();
6193 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
6195 // Do this the hard way by blocking ...
6196 // See http://monaco.sfbay/detail.jsf?cr=5094058.
6197 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
6198 // Only for SPARC >= V8PlusA
6199 #if defined(__sparc) && defined(COMPILER2)
6200 if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
6201 #endif
6203 if (time == 0) {
6204 status = os::Solaris::cond_wait (_cond, _mutex) ;
6205 } else {
6206 status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);
6207 }
6208 // Note that an untimed cond_wait() can sometimes return ETIME on older
6209 // versions of the Solaris.
6210 assert_status(status == 0 || status == EINTR ||
6211 status == ETIME || status == ETIMEDOUT,
6212 status, "cond_timedwait");
6214 #ifdef ASSERT
6215 thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
6216 #endif
6217 _counter = 0 ;
6218 status = os::Solaris::mutex_unlock(_mutex);
6219 assert_status(status == 0, status, "mutex_unlock") ;
6221 // If externally suspended while waiting, re-suspend
6222 if (jt->handle_special_suspend_equivalent_condition()) {
6223 jt->java_suspend_self();
6224 }
6225 OrderAccess::fence();
6226 }
6228 void Parker::unpark() {
6229 int s, status ;
6230 status = os::Solaris::mutex_lock (_mutex) ;
6231 assert (status == 0, "invariant") ;
6232 s = _counter;
6233 _counter = 1;
6234 status = os::Solaris::mutex_unlock (_mutex) ;
6235 assert (status == 0, "invariant") ;
6237 if (s < 1) {
6238 status = os::Solaris::cond_signal (_cond) ;
6239 assert (status == 0, "invariant") ;
6240 }
6241 }
6243 extern char** environ;
6245 // Run the specified command in a separate process. Return its exit value,
6246 // or -1 on failure (e.g. can't fork a new process).
6247 // Unlike system(), this function can be called from signal handler. It
6248 // doesn't block SIGINT et al.
6249 int os::fork_and_exec(char* cmd) {
6250 char * argv[4];
6251 argv[0] = (char *)"sh";
6252 argv[1] = (char *)"-c";
6253 argv[2] = cmd;
6254 argv[3] = NULL;
6256 // fork is async-safe, fork1 is not so can't use in signal handler
6257 pid_t pid;
6258 Thread* t = ThreadLocalStorage::get_thread_slow();
6259 if (t != NULL && t->is_inside_signal_handler()) {
6260 pid = fork();
6261 } else {
6262 pid = fork1();
6263 }
6265 if (pid < 0) {
6266 // fork failed
6267 warning("fork failed: %s", strerror(errno));
6268 return -1;
6270 } else if (pid == 0) {
6271 // child process
6273 // try to be consistent with system(), which uses "/usr/bin/sh" on Solaris
6274 execve("/usr/bin/sh", argv, environ);
6276 // execve failed
6277 _exit(-1);
6279 } else {
6280 // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
6281 // care about the actual exit code, for now.
6283 int status;
6285 // Wait for the child process to exit. This returns immediately if
6286 // the child has already exited. */
6287 while (waitpid(pid, &status, 0) < 0) {
6288 switch (errno) {
6289 case ECHILD: return 0;
6290 case EINTR: break;
6291 default: return -1;
6292 }
6293 }
6295 if (WIFEXITED(status)) {
6296 // The child exited normally; get its exit code.
6297 return WEXITSTATUS(status);
6298 } else if (WIFSIGNALED(status)) {
6299 // The child exited because of a signal
6300 // The best value to return is 0x80 + signal number,
6301 // because that is what all Unix shells do, and because
6302 // it allows callers to distinguish between process exit and
6303 // process death by signal.
6304 return 0x80 + WTERMSIG(status);
6305 } else {
6306 // Unknown exit code; pass it through
6307 return status;
6308 }
6309 }
6310 }
6312 // is_headless_jre()
6313 //
6314 // Test for the existence of xawt/libmawt.so or libawt_xawt.so
6315 // in order to report if we are running in a headless jre
6316 //
6317 // Since JDK8 xawt/libmawt.so was moved into the same directory
6318 // as libawt.so, and renamed libawt_xawt.so
6319 //
6320 bool os::is_headless_jre() {
6321 struct stat statbuf;
6322 char buf[MAXPATHLEN];
6323 char libmawtpath[MAXPATHLEN];
6324 const char *xawtstr = "/xawt/libmawt.so";
6325 const char *new_xawtstr = "/libawt_xawt.so";
6326 char *p;
6328 // Get path to libjvm.so
6329 os::jvm_path(buf, sizeof(buf));
6331 // Get rid of libjvm.so
6332 p = strrchr(buf, '/');
6333 if (p == NULL) return false;
6334 else *p = '\0';
6336 // Get rid of client or server
6337 p = strrchr(buf, '/');
6338 if (p == NULL) return false;
6339 else *p = '\0';
6341 // check xawt/libmawt.so
6342 strcpy(libmawtpath, buf);
6343 strcat(libmawtpath, xawtstr);
6344 if (::stat(libmawtpath, &statbuf) == 0) return false;
6346 // check libawt_xawt.so
6347 strcpy(libmawtpath, buf);
6348 strcat(libmawtpath, new_xawtstr);
6349 if (::stat(libmawtpath, &statbuf) == 0) return false;
6351 return true;
6352 }
6354 size_t os::write(int fd, const void *buf, unsigned int nBytes) {
6355 INTERRUPTIBLE_RETURN_INT(::write(fd, buf, nBytes), os::Solaris::clear_interrupted);
6356 }
6358 int os::close(int fd) {
6359 RESTARTABLE_RETURN_INT(::close(fd));
6360 }
6362 int os::socket_close(int fd) {
6363 RESTARTABLE_RETURN_INT(::close(fd));
6364 }
6366 int os::recv(int fd, char *buf, int nBytes, int flags) {
6367 INTERRUPTIBLE_RETURN_INT(::recv(fd, buf, nBytes, flags), os::Solaris::clear_interrupted);
6368 }
6371 int os::send(int fd, char *buf, int nBytes, int flags) {
6372 INTERRUPTIBLE_RETURN_INT(::send(fd, buf, nBytes, flags), os::Solaris::clear_interrupted);
6373 }
6375 int os::raw_send(int fd, char *buf, int nBytes, int flags) {
6376 RESTARTABLE_RETURN_INT(::send(fd, buf, nBytes, flags));
6377 }
6379 // As both poll and select can be interrupted by signals, we have to be
6380 // prepared to restart the system call after updating the timeout, unless
6381 // a poll() is done with timeout == -1, in which case we repeat with this
6382 // "wait forever" value.
6384 int os::timeout(int fd, long timeout) {
6385 int res;
6386 struct timeval t;
6387 julong prevtime, newtime;
6388 static const char* aNull = 0;
6389 struct pollfd pfd;
6390 pfd.fd = fd;
6391 pfd.events = POLLIN;
6393 gettimeofday(&t, &aNull);
6394 prevtime = ((julong)t.tv_sec * 1000) + t.tv_usec / 1000;
6396 for(;;) {
6397 INTERRUPTIBLE_NORESTART(::poll(&pfd, 1, timeout), res, os::Solaris::clear_interrupted);
6398 if(res == OS_ERR && errno == EINTR) {
6399 if(timeout != -1) {
6400 gettimeofday(&t, &aNull);
6401 newtime = ((julong)t.tv_sec * 1000) + t.tv_usec /1000;
6402 timeout -= newtime - prevtime;
6403 if(timeout <= 0)
6404 return OS_OK;
6405 prevtime = newtime;
6406 }
6407 } else return res;
6408 }
6409 }
6411 int os::connect(int fd, struct sockaddr *him, int len) {
6412 int _result;
6413 INTERRUPTIBLE_NORESTART(::connect(fd, him, len), _result,
6414 os::Solaris::clear_interrupted);
6416 // Depending on when thread interruption is reset, _result could be
6417 // one of two values when errno == EINTR
6419 if (((_result == OS_INTRPT) || (_result == OS_ERR))
6420 && (errno == EINTR)) {
6421 /* restarting a connect() changes its errno semantics */
6422 INTERRUPTIBLE(::connect(fd, him, len), _result,
6423 os::Solaris::clear_interrupted);
6424 /* undo these changes */
6425 if (_result == OS_ERR) {
6426 if (errno == EALREADY) {
6427 errno = EINPROGRESS; /* fall through */
6428 } else if (errno == EISCONN) {
6429 errno = 0;
6430 return OS_OK;
6431 }
6432 }
6433 }
6434 return _result;
6435 }
6437 int os::accept(int fd, struct sockaddr *him, int *len) {
6438 if (fd < 0)
6439 return OS_ERR;
6440 INTERRUPTIBLE_RETURN_INT((int)::accept(fd, him,\
6441 (socklen_t*) len), os::Solaris::clear_interrupted);
6442 }
6444 int os::recvfrom(int fd, char *buf, int nBytes, int flags,
6445 sockaddr *from, int *fromlen) {
6446 //%%note jvm_r11
6447 INTERRUPTIBLE_RETURN_INT((int)::recvfrom(fd, buf, nBytes,\
6448 flags, from, fromlen), os::Solaris::clear_interrupted);
6449 }
6451 int os::sendto(int fd, char *buf, int len, int flags,
6452 struct sockaddr *to, int tolen) {
6453 //%%note jvm_r11
6454 INTERRUPTIBLE_RETURN_INT((int)::sendto(fd, buf, len, flags,\
6455 to, tolen), os::Solaris::clear_interrupted);
6456 }
6458 int os::socket_available(int fd, jint *pbytes) {
6459 if (fd < 0)
6460 return OS_OK;
6462 int ret;
6464 RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret);
6466 //%% note ioctl can return 0 when successful, JVM_SocketAvailable
6467 // is expected to return 0 on failure and 1 on success to the jdk.
6469 return (ret == OS_ERR) ? 0 : 1;
6470 }
6473 int os::bind(int fd, struct sockaddr *him, int len) {
6474 INTERRUPTIBLE_RETURN_INT_NORESTART(::bind(fd, him, len),\
6475 os::Solaris::clear_interrupted);
6476 }