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::get_summary_os_info(char* buf, size_t buflen) {
1975 strncpy(buf, "Solaris", buflen); // default to plain solaris
1976 FILE* fp = fopen("/etc/release", "r");
1977 if (fp != NULL) {
1978 char tmp[256];
1979 // Only get the first line and chop out everything but the os name.
1980 if (fgets(tmp, sizeof(tmp), fp)) {
1981 char* ptr = tmp;
1982 // skip past whitespace characters
1983 while (*ptr != '\0' && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')) ptr++;
1984 if (*ptr != '\0') {
1985 char* nl = strchr(ptr, '\n');
1986 if (nl != NULL) *nl = '\0';
1987 strncpy(buf, ptr, buflen);
1988 }
1989 }
1990 fclose(fp);
1991 }
1992 }
1993
1994 void os::Solaris::print_libversion_info(outputStream* st) {
1995 st->print(" (T2 libthread)");
1996 st->cr();
1997 }
1998
1999 static bool check_addr0(outputStream* st) {
2000 jboolean status = false;
2001 int fd = ::open("/proc/self/map",O_RDONLY);
2002 if (fd >= 0) {
2003 prmap_t p;
2004 while (::read(fd, &p, sizeof(p)) > 0) {
2005 if (p.pr_vaddr == 0x0) {
2006 st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);
2007 st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);
2008 st->print("Access:");
2009 st->print("%s",(p.pr_mflags & MA_READ) ? "r" : "-");
2010 st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-");
2011 st->print("%s",(p.pr_mflags & MA_EXEC) ? "x" : "-");
2012 st->cr();
2013 status = true;
2014 }
2015 }
2016 ::close(fd);
2017 }
2018 return status;
2019 }
2020
2021 void os::get_summary_cpu_info(char* buf, size_t buflen) {
2022 // Get MHz with system call. We don't seem to already have this.
2023 processor_info_t stats;
2024 processorid_t id = getcpuid();
2025 int clock = 0;
2026 if (processor_info(id, &stats) != -1) {
2027 clock = stats.pi_clock; // pi_processor_type isn't more informative than below
2028 }
2029 #ifdef AMD64
2030 snprintf(buf, buflen, "x86 64 bit %d MHz", clock);
2031 #else
2032 // must be sparc
2033 snprintf(buf, buflen, "Sparcv9 64 bit %d MHz", clock);
2034 #endif
2035 }
2036
2037 void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
2038 // Nothing to do for now.
2039 }
2040
2041 void os::print_memory_info(outputStream* st) {
2042 st->print("Memory:");
2043 st->print(" %dk page", os::vm_page_size()>>10);
2044 st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10);
2045 st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10);
2046 st->cr();
2047 (void) check_addr0(st);
2048 }
2049
2050 void os::print_siginfo(outputStream* st, void* siginfo) {
2051 const siginfo_t* si = (const siginfo_t*)siginfo;
2052
2053 os::Posix::print_siginfo_brief(st, si);
2054
2055 if (si && (si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
2056 UseSharedSpaces) {
2057 FileMapInfo* mapinfo = FileMapInfo::current_info();
2058 if (mapinfo->is_in_shared_space(si->si_addr)) {
2059 st->print("\n\nError accessing class data sharing archive." \
2060 " Mapped file inaccessible during execution, " \
2061 " possible disk/network problem.");
2062 }
2063 }
2064 st->cr();
2065 }
2066
2067 // Moved from whole group, because we need them here for diagnostic
2068 // prints.
2069 #define OLDMAXSIGNUM 32
2070 static int Maxsignum = 0;
2071 static int *ourSigFlags = NULL;
2072
2073 extern "C" void sigINTRHandler(int, siginfo_t*, void*);
2074
2075 int os::Solaris::get_our_sigflags(int sig) {
2076 assert(ourSigFlags!=NULL, "signal data structure not initialized");
2077 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2078 return ourSigFlags[sig];
2079 }
2080
2081 void os::Solaris::set_our_sigflags(int sig, int flags) {
2082 assert(ourSigFlags!=NULL, "signal data structure not initialized");
2083 assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2084 ourSigFlags[sig] = flags;
2085 }
2086
2087
2088 static const char* get_signal_handler_name(address handler,
2089 char* buf, int buflen) {
2090 int offset;
2091 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
2092 if (found) {
2093 // skip directory names
2094 const char *p1, *p2;
2095 p1 = buf;
2096 size_t len = strlen(os::file_separator());
2097 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
2098 jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);
2099 } else {
2100 jio_snprintf(buf, buflen, PTR_FORMAT, handler);
2101 }
2102 return buf;
2103 }
2104
2105 static void print_signal_handler(outputStream* st, int sig,
2106 char* buf, size_t buflen) {
2107 struct sigaction sa;
2108
2109 sigaction(sig, NULL, &sa);
2110
2111 st->print("%s: ", os::exception_name(sig, buf, buflen));
2112
2113 address handler = (sa.sa_flags & SA_SIGINFO)
2114 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
2115 : CAST_FROM_FN_PTR(address, sa.sa_handler);
2116
2117 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
2118 st->print("SIG_DFL");
2119 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
2120 st->print("SIG_IGN");
2121 } else {
2122 st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
2123 }
2124
2125 st->print(", sa_mask[0]=");
2126 os::Posix::print_signal_set_short(st, &sa.sa_mask);
2127
2128 address rh = VMError::get_resetted_sighandler(sig);
2129 // May be, handler was resetted by VMError?
2130 if (rh != NULL) {
2131 handler = rh;
2132 sa.sa_flags = VMError::get_resetted_sigflags(sig);
2133 }
2134
2135 st->print(", sa_flags=");
2136 os::Posix::print_sa_flags(st, sa.sa_flags);
2137
2138 // Check: is it our handler?
2139 if (handler == CAST_FROM_FN_PTR(address, signalHandler) ||
2140 handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {
2141 // It is our signal handler
2142 // check for flags
2143 if (sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
2144 st->print(
2145 ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
2146 os::Solaris::get_our_sigflags(sig));
2147 }
2148 }
2149 st->cr();
2150 }
2151
2152 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2153 st->print_cr("Signal Handlers:");
2154 print_signal_handler(st, SIGSEGV, buf, buflen);
2155 print_signal_handler(st, SIGBUS , buf, buflen);
2156 print_signal_handler(st, SIGFPE , buf, buflen);
2157 print_signal_handler(st, SIGPIPE, buf, buflen);
2158 print_signal_handler(st, SIGXFSZ, buf, buflen);
2159 print_signal_handler(st, SIGILL , buf, buflen);
2160 print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
2161 print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);
2162 print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
2163 print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);
2164 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
2165 print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);
2166 print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);
2167 print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);
2168 }
2169
2170 static char saved_jvm_path[MAXPATHLEN] = { 0 };
2171
2172 // Find the full path to the current module, libjvm.so
2173 void os::jvm_path(char *buf, jint buflen) {
2174 // Error checking.
2175 if (buflen < MAXPATHLEN) {
2176 assert(false, "must use a large-enough buffer");
2177 buf[0] = '\0';
2178 return;
2179 }
2180 // Lazy resolve the path to current module.
2181 if (saved_jvm_path[0] != 0) {
2182 strcpy(buf, saved_jvm_path);
2183 return;
2184 }
2185
2186 Dl_info dlinfo;
2187 int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
2188 assert(ret != 0, "cannot locate libjvm");
2189 if (ret != 0 && dlinfo.dli_fname != NULL) {
2190 realpath((char *)dlinfo.dli_fname, buf);
2191 } else {
2192 buf[0] = '\0';
2193 return;
2194 }
2195
2196 if (Arguments::sun_java_launcher_is_altjvm()) {
2197 // Support for the java launcher's '-XXaltjvm=<path>' option. Typical
2198 // value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".
2199 // If "/jre/lib/" appears at the right place in the string, then
2200 // assume we are installed in a JDK and we're done. Otherwise, check
2201 // for a JAVA_HOME environment variable and fix up the path so it
2202 // looks like libjvm.so is installed there (append a fake suffix
2203 // hotspot/libjvm.so).
2204 const char *p = buf + strlen(buf) - 1;
2205 for (int count = 0; p > buf && count < 5; ++count) {
2206 for (--p; p > buf && *p != '/'; --p)
2207 /* empty */ ;
2208 }
2209
2210 if (strncmp(p, "/jre/lib/", 9) != 0) {
2211 // Look for JAVA_HOME in the environment.
2212 char* java_home_var = ::getenv("JAVA_HOME");
2213 if (java_home_var != NULL && java_home_var[0] != 0) {
2214 char cpu_arch[12];
2215 char* jrelib_p;
2216 int len;
2217 sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
2218 #ifdef _LP64
2219 // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.
2220 if (strcmp(cpu_arch, "sparc") == 0) {
2221 strcat(cpu_arch, "v9");
2222 } else if (strcmp(cpu_arch, "i386") == 0) {
2223 strcpy(cpu_arch, "amd64");
2224 }
2225 #endif
2226 // Check the current module name "libjvm.so".
2227 p = strrchr(buf, '/');
2228 assert(strstr(p, "/libjvm") == p, "invalid library name");
2229
2230 realpath(java_home_var, buf);
2231 // determine if this is a legacy image or modules image
2232 // modules image doesn't have "jre" subdirectory
2233 len = strlen(buf);
2234 assert(len < buflen, "Ran out of buffer space");
2235 jrelib_p = buf + len;
2236 snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch);
2237 if (0 != access(buf, F_OK)) {
2238 snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch);
2239 }
2240
2241 if (0 == access(buf, F_OK)) {
2242 // Use current module name "libjvm.so"
2243 len = strlen(buf);
2244 snprintf(buf + len, buflen-len, "/hotspot/libjvm.so");
2245 } else {
2246 // Go back to path of .so
2247 realpath((char *)dlinfo.dli_fname, buf);
2248 }
2249 }
2250 }
2251 }
2252
2253 strncpy(saved_jvm_path, buf, MAXPATHLEN);
2254 saved_jvm_path[MAXPATHLEN - 1] = '\0';
2255 }
2256
2257
2258 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
2259 // no prefix required, not even "_"
2260 }
2261
2262
2263 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
2264 // no suffix required
2265 }
2266
2267 // This method is a copy of JDK's sysGetLastErrorString
2268 // from src/solaris/hpi/src/system_md.c
2269
2270 size_t os::lasterror(char *buf, size_t len) {
2271 if (errno == 0) return 0;
2272
2273 const char *s = ::strerror(errno);
2274 size_t n = ::strlen(s);
2275 if (n >= len) {
2276 n = len - 1;
2277 }
2278 ::strncpy(buf, s, n);
2279 buf[n] = '\0';
2280 return n;
2281 }
2282
2283
2284 // sun.misc.Signal
2285
2286 extern "C" {
2287 static void UserHandler(int sig, void *siginfo, void *context) {
2288 // Ctrl-C is pressed during error reporting, likely because the error
2289 // handler fails to abort. Let VM die immediately.
2290 if (sig == SIGINT && is_error_reported()) {
2291 os::die();
2292 }
2293
2294 os::signal_notify(sig);
2295 // We do not need to reinstate the signal handler each time...
2296 }
2297 }
2298
2299 void* os::user_handler() {
2300 return CAST_FROM_FN_PTR(void*, UserHandler);
2301 }
2302
2303 struct timespec PosixSemaphore::create_timespec(unsigned int sec, int nsec) {
2304 struct timespec ts;
2305 unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
2306
2307 return ts;
2308 }
2309
2310 extern "C" {
2311 typedef void (*sa_handler_t)(int);
2312 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
2313 }
2314
2315 void* os::signal(int signal_number, void* handler) {
2316 struct sigaction sigAct, oldSigAct;
2317 sigfillset(&(sigAct.sa_mask));
2318 sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;
2319 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
2320
2321 if (sigaction(signal_number, &sigAct, &oldSigAct)) {
2322 // -1 means registration failed
2323 return (void *)-1;
2324 }
2325
2326 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
2327 }
2328
2329 void os::signal_raise(int signal_number) {
2330 raise(signal_number);
2331 }
2332
2333 // The following code is moved from os.cpp for making this
2334 // code platform specific, which it is by its very nature.
2335
2336 // a counter for each possible signal value
2337 static int Sigexit = 0;
2338 static int Maxlibjsigsigs;
2339 static jint *pending_signals = NULL;
2340 static int *preinstalled_sigs = NULL;
2341 static struct sigaction *chainedsigactions = NULL;
2342 static sema_t sig_sem;
2343 typedef int (*version_getting_t)();
2344 version_getting_t os::Solaris::get_libjsig_version = NULL;
2345 static int libjsigversion = NULL;
2346
2347 int os::sigexitnum_pd() {
2348 assert(Sigexit > 0, "signal memory not yet initialized");
2349 return Sigexit;
2350 }
2351
2352 void os::Solaris::init_signal_mem() {
2353 // Initialize signal structures
2354 Maxsignum = SIGRTMAX;
2355 Sigexit = Maxsignum+1;
2356 assert(Maxsignum >0, "Unable to obtain max signal number");
2357
2358 Maxlibjsigsigs = Maxsignum;
2359
2360 // pending_signals has one int per signal
2361 // The additional signal is for SIGEXIT - exit signal to signal_thread
2362 pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal);
2363 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
2364
2365 if (UseSignalChaining) {
2366 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
2367 * (Maxsignum + 1), mtInternal);
2368 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
2369 preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
2370 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
2371 }
2372 ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
2373 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
2374 }
2375
2376 void os::signal_init_pd() {
2377 int ret;
2378
2379 ret = ::sema_init(&sig_sem, 0, NULL, NULL);
2380 assert(ret == 0, "sema_init() failed");
2381 }
2382
2383 void os::signal_notify(int signal_number) {
2384 int ret;
2385
2386 Atomic::inc(&pending_signals[signal_number]);
2387 ret = ::sema_post(&sig_sem);
2388 assert(ret == 0, "sema_post() failed");
2389 }
2390
2391 static int check_pending_signals(bool wait_for_signal) {
2392 int ret;
2393 while (true) {
2394 for (int i = 0; i < Sigexit + 1; i++) {
2395 jint n = pending_signals[i];
2396 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2397 return i;
2398 }
2399 }
2400 if (!wait_for_signal) {
2401 return -1;
2402 }
2403 JavaThread *thread = JavaThread::current();
2404 ThreadBlockInVM tbivm(thread);
2405
2406 bool threadIsSuspended;
2407 do {
2408 thread->set_suspend_equivalent();
2409 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2410 while ((ret = ::sema_wait(&sig_sem)) == EINTR)
2411 ;
2412 assert(ret == 0, "sema_wait() failed");
2413
2414 // were we externally suspended while we were waiting?
2415 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2416 if (threadIsSuspended) {
2417 // The semaphore has been incremented, but while we were waiting
2418 // another thread suspended us. We don't want to continue running
2419 // while suspended because that would surprise the thread that
2420 // suspended us.
2421 ret = ::sema_post(&sig_sem);
2422 assert(ret == 0, "sema_post() failed");
2423
2424 thread->java_suspend_self();
2425 }
2426 } while (threadIsSuspended);
2427 }
2428 }
2429
2430 int os::signal_lookup() {
2431 return check_pending_signals(false);
2432 }
2433
2434 int os::signal_wait() {
2435 return check_pending_signals(true);
2436 }
2437
2438 ////////////////////////////////////////////////////////////////////////////////
2439 // Virtual Memory
2440
2441 static int page_size = -1;
2442
2443 // The mmap MAP_ALIGN flag is supported on Solaris 9 and later. init_2() will
2444 // clear this var if support is not available.
2445 static bool has_map_align = true;
2446
2447 int os::vm_page_size() {
2448 assert(page_size != -1, "must call os::init");
2449 return page_size;
2450 }
2451
2452 // Solaris allocates memory by pages.
2453 int os::vm_allocation_granularity() {
2454 assert(page_size != -1, "must call os::init");
2455 return page_size;
2456 }
2457
2458 static bool recoverable_mmap_error(int err) {
2459 // See if the error is one we can let the caller handle. This
2460 // list of errno values comes from the Solaris mmap(2) man page.
2461 switch (err) {
2462 case EBADF:
2463 case EINVAL:
2464 case ENOTSUP:
2465 // let the caller deal with these errors
2466 return true;
2467
2468 default:
2469 // Any remaining errors on this OS can cause our reserved mapping
2470 // to be lost. That can cause confusion where different data
2471 // structures think they have the same memory mapped. The worst
2472 // scenario is if both the VM and a library think they have the
2473 // same memory mapped.
2474 return false;
2475 }
2476 }
2477
2478 static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec,
2479 int err) {
2480 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2481 ", %d) failed; error='%s' (errno=%d)", addr, bytes, exec,
2482 strerror(err), err);
2483 }
2484
2485 static void warn_fail_commit_memory(char* addr, size_t bytes,
2486 size_t alignment_hint, bool exec,
2487 int err) {
2488 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2489 ", " SIZE_FORMAT ", %d) failed; error='%s' (errno=%d)", addr, bytes,
2490 alignment_hint, exec, strerror(err), err);
2491 }
2492
2493 int os::Solaris::commit_memory_impl(char* addr, size_t bytes, bool exec) {
2494 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
2495 size_t size = bytes;
2496 char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
2497 if (res != NULL) {
2498 if (UseNUMAInterleaving) {
2499 numa_make_global(addr, bytes);
2500 }
2501 return 0;
2502 }
2503
2504 int err = errno; // save errno from mmap() call in mmap_chunk()
2505
2506 if (!recoverable_mmap_error(err)) {
2507 warn_fail_commit_memory(addr, bytes, exec, err);
2508 vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, "committing reserved memory.");
2509 }
2510
2511 return err;
2512 }
2513
2514 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
2515 return Solaris::commit_memory_impl(addr, bytes, exec) == 0;
2516 }
2517
2518 void os::pd_commit_memory_or_exit(char* addr, size_t bytes, bool exec,
2519 const char* mesg) {
2520 assert(mesg != NULL, "mesg must be specified");
2521 int err = os::Solaris::commit_memory_impl(addr, bytes, exec);
2522 if (err != 0) {
2523 // the caller wants all commit errors to exit with the specified mesg:
2524 warn_fail_commit_memory(addr, bytes, exec, err);
2525 vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
2526 }
2527 }
2528
2529 size_t os::Solaris::page_size_for_alignment(size_t alignment) {
2530 assert(is_size_aligned(alignment, (size_t) vm_page_size()),
2531 err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT,
2532 alignment, (size_t) vm_page_size()));
2533
2534 for (int i = 0; _page_sizes[i] != 0; i++) {
2535 if (is_size_aligned(alignment, _page_sizes[i])) {
2536 return _page_sizes[i];
2537 }
2538 }
2539
2540 return (size_t) vm_page_size();
2541 }
2542
2543 int os::Solaris::commit_memory_impl(char* addr, size_t bytes,
2544 size_t alignment_hint, bool exec) {
2545 int err = Solaris::commit_memory_impl(addr, bytes, exec);
2546 if (err == 0 && UseLargePages && alignment_hint > 0) {
2547 assert(is_size_aligned(bytes, alignment_hint),
2548 err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, alignment_hint));
2549
2550 // The syscall memcntl requires an exact page size (see man memcntl for details).
2551 size_t page_size = page_size_for_alignment(alignment_hint);
2552 if (page_size > (size_t) vm_page_size()) {
2553 (void)Solaris::setup_large_pages(addr, bytes, page_size);
2554 }
2555 }
2556 return err;
2557 }
2558
2559 bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint,
2560 bool exec) {
2561 return Solaris::commit_memory_impl(addr, bytes, alignment_hint, exec) == 0;
2562 }
2563
2564 void os::pd_commit_memory_or_exit(char* addr, size_t bytes,
2565 size_t alignment_hint, bool exec,
2566 const char* mesg) {
2567 assert(mesg != NULL, "mesg must be specified");
2568 int err = os::Solaris::commit_memory_impl(addr, bytes, alignment_hint, exec);
2569 if (err != 0) {
2570 // the caller wants all commit errors to exit with the specified mesg:
2571 warn_fail_commit_memory(addr, bytes, alignment_hint, exec, err);
2572 vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
2573 }
2574 }
2575
2576 // Uncommit the pages in a specified region.
2577 void os::pd_free_memory(char* addr, size_t bytes, size_t alignment_hint) {
2578 if (madvise(addr, bytes, MADV_FREE) < 0) {
2579 debug_only(warning("MADV_FREE failed."));
2580 return;
2581 }
2582 }
2583
2584 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
2585 return os::commit_memory(addr, size, !ExecMem);
2586 }
2587
2588 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2589 return os::uncommit_memory(addr, size);
2590 }
2591
2592 // Change the page size in a given range.
2593 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2594 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
2595 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
2596 if (UseLargePages) {
2597 size_t page_size = Solaris::page_size_for_alignment(alignment_hint);
2598 if (page_size > (size_t) vm_page_size()) {
2599 Solaris::setup_large_pages(addr, bytes, page_size);
2600 }
2601 }
2602 }
2603
2604 // Tell the OS to make the range local to the first-touching LWP
2605 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2606 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2607 if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) {
2608 debug_only(warning("MADV_ACCESS_LWP failed."));
2609 }
2610 }
2611
2612 // Tell the OS that this range would be accessed from different LWPs.
2613 void os::numa_make_global(char *addr, size_t bytes) {
2614 assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2615 if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) {
2616 debug_only(warning("MADV_ACCESS_MANY failed."));
2617 }
2618 }
2619
2620 // Get the number of the locality groups.
2621 size_t os::numa_get_groups_num() {
2622 size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie());
2623 return n != -1 ? n : 1;
2624 }
2625
2626 // Get a list of leaf locality groups. A leaf lgroup is group that
2627 // doesn't have any children. Typical leaf group is a CPU or a CPU/memory
2628 // board. An LWP is assigned to one of these groups upon creation.
2629 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2630 if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) {
2631 ids[0] = 0;
2632 return 1;
2633 }
2634 int result_size = 0, top = 1, bottom = 0, cur = 0;
2635 for (int k = 0; k < size; k++) {
2636 int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur],
2637 (Solaris::lgrp_id_t*)&ids[top], size - top);
2638 if (r == -1) {
2639 ids[0] = 0;
2640 return 1;
2641 }
2642 if (!r) {
2643 // That's a leaf node.
2644 assert(bottom <= cur, "Sanity check");
2645 // Check if the node has memory
2646 if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur],
2647 NULL, 0, LGRP_RSRC_MEM) > 0) {
2648 ids[bottom++] = ids[cur];
2649 }
2650 }
2651 top += r;
2652 cur++;
2653 }
2654 if (bottom == 0) {
2655 // Handle a situation, when the OS reports no memory available.
2656 // Assume UMA architecture.
2657 ids[0] = 0;
2658 return 1;
2659 }
2660 return bottom;
2661 }
2662
2663 // Detect the topology change. Typically happens during CPU plugging-unplugging.
2664 bool os::numa_topology_changed() {
2665 int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie());
2666 if (is_stale != -1 && is_stale) {
2667 Solaris::lgrp_fini(Solaris::lgrp_cookie());
2668 Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER);
2669 assert(c != 0, "Failure to initialize LGRP API");
2670 Solaris::set_lgrp_cookie(c);
2671 return true;
2672 }
2673 return false;
2674 }
2675
2676 // Get the group id of the current LWP.
2677 int os::numa_get_group_id() {
2678 int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID);
2679 if (lgrp_id == -1) {
2680 return 0;
2681 }
2682 const int size = os::numa_get_groups_num();
2683 int *ids = (int*)alloca(size * sizeof(int));
2684
2685 // Get the ids of all lgroups with memory; r is the count.
2686 int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id,
2687 (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM);
2688 if (r <= 0) {
2689 return 0;
2690 }
2691 return ids[os::random() % r];
2692 }
2693
2694 // Request information about the page.
2695 bool os::get_page_info(char *start, page_info* info) {
2696 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2697 uint64_t addr = (uintptr_t)start;
2698 uint64_t outdata[2];
2699 uint_t validity = 0;
2700
2701 if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) {
2702 return false;
2703 }
2704
2705 info->size = 0;
2706 info->lgrp_id = -1;
2707
2708 if ((validity & 1) != 0) {
2709 if ((validity & 2) != 0) {
2710 info->lgrp_id = outdata[0];
2711 }
2712 if ((validity & 4) != 0) {
2713 info->size = outdata[1];
2714 }
2715 return true;
2716 }
2717 return false;
2718 }
2719
2720 // Scan the pages from start to end until a page different than
2721 // the one described in the info parameter is encountered.
2722 char *os::scan_pages(char *start, char* end, page_info* page_expected,
2723 page_info* page_found) {
2724 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2725 const size_t types = sizeof(info_types) / sizeof(info_types[0]);
2726 uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT + 1];
2727 uint_t validity[MAX_MEMINFO_CNT];
2728
2729 size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size);
2730 uint64_t p = (uint64_t)start;
2731 while (p < (uint64_t)end) {
2732 addrs[0] = p;
2733 size_t addrs_count = 1;
2734 while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] + page_size < (uint64_t)end) {
2735 addrs[addrs_count] = addrs[addrs_count - 1] + page_size;
2736 addrs_count++;
2737 }
2738
2739 if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) {
2740 return NULL;
2741 }
2742
2743 size_t i = 0;
2744 for (; i < addrs_count; i++) {
2745 if ((validity[i] & 1) != 0) {
2746 if ((validity[i] & 4) != 0) {
2747 if (outdata[types * i + 1] != page_expected->size) {
2748 break;
2749 }
2750 } else if (page_expected->size != 0) {
2751 break;
2752 }
2753
2754 if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) {
2755 if (outdata[types * i] != page_expected->lgrp_id) {
2756 break;
2757 }
2758 }
2759 } else {
2760 return NULL;
2761 }
2762 }
2763
2764 if (i < addrs_count) {
2765 if ((validity[i] & 2) != 0) {
2766 page_found->lgrp_id = outdata[types * i];
2767 } else {
2768 page_found->lgrp_id = -1;
2769 }
2770 if ((validity[i] & 4) != 0) {
2771 page_found->size = outdata[types * i + 1];
2772 } else {
2773 page_found->size = 0;
2774 }
2775 return (char*)addrs[i];
2776 }
2777
2778 p = addrs[addrs_count - 1] + page_size;
2779 }
2780 return end;
2781 }
2782
2783 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
2784 size_t size = bytes;
2785 // Map uncommitted pages PROT_NONE so we fail early if we touch an
2786 // uncommitted page. Otherwise, the read/write might succeed if we
2787 // have enough swap space to back the physical page.
2788 return
2789 NULL != Solaris::mmap_chunk(addr, size,
2790 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE,
2791 PROT_NONE);
2792 }
2793
2794 char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) {
2795 char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0);
2796
2797 if (b == MAP_FAILED) {
2798 return NULL;
2799 }
2800 return b;
2801 }
2802
2803 char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes,
2804 size_t alignment_hint, bool fixed) {
2805 char* addr = requested_addr;
2806 int flags = MAP_PRIVATE | MAP_NORESERVE;
2807
2808 assert(!(fixed && (alignment_hint > 0)),
2809 "alignment hint meaningless with fixed mmap");
2810
2811 if (fixed) {
2812 flags |= MAP_FIXED;
2813 } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) {
2814 flags |= MAP_ALIGN;
2815 addr = (char*) alignment_hint;
2816 }
2817
2818 // Map uncommitted pages PROT_NONE so we fail early if we touch an
2819 // uncommitted page. Otherwise, the read/write might succeed if we
2820 // have enough swap space to back the physical page.
2821 return mmap_chunk(addr, bytes, flags, PROT_NONE);
2822 }
2823
2824 char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
2825 size_t alignment_hint) {
2826 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint,
2827 (requested_addr != NULL));
2828
2829 guarantee(requested_addr == NULL || requested_addr == addr,
2830 "OS failed to return requested mmap address.");
2831 return addr;
2832 }
2833
2834 // Reserve memory at an arbitrary address, only if that area is
2835 // available (and not reserved for something else).
2836
2837 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2838 const int max_tries = 10;
2839 char* base[max_tries];
2840 size_t size[max_tries];
2841
2842 // Solaris adds a gap between mmap'ed regions. The size of the gap
2843 // is dependent on the requested size and the MMU. Our initial gap
2844 // value here is just a guess and will be corrected later.
2845 bool had_top_overlap = false;
2846 bool have_adjusted_gap = false;
2847 size_t gap = 0x400000;
2848
2849 // Assert only that the size is a multiple of the page size, since
2850 // that's all that mmap requires, and since that's all we really know
2851 // about at this low abstraction level. If we need higher alignment,
2852 // we can either pass an alignment to this method or verify alignment
2853 // in one of the methods further up the call chain. See bug 5044738.
2854 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
2855
2856 // Since snv_84, Solaris attempts to honor the address hint - see 5003415.
2857 // Give it a try, if the kernel honors the hint we can return immediately.
2858 char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false);
2859
2860 volatile int err = errno;
2861 if (addr == requested_addr) {
2862 return addr;
2863 } else if (addr != NULL) {
2864 pd_unmap_memory(addr, bytes);
2865 }
2866
2867 if (PrintMiscellaneous && Verbose) {
2868 char buf[256];
2869 buf[0] = '\0';
2870 if (addr == NULL) {
2871 jio_snprintf(buf, sizeof(buf), ": %s", strerror(err));
2872 }
2873 warning("attempt_reserve_memory_at: couldn't reserve " SIZE_FORMAT " bytes at "
2874 PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT
2875 "%s", bytes, requested_addr, addr, buf);
2876 }
2877
2878 // Address hint method didn't work. Fall back to the old method.
2879 // In theory, once SNV becomes our oldest supported platform, this
2880 // code will no longer be needed.
2881 //
2882 // Repeatedly allocate blocks until the block is allocated at the
2883 // right spot. Give up after max_tries.
2884 int i;
2885 for (i = 0; i < max_tries; ++i) {
2886 base[i] = reserve_memory(bytes);
2887
2888 if (base[i] != NULL) {
2889 // Is this the block we wanted?
2890 if (base[i] == requested_addr) {
2891 size[i] = bytes;
2892 break;
2893 }
2894
2895 // check that the gap value is right
2896 if (had_top_overlap && !have_adjusted_gap) {
2897 size_t actual_gap = base[i-1] - base[i] - bytes;
2898 if (gap != actual_gap) {
2899 // adjust the gap value and retry the last 2 allocations
2900 assert(i > 0, "gap adjustment code problem");
2901 have_adjusted_gap = true; // adjust the gap only once, just in case
2902 gap = actual_gap;
2903 if (PrintMiscellaneous && Verbose) {
2904 warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap);
2905 }
2906 unmap_memory(base[i], bytes);
2907 unmap_memory(base[i-1], size[i-1]);
2908 i-=2;
2909 continue;
2910 }
2911 }
2912
2913 // Does this overlap the block we wanted? Give back the overlapped
2914 // parts and try again.
2915 //
2916 // There is still a bug in this code: if top_overlap == bytes,
2917 // the overlap is offset from requested region by the value of gap.
2918 // In this case giving back the overlapped part will not work,
2919 // because we'll give back the entire block at base[i] and
2920 // therefore the subsequent allocation will not generate a new gap.
2921 // This could be fixed with a new algorithm that used larger
2922 // or variable size chunks to find the requested region -
2923 // but such a change would introduce additional complications.
2924 // It's rare enough that the planets align for this bug,
2925 // so we'll just wait for a fix for 6204603/5003415 which
2926 // will provide a mmap flag to allow us to avoid this business.
2927
2928 size_t top_overlap = requested_addr + (bytes + gap) - base[i];
2929 if (top_overlap >= 0 && top_overlap < bytes) {
2930 had_top_overlap = true;
2931 unmap_memory(base[i], top_overlap);
2932 base[i] += top_overlap;
2933 size[i] = bytes - top_overlap;
2934 } else {
2935 size_t bottom_overlap = base[i] + bytes - requested_addr;
2936 if (bottom_overlap >= 0 && bottom_overlap < bytes) {
2937 if (PrintMiscellaneous && Verbose && bottom_overlap == 0) {
2938 warning("attempt_reserve_memory_at: possible alignment bug");
2939 }
2940 unmap_memory(requested_addr, bottom_overlap);
2941 size[i] = bytes - bottom_overlap;
2942 } else {
2943 size[i] = bytes;
2944 }
2945 }
2946 }
2947 }
2948
2949 // Give back the unused reserved pieces.
2950
2951 for (int j = 0; j < i; ++j) {
2952 if (base[j] != NULL) {
2953 unmap_memory(base[j], size[j]);
2954 }
2955 }
2956
2957 return (i < max_tries) ? requested_addr : NULL;
2958 }
2959
2960 bool os::pd_release_memory(char* addr, size_t bytes) {
2961 size_t size = bytes;
2962 return munmap(addr, size) == 0;
2963 }
2964
2965 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
2966 assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()),
2967 "addr must be page aligned");
2968 int retVal = mprotect(addr, bytes, prot);
2969 return retVal == 0;
2970 }
2971
2972 // Protect memory (Used to pass readonly pages through
2973 // JNI GetArray<type>Elements with empty arrays.)
2974 // Also, used for serialization page and for compressed oops null pointer
2975 // checking.
2976 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
2977 bool is_committed) {
2978 unsigned int p = 0;
2979 switch (prot) {
2980 case MEM_PROT_NONE: p = PROT_NONE; break;
2981 case MEM_PROT_READ: p = PROT_READ; break;
2982 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break;
2983 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
2984 default:
2985 ShouldNotReachHere();
2986 }
2987 // is_committed is unused.
2988 return solaris_mprotect(addr, bytes, p);
2989 }
2990
2991 // guard_memory and unguard_memory only happens within stack guard pages.
2992 // Since ISM pertains only to the heap, guard and unguard memory should not
2993 /// happen with an ISM region.
2994 bool os::guard_memory(char* addr, size_t bytes) {
2995 return solaris_mprotect(addr, bytes, PROT_NONE);
2996 }
2997
2998 bool os::unguard_memory(char* addr, size_t bytes) {
2999 return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE);
3000 }
3001
3002 // Large page support
3003 static size_t _large_page_size = 0;
3004
3005 // Insertion sort for small arrays (descending order).
3006 static void insertion_sort_descending(size_t* array, int len) {
3007 for (int i = 0; i < len; i++) {
3008 size_t val = array[i];
3009 for (size_t key = i; key > 0 && array[key - 1] < val; --key) {
3010 size_t tmp = array[key];
3011 array[key] = array[key - 1];
3012 array[key - 1] = tmp;
3013 }
3014 }
3015 }
3016
3017 bool os::Solaris::mpss_sanity_check(bool warn, size_t* page_size) {
3018 const unsigned int usable_count = VM_Version::page_size_count();
3019 if (usable_count == 1) {
3020 return false;
3021 }
3022
3023 // Find the right getpagesizes interface. When solaris 11 is the minimum
3024 // build platform, getpagesizes() (without the '2') can be called directly.
3025 typedef int (*gps_t)(size_t[], int);
3026 gps_t gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes2"));
3027 if (gps_func == NULL) {
3028 gps_func = CAST_TO_FN_PTR(gps_t, dlsym(RTLD_DEFAULT, "getpagesizes"));
3029 if (gps_func == NULL) {
3030 if (warn) {
3031 warning("MPSS is not supported by the operating system.");
3032 }
3033 return false;
3034 }
3035 }
3036
3037 // Fill the array of page sizes.
3038 int n = (*gps_func)(_page_sizes, page_sizes_max);
3039 assert(n > 0, "Solaris bug?");
3040
3041 if (n == page_sizes_max) {
3042 // Add a sentinel value (necessary only if the array was completely filled
3043 // since it is static (zeroed at initialization)).
3044 _page_sizes[--n] = 0;
3045 DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");)
3046 }
3047 assert(_page_sizes[n] == 0, "missing sentinel");
3048 trace_page_sizes("available page sizes", _page_sizes, n);
3049
3050 if (n == 1) return false; // Only one page size available.
3051
3052 // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and
3053 // select up to usable_count elements. First sort the array, find the first
3054 // acceptable value, then copy the usable sizes to the top of the array and
3055 // trim the rest. Make sure to include the default page size :-).
3056 //
3057 // A better policy could get rid of the 4M limit by taking the sizes of the
3058 // important VM memory regions (java heap and possibly the code cache) into
3059 // account.
3060 insertion_sort_descending(_page_sizes, n);
3061 const size_t size_limit =
3062 FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes;
3063 int beg;
3064 for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */;
3065 const int end = MIN2((int)usable_count, n) - 1;
3066 for (int cur = 0; cur < end; ++cur, ++beg) {
3067 _page_sizes[cur] = _page_sizes[beg];
3068 }
3069 _page_sizes[end] = vm_page_size();
3070 _page_sizes[end + 1] = 0;
3071
3072 if (_page_sizes[end] > _page_sizes[end - 1]) {
3073 // Default page size is not the smallest; sort again.
3074 insertion_sort_descending(_page_sizes, end + 1);
3075 }
3076 *page_size = _page_sizes[0];
3077
3078 trace_page_sizes("usable page sizes", _page_sizes, end + 1);
3079 return true;
3080 }
3081
3082 void os::large_page_init() {
3083 if (UseLargePages) {
3084 // print a warning if any large page related flag is specified on command line
3085 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
3086 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3087
3088 UseLargePages = Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size);
3089 }
3090 }
3091
3092 bool os::Solaris::is_valid_page_size(size_t bytes) {
3093 for (int i = 0; _page_sizes[i] != 0; i++) {
3094 if (_page_sizes[i] == bytes) {
3095 return true;
3096 }
3097 }
3098 return false;
3099 }
3100
3101 bool os::Solaris::setup_large_pages(caddr_t start, size_t bytes, size_t align) {
3102 assert(is_valid_page_size(align), err_msg(SIZE_FORMAT " is not a valid page size", align));
3103 assert(is_ptr_aligned((void*) start, align),
3104 err_msg(PTR_FORMAT " is not aligned to " SIZE_FORMAT, p2i((void*) start), align));
3105 assert(is_size_aligned(bytes, align),
3106 err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, align));
3107
3108 // Signal to OS that we want large pages for addresses
3109 // from addr, addr + bytes
3110 struct memcntl_mha mpss_struct;
3111 mpss_struct.mha_cmd = MHA_MAPSIZE_VA;
3112 mpss_struct.mha_pagesize = align;
3113 mpss_struct.mha_flags = 0;
3114 // Upon successful completion, memcntl() returns 0
3115 if (memcntl(start, bytes, MC_HAT_ADVISE, (caddr_t) &mpss_struct, 0, 0)) {
3116 debug_only(warning("Attempt to use MPSS failed."));
3117 return false;
3118 }
3119 return true;
3120 }
3121
3122 char* os::reserve_memory_special(size_t size, size_t alignment, char* addr, bool exec) {
3123 fatal("os::reserve_memory_special should not be called on Solaris.");
3124 return NULL;
3125 }
3126
3127 bool os::release_memory_special(char* base, size_t bytes) {
3128 fatal("os::release_memory_special should not be called on Solaris.");
3129 return false;
3130 }
3131
3132 size_t os::large_page_size() {
3133 return _large_page_size;
3134 }
3135
3136 // MPSS allows application to commit large page memory on demand; with ISM
3137 // the entire memory region must be allocated as shared memory.
3138 bool os::can_commit_large_page_memory() {
3139 return true;
3140 }
3141
3142 bool os::can_execute_large_page_memory() {
3143 return true;
3144 }
3145
3146 // Read calls from inside the vm need to perform state transitions
3147 size_t os::read(int fd, void *buf, unsigned int nBytes) {
3148 size_t res;
3149 JavaThread* thread = (JavaThread*)Thread::current();
3150 assert(thread->thread_state() == _thread_in_vm, "Assumed _thread_in_vm");
3151 ThreadBlockInVM tbiv(thread);
3152 RESTARTABLE(::read(fd, buf, (size_t) nBytes), res);
3153 return res;
3154 }
3155
3156 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
3157 size_t res;
3158 JavaThread* thread = (JavaThread*)Thread::current();
3159 assert(thread->thread_state() == _thread_in_vm, "Assumed _thread_in_vm");
3160 ThreadBlockInVM tbiv(thread);
3161 RESTARTABLE(::pread(fd, buf, (size_t) nBytes, offset), res);
3162 return res;
3163 }
3164
3165 size_t os::restartable_read(int fd, void *buf, unsigned int nBytes) {
3166 size_t res;
3167 assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
3168 "Assumed _thread_in_native");
3169 RESTARTABLE(::read(fd, buf, (size_t) nBytes), res);
3170 return res;
3171 }
3172
3173 void os::naked_short_sleep(jlong ms) {
3174 assert(ms < 1000, "Un-interruptable sleep, short time use only");
3175
3176 // usleep is deprecated and removed from POSIX, in favour of nanosleep, but
3177 // Solaris requires -lrt for this.
3178 usleep((ms * 1000));
3179
3180 return;
3181 }
3182
3183 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3184 void os::infinite_sleep() {
3185 while (true) { // sleep forever ...
3186 ::sleep(100); // ... 100 seconds at a time
3187 }
3188 }
3189
3190 // Used to convert frequent JVM_Yield() to nops
3191 bool os::dont_yield() {
3192 if (DontYieldALot) {
3193 static hrtime_t last_time = 0;
3194 hrtime_t diff = getTimeNanos() - last_time;
3195
3196 if (diff < DontYieldALotInterval * 1000000) {
3197 return true;
3198 }
3199
3200 last_time += diff;
3201
3202 return false;
3203 } else {
3204 return false;
3205 }
3206 }
3207
3208 // Note that yield semantics are defined by the scheduling class to which
3209 // the thread currently belongs. Typically, yield will _not yield to
3210 // other equal or higher priority threads that reside on the dispatch queues
3211 // of other CPUs.
3212
3213 void os::naked_yield() {
3214 thr_yield();
3215 }
3216
3217 // Interface for setting lwp priorities. If we are using T2 libthread,
3218 // which forces the use of BoundThreads or we manually set UseBoundThreads,
3219 // all of our threads will be assigned to real lwp's. Using the thr_setprio
3220 // function is meaningless in this mode so we must adjust the real lwp's priority
3221 // The routines below implement the getting and setting of lwp priorities.
3222 //
3223 // Note: T2 is now the only supported libthread. UseBoundThreads flag is
3224 // being deprecated and all threads are now BoundThreads
3225 //
3226 // Note: There are three priority scales used on Solaris. Java priotities
3227 // which range from 1 to 10, libthread "thr_setprio" scale which range
3228 // from 0 to 127, and the current scheduling class of the process we
3229 // are running in. This is typically from -60 to +60.
3230 // The setting of the lwp priorities in done after a call to thr_setprio
3231 // so Java priorities are mapped to libthread priorities and we map from
3232 // the latter to lwp priorities. We don't keep priorities stored in
3233 // Java priorities since some of our worker threads want to set priorities
3234 // higher than all Java threads.
3235 //
3236 // For related information:
3237 // (1) man -s 2 priocntl
3238 // (2) man -s 4 priocntl
3239 // (3) man dispadmin
3240 // = librt.so
3241 // = libthread/common/rtsched.c - thrp_setlwpprio().
3242 // = ps -cL <pid> ... to validate priority.
3243 // = sched_get_priority_min and _max
3244 // pthread_create
3245 // sched_setparam
3246 // pthread_setschedparam
3247 //
3248 // Assumptions:
3249 // + We assume that all threads in the process belong to the same
3250 // scheduling class. IE. an homogenous process.
3251 // + Must be root or in IA group to change change "interactive" attribute.
3252 // Priocntl() will fail silently. The only indication of failure is when
3253 // we read-back the value and notice that it hasn't changed.
3254 // + Interactive threads enter the runq at the head, non-interactive at the tail.
3255 // + For RT, change timeslice as well. Invariant:
3256 // constant "priority integral"
3257 // Konst == TimeSlice * (60-Priority)
3258 // Given a priority, compute appropriate timeslice.
3259 // + Higher numerical values have higher priority.
3260
3261 // sched class attributes
3262 typedef struct {
3263 int schedPolicy; // classID
3264 int maxPrio;
3265 int minPrio;
3266 } SchedInfo;
3267
3268
3269 static SchedInfo tsLimits, iaLimits, rtLimits, fxLimits;
3270
3271 #ifdef ASSERT
3272 static int ReadBackValidate = 1;
3273 #endif
3274 static int myClass = 0;
3275 static int myMin = 0;
3276 static int myMax = 0;
3277 static int myCur = 0;
3278 static bool priocntl_enable = false;
3279
3280 static const int criticalPrio = 60; // FX/60 is critical thread class/priority on T4
3281 static int java_MaxPriority_to_os_priority = 0; // Saved mapping
3282
3283
3284 // lwp_priocntl_init
3285 //
3286 // Try to determine the priority scale for our process.
3287 //
3288 // Return errno or 0 if OK.
3289 //
3290 static int lwp_priocntl_init() {
3291 int rslt;
3292 pcinfo_t ClassInfo;
3293 pcparms_t ParmInfo;
3294 int i;
3295
3296 if (!UseThreadPriorities) return 0;
3297
3298 // If ThreadPriorityPolicy is 1, switch tables
3299 if (ThreadPriorityPolicy == 1) {
3300 for (i = 0; i < CriticalPriority+1; i++)
3301 os::java_to_os_priority[i] = prio_policy1[i];
3302 }
3303 if (UseCriticalJavaThreadPriority) {
3304 // MaxPriority always maps to the FX scheduling class and criticalPrio.
3305 // See set_native_priority() and set_lwp_class_and_priority().
3306 // Save original MaxPriority mapping in case attempt to
3307 // use critical priority fails.
3308 java_MaxPriority_to_os_priority = os::java_to_os_priority[MaxPriority];
3309 // Set negative to distinguish from other priorities
3310 os::java_to_os_priority[MaxPriority] = -criticalPrio;
3311 }
3312
3313 // Get IDs for a set of well-known scheduling classes.
3314 // TODO-FIXME: GETCLINFO returns the current # of classes in the
3315 // the system. We should have a loop that iterates over the
3316 // classID values, which are known to be "small" integers.
3317
3318 strcpy(ClassInfo.pc_clname, "TS");
3319 ClassInfo.pc_cid = -1;
3320 rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3321 if (rslt < 0) return errno;
3322 assert(ClassInfo.pc_cid != -1, "cid for TS class is -1");
3323 tsLimits.schedPolicy = ClassInfo.pc_cid;
3324 tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri;
3325 tsLimits.minPrio = -tsLimits.maxPrio;
3326
3327 strcpy(ClassInfo.pc_clname, "IA");
3328 ClassInfo.pc_cid = -1;
3329 rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3330 if (rslt < 0) return errno;
3331 assert(ClassInfo.pc_cid != -1, "cid for IA class is -1");
3332 iaLimits.schedPolicy = ClassInfo.pc_cid;
3333 iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri;
3334 iaLimits.minPrio = -iaLimits.maxPrio;
3335
3336 strcpy(ClassInfo.pc_clname, "RT");
3337 ClassInfo.pc_cid = -1;
3338 rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3339 if (rslt < 0) return errno;
3340 assert(ClassInfo.pc_cid != -1, "cid for RT class is -1");
3341 rtLimits.schedPolicy = ClassInfo.pc_cid;
3342 rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri;
3343 rtLimits.minPrio = 0;
3344
3345 strcpy(ClassInfo.pc_clname, "FX");
3346 ClassInfo.pc_cid = -1;
3347 rslt = priocntl(P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3348 if (rslt < 0) return errno;
3349 assert(ClassInfo.pc_cid != -1, "cid for FX class is -1");
3350 fxLimits.schedPolicy = ClassInfo.pc_cid;
3351 fxLimits.maxPrio = ((fxinfo_t*)ClassInfo.pc_clinfo)->fx_maxupri;
3352 fxLimits.minPrio = 0;
3353
3354 // Query our "current" scheduling class.
3355 // This will normally be IA, TS or, rarely, FX or RT.
3356 memset(&ParmInfo, 0, sizeof(ParmInfo));
3357 ParmInfo.pc_cid = PC_CLNULL;
3358 rslt = priocntl(P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo);
3359 if (rslt < 0) return errno;
3360 myClass = ParmInfo.pc_cid;
3361
3362 // We now know our scheduling classId, get specific information
3363 // about the class.
3364 ClassInfo.pc_cid = myClass;
3365 ClassInfo.pc_clname[0] = 0;
3366 rslt = priocntl((idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo);
3367 if (rslt < 0) return errno;
3368
3369 if (ThreadPriorityVerbose) {
3370 tty->print_cr("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname);
3371 }
3372
3373 memset(&ParmInfo, 0, sizeof(pcparms_t));
3374 ParmInfo.pc_cid = PC_CLNULL;
3375 rslt = priocntl(P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo);
3376 if (rslt < 0) return errno;
3377
3378 if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3379 myMin = rtLimits.minPrio;
3380 myMax = rtLimits.maxPrio;
3381 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3382 iaparms_t *iaInfo = (iaparms_t*)ParmInfo.pc_clparms;
3383 myMin = iaLimits.minPrio;
3384 myMax = iaLimits.maxPrio;
3385 myMax = MIN2(myMax, (int)iaInfo->ia_uprilim); // clamp - restrict
3386 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3387 tsparms_t *tsInfo = (tsparms_t*)ParmInfo.pc_clparms;
3388 myMin = tsLimits.minPrio;
3389 myMax = tsLimits.maxPrio;
3390 myMax = MIN2(myMax, (int)tsInfo->ts_uprilim); // clamp - restrict
3391 } else if (ParmInfo.pc_cid == fxLimits.schedPolicy) {
3392 fxparms_t *fxInfo = (fxparms_t*)ParmInfo.pc_clparms;
3393 myMin = fxLimits.minPrio;
3394 myMax = fxLimits.maxPrio;
3395 myMax = MIN2(myMax, (int)fxInfo->fx_uprilim); // clamp - restrict
3396 } else {
3397 // No clue - punt
3398 if (ThreadPriorityVerbose) {
3399 tty->print_cr("Unknown scheduling class: %s ... \n",
3400 ClassInfo.pc_clname);
3401 }
3402 return EINVAL; // no clue, punt
3403 }
3404
3405 if (ThreadPriorityVerbose) {
3406 tty->print_cr("Thread priority Range: [%d..%d]\n", myMin, myMax);
3407 }
3408
3409 priocntl_enable = true; // Enable changing priorities
3410 return 0;
3411 }
3412
3413 #define IAPRI(x) ((iaparms_t *)((x).pc_clparms))
3414 #define RTPRI(x) ((rtparms_t *)((x).pc_clparms))
3415 #define TSPRI(x) ((tsparms_t *)((x).pc_clparms))
3416 #define FXPRI(x) ((fxparms_t *)((x).pc_clparms))
3417
3418
3419 // scale_to_lwp_priority
3420 //
3421 // Convert from the libthread "thr_setprio" scale to our current
3422 // lwp scheduling class scale.
3423 //
3424 static int scale_to_lwp_priority(int rMin, int rMax, int x) {
3425 int v;
3426
3427 if (x == 127) return rMax; // avoid round-down
3428 v = (((x*(rMax-rMin)))/128)+rMin;
3429 return v;
3430 }
3431
3432
3433 // set_lwp_class_and_priority
3434 int set_lwp_class_and_priority(int ThreadID, int lwpid,
3435 int newPrio, int new_class, bool scale) {
3436 int rslt;
3437 int Actual, Expected, prv;
3438 pcparms_t ParmInfo; // for GET-SET
3439 #ifdef ASSERT
3440 pcparms_t ReadBack; // for readback
3441 #endif
3442
3443 // Set priority via PC_GETPARMS, update, PC_SETPARMS
3444 // Query current values.
3445 // TODO: accelerate this by eliminating the PC_GETPARMS call.
3446 // Cache "pcparms_t" in global ParmCache.
3447 // TODO: elide set-to-same-value
3448
3449 // If something went wrong on init, don't change priorities.
3450 if (!priocntl_enable) {
3451 if (ThreadPriorityVerbose) {
3452 tty->print_cr("Trying to set priority but init failed, ignoring");
3453 }
3454 return EINVAL;
3455 }
3456
3457 // If lwp hasn't started yet, just return
3458 // the _start routine will call us again.
3459 if (lwpid <= 0) {
3460 if (ThreadPriorityVerbose) {
3461 tty->print_cr("deferring the set_lwp_class_and_priority of thread "
3462 INTPTR_FORMAT " to %d, lwpid not set",
3463 ThreadID, newPrio);
3464 }
3465 return 0;
3466 }
3467
3468 if (ThreadPriorityVerbose) {
3469 tty->print_cr ("set_lwp_class_and_priority("
3470 INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ",
3471 ThreadID, lwpid, newPrio);
3472 }
3473
3474 memset(&ParmInfo, 0, sizeof(pcparms_t));
3475 ParmInfo.pc_cid = PC_CLNULL;
3476 rslt = priocntl(P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo);
3477 if (rslt < 0) return errno;
3478
3479 int cur_class = ParmInfo.pc_cid;
3480 ParmInfo.pc_cid = (id_t)new_class;
3481
3482 if (new_class == rtLimits.schedPolicy) {
3483 rtparms_t *rtInfo = (rtparms_t*)ParmInfo.pc_clparms;
3484 rtInfo->rt_pri = scale ? scale_to_lwp_priority(rtLimits.minPrio,
3485 rtLimits.maxPrio, newPrio)
3486 : newPrio;
3487 rtInfo->rt_tqsecs = RT_NOCHANGE;
3488 rtInfo->rt_tqnsecs = RT_NOCHANGE;
3489 if (ThreadPriorityVerbose) {
3490 tty->print_cr("RT: %d->%d\n", newPrio, rtInfo->rt_pri);
3491 }
3492 } else if (new_class == iaLimits.schedPolicy) {
3493 iaparms_t* iaInfo = (iaparms_t*)ParmInfo.pc_clparms;
3494 int maxClamped = MIN2(iaLimits.maxPrio,
3495 cur_class == new_class
3496 ? (int)iaInfo->ia_uprilim : iaLimits.maxPrio);
3497 iaInfo->ia_upri = scale ? scale_to_lwp_priority(iaLimits.minPrio,
3498 maxClamped, newPrio)
3499 : newPrio;
3500 iaInfo->ia_uprilim = cur_class == new_class
3501 ? IA_NOCHANGE : (pri_t)iaLimits.maxPrio;
3502 iaInfo->ia_mode = IA_NOCHANGE;
3503 if (ThreadPriorityVerbose) {
3504 tty->print_cr("IA: [%d...%d] %d->%d\n",
3505 iaLimits.minPrio, maxClamped, newPrio, iaInfo->ia_upri);
3506 }
3507 } else if (new_class == tsLimits.schedPolicy) {
3508 tsparms_t* tsInfo = (tsparms_t*)ParmInfo.pc_clparms;
3509 int maxClamped = MIN2(tsLimits.maxPrio,
3510 cur_class == new_class
3511 ? (int)tsInfo->ts_uprilim : tsLimits.maxPrio);
3512 tsInfo->ts_upri = scale ? scale_to_lwp_priority(tsLimits.minPrio,
3513 maxClamped, newPrio)
3514 : newPrio;
3515 tsInfo->ts_uprilim = cur_class == new_class
3516 ? TS_NOCHANGE : (pri_t)tsLimits.maxPrio;
3517 if (ThreadPriorityVerbose) {
3518 tty->print_cr("TS: [%d...%d] %d->%d\n",
3519 tsLimits.minPrio, maxClamped, newPrio, tsInfo->ts_upri);
3520 }
3521 } else if (new_class == fxLimits.schedPolicy) {
3522 fxparms_t* fxInfo = (fxparms_t*)ParmInfo.pc_clparms;
3523 int maxClamped = MIN2(fxLimits.maxPrio,
3524 cur_class == new_class
3525 ? (int)fxInfo->fx_uprilim : fxLimits.maxPrio);
3526 fxInfo->fx_upri = scale ? scale_to_lwp_priority(fxLimits.minPrio,
3527 maxClamped, newPrio)
3528 : newPrio;
3529 fxInfo->fx_uprilim = cur_class == new_class
3530 ? FX_NOCHANGE : (pri_t)fxLimits.maxPrio;
3531 fxInfo->fx_tqsecs = FX_NOCHANGE;
3532 fxInfo->fx_tqnsecs = FX_NOCHANGE;
3533 if (ThreadPriorityVerbose) {
3534 tty->print_cr("FX: [%d...%d] %d->%d\n",
3535 fxLimits.minPrio, maxClamped, newPrio, fxInfo->fx_upri);
3536 }
3537 } else {
3538 if (ThreadPriorityVerbose) {
3539 tty->print_cr("Unknown new scheduling class %d\n", new_class);
3540 }
3541 return EINVAL; // no clue, punt
3542 }
3543
3544 rslt = priocntl(P_LWPID, lwpid, PC_SETPARMS, (caddr_t)&ParmInfo);
3545 if (ThreadPriorityVerbose && rslt) {
3546 tty->print_cr ("PC_SETPARMS ->%d %d\n", rslt, errno);
3547 }
3548 if (rslt < 0) return errno;
3549
3550 #ifdef ASSERT
3551 // Sanity check: read back what we just attempted to set.
3552 // In theory it could have changed in the interim ...
3553 //
3554 // The priocntl system call is tricky.
3555 // Sometimes it'll validate the priority value argument and
3556 // return EINVAL if unhappy. At other times it fails silently.
3557 // Readbacks are prudent.
3558
3559 if (!ReadBackValidate) return 0;
3560
3561 memset(&ReadBack, 0, sizeof(pcparms_t));
3562 ReadBack.pc_cid = PC_CLNULL;
3563 rslt = priocntl(P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ReadBack);
3564 assert(rslt >= 0, "priocntl failed");
3565 Actual = Expected = 0xBAD;
3566 assert(ParmInfo.pc_cid == ReadBack.pc_cid, "cid's don't match");
3567 if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3568 Actual = RTPRI(ReadBack)->rt_pri;
3569 Expected = RTPRI(ParmInfo)->rt_pri;
3570 } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3571 Actual = IAPRI(ReadBack)->ia_upri;
3572 Expected = IAPRI(ParmInfo)->ia_upri;
3573 } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3574 Actual = TSPRI(ReadBack)->ts_upri;
3575 Expected = TSPRI(ParmInfo)->ts_upri;
3576 } else if (ParmInfo.pc_cid == fxLimits.schedPolicy) {
3577 Actual = FXPRI(ReadBack)->fx_upri;
3578 Expected = FXPRI(ParmInfo)->fx_upri;
3579 } else {
3580 if (ThreadPriorityVerbose) {
3581 tty->print_cr("set_lwp_class_and_priority: unexpected class in readback: %d\n",
3582 ParmInfo.pc_cid);
3583 }
3584 }
3585
3586 if (Actual != Expected) {
3587 if (ThreadPriorityVerbose) {
3588 tty->print_cr ("set_lwp_class_and_priority(%d %d) Class=%d: actual=%d vs expected=%d\n",
3589 lwpid, newPrio, ReadBack.pc_cid, Actual, Expected);
3590 }
3591 }
3592 #endif
3593
3594 return 0;
3595 }
3596
3597 // Solaris only gives access to 128 real priorities at a time,
3598 // so we expand Java's ten to fill this range. This would be better
3599 // if we dynamically adjusted relative priorities.
3600 //
3601 // The ThreadPriorityPolicy option allows us to select 2 different
3602 // priority scales.
3603 //
3604 // ThreadPriorityPolicy=0
3605 // Since the Solaris' default priority is MaximumPriority, we do not
3606 // set a priority lower than Max unless a priority lower than
3607 // NormPriority is requested.
3608 //
3609 // ThreadPriorityPolicy=1
3610 // This mode causes the priority table to get filled with
3611 // linear values. NormPriority get's mapped to 50% of the
3612 // Maximum priority an so on. This will cause VM threads
3613 // to get unfair treatment against other Solaris processes
3614 // which do not explicitly alter their thread priorities.
3615
3616 int os::java_to_os_priority[CriticalPriority + 1] = {
3617 -99999, // 0 Entry should never be used
3618
3619 0, // 1 MinPriority
3620 32, // 2
3621 64, // 3
3622
3623 96, // 4
3624 127, // 5 NormPriority
3625 127, // 6
3626
3627 127, // 7
3628 127, // 8
3629 127, // 9 NearMaxPriority
3630
3631 127, // 10 MaxPriority
3632
3633 -criticalPrio // 11 CriticalPriority
3634 };
3635
3636 OSReturn os::set_native_priority(Thread* thread, int newpri) {
3637 OSThread* osthread = thread->osthread();
3638
3639 // Save requested priority in case the thread hasn't been started
3640 osthread->set_native_priority(newpri);
3641
3642 // Check for critical priority request
3643 bool fxcritical = false;
3644 if (newpri == -criticalPrio) {
3645 fxcritical = true;
3646 newpri = criticalPrio;
3647 }
3648
3649 assert(newpri >= MinimumPriority && newpri <= MaximumPriority, "bad priority mapping");
3650 if (!UseThreadPriorities) return OS_OK;
3651
3652 int status = 0;
3653
3654 if (!fxcritical) {
3655 // Use thr_setprio only if we have a priority that thr_setprio understands
3656 status = thr_setprio(thread->osthread()->thread_id(), newpri);
3657 }
3658
3659 int lwp_status =
3660 set_lwp_class_and_priority(osthread->thread_id(),
3661 osthread->lwp_id(),
3662 newpri,
3663 fxcritical ? fxLimits.schedPolicy : myClass,
3664 !fxcritical);
3665 if (lwp_status != 0 && fxcritical) {
3666 // Try again, this time without changing the scheduling class
3667 newpri = java_MaxPriority_to_os_priority;
3668 lwp_status = set_lwp_class_and_priority(osthread->thread_id(),
3669 osthread->lwp_id(),
3670 newpri, myClass, false);
3671 }
3672 status |= lwp_status;
3673 return (status == 0) ? OS_OK : OS_ERR;
3674 }
3675
3676
3677 OSReturn os::get_native_priority(const Thread* const thread,
3678 int *priority_ptr) {
3679 int p;
3680 if (!UseThreadPriorities) {
3681 *priority_ptr = NormalPriority;
3682 return OS_OK;
3683 }
3684 int status = thr_getprio(thread->osthread()->thread_id(), &p);
3685 if (status != 0) {
3686 return OS_ERR;
3687 }
3688 *priority_ptr = p;
3689 return OS_OK;
3690 }
3691
3692
3693 // Hint to the underlying OS that a task switch would not be good.
3694 // Void return because it's a hint and can fail.
3695 void os::hint_no_preempt() {
3696 schedctl_start(schedctl_init());
3697 }
3698
3699 static void resume_clear_context(OSThread *osthread) {
3700 osthread->set_ucontext(NULL);
3701 }
3702
3703 static void suspend_save_context(OSThread *osthread, ucontext_t* context) {
3704 osthread->set_ucontext(context);
3705 }
3706
3707 static PosixSemaphore sr_semaphore;
3708
3709 void os::Solaris::SR_handler(Thread* thread, ucontext_t* uc) {
3710 // Save and restore errno to avoid confusing native code with EINTR
3711 // after sigsuspend.
3712 int old_errno = errno;
3713
3714 OSThread* osthread = thread->osthread();
3715 assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread");
3716
3717 os::SuspendResume::State current = osthread->sr.state();
3718 if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
3719 suspend_save_context(osthread, uc);
3720
3721 // attempt to switch the state, we assume we had a SUSPEND_REQUEST
3722 os::SuspendResume::State state = osthread->sr.suspended();
3723 if (state == os::SuspendResume::SR_SUSPENDED) {
3724 sigset_t suspend_set; // signals for sigsuspend()
3725
3726 // get current set of blocked signals and unblock resume signal
3727 thr_sigsetmask(SIG_BLOCK, NULL, &suspend_set);
3728 sigdelset(&suspend_set, os::Solaris::SIGasync());
3729
3730 sr_semaphore.signal();
3731 // wait here until we are resumed
3732 while (1) {
3733 sigsuspend(&suspend_set);
3734
3735 os::SuspendResume::State result = osthread->sr.running();
3736 if (result == os::SuspendResume::SR_RUNNING) {
3737 sr_semaphore.signal();
3738 break;
3739 }
3740 }
3741
3742 } else if (state == os::SuspendResume::SR_RUNNING) {
3743 // request was cancelled, continue
3744 } else {
3745 ShouldNotReachHere();
3746 }
3747
3748 resume_clear_context(osthread);
3749 } else if (current == os::SuspendResume::SR_RUNNING) {
3750 // request was cancelled, continue
3751 } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
3752 // ignore
3753 } else {
3754 // ignore
3755 }
3756
3757 errno = old_errno;
3758 }
3759
3760 void os::print_statistics() {
3761 }
3762
3763 int os::message_box(const char* title, const char* message) {
3764 int i;
3765 fdStream err(defaultStream::error_fd());
3766 for (i = 0; i < 78; i++) err.print_raw("=");
3767 err.cr();
3768 err.print_raw_cr(title);
3769 for (i = 0; i < 78; i++) err.print_raw("-");
3770 err.cr();
3771 err.print_raw_cr(message);
3772 for (i = 0; i < 78; i++) err.print_raw("=");
3773 err.cr();
3774
3775 char buf[16];
3776 // Prevent process from exiting upon "read error" without consuming all CPU
3777 while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
3778
3779 return buf[0] == 'y' || buf[0] == 'Y';
3780 }
3781
3782 static int sr_notify(OSThread* osthread) {
3783 int status = thr_kill(osthread->thread_id(), os::Solaris::SIGasync());
3784 assert_status(status == 0, status, "thr_kill");
3785 return status;
3786 }
3787
3788 // "Randomly" selected value for how long we want to spin
3789 // before bailing out on suspending a thread, also how often
3790 // we send a signal to a thread we want to resume
3791 static const int RANDOMLY_LARGE_INTEGER = 1000000;
3792 static const int RANDOMLY_LARGE_INTEGER2 = 100;
3793
3794 static bool do_suspend(OSThread* osthread) {
3795 assert(osthread->sr.is_running(), "thread should be running");
3796 assert(!sr_semaphore.trywait(), "semaphore has invalid state");
3797
3798 // mark as suspended and send signal
3799 if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
3800 // failed to switch, state wasn't running?
3801 ShouldNotReachHere();
3802 return false;
3803 }
3804
3805 if (sr_notify(osthread) != 0) {
3806 ShouldNotReachHere();
3807 }
3808
3809 // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED
3810 while (true) {
3811 if (sr_semaphore.timedwait(0, 2000 * NANOSECS_PER_MILLISEC)) {
3812 break;
3813 } else {
3814 // timeout
3815 os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
3816 if (cancelled == os::SuspendResume::SR_RUNNING) {
3817 return false;
3818 } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
3819 // make sure that we consume the signal on the semaphore as well
3820 sr_semaphore.wait();
3821 break;
3822 } else {
3823 ShouldNotReachHere();
3824 return false;
3825 }
3826 }
3827 }
3828
3829 guarantee(osthread->sr.is_suspended(), "Must be suspended");
3830 return true;
3831 }
3832
3833 static void do_resume(OSThread* osthread) {
3834 assert(osthread->sr.is_suspended(), "thread should be suspended");
3835 assert(!sr_semaphore.trywait(), "invalid semaphore state");
3836
3837 if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
3838 // failed to switch to WAKEUP_REQUEST
3839 ShouldNotReachHere();
3840 return;
3841 }
3842
3843 while (true) {
3844 if (sr_notify(osthread) == 0) {
3845 if (sr_semaphore.timedwait(0, 2 * NANOSECS_PER_MILLISEC)) {
3846 if (osthread->sr.is_running()) {
3847 return;
3848 }
3849 }
3850 } else {
3851 ShouldNotReachHere();
3852 }
3853 }
3854
3855 guarantee(osthread->sr.is_running(), "Must be running!");
3856 }
3857
3858 void os::SuspendedThreadTask::internal_do_task() {
3859 if (do_suspend(_thread->osthread())) {
3860 SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext());
3861 do_task(context);
3862 do_resume(_thread->osthread());
3863 }
3864 }
3865
3866 class PcFetcher : public os::SuspendedThreadTask {
3867 public:
3868 PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
3869 ExtendedPC result();
3870 protected:
3871 void do_task(const os::SuspendedThreadTaskContext& context);
3872 private:
3873 ExtendedPC _epc;
3874 };
3875
3876 ExtendedPC PcFetcher::result() {
3877 guarantee(is_done(), "task is not done yet.");
3878 return _epc;
3879 }
3880
3881 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
3882 Thread* thread = context.thread();
3883 OSThread* osthread = thread->osthread();
3884 if (osthread->ucontext() != NULL) {
3885 _epc = os::Solaris::ucontext_get_pc((ucontext_t *) context.ucontext());
3886 } else {
3887 // NULL context is unexpected, double-check this is the VMThread
3888 guarantee(thread->is_VM_thread(), "can only be called for VMThread");
3889 }
3890 }
3891
3892 // A lightweight implementation that does not suspend the target thread and
3893 // thus returns only a hint. Used for profiling only!
3894 ExtendedPC os::get_thread_pc(Thread* thread) {
3895 // Make sure that it is called by the watcher and the Threads lock is owned.
3896 assert(Thread::current()->is_Watcher_thread(), "Must be watcher and own Threads_lock");
3897 // For now, is only used to profile the VM Thread
3898 assert(thread->is_VM_thread(), "Can only be called for VMThread");
3899 PcFetcher fetcher(thread);
3900 fetcher.run();
3901 return fetcher.result();
3902 }
3903
3904
3905 // This does not do anything on Solaris. This is basically a hook for being
3906 // able to use structured exception handling (thread-local exception filters) on, e.g., Win32.
3907 void os::os_exception_wrapper(java_call_t f, JavaValue* value,
3908 methodHandle* method, JavaCallArguments* args,
3909 Thread* thread) {
3910 f(value, method, args, thread);
3911 }
3912
3913 // This routine may be used by user applications as a "hook" to catch signals.
3914 // The user-defined signal handler must pass unrecognized signals to this
3915 // routine, and if it returns true (non-zero), then the signal handler must
3916 // return immediately. If the flag "abort_if_unrecognized" is true, then this
3917 // routine will never retun false (zero), but instead will execute a VM panic
3918 // routine kill the process.
3919 //
3920 // If this routine returns false, it is OK to call it again. This allows
3921 // the user-defined signal handler to perform checks either before or after
3922 // the VM performs its own checks. Naturally, the user code would be making
3923 // a serious error if it tried to handle an exception (such as a null check
3924 // or breakpoint) that the VM was generating for its own correct operation.
3925 //
3926 // This routine may recognize any of the following kinds of signals:
3927 // SIGBUS, SIGSEGV, SIGILL, SIGFPE, BREAK_SIGNAL, SIGPIPE, SIGXFSZ,
3928 // os::Solaris::SIGasync
3929 // It should be consulted by handlers for any of those signals.
3930 // It explicitly does not recognize os::Solaris::SIGinterrupt
3931 //
3932 // The caller of this routine must pass in the three arguments supplied
3933 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
3934 // field of the structure passed to sigaction(). This routine assumes that
3935 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
3936 //
3937 // Note that the VM will print warnings if it detects conflicting signal
3938 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
3939 //
3940 extern "C" JNIEXPORT int JVM_handle_solaris_signal(int signo,
3941 siginfo_t* siginfo,
3942 void* ucontext,
3943 int abort_if_unrecognized);
3944
3945
3946 void signalHandler(int sig, siginfo_t* info, void* ucVoid) {
3947 int orig_errno = errno; // Preserve errno value over signal handler.
3948 JVM_handle_solaris_signal(sig, info, ucVoid, true);
3949 errno = orig_errno;
3950 }
3951
3952 // Do not delete - if guarantee is ever removed, a signal handler (even empty)
3953 // is needed to provoke threads blocked on IO to return an EINTR
3954 // Note: this explicitly does NOT call JVM_handle_solaris_signal and
3955 // does NOT participate in signal chaining due to requirement for
3956 // NOT setting SA_RESTART to make EINTR work.
3957 extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) {
3958 if (UseSignalChaining) {
3959 struct sigaction *actp = os::Solaris::get_chained_signal_action(sig);
3960 if (actp && actp->sa_handler) {
3961 vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs");
3962 }
3963 }
3964 }
3965
3966 // This boolean allows users to forward their own non-matching signals
3967 // to JVM_handle_solaris_signal, harmlessly.
3968 bool os::Solaris::signal_handlers_are_installed = false;
3969
3970 // For signal-chaining
3971 bool os::Solaris::libjsig_is_loaded = false;
3972 typedef struct sigaction *(*get_signal_t)(int);
3973 get_signal_t os::Solaris::get_signal_action = NULL;
3974
3975 struct sigaction* os::Solaris::get_chained_signal_action(int sig) {
3976 struct sigaction *actp = NULL;
3977
3978 if ((libjsig_is_loaded) && (sig <= Maxlibjsigsigs)) {
3979 // Retrieve the old signal handler from libjsig
3980 actp = (*get_signal_action)(sig);
3981 }
3982 if (actp == NULL) {
3983 // Retrieve the preinstalled signal handler from jvm
3984 actp = get_preinstalled_handler(sig);
3985 }
3986
3987 return actp;
3988 }
3989
3990 static bool call_chained_handler(struct sigaction *actp, int sig,
3991 siginfo_t *siginfo, void *context) {
3992 // Call the old signal handler
3993 if (actp->sa_handler == SIG_DFL) {
3994 // It's more reasonable to let jvm treat it as an unexpected exception
3995 // instead of taking the default action.
3996 return false;
3997 } else if (actp->sa_handler != SIG_IGN) {
3998 if ((actp->sa_flags & SA_NODEFER) == 0) {
3999 // automaticlly block the signal
4000 sigaddset(&(actp->sa_mask), sig);
4001 }
4002
4003 sa_handler_t hand;
4004 sa_sigaction_t sa;
4005 bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
4006 // retrieve the chained handler
4007 if (siginfo_flag_set) {
4008 sa = actp->sa_sigaction;
4009 } else {
4010 hand = actp->sa_handler;
4011 }
4012
4013 if ((actp->sa_flags & SA_RESETHAND) != 0) {
4014 actp->sa_handler = SIG_DFL;
4015 }
4016
4017 // try to honor the signal mask
4018 sigset_t oset;
4019 thr_sigsetmask(SIG_SETMASK, &(actp->sa_mask), &oset);
4020
4021 // call into the chained handler
4022 if (siginfo_flag_set) {
4023 (*sa)(sig, siginfo, context);
4024 } else {
4025 (*hand)(sig);
4026 }
4027
4028 // restore the signal mask
4029 thr_sigsetmask(SIG_SETMASK, &oset, 0);
4030 }
4031 // Tell jvm's signal handler the signal is taken care of.
4032 return true;
4033 }
4034
4035 bool os::Solaris::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4036 bool chained = false;
4037 // signal-chaining
4038 if (UseSignalChaining) {
4039 struct sigaction *actp = get_chained_signal_action(sig);
4040 if (actp != NULL) {
4041 chained = call_chained_handler(actp, sig, siginfo, context);
4042 }
4043 }
4044 return chained;
4045 }
4046
4047 struct sigaction* os::Solaris::get_preinstalled_handler(int sig) {
4048 assert((chainedsigactions != (struct sigaction *)NULL) &&
4049 (preinstalled_sigs != (int *)NULL), "signals not yet initialized");
4050 if (preinstalled_sigs[sig] != 0) {
4051 return &chainedsigactions[sig];
4052 }
4053 return NULL;
4054 }
4055
4056 void os::Solaris::save_preinstalled_handler(int sig,
4057 struct sigaction& oldAct) {
4058 assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range");
4059 assert((chainedsigactions != (struct sigaction *)NULL) &&
4060 (preinstalled_sigs != (int *)NULL), "signals not yet initialized");
4061 chainedsigactions[sig] = oldAct;
4062 preinstalled_sigs[sig] = 1;
4063 }
4064
4065 void os::Solaris::set_signal_handler(int sig, bool set_installed,
4066 bool oktochain) {
4067 // Check for overwrite.
4068 struct sigaction oldAct;
4069 sigaction(sig, (struct sigaction*)NULL, &oldAct);
4070 void* oldhand =
4071 oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
4072 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
4073 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
4074 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
4075 oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) {
4076 if (AllowUserSignalHandlers || !set_installed) {
4077 // Do not overwrite; user takes responsibility to forward to us.
4078 return;
4079 } else if (UseSignalChaining) {
4080 if (oktochain) {
4081 // save the old handler in jvm
4082 save_preinstalled_handler(sig, oldAct);
4083 } else {
4084 vm_exit_during_initialization("Signal chaining not allowed for VM interrupt signal, try -XX:+UseAltSigs.");
4085 }
4086 // libjsig also interposes the sigaction() call below and saves the
4087 // old sigaction on it own.
4088 } else {
4089 fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
4090 "%#lx for signal %d.", (long)oldhand, sig));
4091 }
4092 }
4093
4094 struct sigaction sigAct;
4095 sigfillset(&(sigAct.sa_mask));
4096 sigAct.sa_handler = SIG_DFL;
4097
4098 sigAct.sa_sigaction = signalHandler;
4099 // Handle SIGSEGV on alternate signal stack if
4100 // not using stack banging
4101 if (!UseStackBanging && sig == SIGSEGV) {
4102 sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
4103 } else if (sig == os::Solaris::SIGinterrupt()) {
4104 // Interruptible i/o requires SA_RESTART cleared so EINTR
4105 // is returned instead of restarting system calls
4106 sigemptyset(&sigAct.sa_mask);
4107 sigAct.sa_handler = NULL;
4108 sigAct.sa_flags = SA_SIGINFO;
4109 sigAct.sa_sigaction = sigINTRHandler;
4110 } else {
4111 sigAct.sa_flags = SA_SIGINFO | SA_RESTART;
4112 }
4113 os::Solaris::set_our_sigflags(sig, sigAct.sa_flags);
4114
4115 sigaction(sig, &sigAct, &oldAct);
4116
4117 void* oldhand2 = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
4118 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
4119 assert(oldhand2 == oldhand, "no concurrent signal handler installation");
4120 }
4121
4122
4123 #define DO_SIGNAL_CHECK(sig) \
4124 do { \
4125 if (!sigismember(&check_signal_done, sig)) { \
4126 os::Solaris::check_signal_handler(sig); \
4127 } \
4128 } while (0)
4129
4130 // This method is a periodic task to check for misbehaving JNI applications
4131 // under CheckJNI, we can add any periodic checks here
4132
4133 void os::run_periodic_checks() {
4134 // A big source of grief is hijacking virt. addr 0x0 on Solaris,
4135 // thereby preventing a NULL checks.
4136 if (!check_addr0_done) check_addr0_done = check_addr0(tty);
4137
4138 if (check_signals == false) return;
4139
4140 // SEGV and BUS if overridden could potentially prevent
4141 // generation of hs*.log in the event of a crash, debugging
4142 // such a case can be very challenging, so we absolutely
4143 // check for the following for a good measure:
4144 DO_SIGNAL_CHECK(SIGSEGV);
4145 DO_SIGNAL_CHECK(SIGILL);
4146 DO_SIGNAL_CHECK(SIGFPE);
4147 DO_SIGNAL_CHECK(SIGBUS);
4148 DO_SIGNAL_CHECK(SIGPIPE);
4149 DO_SIGNAL_CHECK(SIGXFSZ);
4150
4151 // ReduceSignalUsage allows the user to override these handlers
4152 // see comments at the very top and jvm_solaris.h
4153 if (!ReduceSignalUsage) {
4154 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
4155 DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
4156 DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
4157 DO_SIGNAL_CHECK(BREAK_SIGNAL);
4158 }
4159
4160 // See comments above for using JVM1/JVM2 and UseAltSigs
4161 DO_SIGNAL_CHECK(os::Solaris::SIGinterrupt());
4162 DO_SIGNAL_CHECK(os::Solaris::SIGasync());
4163
4164 }
4165
4166 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
4167
4168 static os_sigaction_t os_sigaction = NULL;
4169
4170 void os::Solaris::check_signal_handler(int sig) {
4171 char buf[O_BUFLEN];
4172 address jvmHandler = NULL;
4173
4174 struct sigaction act;
4175 if (os_sigaction == NULL) {
4176 // only trust the default sigaction, in case it has been interposed
4177 os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
4178 if (os_sigaction == NULL) return;
4179 }
4180
4181 os_sigaction(sig, (struct sigaction*)NULL, &act);
4182
4183 address thisHandler = (act.sa_flags & SA_SIGINFO)
4184 ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
4185 : CAST_FROM_FN_PTR(address, act.sa_handler);
4186
4187
4188 switch (sig) {
4189 case SIGSEGV:
4190 case SIGBUS:
4191 case SIGFPE:
4192 case SIGPIPE:
4193 case SIGXFSZ:
4194 case SIGILL:
4195 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4196 break;
4197
4198 case SHUTDOWN1_SIGNAL:
4199 case SHUTDOWN2_SIGNAL:
4200 case SHUTDOWN3_SIGNAL:
4201 case BREAK_SIGNAL:
4202 jvmHandler = (address)user_handler();
4203 break;
4204
4205 default:
4206 int intrsig = os::Solaris::SIGinterrupt();
4207 int asynsig = os::Solaris::SIGasync();
4208
4209 if (sig == intrsig) {
4210 jvmHandler = CAST_FROM_FN_PTR(address, sigINTRHandler);
4211 } else if (sig == asynsig) {
4212 jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4213 } else {
4214 return;
4215 }
4216 break;
4217 }
4218
4219
4220 if (thisHandler != jvmHandler) {
4221 tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
4222 tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
4223 tty->print_cr(" found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
4224 // No need to check this sig any longer
4225 sigaddset(&check_signal_done, sig);
4226 // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN
4227 if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) {
4228 tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell",
4229 exception_name(sig, buf, O_BUFLEN));
4230 }
4231 } else if(os::Solaris::get_our_sigflags(sig) != 0 && act.sa_flags != os::Solaris::get_our_sigflags(sig)) {
4232 tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
4233 tty->print("expected:" PTR32_FORMAT, os::Solaris::get_our_sigflags(sig));
4234 tty->print_cr(" found:" PTR32_FORMAT, act.sa_flags);
4235 // No need to check this sig any longer
4236 sigaddset(&check_signal_done, sig);
4237 }
4238
4239 // Print all the signal handler state
4240 if (sigismember(&check_signal_done, sig)) {
4241 print_signal_handlers(tty, buf, O_BUFLEN);
4242 }
4243
4244 }
4245
4246 void os::Solaris::install_signal_handlers() {
4247 bool libjsigdone = false;
4248 signal_handlers_are_installed = true;
4249
4250 // signal-chaining
4251 typedef void (*signal_setting_t)();
4252 signal_setting_t begin_signal_setting = NULL;
4253 signal_setting_t end_signal_setting = NULL;
4254 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4255 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
4256 if (begin_signal_setting != NULL) {
4257 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4258 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
4259 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
4260 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
4261 get_libjsig_version = CAST_TO_FN_PTR(version_getting_t,
4262 dlsym(RTLD_DEFAULT, "JVM_get_libjsig_version"));
4263 libjsig_is_loaded = true;
4264 if (os::Solaris::get_libjsig_version != NULL) {
4265 libjsigversion = (*os::Solaris::get_libjsig_version)();
4266 }
4267 assert(UseSignalChaining, "should enable signal-chaining");
4268 }
4269 if (libjsig_is_loaded) {
4270 // Tell libjsig jvm is setting signal handlers
4271 (*begin_signal_setting)();
4272 }
4273
4274 set_signal_handler(SIGSEGV, true, true);
4275 set_signal_handler(SIGPIPE, true, true);
4276 set_signal_handler(SIGXFSZ, true, true);
4277 set_signal_handler(SIGBUS, true, true);
4278 set_signal_handler(SIGILL, true, true);
4279 set_signal_handler(SIGFPE, true, true);
4280
4281
4282 if (os::Solaris::SIGinterrupt() > OLDMAXSIGNUM || os::Solaris::SIGasync() > OLDMAXSIGNUM) {
4283
4284 // Pre-1.4.1 Libjsig limited to signal chaining signals <= 32 so
4285 // can not register overridable signals which might be > 32
4286 if (libjsig_is_loaded && libjsigversion <= JSIG_VERSION_1_4_1) {
4287 // Tell libjsig jvm has finished setting signal handlers
4288 (*end_signal_setting)();
4289 libjsigdone = true;
4290 }
4291 }
4292
4293 // Never ok to chain our SIGinterrupt
4294 set_signal_handler(os::Solaris::SIGinterrupt(), true, false);
4295 set_signal_handler(os::Solaris::SIGasync(), true, true);
4296
4297 if (libjsig_is_loaded && !libjsigdone) {
4298 // Tell libjsig jvm finishes setting signal handlers
4299 (*end_signal_setting)();
4300 }
4301
4302 // We don't activate signal checker if libjsig is in place, we trust ourselves
4303 // and if UserSignalHandler is installed all bets are off.
4304 // Log that signal checking is off only if -verbose:jni is specified.
4305 if (CheckJNICalls) {
4306 if (libjsig_is_loaded) {
4307 if (PrintJNIResolving) {
4308 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
4309 }
4310 check_signals = false;
4311 }
4312 if (AllowUserSignalHandlers) {
4313 if (PrintJNIResolving) {
4314 tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
4315 }
4316 check_signals = false;
4317 }
4318 }
4319 }
4320
4321
4322 void report_error(const char* file_name, int line_no, const char* title,
4323 const char* format, ...);
4324
4325 const char * signames[] = {
4326 "SIG0",
4327 "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP",
4328 "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS",
4329 "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM",
4330 "SIGUSR1", "SIGUSR2", "SIGCLD", "SIGPWR", "SIGWINCH",
4331 "SIGURG", "SIGPOLL", "SIGSTOP", "SIGTSTP", "SIGCONT",
4332 "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU",
4333 "SIGXFSZ", "SIGWAITING", "SIGLWP", "SIGFREEZE", "SIGTHAW",
4334 "SIGCANCEL", "SIGLOST"
4335 };
4336
4337 const char* os::exception_name(int exception_code, char* buf, size_t size) {
4338 if (0 < exception_code && exception_code <= SIGRTMAX) {
4339 // signal
4340 if (exception_code < sizeof(signames)/sizeof(const char*)) {
4341 jio_snprintf(buf, size, "%s", signames[exception_code]);
4342 } else {
4343 jio_snprintf(buf, size, "SIG%d", exception_code);
4344 }
4345 return buf;
4346 } else {
4347 return NULL;
4348 }
4349 }
4350
4351 // (Static) wrapper for getisax(2) call.
4352 os::Solaris::getisax_func_t os::Solaris::_getisax = 0;
4353
4354 // (Static) wrappers for the liblgrp API
4355 os::Solaris::lgrp_home_func_t os::Solaris::_lgrp_home;
4356 os::Solaris::lgrp_init_func_t os::Solaris::_lgrp_init;
4357 os::Solaris::lgrp_fini_func_t os::Solaris::_lgrp_fini;
4358 os::Solaris::lgrp_root_func_t os::Solaris::_lgrp_root;
4359 os::Solaris::lgrp_children_func_t os::Solaris::_lgrp_children;
4360 os::Solaris::lgrp_resources_func_t os::Solaris::_lgrp_resources;
4361 os::Solaris::lgrp_nlgrps_func_t os::Solaris::_lgrp_nlgrps;
4362 os::Solaris::lgrp_cookie_stale_func_t os::Solaris::_lgrp_cookie_stale;
4363 os::Solaris::lgrp_cookie_t os::Solaris::_lgrp_cookie = 0;
4364
4365 // (Static) wrapper for meminfo() call.
4366 os::Solaris::meminfo_func_t os::Solaris::_meminfo = 0;
4367
4368 static address resolve_symbol_lazy(const char* name) {
4369 address addr = (address) dlsym(RTLD_DEFAULT, name);
4370 if (addr == NULL) {
4371 // RTLD_DEFAULT was not defined on some early versions of 2.5.1
4372 addr = (address) dlsym(RTLD_NEXT, name);
4373 }
4374 return addr;
4375 }
4376
4377 static address resolve_symbol(const char* name) {
4378 address addr = resolve_symbol_lazy(name);
4379 if (addr == NULL) {
4380 fatal(dlerror());
4381 }
4382 return addr;
4383 }
4384
4385 void os::Solaris::libthread_init() {
4386 address func = (address)dlsym(RTLD_DEFAULT, "_thr_suspend_allmutators");
4387
4388 lwp_priocntl_init();
4389
4390 // RTLD_DEFAULT was not defined on some early versions of 5.5.1
4391 if (func == NULL) {
4392 func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators");
4393 // Guarantee that this VM is running on an new enough OS (5.6 or
4394 // later) that it will have a new enough libthread.so.
4395 guarantee(func != NULL, "libthread.so is too old.");
4396 }
4397
4398 int size;
4399 void (*handler_info_func)(address *, int *);
4400 handler_info_func = CAST_TO_FN_PTR(void (*)(address *, int *), resolve_symbol("thr_sighndlrinfo"));
4401 handler_info_func(&handler_start, &size);
4402 handler_end = handler_start + size;
4403 }
4404
4405
4406 int_fnP_mutex_tP os::Solaris::_mutex_lock;
4407 int_fnP_mutex_tP os::Solaris::_mutex_trylock;
4408 int_fnP_mutex_tP os::Solaris::_mutex_unlock;
4409 int_fnP_mutex_tP_i_vP os::Solaris::_mutex_init;
4410 int_fnP_mutex_tP os::Solaris::_mutex_destroy;
4411 int os::Solaris::_mutex_scope = USYNC_THREAD;
4412
4413 int_fnP_cond_tP_mutex_tP_timestruc_tP os::Solaris::_cond_timedwait;
4414 int_fnP_cond_tP_mutex_tP os::Solaris::_cond_wait;
4415 int_fnP_cond_tP os::Solaris::_cond_signal;
4416 int_fnP_cond_tP os::Solaris::_cond_broadcast;
4417 int_fnP_cond_tP_i_vP os::Solaris::_cond_init;
4418 int_fnP_cond_tP os::Solaris::_cond_destroy;
4419 int os::Solaris::_cond_scope = USYNC_THREAD;
4420
4421 void os::Solaris::synchronization_init() {
4422 if (UseLWPSynchronization) {
4423 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock")));
4424 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock")));
4425 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock")));
4426 os::Solaris::set_mutex_init(lwp_mutex_init);
4427 os::Solaris::set_mutex_destroy(lwp_mutex_destroy);
4428 os::Solaris::set_mutex_scope(USYNC_THREAD);
4429
4430 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("_lwp_cond_timedwait")));
4431 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("_lwp_cond_wait")));
4432 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal")));
4433 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast")));
4434 os::Solaris::set_cond_init(lwp_cond_init);
4435 os::Solaris::set_cond_destroy(lwp_cond_destroy);
4436 os::Solaris::set_cond_scope(USYNC_THREAD);
4437 } else {
4438 os::Solaris::set_mutex_scope(USYNC_THREAD);
4439 os::Solaris::set_cond_scope(USYNC_THREAD);
4440
4441 if (UsePthreads) {
4442 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock")));
4443 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock")));
4444 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock")));
4445 os::Solaris::set_mutex_init(pthread_mutex_default_init);
4446 os::Solaris::set_mutex_destroy(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_destroy")));
4447
4448 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("pthread_cond_timedwait")));
4449 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait")));
4450 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal")));
4451 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast")));
4452 os::Solaris::set_cond_init(pthread_cond_default_init);
4453 os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy")));
4454 } else {
4455 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock")));
4456 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock")));
4457 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock")));
4458 os::Solaris::set_mutex_init(::mutex_init);
4459 os::Solaris::set_mutex_destroy(::mutex_destroy);
4460
4461 os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("cond_timedwait")));
4462 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("cond_wait")));
4463 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_signal")));
4464 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_broadcast")));
4465 os::Solaris::set_cond_init(::cond_init);
4466 os::Solaris::set_cond_destroy(::cond_destroy);
4467 }
4468 }
4469 }
4470
4471 bool os::Solaris::liblgrp_init() {
4472 void *handle = dlopen("liblgrp.so.1", RTLD_LAZY);
4473 if (handle != NULL) {
4474 os::Solaris::set_lgrp_home(CAST_TO_FN_PTR(lgrp_home_func_t, dlsym(handle, "lgrp_home")));
4475 os::Solaris::set_lgrp_init(CAST_TO_FN_PTR(lgrp_init_func_t, dlsym(handle, "lgrp_init")));
4476 os::Solaris::set_lgrp_fini(CAST_TO_FN_PTR(lgrp_fini_func_t, dlsym(handle, "lgrp_fini")));
4477 os::Solaris::set_lgrp_root(CAST_TO_FN_PTR(lgrp_root_func_t, dlsym(handle, "lgrp_root")));
4478 os::Solaris::set_lgrp_children(CAST_TO_FN_PTR(lgrp_children_func_t, dlsym(handle, "lgrp_children")));
4479 os::Solaris::set_lgrp_resources(CAST_TO_FN_PTR(lgrp_resources_func_t, dlsym(handle, "lgrp_resources")));
4480 os::Solaris::set_lgrp_nlgrps(CAST_TO_FN_PTR(lgrp_nlgrps_func_t, dlsym(handle, "lgrp_nlgrps")));
4481 os::Solaris::set_lgrp_cookie_stale(CAST_TO_FN_PTR(lgrp_cookie_stale_func_t,
4482 dlsym(handle, "lgrp_cookie_stale")));
4483
4484 lgrp_cookie_t c = lgrp_init(LGRP_VIEW_CALLER);
4485 set_lgrp_cookie(c);
4486 return true;
4487 }
4488 return false;
4489 }
4490
4491 void os::Solaris::misc_sym_init() {
4492 address func;
4493
4494 // getisax
4495 func = resolve_symbol_lazy("getisax");
4496 if (func != NULL) {
4497 os::Solaris::_getisax = CAST_TO_FN_PTR(getisax_func_t, func);
4498 }
4499
4500 // meminfo
4501 func = resolve_symbol_lazy("meminfo");
4502 if (func != NULL) {
4503 os::Solaris::set_meminfo(CAST_TO_FN_PTR(meminfo_func_t, func));
4504 }
4505 }
4506
4507 uint_t os::Solaris::getisax(uint32_t* array, uint_t n) {
4508 assert(_getisax != NULL, "_getisax not set");
4509 return _getisax(array, n);
4510 }
4511
4512 // int pset_getloadavg(psetid_t pset, double loadavg[], int nelem);
4513 typedef long (*pset_getloadavg_type)(psetid_t pset, double loadavg[], int nelem);
4514 static pset_getloadavg_type pset_getloadavg_ptr = NULL;
4515
4516 void init_pset_getloadavg_ptr(void) {
4517 pset_getloadavg_ptr =
4518 (pset_getloadavg_type)dlsym(RTLD_DEFAULT, "pset_getloadavg");
4519 if (PrintMiscellaneous && Verbose && pset_getloadavg_ptr == NULL) {
4520 warning("pset_getloadavg function not found");
4521 }
4522 }
4523
4524 int os::Solaris::_dev_zero_fd = -1;
4525
4526 // this is called _before_ the global arguments have been parsed
4527 void os::init(void) {
4528 _initial_pid = getpid();
4529
4530 max_hrtime = first_hrtime = gethrtime();
4531
4532 init_random(1234567);
4533
4534 page_size = sysconf(_SC_PAGESIZE);
4535 if (page_size == -1) {
4536 fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)",
4537 strerror(errno)));
4538 }
4539 init_page_sizes((size_t) page_size);
4540
4541 Solaris::initialize_system_info();
4542
4543 // Initialize misc. symbols as soon as possible, so we can use them
4544 // if we need them.
4545 Solaris::misc_sym_init();
4546
4547 int fd = ::open("/dev/zero", O_RDWR);
4548 if (fd < 0) {
4549 fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno)));
4550 } else {
4551 Solaris::set_dev_zero_fd(fd);
4552
4553 // Close on exec, child won't inherit.
4554 fcntl(fd, F_SETFD, FD_CLOEXEC);
4555 }
4556
4557 clock_tics_per_sec = CLK_TCK;
4558
4559 // check if dladdr1() exists; dladdr1 can provide more information than
4560 // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9
4561 // and is available on linker patches for 5.7 and 5.8.
4562 // libdl.so must have been loaded, this call is just an entry lookup
4563 void * hdl = dlopen("libdl.so", RTLD_NOW);
4564 if (hdl) {
4565 dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1"));
4566 }
4567
4568 // (Solaris only) this switches to calls that actually do locking.
4569 ThreadCritical::initialize();
4570
4571 main_thread = thr_self();
4572
4573 // Constant minimum stack size allowed. It must be at least
4574 // the minimum of what the OS supports (thr_min_stack()), and
4575 // enough to allow the thread to get to user bytecode execution.
4576 Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed);
4577 // If the pagesize of the VM is greater than 8K determine the appropriate
4578 // number of initial guard pages. The user can change this with the
4579 // command line arguments, if needed.
4580 if (vm_page_size() > 8*K) {
4581 StackYellowPages = 1;
4582 StackRedPages = 1;
4583 StackShadowPages = round_to((StackShadowPages*8*K), vm_page_size()) / vm_page_size();
4584 }
4585 }
4586
4587 // To install functions for atexit system call
4588 extern "C" {
4589 static void perfMemory_exit_helper() {
4590 perfMemory_exit();
4591 }
4592 }
4593
4594 // this is called _after_ the global arguments have been parsed
4595 jint os::init_2(void) {
4596 // try to enable extended file IO ASAP, see 6431278
4597 os::Solaris::try_enable_extended_io();
4598
4599 // Allocate a single page and mark it as readable for safepoint polling. Also
4600 // use this first mmap call to check support for MAP_ALIGN.
4601 address polling_page = (address)Solaris::mmap_chunk((char*)page_size,
4602 page_size,
4603 MAP_PRIVATE | MAP_ALIGN,
4604 PROT_READ);
4605 if (polling_page == NULL) {
4606 has_map_align = false;
4607 polling_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE,
4608 PROT_READ);
4609 }
4610
4611 os::set_polling_page(polling_page);
4612
4613 #ifndef PRODUCT
4614 if (Verbose && PrintMiscellaneous) {
4615 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n",
4616 (intptr_t)polling_page);
4617 }
4618 #endif
4619
4620 if (!UseMembar) {
4621 address mem_serialize_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE);
4622 guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
4623 os::set_memory_serialize_page(mem_serialize_page);
4624
4625 #ifndef PRODUCT
4626 if (Verbose && PrintMiscellaneous) {
4627 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n",
4628 (intptr_t)mem_serialize_page);
4629 }
4630 #endif
4631 }
4632
4633 // Check minimum allowable stack size for thread creation and to initialize
4634 // the java system classes, including StackOverflowError - depends on page
4635 // size. Add a page for compiler2 recursion in main thread.
4636 // Add in 2*BytesPerWord times page size to account for VM stack during
4637 // class initialization depending on 32 or 64 bit VM.
4638 os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed,
4639 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
4640 2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size);
4641
4642 size_t threadStackSizeInBytes = ThreadStackSize * K;
4643 if (threadStackSizeInBytes != 0 &&
4644 threadStackSizeInBytes < os::Solaris::min_stack_allowed) {
4645 tty->print_cr("\nThe stack size specified is too small, Specify at least %dk",
4646 os::Solaris::min_stack_allowed/K);
4647 return JNI_ERR;
4648 }
4649
4650 // For 64kbps there will be a 64kb page size, which makes
4651 // the usable default stack size quite a bit less. Increase the
4652 // stack for 64kb (or any > than 8kb) pages, this increases
4653 // virtual memory fragmentation (since we're not creating the
4654 // stack on a power of 2 boundary. The real fix for this
4655 // should be to fix the guard page mechanism.
4656
4657 if (vm_page_size() > 8*K) {
4658 threadStackSizeInBytes = (threadStackSizeInBytes != 0)
4659 ? threadStackSizeInBytes +
4660 ((StackYellowPages + StackRedPages) * vm_page_size())
4661 : 0;
4662 ThreadStackSize = threadStackSizeInBytes/K;
4663 }
4664
4665 // Make the stack size a multiple of the page size so that
4666 // the yellow/red zones can be guarded.
4667 JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
4668 vm_page_size()));
4669
4670 Solaris::libthread_init();
4671
4672 if (UseNUMA) {
4673 if (!Solaris::liblgrp_init()) {
4674 UseNUMA = false;
4675 } else {
4676 size_t lgrp_limit = os::numa_get_groups_num();
4677 int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtInternal);
4678 size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit);
4679 FREE_C_HEAP_ARRAY(int, lgrp_ids);
4680 if (lgrp_num < 2) {
4681 // There's only one locality group, disable NUMA.
4682 UseNUMA = false;
4683 }
4684 }
4685 if (!UseNUMA && ForceNUMA) {
4686 UseNUMA = true;
4687 }
4688 }
4689
4690 Solaris::signal_sets_init();
4691 Solaris::init_signal_mem();
4692 Solaris::install_signal_handlers();
4693
4694 if (libjsigversion < JSIG_VERSION_1_4_1) {
4695 Maxlibjsigsigs = OLDMAXSIGNUM;
4696 }
4697
4698 // initialize synchronization primitives to use either thread or
4699 // lwp synchronization (controlled by UseLWPSynchronization)
4700 Solaris::synchronization_init();
4701
4702 if (MaxFDLimit) {
4703 // set the number of file descriptors to max. print out error
4704 // if getrlimit/setrlimit fails but continue regardless.
4705 struct rlimit nbr_files;
4706 int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
4707 if (status != 0) {
4708 if (PrintMiscellaneous && (Verbose || WizardMode)) {
4709 perror("os::init_2 getrlimit failed");
4710 }
4711 } else {
4712 nbr_files.rlim_cur = nbr_files.rlim_max;
4713 status = setrlimit(RLIMIT_NOFILE, &nbr_files);
4714 if (status != 0) {
4715 if (PrintMiscellaneous && (Verbose || WizardMode)) {
4716 perror("os::init_2 setrlimit failed");
4717 }
4718 }
4719 }
4720 }
4721
4722 // Calculate theoretical max. size of Threads to guard gainst
4723 // artifical out-of-memory situations, where all available address-
4724 // space has been reserved by thread stacks. Default stack size is 1Mb.
4725 size_t pre_thread_stack_size = (JavaThread::stack_size_at_create()) ?
4726 JavaThread::stack_size_at_create() : (1*K*K);
4727 assert(pre_thread_stack_size != 0, "Must have a stack");
4728 // Solaris has a maximum of 4Gb of user programs. Calculate the thread limit when
4729 // we should start doing Virtual Memory banging. Currently when the threads will
4730 // have used all but 200Mb of space.
4731 size_t max_address_space = ((unsigned int)4 * K * K * K) - (200 * K * K);
4732 Solaris::_os_thread_limit = max_address_space / pre_thread_stack_size;
4733
4734 // at-exit methods are called in the reverse order of their registration.
4735 // In Solaris 7 and earlier, atexit functions are called on return from
4736 // main or as a result of a call to exit(3C). There can be only 32 of
4737 // these functions registered and atexit() does not set errno. In Solaris
4738 // 8 and later, there is no limit to the number of functions registered
4739 // and atexit() sets errno. In addition, in Solaris 8 and later, atexit
4740 // functions are called upon dlclose(3DL) in addition to return from main
4741 // and exit(3C).
4742
4743 if (PerfAllowAtExitRegistration) {
4744 // only register atexit functions if PerfAllowAtExitRegistration is set.
4745 // atexit functions can be delayed until process exit time, which
4746 // can be problematic for embedded VM situations. Embedded VMs should
4747 // call DestroyJavaVM() to assure that VM resources are released.
4748
4749 // note: perfMemory_exit_helper atexit function may be removed in
4750 // the future if the appropriate cleanup code can be added to the
4751 // VM_Exit VMOperation's doit method.
4752 if (atexit(perfMemory_exit_helper) != 0) {
4753 warning("os::init2 atexit(perfMemory_exit_helper) failed");
4754 }
4755 }
4756
4757 // Init pset_loadavg function pointer
4758 init_pset_getloadavg_ptr();
4759
4760 return JNI_OK;
4761 }
4762
4763 // Mark the polling page as unreadable
4764 void os::make_polling_page_unreadable(void) {
4765 if (mprotect((char *)_polling_page, page_size, PROT_NONE) != 0) {
4766 fatal("Could not disable polling page");
4767 }
4768 }
4769
4770 // Mark the polling page as readable
4771 void os::make_polling_page_readable(void) {
4772 if (mprotect((char *)_polling_page, page_size, PROT_READ) != 0) {
4773 fatal("Could not enable polling page");
4774 }
4775 }
4776
4777 // OS interface.
4778
4779 bool os::check_heap(bool force) { return true; }
4780
4781 // Is a (classpath) directory empty?
4782 bool os::dir_is_empty(const char* path) {
4783 DIR *dir = NULL;
4784 struct dirent *ptr;
4785
4786 dir = opendir(path);
4787 if (dir == NULL) return true;
4788
4789 // Scan the directory
4790 bool result = true;
4791 char buf[sizeof(struct dirent) + MAX_PATH];
4792 struct dirent *dbuf = (struct dirent *) buf;
4793 while (result && (ptr = readdir(dir, dbuf)) != NULL) {
4794 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
4795 result = false;
4796 }
4797 }
4798 closedir(dir);
4799 return result;
4800 }
4801
4802 // This code originates from JDK's sysOpen and open64_w
4803 // from src/solaris/hpi/src/system_md.c
4804
4805 int os::open(const char *path, int oflag, int mode) {
4806 if (strlen(path) > MAX_PATH - 1) {
4807 errno = ENAMETOOLONG;
4808 return -1;
4809 }
4810 int fd;
4811
4812 fd = ::open64(path, oflag, mode);
4813 if (fd == -1) return -1;
4814
4815 // If the open succeeded, the file might still be a directory
4816 {
4817 struct stat64 buf64;
4818 int ret = ::fstat64(fd, &buf64);
4819 int st_mode = buf64.st_mode;
4820
4821 if (ret != -1) {
4822 if ((st_mode & S_IFMT) == S_IFDIR) {
4823 errno = EISDIR;
4824 ::close(fd);
4825 return -1;
4826 }
4827 } else {
4828 ::close(fd);
4829 return -1;
4830 }
4831 }
4832
4833 // 32-bit Solaris systems suffer from:
4834 //
4835 // - an historical default soft limit of 256 per-process file
4836 // descriptors that is too low for many Java programs.
4837 //
4838 // - a design flaw where file descriptors created using stdio
4839 // fopen must be less than 256, _even_ when the first limit above
4840 // has been raised. This can cause calls to fopen (but not calls to
4841 // open, for example) to fail mysteriously, perhaps in 3rd party
4842 // native code (although the JDK itself uses fopen). One can hardly
4843 // criticize them for using this most standard of all functions.
4844 //
4845 // We attempt to make everything work anyways by:
4846 //
4847 // - raising the soft limit on per-process file descriptors beyond
4848 // 256
4849 //
4850 // - As of Solaris 10u4, we can request that Solaris raise the 256
4851 // stdio fopen limit by calling function enable_extended_FILE_stdio.
4852 // This is done in init_2 and recorded in enabled_extended_FILE_stdio
4853 //
4854 // - If we are stuck on an old (pre 10u4) Solaris system, we can
4855 // workaround the bug by remapping non-stdio file descriptors below
4856 // 256 to ones beyond 256, which is done below.
4857 //
4858 // See:
4859 // 1085341: 32-bit stdio routines should support file descriptors >255
4860 // 6533291: Work around 32-bit Solaris stdio limit of 256 open files
4861 // 6431278: Netbeans crash on 32 bit Solaris: need to call
4862 // enable_extended_FILE_stdio() in VM initialisation
4863 // Giri Mandalika's blog
4864 // http://technopark02.blogspot.com/2005_05_01_archive.html
4865 //
4866 #ifndef _LP64
4867 if ((!enabled_extended_FILE_stdio) && fd < 256) {
4868 int newfd = ::fcntl(fd, F_DUPFD, 256);
4869 if (newfd != -1) {
4870 ::close(fd);
4871 fd = newfd;
4872 }
4873 }
4874 #endif // 32-bit Solaris
4875
4876 // All file descriptors that are opened in the JVM and not
4877 // specifically destined for a subprocess should have the
4878 // close-on-exec flag set. If we don't set it, then careless 3rd
4879 // party native code might fork and exec without closing all
4880 // appropriate file descriptors (e.g. as we do in closeDescriptors in
4881 // UNIXProcess.c), and this in turn might:
4882 //
4883 // - cause end-of-file to fail to be detected on some file
4884 // descriptors, resulting in mysterious hangs, or
4885 //
4886 // - might cause an fopen in the subprocess to fail on a system
4887 // suffering from bug 1085341.
4888 //
4889 // (Yes, the default setting of the close-on-exec flag is a Unix
4890 // design flaw)
4891 //
4892 // See:
4893 // 1085341: 32-bit stdio routines should support file descriptors >255
4894 // 4843136: (process) pipe file descriptor from Runtime.exec not being closed
4895 // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
4896 //
4897 #ifdef FD_CLOEXEC
4898 {
4899 int flags = ::fcntl(fd, F_GETFD);
4900 if (flags != -1) {
4901 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
4902 }
4903 }
4904 #endif
4905
4906 return fd;
4907 }
4908
4909 // create binary file, rewriting existing file if required
4910 int os::create_binary_file(const char* path, bool rewrite_existing) {
4911 int oflags = O_WRONLY | O_CREAT;
4912 if (!rewrite_existing) {
4913 oflags |= O_EXCL;
4914 }
4915 return ::open64(path, oflags, S_IREAD | S_IWRITE);
4916 }
4917
4918 // return current position of file pointer
4919 jlong os::current_file_offset(int fd) {
4920 return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
4921 }
4922
4923 // move file pointer to the specified offset
4924 jlong os::seek_to_file_offset(int fd, jlong offset) {
4925 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
4926 }
4927
4928 jlong os::lseek(int fd, jlong offset, int whence) {
4929 return (jlong) ::lseek64(fd, offset, whence);
4930 }
4931
4932 char * os::native_path(char *path) {
4933 return path;
4934 }
4935
4936 int os::ftruncate(int fd, jlong length) {
4937 return ::ftruncate64(fd, length);
4938 }
4939
4940 int os::fsync(int fd) {
4941 RESTARTABLE_RETURN_INT(::fsync(fd));
4942 }
4943
4944 int os::available(int fd, jlong *bytes) {
4945 assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
4946 "Assumed _thread_in_native");
4947 jlong cur, end;
4948 int mode;
4949 struct stat64 buf64;
4950
4951 if (::fstat64(fd, &buf64) >= 0) {
4952 mode = buf64.st_mode;
4953 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
4954 int n,ioctl_return;
4955
4956 RESTARTABLE(::ioctl(fd, FIONREAD, &n), ioctl_return);
4957 if (ioctl_return>= 0) {
4958 *bytes = n;
4959 return 1;
4960 }
4961 }
4962 }
4963 if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
4964 return 0;
4965 } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
4966 return 0;
4967 } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
4968 return 0;
4969 }
4970 *bytes = end - cur;
4971 return 1;
4972 }
4973
4974 // Map a block of memory.
4975 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4976 char *addr, size_t bytes, bool read_only,
4977 bool allow_exec) {
4978 int prot;
4979 int flags;
4980
4981 if (read_only) {
4982 prot = PROT_READ;
4983 flags = MAP_SHARED;
4984 } else {
4985 prot = PROT_READ | PROT_WRITE;
4986 flags = MAP_PRIVATE;
4987 }
4988
4989 if (allow_exec) {
4990 prot |= PROT_EXEC;
4991 }
4992
4993 if (addr != NULL) {
4994 flags |= MAP_FIXED;
4995 }
4996
4997 char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags,
4998 fd, file_offset);
4999 if (mapped_address == MAP_FAILED) {
5000 return NULL;
5001 }
5002 return mapped_address;
5003 }
5004
5005
5006 // Remap a block of memory.
5007 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
5008 char *addr, size_t bytes, bool read_only,
5009 bool allow_exec) {
5010 // same as map_memory() on this OS
5011 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
5012 allow_exec);
5013 }
5014
5015
5016 // Unmap a block of memory.
5017 bool os::pd_unmap_memory(char* addr, size_t bytes) {
5018 return munmap(addr, bytes) == 0;
5019 }
5020
5021 void os::pause() {
5022 char filename[MAX_PATH];
5023 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
5024 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
5025 } else {
5026 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
5027 }
5028
5029 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
5030 if (fd != -1) {
5031 struct stat buf;
5032 ::close(fd);
5033 while (::stat(filename, &buf) == 0) {
5034 (void)::poll(NULL, 0, 100);
5035 }
5036 } else {
5037 jio_fprintf(stderr,
5038 "Could not open pause file '%s', continuing immediately.\n", filename);
5039 }
5040 }
5041
5042 #ifndef PRODUCT
5043 #ifdef INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5044 // Turn this on if you need to trace synch operations.
5045 // Set RECORD_SYNCH_LIMIT to a large-enough value,
5046 // and call record_synch_enable and record_synch_disable
5047 // around the computation of interest.
5048
5049 void record_synch(char* name, bool returning); // defined below
5050
5051 class RecordSynch {
5052 char* _name;
5053 public:
5054 RecordSynch(char* name) :_name(name) { record_synch(_name, false); }
5055 ~RecordSynch() { record_synch(_name, true); }
5056 };
5057
5058 #define CHECK_SYNCH_OP(ret, name, params, args, inner) \
5059 extern "C" ret name params { \
5060 typedef ret name##_t params; \
5061 static name##_t* implem = NULL; \
5062 static int callcount = 0; \
5063 if (implem == NULL) { \
5064 implem = (name##_t*) dlsym(RTLD_NEXT, #name); \
5065 if (implem == NULL) fatal(dlerror()); \
5066 } \
5067 ++callcount; \
5068 RecordSynch _rs(#name); \
5069 inner; \
5070 return implem args; \
5071 }
5072 // in dbx, examine callcounts this way:
5073 // for n in $(eval whereis callcount | awk '{print $2}'); do print $n; done
5074
5075 #define CHECK_POINTER_OK(p) \
5076 (!Universe::is_fully_initialized() || !Universe::is_reserved_heap((oop)(p)))
5077 #define CHECK_MU \
5078 if (!CHECK_POINTER_OK(mu)) fatal("Mutex must be in C heap only.");
5079 #define CHECK_CV \
5080 if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only.");
5081 #define CHECK_P(p) \
5082 if (!CHECK_POINTER_OK(p)) fatal(false, "Pointer must be in C heap only.");
5083
5084 #define CHECK_MUTEX(mutex_op) \
5085 CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU);
5086
5087 CHECK_MUTEX( mutex_lock)
5088 CHECK_MUTEX( _mutex_lock)
5089 CHECK_MUTEX( mutex_unlock)
5090 CHECK_MUTEX(_mutex_unlock)
5091 CHECK_MUTEX( mutex_trylock)
5092 CHECK_MUTEX(_mutex_trylock)
5093
5094 #define CHECK_COND(cond_op) \
5095 CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU; CHECK_CV);
5096
5097 CHECK_COND( cond_wait);
5098 CHECK_COND(_cond_wait);
5099 CHECK_COND(_cond_wait_cancel);
5100
5101 #define CHECK_COND2(cond_op) \
5102 CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU; CHECK_CV);
5103
5104 CHECK_COND2( cond_timedwait);
5105 CHECK_COND2(_cond_timedwait);
5106 CHECK_COND2(_cond_timedwait_cancel);
5107
5108 // do the _lwp_* versions too
5109 #define mutex_t lwp_mutex_t
5110 #define cond_t lwp_cond_t
5111 CHECK_MUTEX( _lwp_mutex_lock)
5112 CHECK_MUTEX( _lwp_mutex_unlock)
5113 CHECK_MUTEX( _lwp_mutex_trylock)
5114 CHECK_MUTEX( __lwp_mutex_lock)
5115 CHECK_MUTEX( __lwp_mutex_unlock)
5116 CHECK_MUTEX( __lwp_mutex_trylock)
5117 CHECK_MUTEX(___lwp_mutex_lock)
5118 CHECK_MUTEX(___lwp_mutex_unlock)
5119
5120 CHECK_COND( _lwp_cond_wait);
5121 CHECK_COND( __lwp_cond_wait);
5122 CHECK_COND(___lwp_cond_wait);
5123
5124 CHECK_COND2( _lwp_cond_timedwait);
5125 CHECK_COND2( __lwp_cond_timedwait);
5126 #undef mutex_t
5127 #undef cond_t
5128
5129 CHECK_SYNCH_OP(int, _lwp_suspend2, (int lwp, int *n), (lwp, n), 0);
5130 CHECK_SYNCH_OP(int,__lwp_suspend2, (int lwp, int *n), (lwp, n), 0);
5131 CHECK_SYNCH_OP(int, _lwp_kill, (int lwp, int n), (lwp, n), 0);
5132 CHECK_SYNCH_OP(int,__lwp_kill, (int lwp, int n), (lwp, n), 0);
5133 CHECK_SYNCH_OP(int, _lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p));
5134 CHECK_SYNCH_OP(int,__lwp_sema_wait, (lwp_sema_t* p), (p), CHECK_P(p));
5135 CHECK_SYNCH_OP(int, _lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV);
5136 CHECK_SYNCH_OP(int,__lwp_cond_broadcast, (lwp_cond_t* cv), (cv), CHECK_CV);
5137
5138
5139 // recording machinery:
5140
5141 enum { RECORD_SYNCH_LIMIT = 200 };
5142 char* record_synch_name[RECORD_SYNCH_LIMIT];
5143 void* record_synch_arg0ptr[RECORD_SYNCH_LIMIT];
5144 bool record_synch_returning[RECORD_SYNCH_LIMIT];
5145 thread_t record_synch_thread[RECORD_SYNCH_LIMIT];
5146 int record_synch_count = 0;
5147 bool record_synch_enabled = false;
5148
5149 // in dbx, examine recorded data this way:
5150 // for n in name arg0ptr returning thread; do print record_synch_$n[0..record_synch_count-1]; done
5151
5152 void record_synch(char* name, bool returning) {
5153 if (record_synch_enabled) {
5154 if (record_synch_count < RECORD_SYNCH_LIMIT) {
5155 record_synch_name[record_synch_count] = name;
5156 record_synch_returning[record_synch_count] = returning;
5157 record_synch_thread[record_synch_count] = thr_self();
5158 record_synch_arg0ptr[record_synch_count] = &name;
5159 record_synch_count++;
5160 }
5161 // put more checking code here:
5162 // ...
5163 }
5164 }
5165
5166 void record_synch_enable() {
5167 // start collecting trace data, if not already doing so
5168 if (!record_synch_enabled) record_synch_count = 0;
5169 record_synch_enabled = true;
5170 }
5171
5172 void record_synch_disable() {
5173 // stop collecting trace data
5174 record_synch_enabled = false;
5175 }
5176
5177 #endif // INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5178 #endif // PRODUCT
5179
5180 const intptr_t thr_time_off = (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5181 const intptr_t thr_time_size = (intptr_t)(&((prusage_t *)(NULL))->pr_ttime) -
5182 (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5183
5184
5185 // JVMTI & JVM monitoring and management support
5186 // The thread_cpu_time() and current_thread_cpu_time() are only
5187 // supported if is_thread_cpu_time_supported() returns true.
5188 // They are not supported on Solaris T1.
5189
5190 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
5191 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
5192 // of a thread.
5193 //
5194 // current_thread_cpu_time() and thread_cpu_time(Thread *)
5195 // returns the fast estimate available on the platform.
5196
5197 // hrtime_t gethrvtime() return value includes
5198 // user time but does not include system time
5199 jlong os::current_thread_cpu_time() {
5200 return (jlong) gethrvtime();
5201 }
5202
5203 jlong os::thread_cpu_time(Thread *thread) {
5204 // return user level CPU time only to be consistent with
5205 // what current_thread_cpu_time returns.
5206 // thread_cpu_time_info() must be changed if this changes
5207 return os::thread_cpu_time(thread, false /* user time only */);
5208 }
5209
5210 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
5211 if (user_sys_cpu_time) {
5212 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
5213 } else {
5214 return os::current_thread_cpu_time();
5215 }
5216 }
5217
5218 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
5219 char proc_name[64];
5220 int count;
5221 prusage_t prusage;
5222 jlong lwp_time;
5223 int fd;
5224
5225 sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage",
5226 getpid(),
5227 thread->osthread()->lwp_id());
5228 fd = ::open(proc_name, O_RDONLY);
5229 if (fd == -1) return -1;
5230
5231 do {
5232 count = ::pread(fd,
5233 (void *)&prusage.pr_utime,
5234 thr_time_size,
5235 thr_time_off);
5236 } while (count < 0 && errno == EINTR);
5237 ::close(fd);
5238 if (count < 0) return -1;
5239
5240 if (user_sys_cpu_time) {
5241 // user + system CPU time
5242 lwp_time = (((jlong)prusage.pr_stime.tv_sec +
5243 (jlong)prusage.pr_utime.tv_sec) * (jlong)1000000000) +
5244 (jlong)prusage.pr_stime.tv_nsec +
5245 (jlong)prusage.pr_utime.tv_nsec;
5246 } else {
5247 // user level CPU time only
5248 lwp_time = ((jlong)prusage.pr_utime.tv_sec * (jlong)1000000000) +
5249 (jlong)prusage.pr_utime.tv_nsec;
5250 }
5251
5252 return (lwp_time);
5253 }
5254
5255 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5256 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits
5257 info_ptr->may_skip_backward = false; // elapsed time not wall time
5258 info_ptr->may_skip_forward = false; // elapsed time not wall time
5259 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned
5260 }
5261
5262 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5263 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits
5264 info_ptr->may_skip_backward = false; // elapsed time not wall time
5265 info_ptr->may_skip_forward = false; // elapsed time not wall time
5266 info_ptr->kind = JVMTI_TIMER_USER_CPU; // only user time is returned
5267 }
5268
5269 bool os::is_thread_cpu_time_supported() {
5270 return true;
5271 }
5272
5273 // System loadavg support. Returns -1 if load average cannot be obtained.
5274 // Return the load average for our processor set if the primitive exists
5275 // (Solaris 9 and later). Otherwise just return system wide loadavg.
5276 int os::loadavg(double loadavg[], int nelem) {
5277 if (pset_getloadavg_ptr != NULL) {
5278 return (*pset_getloadavg_ptr)(PS_MYID, loadavg, nelem);
5279 } else {
5280 return ::getloadavg(loadavg, nelem);
5281 }
5282 }
5283
5284 //---------------------------------------------------------------------------------
5285
5286 bool os::find(address addr, outputStream* st) {
5287 Dl_info dlinfo;
5288 memset(&dlinfo, 0, sizeof(dlinfo));
5289 if (dladdr(addr, &dlinfo) != 0) {
5290 st->print(PTR_FORMAT ": ", addr);
5291 if (dlinfo.dli_sname != NULL && dlinfo.dli_saddr != NULL) {
5292 st->print("%s+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr);
5293 } else if (dlinfo.dli_fbase != NULL) {
5294 st->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase);
5295 } else {
5296 st->print("<absolute address>");
5297 }
5298 if (dlinfo.dli_fname != NULL) {
5299 st->print(" in %s", dlinfo.dli_fname);
5300 }
5301 if (dlinfo.dli_fbase != NULL) {
5302 st->print(" at " PTR_FORMAT, dlinfo.dli_fbase);
5303 }
5304 st->cr();
5305
5306 if (Verbose) {
5307 // decode some bytes around the PC
5308 address begin = clamp_address_in_page(addr-40, addr, os::vm_page_size());
5309 address end = clamp_address_in_page(addr+40, addr, os::vm_page_size());
5310 address lowest = (address) dlinfo.dli_sname;
5311 if (!lowest) lowest = (address) dlinfo.dli_fbase;
5312 if (begin < lowest) begin = lowest;
5313 Dl_info dlinfo2;
5314 if (dladdr(end, &dlinfo2) != 0 && dlinfo2.dli_saddr != dlinfo.dli_saddr
5315 && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) {
5316 end = (address) dlinfo2.dli_saddr;
5317 }
5318 Disassembler::decode(begin, end, st);
5319 }
5320 return true;
5321 }
5322 return false;
5323 }
5324
5325 // Following function has been added to support HotSparc's libjvm.so running
5326 // under Solaris production JDK 1.2.2 / 1.3.0. These came from
5327 // src/solaris/hpi/native_threads in the EVM codebase.
5328 //
5329 // NOTE: This is no longer needed in the 1.3.1 and 1.4 production release
5330 // libraries and should thus be removed. We will leave it behind for a while
5331 // until we no longer want to able to run on top of 1.3.0 Solaris production
5332 // JDK. See 4341971.
5333
5334 #define STACK_SLACK 0x800
5335
5336 extern "C" {
5337 intptr_t sysThreadAvailableStackWithSlack() {
5338 stack_t st;
5339 intptr_t retval, stack_top;
5340 retval = thr_stksegment(&st);
5341 assert(retval == 0, "incorrect return value from thr_stksegment");
5342 assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
5343 assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
5344 stack_top=(intptr_t)st.ss_sp-st.ss_size;
5345 return ((intptr_t)&stack_top - stack_top - STACK_SLACK);
5346 }
5347 }
5348
5349 // ObjectMonitor park-unpark infrastructure ...
5350 //
5351 // We implement Solaris and Linux PlatformEvents with the
5352 // obvious condvar-mutex-flag triple.
5353 // Another alternative that works quite well is pipes:
5354 // Each PlatformEvent consists of a pipe-pair.
5355 // The thread associated with the PlatformEvent
5356 // calls park(), which reads from the input end of the pipe.
5357 // Unpark() writes into the other end of the pipe.
5358 // The write-side of the pipe must be set NDELAY.
5359 // Unfortunately pipes consume a large # of handles.
5360 // Native solaris lwp_park() and lwp_unpark() work nicely, too.
5361 // Using pipes for the 1st few threads might be workable, however.
5362 //
5363 // park() is permitted to return spuriously.
5364 // Callers of park() should wrap the call to park() in
5365 // an appropriate loop. A litmus test for the correct
5366 // usage of park is the following: if park() were modified
5367 // to immediately return 0 your code should still work,
5368 // albeit degenerating to a spin loop.
5369 //
5370 // In a sense, park()-unpark() just provides more polite spinning
5371 // and polling with the key difference over naive spinning being
5372 // that a parked thread needs to be explicitly unparked() in order
5373 // to wake up and to poll the underlying condition.
5374 //
5375 // Assumption:
5376 // Only one parker can exist on an event, which is why we allocate
5377 // them per-thread. Multiple unparkers can coexist.
5378 //
5379 // _Event transitions in park()
5380 // -1 => -1 : illegal
5381 // 1 => 0 : pass - return immediately
5382 // 0 => -1 : block; then set _Event to 0 before returning
5383 //
5384 // _Event transitions in unpark()
5385 // 0 => 1 : just return
5386 // 1 => 1 : just return
5387 // -1 => either 0 or 1; must signal target thread
5388 // That is, we can safely transition _Event from -1 to either
5389 // 0 or 1.
5390 //
5391 // _Event serves as a restricted-range semaphore.
5392 // -1 : thread is blocked, i.e. there is a waiter
5393 // 0 : neutral: thread is running or ready,
5394 // could have been signaled after a wait started
5395 // 1 : signaled - thread is running or ready
5396 //
5397 // Another possible encoding of _Event would be with
5398 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5399 //
5400 // TODO-FIXME: add DTRACE probes for:
5401 // 1. Tx parks
5402 // 2. Ty unparks Tx
5403 // 3. Tx resumes from park
5404
5405
5406 // value determined through experimentation
5407 #define ROUNDINGFIX 11
5408
5409 // utility to compute the abstime argument to timedwait.
5410 // TODO-FIXME: switch from compute_abstime() to unpackTime().
5411
5412 static timestruc_t* compute_abstime(timestruc_t* abstime, jlong millis) {
5413 // millis is the relative timeout time
5414 // abstime will be the absolute timeout time
5415 if (millis < 0) millis = 0;
5416 struct timeval now;
5417 int status = gettimeofday(&now, NULL);
5418 assert(status == 0, "gettimeofday");
5419 jlong seconds = millis / 1000;
5420 jlong max_wait_period;
5421
5422 if (UseLWPSynchronization) {
5423 // forward port of fix for 4275818 (not sleeping long enough)
5424 // There was a bug in Solaris 6, 7 and pre-patch 5 of 8 where
5425 // _lwp_cond_timedwait() used a round_down algorithm rather
5426 // than a round_up. For millis less than our roundfactor
5427 // it rounded down to 0 which doesn't meet the spec.
5428 // For millis > roundfactor we may return a bit sooner, but
5429 // since we can not accurately identify the patch level and
5430 // this has already been fixed in Solaris 9 and 8 we will
5431 // leave it alone rather than always rounding down.
5432
5433 if (millis > 0 && millis < ROUNDINGFIX) millis = ROUNDINGFIX;
5434 // It appears that when we go directly through Solaris _lwp_cond_timedwait()
5435 // the acceptable max time threshold is smaller than for libthread on 2.5.1 and 2.6
5436 max_wait_period = 21000000;
5437 } else {
5438 max_wait_period = 50000000;
5439 }
5440 millis %= 1000;
5441 if (seconds > max_wait_period) { // see man cond_timedwait(3T)
5442 seconds = max_wait_period;
5443 }
5444 abstime->tv_sec = now.tv_sec + seconds;
5445 long usec = now.tv_usec + millis * 1000;
5446 if (usec >= 1000000) {
5447 abstime->tv_sec += 1;
5448 usec -= 1000000;
5449 }
5450 abstime->tv_nsec = usec * 1000;
5451 return abstime;
5452 }
5453
5454 void os::PlatformEvent::park() { // AKA: down()
5455 // Transitions for _Event:
5456 // -1 => -1 : illegal
5457 // 1 => 0 : pass - return immediately
5458 // 0 => -1 : block; then set _Event to 0 before returning
5459
5460 // Invariant: Only the thread associated with the Event/PlatformEvent
5461 // may call park().
5462 assert(_nParked == 0, "invariant");
5463
5464 int v;
5465 for (;;) {
5466 v = _Event;
5467 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5468 }
5469 guarantee(v >= 0, "invariant");
5470 if (v == 0) {
5471 // Do this the hard way by blocking ...
5472 // See http://monaco.sfbay/detail.jsf?cr=5094058.
5473 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
5474 // Only for SPARC >= V8PlusA
5475 #if defined(__sparc) && defined(COMPILER2)
5476 if (ClearFPUAtPark) { _mark_fpu_nosave(); }
5477 #endif
5478 int status = os::Solaris::mutex_lock(_mutex);
5479 assert_status(status == 0, status, "mutex_lock");
5480 guarantee(_nParked == 0, "invariant");
5481 ++_nParked;
5482 while (_Event < 0) {
5483 // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
5484 // Treat this the same as if the wait was interrupted
5485 // With usr/lib/lwp going to kernel, always handle ETIME
5486 status = os::Solaris::cond_wait(_cond, _mutex);
5487 if (status == ETIME) status = EINTR;
5488 assert_status(status == 0 || status == EINTR, status, "cond_wait");
5489 }
5490 --_nParked;
5491 _Event = 0;
5492 status = os::Solaris::mutex_unlock(_mutex);
5493 assert_status(status == 0, status, "mutex_unlock");
5494 // Paranoia to ensure our locked and lock-free paths interact
5495 // correctly with each other.
5496 OrderAccess::fence();
5497 }
5498 }
5499
5500 int os::PlatformEvent::park(jlong millis) {
5501 // Transitions for _Event:
5502 // -1 => -1 : illegal
5503 // 1 => 0 : pass - return immediately
5504 // 0 => -1 : block; then set _Event to 0 before returning
5505
5506 guarantee(_nParked == 0, "invariant");
5507 int v;
5508 for (;;) {
5509 v = _Event;
5510 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5511 }
5512 guarantee(v >= 0, "invariant");
5513 if (v != 0) return OS_OK;
5514
5515 int ret = OS_TIMEOUT;
5516 timestruc_t abst;
5517 compute_abstime(&abst, millis);
5518
5519 // See http://monaco.sfbay/detail.jsf?cr=5094058.
5520 // For Solaris SPARC set fprs.FEF=0 prior to parking.
5521 // Only for SPARC >= V8PlusA
5522 #if defined(__sparc) && defined(COMPILER2)
5523 if (ClearFPUAtPark) { _mark_fpu_nosave(); }
5524 #endif
5525 int status = os::Solaris::mutex_lock(_mutex);
5526 assert_status(status == 0, status, "mutex_lock");
5527 guarantee(_nParked == 0, "invariant");
5528 ++_nParked;
5529 while (_Event < 0) {
5530 int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst);
5531 assert_status(status == 0 || status == EINTR ||
5532 status == ETIME || status == ETIMEDOUT,
5533 status, "cond_timedwait");
5534 if (!FilterSpuriousWakeups) break; // previous semantics
5535 if (status == ETIME || status == ETIMEDOUT) break;
5536 // We consume and ignore EINTR and spurious wakeups.
5537 }
5538 --_nParked;
5539 if (_Event >= 0) ret = OS_OK;
5540 _Event = 0;
5541 status = os::Solaris::mutex_unlock(_mutex);
5542 assert_status(status == 0, status, "mutex_unlock");
5543 // Paranoia to ensure our locked and lock-free paths interact
5544 // correctly with each other.
5545 OrderAccess::fence();
5546 return ret;
5547 }
5548
5549 void os::PlatformEvent::unpark() {
5550 // Transitions for _Event:
5551 // 0 => 1 : just return
5552 // 1 => 1 : just return
5553 // -1 => either 0 or 1; must signal target thread
5554 // That is, we can safely transition _Event from -1 to either
5555 // 0 or 1.
5556 // See also: "Semaphores in Plan 9" by Mullender & Cox
5557 //
5558 // Note: Forcing a transition from "-1" to "1" on an unpark() means
5559 // that it will take two back-to-back park() calls for the owning
5560 // thread to block. This has the benefit of forcing a spurious return
5561 // from the first park() call after an unpark() call which will help
5562 // shake out uses of park() and unpark() without condition variables.
5563
5564 if (Atomic::xchg(1, &_Event) >= 0) return;
5565
5566 // If the thread associated with the event was parked, wake it.
5567 // Wait for the thread assoc with the PlatformEvent to vacate.
5568 int status = os::Solaris::mutex_lock(_mutex);
5569 assert_status(status == 0, status, "mutex_lock");
5570 int AnyWaiters = _nParked;
5571 status = os::Solaris::mutex_unlock(_mutex);
5572 assert_status(status == 0, status, "mutex_unlock");
5573 guarantee(AnyWaiters == 0 || AnyWaiters == 1, "invariant");
5574 if (AnyWaiters != 0) {
5575 // Note that we signal() *after* dropping the lock for "immortal" Events.
5576 // This is safe and avoids a common class of futile wakeups. In rare
5577 // circumstances this can cause a thread to return prematurely from
5578 // cond_{timed}wait() but the spurious wakeup is benign and the victim
5579 // will simply re-test the condition and re-park itself.
5580 // This provides particular benefit if the underlying platform does not
5581 // provide wait morphing.
5582 status = os::Solaris::cond_signal(_cond);
5583 assert_status(status == 0, status, "cond_signal");
5584 }
5585 }
5586
5587 // JSR166
5588 // -------------------------------------------------------
5589
5590 // The solaris and linux implementations of park/unpark are fairly
5591 // conservative for now, but can be improved. They currently use a
5592 // mutex/condvar pair, plus _counter.
5593 // Park decrements _counter if > 0, else does a condvar wait. Unpark
5594 // sets count to 1 and signals condvar. Only one thread ever waits
5595 // on the condvar. Contention seen when trying to park implies that someone
5596 // is unparking you, so don't wait. And spurious returns are fine, so there
5597 // is no need to track notifications.
5598
5599 #define MAX_SECS 100000000
5600
5601 // This code is common to linux and solaris and will be moved to a
5602 // common place in dolphin.
5603 //
5604 // The passed in time value is either a relative time in nanoseconds
5605 // or an absolute time in milliseconds. Either way it has to be unpacked
5606 // into suitable seconds and nanoseconds components and stored in the
5607 // given timespec structure.
5608 // Given time is a 64-bit value and the time_t used in the timespec is only
5609 // a signed-32-bit value (except on 64-bit Linux) we have to watch for
5610 // overflow if times way in the future are given. Further on Solaris versions
5611 // prior to 10 there is a restriction (see cond_timedwait) that the specified
5612 // number of seconds, in abstime, is less than current_time + 100,000,000.
5613 // As it will be 28 years before "now + 100000000" will overflow we can
5614 // ignore overflow and just impose a hard-limit on seconds using the value
5615 // of "now + 100,000,000". This places a limit on the timeout of about 3.17
5616 // years from "now".
5617 //
5618 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
5619 assert(time > 0, "convertTime");
5620
5621 struct timeval now;
5622 int status = gettimeofday(&now, NULL);
5623 assert(status == 0, "gettimeofday");
5624
5625 time_t max_secs = now.tv_sec + MAX_SECS;
5626
5627 if (isAbsolute) {
5628 jlong secs = time / 1000;
5629 if (secs > max_secs) {
5630 absTime->tv_sec = max_secs;
5631 } else {
5632 absTime->tv_sec = secs;
5633 }
5634 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
5635 } else {
5636 jlong secs = time / NANOSECS_PER_SEC;
5637 if (secs >= MAX_SECS) {
5638 absTime->tv_sec = max_secs;
5639 absTime->tv_nsec = 0;
5640 } else {
5641 absTime->tv_sec = now.tv_sec + secs;
5642 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
5643 if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
5644 absTime->tv_nsec -= NANOSECS_PER_SEC;
5645 ++absTime->tv_sec; // note: this must be <= max_secs
5646 }
5647 }
5648 }
5649 assert(absTime->tv_sec >= 0, "tv_sec < 0");
5650 assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
5651 assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
5652 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
5653 }
5654
5655 void Parker::park(bool isAbsolute, jlong time) {
5656 // Ideally we'd do something useful while spinning, such
5657 // as calling unpackTime().
5658
5659 // Optional fast-path check:
5660 // Return immediately if a permit is available.
5661 // We depend on Atomic::xchg() having full barrier semantics
5662 // since we are doing a lock-free update to _counter.
5663 if (Atomic::xchg(0, &_counter) > 0) return;
5664
5665 // Optional fast-exit: Check interrupt before trying to wait
5666 Thread* thread = Thread::current();
5667 assert(thread->is_Java_thread(), "Must be JavaThread");
5668 JavaThread *jt = (JavaThread *)thread;
5669 if (Thread::is_interrupted(thread, false)) {
5670 return;
5671 }
5672
5673 // First, demultiplex/decode time arguments
5674 timespec absTime;
5675 if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
5676 return;
5677 }
5678 if (time > 0) {
5679 // Warning: this code might be exposed to the old Solaris time
5680 // round-down bugs. Grep "roundingFix" for details.
5681 unpackTime(&absTime, isAbsolute, time);
5682 }
5683
5684 // Enter safepoint region
5685 // Beware of deadlocks such as 6317397.
5686 // The per-thread Parker:: _mutex is a classic leaf-lock.
5687 // In particular a thread must never block on the Threads_lock while
5688 // holding the Parker:: mutex. If safepoints are pending both the
5689 // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
5690 ThreadBlockInVM tbivm(jt);
5691
5692 // Don't wait if cannot get lock since interference arises from
5693 // unblocking. Also. check interrupt before trying wait
5694 if (Thread::is_interrupted(thread, false) ||
5695 os::Solaris::mutex_trylock(_mutex) != 0) {
5696 return;
5697 }
5698
5699 int status;
5700
5701 if (_counter > 0) { // no wait needed
5702 _counter = 0;
5703 status = os::Solaris::mutex_unlock(_mutex);
5704 assert(status == 0, "invariant");
5705 // Paranoia to ensure our locked and lock-free paths interact
5706 // correctly with each other and Java-level accesses.
5707 OrderAccess::fence();
5708 return;
5709 }
5710
5711 #ifdef ASSERT
5712 // Don't catch signals while blocked; let the running threads have the signals.
5713 // (This allows a debugger to break into the running thread.)
5714 sigset_t oldsigs;
5715 sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals();
5716 thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
5717 #endif
5718
5719 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5720 jt->set_suspend_equivalent();
5721 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
5722
5723 // Do this the hard way by blocking ...
5724 // See http://monaco.sfbay/detail.jsf?cr=5094058.
5725 // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
5726 // Only for SPARC >= V8PlusA
5727 #if defined(__sparc) && defined(COMPILER2)
5728 if (ClearFPUAtPark) { _mark_fpu_nosave(); }
5729 #endif
5730
5731 if (time == 0) {
5732 status = os::Solaris::cond_wait(_cond, _mutex);
5733 } else {
5734 status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);
5735 }
5736 // Note that an untimed cond_wait() can sometimes return ETIME on older
5737 // versions of the Solaris.
5738 assert_status(status == 0 || status == EINTR ||
5739 status == ETIME || status == ETIMEDOUT,
5740 status, "cond_timedwait");
5741
5742 #ifdef ASSERT
5743 thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
5744 #endif
5745 _counter = 0;
5746 status = os::Solaris::mutex_unlock(_mutex);
5747 assert_status(status == 0, status, "mutex_unlock");
5748 // Paranoia to ensure our locked and lock-free paths interact
5749 // correctly with each other and Java-level accesses.
5750 OrderAccess::fence();
5751
5752 // If externally suspended while waiting, re-suspend
5753 if (jt->handle_special_suspend_equivalent_condition()) {
5754 jt->java_suspend_self();
5755 }
5756 }
5757
5758 void Parker::unpark() {
5759 int status = os::Solaris::mutex_lock(_mutex);
5760 assert(status == 0, "invariant");
5761 const int s = _counter;
5762 _counter = 1;
5763 status = os::Solaris::mutex_unlock(_mutex);
5764 assert(status == 0, "invariant");
5765
5766 if (s < 1) {
5767 status = os::Solaris::cond_signal(_cond);
5768 assert(status == 0, "invariant");
5769 }
5770 }
5771
5772 extern char** environ;
5773
5774 // Run the specified command in a separate process. Return its exit value,
5775 // or -1 on failure (e.g. can't fork a new process).
5776 // Unlike system(), this function can be called from signal handler. It
5777 // doesn't block SIGINT et al.
5778 int os::fork_and_exec(char* cmd) {
5779 char * argv[4];
5780 argv[0] = (char *)"sh";
5781 argv[1] = (char *)"-c";
5782 argv[2] = cmd;
5783 argv[3] = NULL;
5784
5785 // fork is async-safe, fork1 is not so can't use in signal handler
5786 pid_t pid;
5787 Thread* t = ThreadLocalStorage::get_thread_slow();
5788 if (t != NULL && t->is_inside_signal_handler()) {
5789 pid = fork();
5790 } else {
5791 pid = fork1();
5792 }
5793
5794 if (pid < 0) {
5795 // fork failed
5796 warning("fork failed: %s", strerror(errno));
5797 return -1;
5798
5799 } else if (pid == 0) {
5800 // child process
5801
5802 // try to be consistent with system(), which uses "/usr/bin/sh" on Solaris
5803 execve("/usr/bin/sh", argv, environ);
5804
5805 // execve failed
5806 _exit(-1);
5807
5808 } else {
5809 // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
5810 // care about the actual exit code, for now.
5811
5812 int status;
5813
5814 // Wait for the child process to exit. This returns immediately if
5815 // the child has already exited. */
5816 while (waitpid(pid, &status, 0) < 0) {
5817 switch (errno) {
5818 case ECHILD: return 0;
5819 case EINTR: break;
5820 default: return -1;
5821 }
5822 }
5823
5824 if (WIFEXITED(status)) {
5825 // The child exited normally; get its exit code.
5826 return WEXITSTATUS(status);
5827 } else if (WIFSIGNALED(status)) {
5828 // The child exited because of a signal
5829 // The best value to return is 0x80 + signal number,
5830 // because that is what all Unix shells do, and because
5831 // it allows callers to distinguish between process exit and
5832 // process death by signal.
5833 return 0x80 + WTERMSIG(status);
5834 } else {
5835 // Unknown exit code; pass it through
5836 return status;
5837 }
5838 }
5839 }
5840
5841 // is_headless_jre()
5842 //
5843 // Test for the existence of xawt/libmawt.so or libawt_xawt.so
5844 // in order to report if we are running in a headless jre
5845 //
5846 // Since JDK8 xawt/libmawt.so was moved into the same directory
5847 // as libawt.so, and renamed libawt_xawt.so
5848 //
5849 bool os::is_headless_jre() {
5850 struct stat statbuf;
5851 char buf[MAXPATHLEN];
5852 char libmawtpath[MAXPATHLEN];
5853 const char *xawtstr = "/xawt/libmawt.so";
5854 const char *new_xawtstr = "/libawt_xawt.so";
5855 char *p;
5856
5857 // Get path to libjvm.so
5858 os::jvm_path(buf, sizeof(buf));
5859
5860 // Get rid of libjvm.so
5861 p = strrchr(buf, '/');
5862 if (p == NULL) {
5863 return false;
5864 } else {
5865 *p = '\0';
5866 }
5867
5868 // Get rid of client or server
5869 p = strrchr(buf, '/');
5870 if (p == NULL) {
5871 return false;
5872 } else {
5873 *p = '\0';
5874 }
5875
5876 // check xawt/libmawt.so
5877 strcpy(libmawtpath, buf);
5878 strcat(libmawtpath, xawtstr);
5879 if (::stat(libmawtpath, &statbuf) == 0) return false;
5880
5881 // check libawt_xawt.so
5882 strcpy(libmawtpath, buf);
5883 strcat(libmawtpath, new_xawtstr);
5884 if (::stat(libmawtpath, &statbuf) == 0) return false;
5885
5886 return true;
5887 }
5888
5889 size_t os::write(int fd, const void *buf, unsigned int nBytes) {
5890 size_t res;
5891 assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
5892 "Assumed _thread_in_native");
5893 RESTARTABLE((size_t) ::write(fd, buf, (size_t) nBytes), res);
5894 return res;
5895 }
5896
5897 int os::close(int fd) {
5898 return ::close(fd);
5899 }
5900
5901 int os::socket_close(int fd) {
5902 return ::close(fd);
5903 }
5904
5905 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5906 assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
5907 "Assumed _thread_in_native");
5908 RESTARTABLE_RETURN_INT((int)::recv(fd, buf, nBytes, flags));
5909 }
5910
5911 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5912 assert(((JavaThread*)Thread::current())->thread_state() == _thread_in_native,
5913 "Assumed _thread_in_native");
5914 RESTARTABLE_RETURN_INT((int)::send(fd, buf, nBytes, flags));
5915 }
5916
5917 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5918 RESTARTABLE_RETURN_INT((int)::send(fd, buf, nBytes, flags));
5919 }
5920
5921 // As both poll and select can be interrupted by signals, we have to be
5922 // prepared to restart the system call after updating the timeout, unless
5923 // a poll() is done with timeout == -1, in which case we repeat with this
5924 // "wait forever" value.
5925
5926 int os::connect(int fd, struct sockaddr *him, socklen_t len) {
5927 int _result;
5928 _result = ::connect(fd, him, len);
5929
5930 // On Solaris, when a connect() call is interrupted, the connection
5931 // can be established asynchronously (see 6343810). Subsequent calls
5932 // to connect() must check the errno value which has the semantic
5933 // described below (copied from the connect() man page). Handling
5934 // of asynchronously established connections is required for both
5935 // blocking and non-blocking sockets.
5936 // EINTR The connection attempt was interrupted
5937 // before any data arrived by the delivery of
5938 // a signal. The connection, however, will be
5939 // established asynchronously.
5940 //
5941 // EINPROGRESS The socket is non-blocking, and the connec-
5942 // tion cannot be completed immediately.
5943 //
5944 // EALREADY The socket is non-blocking, and a previous
5945 // connection attempt has not yet been com-
5946 // pleted.
5947 //
5948 // EISCONN The socket is already connected.
5949 if (_result == OS_ERR && errno == EINTR) {
5950 // restarting a connect() changes its errno semantics
5951 RESTARTABLE(::connect(fd, him, len), _result);
5952 // undo these changes
5953 if (_result == OS_ERR) {
5954 if (errno == EALREADY) {
5955 errno = EINPROGRESS; // fall through
5956 } else if (errno == EISCONN) {
5957 errno = 0;
5958 return OS_OK;
5959 }
5960 }
5961 }
5962 return _result;
5963 }
5964
5965 // Get the default path to the core file
5966 // Returns the length of the string
5967 int os::get_core_path(char* buffer, size_t bufferSize) {
5968 const char* p = get_current_directory(buffer, bufferSize);
5969
5970 if (p == NULL) {
5971 assert(p != NULL, "failed to get current directory");
5972 return 0;
5973 }
5974
5975 jio_snprintf(buffer, bufferSize, "%s/core or core.%d",
5976 p, current_process_id());
5977
5978 return strlen(buffer);
5979 }
5980
5981 #ifndef PRODUCT
5982 void TestReserveMemorySpecial_test() {
5983 // No tests available for this platform
5984 }
5985 #endif