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