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