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