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