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