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