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