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