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