1 /* 2 * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2012, 2016 SAP SE. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 // According to the AIX OS doc #pragma alloca must be used 27 // with C++ compiler before referencing the function alloca() 28 #pragma alloca 29 30 // no precompiled headers 31 #include "classfile/classLoader.hpp" 32 #include "classfile/systemDictionary.hpp" 33 #include "classfile/vmSymbols.hpp" 34 #include "code/icBuffer.hpp" 35 #include "code/vtableStubs.hpp" 36 #include "compiler/compileBroker.hpp" 37 #include "interpreter/interpreter.hpp" 38 #include "jvm_aix.h" 39 #include "logging/log.hpp" 40 #include "libo4.hpp" 41 #include "libperfstat_aix.hpp" 42 #include "libodm_aix.hpp" 43 #include "loadlib_aix.hpp" 44 #include "memory/allocation.inline.hpp" 45 #include "memory/filemap.hpp" 46 #include "misc_aix.hpp" 47 #include "oops/oop.inline.hpp" 48 #include "os_aix.inline.hpp" 49 #include "os_share_aix.hpp" 50 #include "porting_aix.hpp" 51 #include "prims/jniFastGetField.hpp" 52 #include "prims/jvm.h" 53 #include "prims/jvm_misc.hpp" 54 #include "runtime/arguments.hpp" 55 #include "runtime/atomic.hpp" 56 #include "runtime/extendedPC.hpp" 57 #include "runtime/globals.hpp" 58 #include "runtime/interfaceSupport.hpp" 59 #include "runtime/java.hpp" 60 #include "runtime/javaCalls.hpp" 61 #include "runtime/mutexLocker.hpp" 62 #include "runtime/objectMonitor.hpp" 63 #include "runtime/orderAccess.inline.hpp" 64 #include "runtime/os.hpp" 65 #include "runtime/osThread.hpp" 66 #include "runtime/perfMemory.hpp" 67 #include "runtime/sharedRuntime.hpp" 68 #include "runtime/statSampler.hpp" 69 #include "runtime/stubRoutines.hpp" 70 #include "runtime/thread.inline.hpp" 71 #include "runtime/threadCritical.hpp" 72 #include "runtime/timer.hpp" 73 #include "runtime/vm_version.hpp" 74 #include "services/attachListener.hpp" 75 #include "services/runtimeService.hpp" 76 #include "utilities/decoder.hpp" 77 #include "utilities/defaultStream.hpp" 78 #include "utilities/events.hpp" 79 #include "utilities/growableArray.hpp" 80 #include "utilities/vmError.hpp" 81 82 // put OS-includes here (sorted alphabetically) 83 #include <errno.h> 84 #include <fcntl.h> 85 #include <inttypes.h> 86 #include <poll.h> 87 #include <procinfo.h> 88 #include <pthread.h> 89 #include <pwd.h> 90 #include <semaphore.h> 91 #include <signal.h> 92 #include <stdint.h> 93 #include <stdio.h> 94 #include <string.h> 95 #include <unistd.h> 96 #include <sys/ioctl.h> 97 #include <sys/ipc.h> 98 #include <sys/mman.h> 99 #include <sys/resource.h> 100 #include <sys/select.h> 101 #include <sys/shm.h> 102 #include <sys/socket.h> 103 #include <sys/stat.h> 104 #include <sys/sysinfo.h> 105 #include <sys/systemcfg.h> 106 #include <sys/time.h> 107 #include <sys/times.h> 108 #include <sys/types.h> 109 #include <sys/utsname.h> 110 #include <sys/vminfo.h> 111 #include <sys/wait.h> 112 113 // Missing prototypes for various system APIs. 114 extern "C" 115 int mread_real_time(timebasestruct_t *t, size_t size_of_timebasestruct_t); 116 117 #if !defined(_AIXVERSION_610) 118 extern "C" int getthrds64(pid_t, struct thrdentry64*, int, tid64_t*, int); 119 extern "C" int getprocs64(procentry64*, int, fdsinfo*, int, pid_t*, int); 120 extern "C" int getargs (procsinfo*, int, char*, int); 121 #endif 122 123 #define MAX_PATH (2 * K) 124 125 // for timer info max values which include all bits 126 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF) 127 // for multipage initialization error analysis (in 'g_multipage_error') 128 #define ERROR_MP_OS_TOO_OLD 100 129 #define ERROR_MP_EXTSHM_ACTIVE 101 130 #define ERROR_MP_VMGETINFO_FAILED 102 131 #define ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K 103 132 133 // Query dimensions of the stack of the calling thread. 134 static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size); 135 static address resolve_function_descriptor_to_code_pointer(address p); 136 137 static void vmembk_print_on(outputStream* os); 138 139 //////////////////////////////////////////////////////////////////////////////// 140 // global variables (for a description see os_aix.hpp) 141 142 julong os::Aix::_physical_memory = 0; 143 144 pthread_t os::Aix::_main_thread = ((pthread_t)0); 145 int os::Aix::_page_size = -1; 146 147 // -1 = uninitialized, 0 if AIX, 1 if OS/400 pase 148 int os::Aix::_on_pase = -1; 149 150 // 0 = uninitialized, otherwise 32 bit number: 151 // 0xVVRRTTSS 152 // VV - major version 153 // RR - minor version 154 // TT - tech level, if known, 0 otherwise 155 // SS - service pack, if known, 0 otherwise 156 uint32_t os::Aix::_os_version = 0; 157 158 // -1 = uninitialized, 0 - no, 1 - yes 159 int os::Aix::_xpg_sus_mode = -1; 160 161 // -1 = uninitialized, 0 - no, 1 - yes 162 int os::Aix::_extshm = -1; 163 164 //////////////////////////////////////////////////////////////////////////////// 165 // local variables 166 167 static jlong initial_time_count = 0; 168 static int clock_tics_per_sec = 100; 169 static sigset_t check_signal_done; // For diagnostics to print a message once (see run_periodic_checks) 170 static bool check_signals = true; 171 static int SR_signum = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769) 172 static sigset_t SR_sigset; 173 174 // Process break recorded at startup. 175 static address g_brk_at_startup = NULL; 176 177 // This describes the state of multipage support of the underlying 178 // OS. Note that this is of no interest to the outsize world and 179 // therefore should not be defined in AIX class. 180 // 181 // AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The 182 // latter two (16M "large" resp. 16G "huge" pages) require special 183 // setup and are normally not available. 184 // 185 // AIX supports multiple page sizes per process, for: 186 // - Stack (of the primordial thread, so not relevant for us) 187 // - Data - data, bss, heap, for us also pthread stacks 188 // - Text - text code 189 // - shared memory 190 // 191 // Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...) 192 // and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...). 193 // 194 // For shared memory, page size can be set dynamically via 195 // shmctl(). Different shared memory regions can have different page 196 // sizes. 197 // 198 // More information can be found at AIBM info center: 199 // http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm 200 // 201 static struct { 202 size_t pagesize; // sysconf _SC_PAGESIZE (4K) 203 size_t datapsize; // default data page size (LDR_CNTRL DATAPSIZE) 204 size_t shmpsize; // default shared memory page size (LDR_CNTRL SHMPSIZE) 205 size_t pthr_stack_pagesize; // stack page size of pthread threads 206 size_t textpsize; // default text page size (LDR_CNTRL STACKPSIZE) 207 bool can_use_64K_pages; // True if we can alloc 64K pages dynamically with Sys V shm. 208 bool can_use_16M_pages; // True if we can alloc 16M pages dynamically with Sys V shm. 209 int error; // Error describing if something went wrong at multipage init. 210 } g_multipage_support = { 211 (size_t) -1, 212 (size_t) -1, 213 (size_t) -1, 214 (size_t) -1, 215 (size_t) -1, 216 false, false, 217 0 218 }; 219 220 // We must not accidentally allocate memory close to the BRK - even if 221 // that would work - because then we prevent the BRK segment from 222 // growing which may result in a malloc OOM even though there is 223 // enough memory. The problem only arises if we shmat() or mmap() at 224 // a specific wish address, e.g. to place the heap in a 225 // compressed-oops-friendly way. 226 static bool is_close_to_brk(address a) { 227 assert0(g_brk_at_startup != NULL); 228 if (a >= g_brk_at_startup && 229 a < (g_brk_at_startup + MaxExpectedDataSegmentSize)) { 230 return true; 231 } 232 return false; 233 } 234 235 julong os::available_memory() { 236 return Aix::available_memory(); 237 } 238 239 julong os::Aix::available_memory() { 240 // Avoid expensive API call here, as returned value will always be null. 241 if (os::Aix::on_pase()) { 242 return 0x0LL; 243 } 244 os::Aix::meminfo_t mi; 245 if (os::Aix::get_meminfo(&mi)) { 246 return mi.real_free; 247 } else { 248 return ULONG_MAX; 249 } 250 } 251 252 julong os::physical_memory() { 253 return Aix::physical_memory(); 254 } 255 256 // Return true if user is running as root. 257 258 bool os::have_special_privileges() { 259 static bool init = false; 260 static bool privileges = false; 261 if (!init) { 262 privileges = (getuid() != geteuid()) || (getgid() != getegid()); 263 init = true; 264 } 265 return privileges; 266 } 267 268 // Helper function, emulates disclaim64 using multiple 32bit disclaims 269 // because we cannot use disclaim64() on AS/400 and old AIX releases. 270 static bool my_disclaim64(char* addr, size_t size) { 271 272 if (size == 0) { 273 return true; 274 } 275 276 // Maximum size 32bit disclaim() accepts. (Theoretically 4GB, but I just do not trust that.) 277 const unsigned int maxDisclaimSize = 0x40000000; 278 279 const unsigned int numFullDisclaimsNeeded = (size / maxDisclaimSize); 280 const unsigned int lastDisclaimSize = (size % maxDisclaimSize); 281 282 char* p = addr; 283 284 for (int i = 0; i < numFullDisclaimsNeeded; i ++) { 285 if (::disclaim(p, maxDisclaimSize, DISCLAIM_ZEROMEM) != 0) { 286 trcVerbose("Cannot disclaim %p - %p (errno %d)\n", p, p + maxDisclaimSize, errno); 287 return false; 288 } 289 p += maxDisclaimSize; 290 } 291 292 if (lastDisclaimSize > 0) { 293 if (::disclaim(p, lastDisclaimSize, DISCLAIM_ZEROMEM) != 0) { 294 trcVerbose("Cannot disclaim %p - %p (errno %d)\n", p, p + lastDisclaimSize, errno); 295 return false; 296 } 297 } 298 299 return true; 300 } 301 302 // Cpu architecture string 303 #if defined(PPC32) 304 static char cpu_arch[] = "ppc"; 305 #elif defined(PPC64) 306 static char cpu_arch[] = "ppc64"; 307 #else 308 #error Add appropriate cpu_arch setting 309 #endif 310 311 // Wrap the function "vmgetinfo" which is not available on older OS releases. 312 static int checked_vmgetinfo(void *out, int command, int arg) { 313 if (os::Aix::on_pase() && os::Aix::os_version_short() < 0x0601) { 314 guarantee(false, "cannot call vmgetinfo on AS/400 older than V6R1"); 315 } 316 return ::vmgetinfo(out, command, arg); 317 } 318 319 // Given an address, returns the size of the page backing that address. 320 size_t os::Aix::query_pagesize(void* addr) { 321 322 if (os::Aix::on_pase() && os::Aix::os_version_short() < 0x0601) { 323 // AS/400 older than V6R1: no vmgetinfo here, default to 4K 324 return SIZE_4K; 325 } 326 327 vm_page_info pi; 328 pi.addr = (uint64_t)addr; 329 if (checked_vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) { 330 return pi.pagesize; 331 } else { 332 assert(false, "vmgetinfo failed to retrieve page size"); 333 return SIZE_4K; 334 } 335 } 336 337 void os::Aix::initialize_system_info() { 338 339 // Get the number of online(logical) cpus instead of configured. 340 os::_processor_count = sysconf(_SC_NPROCESSORS_ONLN); 341 assert(_processor_count > 0, "_processor_count must be > 0"); 342 343 // Retrieve total physical storage. 344 os::Aix::meminfo_t mi; 345 if (!os::Aix::get_meminfo(&mi)) { 346 assert(false, "os::Aix::get_meminfo failed."); 347 } 348 _physical_memory = (julong) mi.real_total; 349 } 350 351 // Helper function for tracing page sizes. 352 static const char* describe_pagesize(size_t pagesize) { 353 switch (pagesize) { 354 case SIZE_4K : return "4K"; 355 case SIZE_64K: return "64K"; 356 case SIZE_16M: return "16M"; 357 case SIZE_16G: return "16G"; 358 default: 359 assert(false, "surprise"); 360 return "??"; 361 } 362 } 363 364 // Probe OS for multipage support. 365 // Will fill the global g_multipage_support structure. 366 // Must be called before calling os::large_page_init(). 367 static void query_multipage_support() { 368 369 guarantee(g_multipage_support.pagesize == -1, 370 "do not call twice"); 371 372 g_multipage_support.pagesize = ::sysconf(_SC_PAGESIZE); 373 374 // This really would surprise me. 375 assert(g_multipage_support.pagesize == SIZE_4K, "surprise!"); 376 377 // Query default data page size (default page size for C-Heap, pthread stacks and .bss). 378 // Default data page size is defined either by linker options (-bdatapsize) 379 // or by environment variable LDR_CNTRL (suboption DATAPSIZE). If none is given, 380 // default should be 4K. 381 { 382 void* p = ::malloc(SIZE_16M); 383 g_multipage_support.datapsize = os::Aix::query_pagesize(p); 384 ::free(p); 385 } 386 387 // Query default shm page size (LDR_CNTRL SHMPSIZE). 388 // Note that this is pure curiosity. We do not rely on default page size but set 389 // our own page size after allocated. 390 { 391 const int shmid = ::shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR | S_IWUSR); 392 guarantee(shmid != -1, "shmget failed"); 393 void* p = ::shmat(shmid, NULL, 0); 394 ::shmctl(shmid, IPC_RMID, NULL); 395 guarantee(p != (void*) -1, "shmat failed"); 396 g_multipage_support.shmpsize = os::Aix::query_pagesize(p); 397 ::shmdt(p); 398 } 399 400 // Before querying the stack page size, make sure we are not running as primordial 401 // thread (because primordial thread's stack may have different page size than 402 // pthread thread stacks). Running a VM on the primordial thread won't work for a 403 // number of reasons so we may just as well guarantee it here. 404 guarantee0(!os::Aix::is_primordial_thread()); 405 406 // Query pthread stack page size. Should be the same as data page size because 407 // pthread stacks are allocated from C-Heap. 408 { 409 int dummy = 0; 410 g_multipage_support.pthr_stack_pagesize = os::Aix::query_pagesize(&dummy); 411 } 412 413 // Query default text page size (LDR_CNTRL TEXTPSIZE). 414 { 415 address any_function = 416 resolve_function_descriptor_to_code_pointer((address)describe_pagesize); 417 g_multipage_support.textpsize = os::Aix::query_pagesize(any_function); 418 } 419 420 // Now probe for support of 64K pages and 16M pages. 421 422 // Before OS/400 V6R1, there is no support for pages other than 4K. 423 if (os::Aix::on_pase_V5R4_or_older()) { 424 trcVerbose("OS/400 < V6R1 - no large page support."); 425 g_multipage_support.error = ERROR_MP_OS_TOO_OLD; 426 goto query_multipage_support_end; 427 } 428 429 // Now check which page sizes the OS claims it supports, and of those, which actually can be used. 430 { 431 const int MAX_PAGE_SIZES = 4; 432 psize_t sizes[MAX_PAGE_SIZES]; 433 const int num_psizes = checked_vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES); 434 if (num_psizes == -1) { 435 trcVerbose("vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)", errno); 436 trcVerbose("disabling multipage support."); 437 g_multipage_support.error = ERROR_MP_VMGETINFO_FAILED; 438 goto query_multipage_support_end; 439 } 440 guarantee(num_psizes > 0, "vmgetinfo(.., VMINFO_GETPSIZES, ...) failed."); 441 assert(num_psizes <= MAX_PAGE_SIZES, "Surprise! more than 4 page sizes?"); 442 trcVerbose("vmgetinfo(.., VMINFO_GETPSIZES, ...) returns %d supported page sizes: ", num_psizes); 443 for (int i = 0; i < num_psizes; i ++) { 444 trcVerbose(" %s ", describe_pagesize(sizes[i])); 445 } 446 447 // Can we use 64K, 16M pages? 448 for (int i = 0; i < num_psizes; i ++) { 449 const size_t pagesize = sizes[i]; 450 if (pagesize != SIZE_64K && pagesize != SIZE_16M) { 451 continue; 452 } 453 bool can_use = false; 454 trcVerbose("Probing support for %s pages...", describe_pagesize(pagesize)); 455 const int shmid = ::shmget(IPC_PRIVATE, pagesize, 456 IPC_CREAT | S_IRUSR | S_IWUSR); 457 guarantee0(shmid != -1); // Should always work. 458 // Try to set pagesize. 459 struct shmid_ds shm_buf = { 0 }; 460 shm_buf.shm_pagesize = pagesize; 461 if (::shmctl(shmid, SHM_PAGESIZE, &shm_buf) != 0) { 462 const int en = errno; 463 ::shmctl(shmid, IPC_RMID, NULL); // As early as possible! 464 trcVerbose("shmctl(SHM_PAGESIZE) failed with errno=%n", 465 errno); 466 } else { 467 // Attach and double check pageisze. 468 void* p = ::shmat(shmid, NULL, 0); 469 ::shmctl(shmid, IPC_RMID, NULL); // As early as possible! 470 guarantee0(p != (void*) -1); // Should always work. 471 const size_t real_pagesize = os::Aix::query_pagesize(p); 472 if (real_pagesize != pagesize) { 473 trcVerbose("real page size (0x%llX) differs.", real_pagesize); 474 } else { 475 can_use = true; 476 } 477 ::shmdt(p); 478 } 479 trcVerbose("Can use: %s", (can_use ? "yes" : "no")); 480 if (pagesize == SIZE_64K) { 481 g_multipage_support.can_use_64K_pages = can_use; 482 } else if (pagesize == SIZE_16M) { 483 g_multipage_support.can_use_16M_pages = can_use; 484 } 485 } 486 487 } // end: check which pages can be used for shared memory 488 489 query_multipage_support_end: 490 491 trcVerbose("base page size (sysconf _SC_PAGESIZE): %s", 492 describe_pagesize(g_multipage_support.pagesize)); 493 trcVerbose("Data page size (C-Heap, bss, etc): %s", 494 describe_pagesize(g_multipage_support.datapsize)); 495 trcVerbose("Text page size: %s", 496 describe_pagesize(g_multipage_support.textpsize)); 497 trcVerbose("Thread stack page size (pthread): %s", 498 describe_pagesize(g_multipage_support.pthr_stack_pagesize)); 499 trcVerbose("Default shared memory page size: %s", 500 describe_pagesize(g_multipage_support.shmpsize)); 501 trcVerbose("Can use 64K pages dynamically with shared meory: %s", 502 (g_multipage_support.can_use_64K_pages ? "yes" :"no")); 503 trcVerbose("Can use 16M pages dynamically with shared memory: %s", 504 (g_multipage_support.can_use_16M_pages ? "yes" :"no")); 505 trcVerbose("Multipage error details: %d", 506 g_multipage_support.error); 507 508 // sanity checks 509 assert0(g_multipage_support.pagesize == SIZE_4K); 510 assert0(g_multipage_support.datapsize == SIZE_4K || g_multipage_support.datapsize == SIZE_64K); 511 assert0(g_multipage_support.textpsize == SIZE_4K || g_multipage_support.textpsize == SIZE_64K); 512 assert0(g_multipage_support.pthr_stack_pagesize == g_multipage_support.datapsize); 513 assert0(g_multipage_support.shmpsize == SIZE_4K || g_multipage_support.shmpsize == SIZE_64K); 514 515 } 516 517 void os::init_system_properties_values() { 518 519 #define DEFAULT_LIBPATH "/lib:/usr/lib" 520 #define EXTENSIONS_DIR "/lib/ext" 521 522 // Buffer that fits several sprintfs. 523 // Note that the space for the trailing null is provided 524 // by the nulls included by the sizeof operator. 525 const size_t bufsize = 526 MAX2((size_t)MAXPATHLEN, // For dll_dir & friends. 527 (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR)); // extensions dir 528 char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal); 529 530 // sysclasspath, java_home, dll_dir 531 { 532 char *pslash; 533 os::jvm_path(buf, bufsize); 534 535 // Found the full path to libjvm.so. 536 // Now cut the path to <java_home>/jre if we can. 537 pslash = strrchr(buf, '/'); 538 if (pslash != NULL) { 539 *pslash = '\0'; // Get rid of /libjvm.so. 540 } 541 pslash = strrchr(buf, '/'); 542 if (pslash != NULL) { 543 *pslash = '\0'; // Get rid of /{client|server|hotspot}. 544 } 545 Arguments::set_dll_dir(buf); 546 547 if (pslash != NULL) { 548 pslash = strrchr(buf, '/'); 549 if (pslash != NULL) { 550 *pslash = '\0'; // Get rid of /<arch>. 551 pslash = strrchr(buf, '/'); 552 if (pslash != NULL) { 553 *pslash = '\0'; // Get rid of /lib. 554 } 555 } 556 } 557 Arguments::set_java_home(buf); 558 set_boot_path('/', ':'); 559 } 560 561 // Where to look for native libraries. 562 563 // On Aix we get the user setting of LIBPATH. 564 // Eventually, all the library path setting will be done here. 565 // Get the user setting of LIBPATH. 566 const char *v = ::getenv("LIBPATH"); 567 const char *v_colon = ":"; 568 if (v == NULL) { v = ""; v_colon = ""; } 569 570 // Concatenate user and invariant part of ld_library_path. 571 // That's +1 for the colon and +1 for the trailing '\0'. 572 char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal); 573 sprintf(ld_library_path, "%s%s" DEFAULT_LIBPATH, v, v_colon); 574 Arguments::set_library_path(ld_library_path); 575 FREE_C_HEAP_ARRAY(char, ld_library_path); 576 577 // Extensions directories. 578 sprintf(buf, "%s" EXTENSIONS_DIR, Arguments::get_java_home()); 579 Arguments::set_ext_dirs(buf); 580 581 FREE_C_HEAP_ARRAY(char, buf); 582 583 #undef DEFAULT_LIBPATH 584 #undef EXTENSIONS_DIR 585 } 586 587 //////////////////////////////////////////////////////////////////////////////// 588 // breakpoint support 589 590 void os::breakpoint() { 591 BREAKPOINT; 592 } 593 594 extern "C" void breakpoint() { 595 // use debugger to set breakpoint here 596 } 597 598 //////////////////////////////////////////////////////////////////////////////// 599 // signal support 600 601 debug_only(static bool signal_sets_initialized = false); 602 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs; 603 604 bool os::Aix::is_sig_ignored(int sig) { 605 struct sigaction oact; 606 sigaction(sig, (struct sigaction*)NULL, &oact); 607 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction) 608 : CAST_FROM_FN_PTR(void*, oact.sa_handler); 609 if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) { 610 return true; 611 } else { 612 return false; 613 } 614 } 615 616 void os::Aix::signal_sets_init() { 617 // Should also have an assertion stating we are still single-threaded. 618 assert(!signal_sets_initialized, "Already initialized"); 619 // Fill in signals that are necessarily unblocked for all threads in 620 // the VM. Currently, we unblock the following signals: 621 // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden 622 // by -Xrs (=ReduceSignalUsage)); 623 // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all 624 // other threads. The "ReduceSignalUsage" boolean tells us not to alter 625 // the dispositions or masks wrt these signals. 626 // Programs embedding the VM that want to use the above signals for their 627 // own purposes must, at this time, use the "-Xrs" option to prevent 628 // interference with shutdown hooks and BREAK_SIGNAL thread dumping. 629 // (See bug 4345157, and other related bugs). 630 // In reality, though, unblocking these signals is really a nop, since 631 // these signals are not blocked by default. 632 sigemptyset(&unblocked_sigs); 633 sigemptyset(&allowdebug_blocked_sigs); 634 sigaddset(&unblocked_sigs, SIGILL); 635 sigaddset(&unblocked_sigs, SIGSEGV); 636 sigaddset(&unblocked_sigs, SIGBUS); 637 sigaddset(&unblocked_sigs, SIGFPE); 638 sigaddset(&unblocked_sigs, SIGTRAP); 639 sigaddset(&unblocked_sigs, SIGDANGER); 640 sigaddset(&unblocked_sigs, SR_signum); 641 642 if (!ReduceSignalUsage) { 643 if (!os::Aix::is_sig_ignored(SHUTDOWN1_SIGNAL)) { 644 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL); 645 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL); 646 } 647 if (!os::Aix::is_sig_ignored(SHUTDOWN2_SIGNAL)) { 648 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL); 649 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL); 650 } 651 if (!os::Aix::is_sig_ignored(SHUTDOWN3_SIGNAL)) { 652 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL); 653 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL); 654 } 655 } 656 // Fill in signals that are blocked by all but the VM thread. 657 sigemptyset(&vm_sigs); 658 if (!ReduceSignalUsage) 659 sigaddset(&vm_sigs, BREAK_SIGNAL); 660 debug_only(signal_sets_initialized = true); 661 } 662 663 // These are signals that are unblocked while a thread is running Java. 664 // (For some reason, they get blocked by default.) 665 sigset_t* os::Aix::unblocked_signals() { 666 assert(signal_sets_initialized, "Not initialized"); 667 return &unblocked_sigs; 668 } 669 670 // These are the signals that are blocked while a (non-VM) thread is 671 // running Java. Only the VM thread handles these signals. 672 sigset_t* os::Aix::vm_signals() { 673 assert(signal_sets_initialized, "Not initialized"); 674 return &vm_sigs; 675 } 676 677 // These are signals that are blocked during cond_wait to allow debugger in 678 sigset_t* os::Aix::allowdebug_blocked_signals() { 679 assert(signal_sets_initialized, "Not initialized"); 680 return &allowdebug_blocked_sigs; 681 } 682 683 void os::Aix::hotspot_sigmask(Thread* thread) { 684 685 //Save caller's signal mask before setting VM signal mask 686 sigset_t caller_sigmask; 687 pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask); 688 689 OSThread* osthread = thread->osthread(); 690 osthread->set_caller_sigmask(caller_sigmask); 691 692 pthread_sigmask(SIG_UNBLOCK, os::Aix::unblocked_signals(), NULL); 693 694 if (!ReduceSignalUsage) { 695 if (thread->is_VM_thread()) { 696 // Only the VM thread handles BREAK_SIGNAL ... 697 pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL); 698 } else { 699 // ... all other threads block BREAK_SIGNAL 700 pthread_sigmask(SIG_BLOCK, vm_signals(), NULL); 701 } 702 } 703 } 704 705 // retrieve memory information. 706 // Returns false if something went wrong; 707 // content of pmi undefined in this case. 708 bool os::Aix::get_meminfo(meminfo_t* pmi) { 709 710 assert(pmi, "get_meminfo: invalid parameter"); 711 712 memset(pmi, 0, sizeof(meminfo_t)); 713 714 if (os::Aix::on_pase()) { 715 // On PASE, use the libo4 porting library. 716 717 unsigned long long virt_total = 0; 718 unsigned long long real_total = 0; 719 unsigned long long real_free = 0; 720 unsigned long long pgsp_total = 0; 721 unsigned long long pgsp_free = 0; 722 if (libo4::get_memory_info(&virt_total, &real_total, &real_free, &pgsp_total, &pgsp_free)) { 723 pmi->virt_total = virt_total; 724 pmi->real_total = real_total; 725 pmi->real_free = real_free; 726 pmi->pgsp_total = pgsp_total; 727 pmi->pgsp_free = pgsp_free; 728 return true; 729 } 730 return false; 731 732 } else { 733 734 // On AIX, I use the (dynamically loaded) perfstat library to retrieve memory statistics 735 // See: 736 // http://publib.boulder.ibm.com/infocenter/systems/index.jsp 737 // ?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_memtot.htm 738 // http://publib.boulder.ibm.com/infocenter/systems/index.jsp 739 // ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm 740 741 perfstat_memory_total_t psmt; 742 memset (&psmt, '\0', sizeof(psmt)); 743 const int rc = libperfstat::perfstat_memory_total(NULL, &psmt, sizeof(psmt), 1); 744 if (rc == -1) { 745 trcVerbose("perfstat_memory_total() failed (errno=%d)", errno); 746 assert(0, "perfstat_memory_total() failed"); 747 return false; 748 } 749 750 assert(rc == 1, "perfstat_memory_total() - weird return code"); 751 752 // excerpt from 753 // http://publib.boulder.ibm.com/infocenter/systems/index.jsp 754 // ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm 755 // The fields of perfstat_memory_total_t: 756 // u_longlong_t virt_total Total virtual memory (in 4 KB pages). 757 // u_longlong_t real_total Total real memory (in 4 KB pages). 758 // u_longlong_t real_free Free real memory (in 4 KB pages). 759 // u_longlong_t pgsp_total Total paging space (in 4 KB pages). 760 // u_longlong_t pgsp_free Free paging space (in 4 KB pages). 761 762 pmi->virt_total = psmt.virt_total * 4096; 763 pmi->real_total = psmt.real_total * 4096; 764 pmi->real_free = psmt.real_free * 4096; 765 pmi->pgsp_total = psmt.pgsp_total * 4096; 766 pmi->pgsp_free = psmt.pgsp_free * 4096; 767 768 return true; 769 770 } 771 } // end os::Aix::get_meminfo 772 773 ////////////////////////////////////////////////////////////////////////////// 774 // create new thread 775 776 // Thread start routine for all newly created threads 777 static void *thread_native_entry(Thread *thread) { 778 779 // find out my own stack dimensions 780 { 781 // actually, this should do exactly the same as thread->record_stack_base_and_size... 782 address base = 0; 783 size_t size = 0; 784 query_stack_dimensions(&base, &size); 785 thread->set_stack_base(base); 786 thread->set_stack_size(size); 787 } 788 789 const pthread_t pthread_id = ::pthread_self(); 790 const tid_t kernel_thread_id = ::thread_self(); 791 792 log_info(os, thread)("Thread is alive (tid: " UINTX_FORMAT ", kernel thread id: " UINTX_FORMAT ").", 793 os::current_thread_id(), (uintx) kernel_thread_id); 794 795 // Normally, pthread stacks on AIX live in the data segment (are allocated with malloc() 796 // by the pthread library). In rare cases, this may not be the case, e.g. when third-party 797 // tools hook pthread_create(). In this case, we may run into problems establishing 798 // guard pages on those stacks, because the stacks may reside in memory which is not 799 // protectable (shmated). 800 if (thread->stack_base() > ::sbrk(0)) { 801 log_warning(os, thread)("Thread stack not in data segment."); 802 } 803 804 // Try to randomize the cache line index of hot stack frames. 805 // This helps when threads of the same stack traces evict each other's 806 // cache lines. The threads can be either from the same JVM instance, or 807 // from different JVM instances. The benefit is especially true for 808 // processors with hyperthreading technology. 809 810 static int counter = 0; 811 int pid = os::current_process_id(); 812 alloca(((pid ^ counter++) & 7) * 128); 813 814 thread->initialize_thread_current(); 815 816 OSThread* osthread = thread->osthread(); 817 818 // Thread_id is pthread id. 819 osthread->set_thread_id(pthread_id); 820 821 // .. but keep kernel thread id too for diagnostics 822 osthread->set_kernel_thread_id(kernel_thread_id); 823 824 // Initialize signal mask for this thread. 825 os::Aix::hotspot_sigmask(thread); 826 827 // Initialize floating point control register. 828 os::Aix::init_thread_fpu_state(); 829 830 assert(osthread->get_state() == RUNNABLE, "invalid os thread state"); 831 832 // Call one more level start routine. 833 thread->run(); 834 835 log_info(os, thread)("Thread finished (tid: " UINTX_FORMAT ", kernel thread id: " UINTX_FORMAT ").", 836 os::current_thread_id(), (uintx) kernel_thread_id); 837 838 // If a thread has not deleted itself ("delete this") as part of its 839 // termination sequence, we have to ensure thread-local-storage is 840 // cleared before we actually terminate. No threads should ever be 841 // deleted asynchronously with respect to their termination. 842 if (Thread::current_or_null_safe() != NULL) { 843 assert(Thread::current_or_null_safe() == thread, "current thread is wrong"); 844 thread->clear_thread_current(); 845 } 846 847 return 0; 848 } 849 850 bool os::create_thread(Thread* thread, ThreadType thr_type, 851 size_t req_stack_size) { 852 853 assert(thread->osthread() == NULL, "caller responsible"); 854 855 // Allocate the OSThread object 856 OSThread* osthread = new OSThread(NULL, NULL); 857 if (osthread == NULL) { 858 return false; 859 } 860 861 // set the correct thread state 862 osthread->set_thread_type(thr_type); 863 864 // Initial state is ALLOCATED but not INITIALIZED 865 osthread->set_state(ALLOCATED); 866 867 thread->set_osthread(osthread); 868 869 // init thread attributes 870 pthread_attr_t attr; 871 pthread_attr_init(&attr); 872 guarantee(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0, "???"); 873 874 // Make sure we run in 1:1 kernel-user-thread mode. 875 if (os::Aix::on_aix()) { 876 guarantee(pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0, "???"); 877 guarantee(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0, "???"); 878 } // end: aix 879 880 // Start in suspended state, and in os::thread_start, wake the thread up. 881 guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???"); 882 883 // calculate stack size if it's not specified by caller 884 size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size); 885 pthread_attr_setstacksize(&attr, stack_size); 886 887 pthread_t tid; 888 int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread); 889 890 char buf[64]; 891 if (ret == 0) { 892 log_info(os, thread)("Thread started (pthread id: " UINTX_FORMAT ", attributes: %s). ", 893 (uintx) tid, os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr)); 894 } else { 895 log_warning(os, thread)("Failed to start thread - pthread_create failed (%d=%s) for attributes: %s.", 896 ret, os::errno_name(ret), os::Posix::describe_pthread_attr(buf, sizeof(buf), &attr)); 897 } 898 899 pthread_attr_destroy(&attr); 900 901 if (ret != 0) { 902 // Need to clean up stuff we've allocated so far 903 thread->set_osthread(NULL); 904 delete osthread; 905 return false; 906 } 907 908 // OSThread::thread_id is the pthread id. 909 osthread->set_thread_id(tid); 910 911 return true; 912 } 913 914 ///////////////////////////////////////////////////////////////////////////// 915 // attach existing thread 916 917 // bootstrap the main thread 918 bool os::create_main_thread(JavaThread* thread) { 919 assert(os::Aix::_main_thread == pthread_self(), "should be called inside main thread"); 920 return create_attached_thread(thread); 921 } 922 923 bool os::create_attached_thread(JavaThread* thread) { 924 #ifdef ASSERT 925 thread->verify_not_published(); 926 #endif 927 928 // Allocate the OSThread object 929 OSThread* osthread = new OSThread(NULL, NULL); 930 931 if (osthread == NULL) { 932 return false; 933 } 934 935 const pthread_t pthread_id = ::pthread_self(); 936 const tid_t kernel_thread_id = ::thread_self(); 937 938 // OSThread::thread_id is the pthread id. 939 osthread->set_thread_id(pthread_id); 940 941 // .. but keep kernel thread id too for diagnostics 942 osthread->set_kernel_thread_id(kernel_thread_id); 943 944 // initialize floating point control register 945 os::Aix::init_thread_fpu_state(); 946 947 // Initial thread state is RUNNABLE 948 osthread->set_state(RUNNABLE); 949 950 thread->set_osthread(osthread); 951 952 if (UseNUMA) { 953 int lgrp_id = os::numa_get_group_id(); 954 if (lgrp_id != -1) { 955 thread->set_lgrp_id(lgrp_id); 956 } 957 } 958 959 // initialize signal mask for this thread 960 // and save the caller's signal mask 961 os::Aix::hotspot_sigmask(thread); 962 963 log_info(os, thread)("Thread attached (tid: " UINTX_FORMAT ", kernel thread id: " UINTX_FORMAT ").", 964 os::current_thread_id(), (uintx) kernel_thread_id); 965 966 return true; 967 } 968 969 void os::pd_start_thread(Thread* thread) { 970 int status = pthread_continue_np(thread->osthread()->pthread_id()); 971 assert(status == 0, "thr_continue failed"); 972 } 973 974 // Free OS resources related to the OSThread 975 void os::free_thread(OSThread* osthread) { 976 assert(osthread != NULL, "osthread not set"); 977 978 // We are told to free resources of the argument thread, 979 // but we can only really operate on the current thread. 980 assert(Thread::current()->osthread() == osthread, 981 "os::free_thread but not current thread"); 982 983 // Restore caller's signal mask 984 sigset_t sigmask = osthread->caller_sigmask(); 985 pthread_sigmask(SIG_SETMASK, &sigmask, NULL); 986 987 delete osthread; 988 } 989 990 //////////////////////////////////////////////////////////////////////////////// 991 // time support 992 993 // Time since start-up in seconds to a fine granularity. 994 // Used by VMSelfDestructTimer and the MemProfiler. 995 double os::elapsedTime() { 996 return (double)(os::elapsed_counter()) * 0.000001; 997 } 998 999 jlong os::elapsed_counter() { 1000 timeval time; 1001 int status = gettimeofday(&time, NULL); 1002 return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count; 1003 } 1004 1005 jlong os::elapsed_frequency() { 1006 return (1000 * 1000); 1007 } 1008 1009 bool os::supports_vtime() { return true; } 1010 bool os::enable_vtime() { return false; } 1011 bool os::vtime_enabled() { return false; } 1012 1013 double os::elapsedVTime() { 1014 struct rusage usage; 1015 int retval = getrusage(RUSAGE_THREAD, &usage); 1016 if (retval == 0) { 1017 return usage.ru_utime.tv_sec + usage.ru_stime.tv_sec + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec) / (1000.0 * 1000); 1018 } else { 1019 // better than nothing, but not much 1020 return elapsedTime(); 1021 } 1022 } 1023 1024 jlong os::javaTimeMillis() { 1025 timeval time; 1026 int status = gettimeofday(&time, NULL); 1027 assert(status != -1, "aix error at gettimeofday()"); 1028 return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000); 1029 } 1030 1031 void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) { 1032 timeval time; 1033 int status = gettimeofday(&time, NULL); 1034 assert(status != -1, "aix error at gettimeofday()"); 1035 seconds = jlong(time.tv_sec); 1036 nanos = jlong(time.tv_usec) * 1000; 1037 } 1038 1039 jlong os::javaTimeNanos() { 1040 if (os::Aix::on_pase()) { 1041 1042 timeval time; 1043 int status = gettimeofday(&time, NULL); 1044 assert(status != -1, "PASE error at gettimeofday()"); 1045 jlong usecs = jlong((unsigned long long) time.tv_sec * (1000 * 1000) + time.tv_usec); 1046 return 1000 * usecs; 1047 1048 } else { 1049 // On AIX use the precision of processors real time clock 1050 // or time base registers. 1051 timebasestruct_t time; 1052 int rc; 1053 1054 // If the CPU has a time register, it will be used and 1055 // we have to convert to real time first. After convertion we have following data: 1056 // time.tb_high [seconds since 00:00:00 UTC on 1.1.1970] 1057 // time.tb_low [nanoseconds after the last full second above] 1058 // We better use mread_real_time here instead of read_real_time 1059 // to ensure that we will get a monotonic increasing time. 1060 if (mread_real_time(&time, TIMEBASE_SZ) != RTC_POWER) { 1061 rc = time_base_to_time(&time, TIMEBASE_SZ); 1062 assert(rc != -1, "aix error at time_base_to_time()"); 1063 } 1064 return jlong(time.tb_high) * (1000 * 1000 * 1000) + jlong(time.tb_low); 1065 } 1066 } 1067 1068 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { 1069 info_ptr->max_value = ALL_64_BITS; 1070 // mread_real_time() is monotonic (see 'os::javaTimeNanos()') 1071 info_ptr->may_skip_backward = false; 1072 info_ptr->may_skip_forward = false; 1073 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time 1074 } 1075 1076 // Return the real, user, and system times in seconds from an 1077 // arbitrary fixed point in the past. 1078 bool os::getTimesSecs(double* process_real_time, 1079 double* process_user_time, 1080 double* process_system_time) { 1081 struct tms ticks; 1082 clock_t real_ticks = times(&ticks); 1083 1084 if (real_ticks == (clock_t) (-1)) { 1085 return false; 1086 } else { 1087 double ticks_per_second = (double) clock_tics_per_sec; 1088 *process_user_time = ((double) ticks.tms_utime) / ticks_per_second; 1089 *process_system_time = ((double) ticks.tms_stime) / ticks_per_second; 1090 *process_real_time = ((double) real_ticks) / ticks_per_second; 1091 1092 return true; 1093 } 1094 } 1095 1096 char * os::local_time_string(char *buf, size_t buflen) { 1097 struct tm t; 1098 time_t long_time; 1099 time(&long_time); 1100 localtime_r(&long_time, &t); 1101 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d", 1102 t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, 1103 t.tm_hour, t.tm_min, t.tm_sec); 1104 return buf; 1105 } 1106 1107 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) { 1108 return localtime_r(clock, res); 1109 } 1110 1111 //////////////////////////////////////////////////////////////////////////////// 1112 // runtime exit support 1113 1114 // Note: os::shutdown() might be called very early during initialization, or 1115 // called from signal handler. Before adding something to os::shutdown(), make 1116 // sure it is async-safe and can handle partially initialized VM. 1117 void os::shutdown() { 1118 1119 // allow PerfMemory to attempt cleanup of any persistent resources 1120 perfMemory_exit(); 1121 1122 // needs to remove object in file system 1123 AttachListener::abort(); 1124 1125 // flush buffered output, finish log files 1126 ostream_abort(); 1127 1128 // Check for abort hook 1129 abort_hook_t abort_hook = Arguments::abort_hook(); 1130 if (abort_hook != NULL) { 1131 abort_hook(); 1132 } 1133 } 1134 1135 // Note: os::abort() might be called very early during initialization, or 1136 // called from signal handler. Before adding something to os::abort(), make 1137 // sure it is async-safe and can handle partially initialized VM. 1138 void os::abort(bool dump_core, void* siginfo, const void* context) { 1139 os::shutdown(); 1140 if (dump_core) { 1141 #ifndef PRODUCT 1142 fdStream out(defaultStream::output_fd()); 1143 out.print_raw("Current thread is "); 1144 char buf[16]; 1145 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id()); 1146 out.print_raw_cr(buf); 1147 out.print_raw_cr("Dumping core ..."); 1148 #endif 1149 ::abort(); // dump core 1150 } 1151 1152 ::exit(1); 1153 } 1154 1155 // Die immediately, no exit hook, no abort hook, no cleanup. 1156 void os::die() { 1157 ::abort(); 1158 } 1159 1160 // This method is a copy of JDK's sysGetLastErrorString 1161 // from src/solaris/hpi/src/system_md.c 1162 1163 size_t os::lasterror(char *buf, size_t len) { 1164 if (errno == 0) return 0; 1165 1166 const char *s = os::strerror(errno); 1167 size_t n = ::strlen(s); 1168 if (n >= len) { 1169 n = len - 1; 1170 } 1171 ::strncpy(buf, s, n); 1172 buf[n] = '\0'; 1173 return n; 1174 } 1175 1176 intx os::current_thread_id() { 1177 return (intx)pthread_self(); 1178 } 1179 1180 int os::current_process_id() { 1181 return getpid(); 1182 } 1183 1184 // DLL functions 1185 1186 const char* os::dll_file_extension() { return ".so"; } 1187 1188 // This must be hard coded because it's the system's temporary 1189 // directory not the java application's temp directory, ala java.io.tmpdir. 1190 const char* os::get_temp_directory() { return "/tmp"; } 1191 1192 static bool file_exists(const char* filename) { 1193 struct stat statbuf; 1194 if (filename == NULL || strlen(filename) == 0) { 1195 return false; 1196 } 1197 return os::stat(filename, &statbuf) == 0; 1198 } 1199 1200 bool os::dll_build_name(char* buffer, size_t buflen, 1201 const char* pname, const char* fname) { 1202 bool retval = false; 1203 // Copied from libhpi 1204 const size_t pnamelen = pname ? strlen(pname) : 0; 1205 1206 // Return error on buffer overflow. 1207 if (pnamelen + strlen(fname) + 10 > (size_t) buflen) { 1208 *buffer = '\0'; 1209 return retval; 1210 } 1211 1212 if (pnamelen == 0) { 1213 snprintf(buffer, buflen, "lib%s.so", fname); 1214 retval = true; 1215 } else if (strchr(pname, *os::path_separator()) != NULL) { 1216 int n; 1217 char** pelements = split_path(pname, &n); 1218 if (pelements == NULL) { 1219 return false; 1220 } 1221 for (int i = 0; i < n; i++) { 1222 // Really shouldn't be NULL, but check can't hurt 1223 if (pelements[i] == NULL || strlen(pelements[i]) == 0) { 1224 continue; // skip the empty path values 1225 } 1226 snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname); 1227 if (file_exists(buffer)) { 1228 retval = true; 1229 break; 1230 } 1231 } 1232 // release the storage 1233 for (int i = 0; i < n; i++) { 1234 if (pelements[i] != NULL) { 1235 FREE_C_HEAP_ARRAY(char, pelements[i]); 1236 } 1237 } 1238 if (pelements != NULL) { 1239 FREE_C_HEAP_ARRAY(char*, pelements); 1240 } 1241 } else { 1242 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname); 1243 retval = true; 1244 } 1245 return retval; 1246 } 1247 1248 // Check if addr is inside libjvm.so. 1249 bool os::address_is_in_vm(address addr) { 1250 1251 // Input could be a real pc or a function pointer literal. The latter 1252 // would be a function descriptor residing in the data segment of a module. 1253 loaded_module_t lm; 1254 if (LoadedLibraries::find_for_text_address(addr, &lm) != NULL) { 1255 return lm.is_in_vm; 1256 } else if (LoadedLibraries::find_for_data_address(addr, &lm) != NULL) { 1257 return lm.is_in_vm; 1258 } else { 1259 return false; 1260 } 1261 1262 } 1263 1264 // Resolve an AIX function descriptor literal to a code pointer. 1265 // If the input is a valid code pointer to a text segment of a loaded module, 1266 // it is returned unchanged. 1267 // If the input is a valid AIX function descriptor, it is resolved to the 1268 // code entry point. 1269 // If the input is neither a valid function descriptor nor a valid code pointer, 1270 // NULL is returned. 1271 static address resolve_function_descriptor_to_code_pointer(address p) { 1272 1273 if (LoadedLibraries::find_for_text_address(p, NULL) != NULL) { 1274 // It is a real code pointer. 1275 return p; 1276 } else if (LoadedLibraries::find_for_data_address(p, NULL) != NULL) { 1277 // Pointer to data segment, potential function descriptor. 1278 address code_entry = (address)(((FunctionDescriptor*)p)->entry()); 1279 if (LoadedLibraries::find_for_text_address(code_entry, NULL) != NULL) { 1280 // It is a function descriptor. 1281 return code_entry; 1282 } 1283 } 1284 1285 return NULL; 1286 } 1287 1288 bool os::dll_address_to_function_name(address addr, char *buf, 1289 int buflen, int *offset, 1290 bool demangle) { 1291 if (offset) { 1292 *offset = -1; 1293 } 1294 // Buf is not optional, but offset is optional. 1295 assert(buf != NULL, "sanity check"); 1296 buf[0] = '\0'; 1297 1298 // Resolve function ptr literals first. 1299 addr = resolve_function_descriptor_to_code_pointer(addr); 1300 if (!addr) { 1301 return false; 1302 } 1303 1304 return AixSymbols::get_function_name(addr, buf, buflen, offset, NULL, demangle); 1305 } 1306 1307 bool os::dll_address_to_library_name(address addr, char* buf, 1308 int buflen, int* offset) { 1309 if (offset) { 1310 *offset = -1; 1311 } 1312 // Buf is not optional, but offset is optional. 1313 assert(buf != NULL, "sanity check"); 1314 buf[0] = '\0'; 1315 1316 // Resolve function ptr literals first. 1317 addr = resolve_function_descriptor_to_code_pointer(addr); 1318 if (!addr) { 1319 return false; 1320 } 1321 1322 return AixSymbols::get_module_name(addr, buf, buflen); 1323 } 1324 1325 // Loads .dll/.so and in case of error it checks if .dll/.so was built 1326 // for the same architecture as Hotspot is running on. 1327 void *os::dll_load(const char *filename, char *ebuf, int ebuflen) { 1328 1329 if (ebuf && ebuflen > 0) { 1330 ebuf[0] = '\0'; 1331 ebuf[ebuflen - 1] = '\0'; 1332 } 1333 1334 if (!filename || strlen(filename) == 0) { 1335 ::strncpy(ebuf, "dll_load: empty filename specified", ebuflen - 1); 1336 return NULL; 1337 } 1338 1339 // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants. 1340 void * result= ::dlopen(filename, RTLD_LAZY); 1341 if (result != NULL) { 1342 // Reload dll cache. Don't do this in signal handling. 1343 LoadedLibraries::reload(); 1344 return result; 1345 } else { 1346 // error analysis when dlopen fails 1347 const char* const error_report = ::dlerror(); 1348 if (error_report && ebuf && ebuflen > 0) { 1349 snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s", 1350 filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report); 1351 } 1352 } 1353 return NULL; 1354 } 1355 1356 void* os::dll_lookup(void* handle, const char* name) { 1357 void* res = dlsym(handle, name); 1358 return res; 1359 } 1360 1361 void* os::get_default_process_handle() { 1362 return (void*)::dlopen(NULL, RTLD_LAZY); 1363 } 1364 1365 void os::print_dll_info(outputStream *st) { 1366 st->print_cr("Dynamic libraries:"); 1367 LoadedLibraries::print(st); 1368 } 1369 1370 void os::get_summary_os_info(char* buf, size_t buflen) { 1371 // There might be something more readable than uname results for AIX. 1372 struct utsname name; 1373 uname(&name); 1374 snprintf(buf, buflen, "%s %s", name.release, name.version); 1375 } 1376 1377 void os::print_os_info(outputStream* st) { 1378 st->print("OS:"); 1379 1380 st->print("uname:"); 1381 struct utsname name; 1382 uname(&name); 1383 st->print(name.sysname); st->print(" "); 1384 st->print(name.nodename); st->print(" "); 1385 st->print(name.release); st->print(" "); 1386 st->print(name.version); st->print(" "); 1387 st->print(name.machine); 1388 st->cr(); 1389 1390 uint32_t ver = os::Aix::os_version(); 1391 st->print_cr("AIX kernel version %u.%u.%u.%u", 1392 (ver >> 24) & 0xFF, (ver >> 16) & 0xFF, (ver >> 8) & 0xFF, ver & 0xFF); 1393 1394 // rlimit 1395 st->print("rlimit:"); 1396 struct rlimit rlim; 1397 1398 st->print(" STACK "); 1399 getrlimit(RLIMIT_STACK, &rlim); 1400 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1401 else st->print("%uk", rlim.rlim_cur >> 10); 1402 1403 st->print(", CORE "); 1404 getrlimit(RLIMIT_CORE, &rlim); 1405 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1406 else st->print("%uk", rlim.rlim_cur >> 10); 1407 1408 st->print(", NPROC "); 1409 st->print("%d", sysconf(_SC_CHILD_MAX)); 1410 1411 st->print(", NOFILE "); 1412 getrlimit(RLIMIT_NOFILE, &rlim); 1413 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1414 else st->print("%d", rlim.rlim_cur); 1415 1416 st->print(", AS "); 1417 getrlimit(RLIMIT_AS, &rlim); 1418 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1419 else st->print("%uk", rlim.rlim_cur >> 10); 1420 1421 // Print limits on DATA, because it limits the C-heap. 1422 st->print(", DATA "); 1423 getrlimit(RLIMIT_DATA, &rlim); 1424 if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity"); 1425 else st->print("%uk", rlim.rlim_cur >> 10); 1426 st->cr(); 1427 1428 // load average 1429 st->print("load average:"); 1430 double loadavg[3] = {-1.L, -1.L, -1.L}; 1431 os::loadavg(loadavg, 3); 1432 st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]); 1433 st->cr(); 1434 1435 // print wpar info 1436 libperfstat::wparinfo_t wi; 1437 if (libperfstat::get_wparinfo(&wi)) { 1438 st->print_cr("wpar info"); 1439 st->print_cr("name: %s", wi.name); 1440 st->print_cr("id: %d", wi.wpar_id); 1441 st->print_cr("type: %s", (wi.app_wpar ? "application" : "system")); 1442 } 1443 1444 // print partition info 1445 libperfstat::partitioninfo_t pi; 1446 if (libperfstat::get_partitioninfo(&pi)) { 1447 st->print_cr("partition info"); 1448 st->print_cr(" name: %s", pi.name); 1449 } 1450 1451 } 1452 1453 void os::print_memory_info(outputStream* st) { 1454 1455 st->print_cr("Memory:"); 1456 1457 st->print_cr(" Base page size (sysconf _SC_PAGESIZE): %s", 1458 describe_pagesize(g_multipage_support.pagesize)); 1459 st->print_cr(" Data page size (C-Heap, bss, etc): %s", 1460 describe_pagesize(g_multipage_support.datapsize)); 1461 st->print_cr(" Text page size: %s", 1462 describe_pagesize(g_multipage_support.textpsize)); 1463 st->print_cr(" Thread stack page size (pthread): %s", 1464 describe_pagesize(g_multipage_support.pthr_stack_pagesize)); 1465 st->print_cr(" Default shared memory page size: %s", 1466 describe_pagesize(g_multipage_support.shmpsize)); 1467 st->print_cr(" Can use 64K pages dynamically with shared meory: %s", 1468 (g_multipage_support.can_use_64K_pages ? "yes" :"no")); 1469 st->print_cr(" Can use 16M pages dynamically with shared memory: %s", 1470 (g_multipage_support.can_use_16M_pages ? "yes" :"no")); 1471 st->print_cr(" Multipage error: %d", 1472 g_multipage_support.error); 1473 st->cr(); 1474 st->print_cr(" os::vm_page_size: %s", describe_pagesize(os::vm_page_size())); 1475 1476 // print out LDR_CNTRL because it affects the default page sizes 1477 const char* const ldr_cntrl = ::getenv("LDR_CNTRL"); 1478 st->print_cr(" LDR_CNTRL=%s.", ldr_cntrl ? ldr_cntrl : "<unset>"); 1479 1480 // Print out EXTSHM because it is an unsupported setting. 1481 const char* const extshm = ::getenv("EXTSHM"); 1482 st->print_cr(" EXTSHM=%s.", extshm ? extshm : "<unset>"); 1483 if ( (strcmp(extshm, "on") == 0) || (strcmp(extshm, "ON") == 0) ) { 1484 st->print_cr(" *** Unsupported! Please remove EXTSHM from your environment! ***"); 1485 } 1486 1487 // Print out AIXTHREAD_GUARDPAGES because it affects the size of pthread stacks. 1488 const char* const aixthread_guardpages = ::getenv("AIXTHREAD_GUARDPAGES"); 1489 st->print_cr(" AIXTHREAD_GUARDPAGES=%s.", 1490 aixthread_guardpages ? aixthread_guardpages : "<unset>"); 1491 1492 os::Aix::meminfo_t mi; 1493 if (os::Aix::get_meminfo(&mi)) { 1494 char buffer[256]; 1495 if (os::Aix::on_aix()) { 1496 st->print_cr("physical total : " SIZE_FORMAT, mi.real_total); 1497 st->print_cr("physical free : " SIZE_FORMAT, mi.real_free); 1498 st->print_cr("swap total : " SIZE_FORMAT, mi.pgsp_total); 1499 st->print_cr("swap free : " SIZE_FORMAT, mi.pgsp_free); 1500 } else { 1501 // PASE - Numbers are result of QWCRSSTS; they mean: 1502 // real_total: Sum of all system pools 1503 // real_free: always 0 1504 // pgsp_total: we take the size of the system ASP 1505 // pgsp_free: size of system ASP times percentage of system ASP unused 1506 st->print_cr("physical total : " SIZE_FORMAT, mi.real_total); 1507 st->print_cr("system asp total : " SIZE_FORMAT, mi.pgsp_total); 1508 st->print_cr("%% system asp used : " SIZE_FORMAT, 1509 mi.pgsp_total ? (100.0f * (mi.pgsp_total - mi.pgsp_free) / mi.pgsp_total) : -1.0f); 1510 } 1511 st->print_raw(buffer); 1512 } 1513 st->cr(); 1514 1515 // Print segments allocated with os::reserve_memory. 1516 st->print_cr("internal virtual memory regions used by vm:"); 1517 vmembk_print_on(st); 1518 } 1519 1520 // Get a string for the cpuinfo that is a summary of the cpu type 1521 void os::get_summary_cpu_info(char* buf, size_t buflen) { 1522 // This looks good 1523 libperfstat::cpuinfo_t ci; 1524 if (libperfstat::get_cpuinfo(&ci)) { 1525 strncpy(buf, ci.version, buflen); 1526 } else { 1527 strncpy(buf, "AIX", buflen); 1528 } 1529 } 1530 1531 void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) { 1532 st->print("CPU:"); 1533 st->print("total %d", os::processor_count()); 1534 // It's not safe to query number of active processors after crash. 1535 // st->print("(active %d)", os::active_processor_count()); 1536 st->print(" %s", VM_Version::features()); 1537 st->cr(); 1538 } 1539 1540 static void print_signal_handler(outputStream* st, int sig, 1541 char* buf, size_t buflen); 1542 1543 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 1544 st->print_cr("Signal Handlers:"); 1545 print_signal_handler(st, SIGSEGV, buf, buflen); 1546 print_signal_handler(st, SIGBUS , buf, buflen); 1547 print_signal_handler(st, SIGFPE , buf, buflen); 1548 print_signal_handler(st, SIGPIPE, buf, buflen); 1549 print_signal_handler(st, SIGXFSZ, buf, buflen); 1550 print_signal_handler(st, SIGILL , buf, buflen); 1551 print_signal_handler(st, SR_signum, buf, buflen); 1552 print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen); 1553 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen); 1554 print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen); 1555 print_signal_handler(st, BREAK_SIGNAL, buf, buflen); 1556 print_signal_handler(st, SIGTRAP, buf, buflen); 1557 print_signal_handler(st, SIGDANGER, buf, buflen); 1558 } 1559 1560 static char saved_jvm_path[MAXPATHLEN] = {0}; 1561 1562 // Find the full path to the current module, libjvm.so. 1563 void os::jvm_path(char *buf, jint buflen) { 1564 // Error checking. 1565 if (buflen < MAXPATHLEN) { 1566 assert(false, "must use a large-enough buffer"); 1567 buf[0] = '\0'; 1568 return; 1569 } 1570 // Lazy resolve the path to current module. 1571 if (saved_jvm_path[0] != 0) { 1572 strcpy(buf, saved_jvm_path); 1573 return; 1574 } 1575 1576 Dl_info dlinfo; 1577 int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo); 1578 assert(ret != 0, "cannot locate libjvm"); 1579 char* rp = realpath((char *)dlinfo.dli_fname, buf); 1580 assert(rp != NULL, "error in realpath(): maybe the 'path' argument is too long?"); 1581 1582 strncpy(saved_jvm_path, buf, sizeof(saved_jvm_path)); 1583 saved_jvm_path[sizeof(saved_jvm_path) - 1] = '\0'; 1584 } 1585 1586 void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 1587 // no prefix required, not even "_" 1588 } 1589 1590 void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 1591 // no suffix required 1592 } 1593 1594 //////////////////////////////////////////////////////////////////////////////// 1595 // sun.misc.Signal support 1596 1597 static volatile jint sigint_count = 0; 1598 1599 static void 1600 UserHandler(int sig, void *siginfo, void *context) { 1601 // 4511530 - sem_post is serialized and handled by the manager thread. When 1602 // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We 1603 // don't want to flood the manager thread with sem_post requests. 1604 if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1) 1605 return; 1606 1607 // Ctrl-C is pressed during error reporting, likely because the error 1608 // handler fails to abort. Let VM die immediately. 1609 if (sig == SIGINT && is_error_reported()) { 1610 os::die(); 1611 } 1612 1613 os::signal_notify(sig); 1614 } 1615 1616 void* os::user_handler() { 1617 return CAST_FROM_FN_PTR(void*, UserHandler); 1618 } 1619 1620 extern "C" { 1621 typedef void (*sa_handler_t)(int); 1622 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *); 1623 } 1624 1625 void* os::signal(int signal_number, void* handler) { 1626 struct sigaction sigAct, oldSigAct; 1627 1628 sigfillset(&(sigAct.sa_mask)); 1629 1630 // Do not block out synchronous signals in the signal handler. 1631 // Blocking synchronous signals only makes sense if you can really 1632 // be sure that those signals won't happen during signal handling, 1633 // when the blocking applies. Normal signal handlers are lean and 1634 // do not cause signals. But our signal handlers tend to be "risky" 1635 // - secondary SIGSEGV, SIGILL, SIGBUS' may and do happen. 1636 // On AIX, PASE there was a case where a SIGSEGV happened, followed 1637 // by a SIGILL, which was blocked due to the signal mask. The process 1638 // just hung forever. Better to crash from a secondary signal than to hang. 1639 sigdelset(&(sigAct.sa_mask), SIGSEGV); 1640 sigdelset(&(sigAct.sa_mask), SIGBUS); 1641 sigdelset(&(sigAct.sa_mask), SIGILL); 1642 sigdelset(&(sigAct.sa_mask), SIGFPE); 1643 sigdelset(&(sigAct.sa_mask), SIGTRAP); 1644 1645 sigAct.sa_flags = SA_RESTART|SA_SIGINFO; 1646 1647 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler); 1648 1649 if (sigaction(signal_number, &sigAct, &oldSigAct)) { 1650 // -1 means registration failed 1651 return (void *)-1; 1652 } 1653 1654 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler); 1655 } 1656 1657 void os::signal_raise(int signal_number) { 1658 ::raise(signal_number); 1659 } 1660 1661 // 1662 // The following code is moved from os.cpp for making this 1663 // code platform specific, which it is by its very nature. 1664 // 1665 1666 // Will be modified when max signal is changed to be dynamic 1667 int os::sigexitnum_pd() { 1668 return NSIG; 1669 } 1670 1671 // a counter for each possible signal value 1672 static volatile jint pending_signals[NSIG+1] = { 0 }; 1673 1674 // Wrapper functions for: sem_init(), sem_post(), sem_wait() 1675 // On AIX, we use sem_init(), sem_post(), sem_wait() 1676 // On Pase, we need to use msem_lock() and msem_unlock(), because Posix Semaphores 1677 // do not seem to work at all on PASE (unimplemented, will cause SIGILL). 1678 // Note that just using msem_.. APIs for both PASE and AIX is not an option either, as 1679 // on AIX, msem_..() calls are suspected of causing problems. 1680 static sem_t sig_sem; 1681 static msemaphore* p_sig_msem = 0; 1682 1683 static void local_sem_init() { 1684 if (os::Aix::on_aix()) { 1685 int rc = ::sem_init(&sig_sem, 0, 0); 1686 guarantee(rc != -1, "sem_init failed"); 1687 } else { 1688 // Memory semaphores must live in shared mem. 1689 guarantee0(p_sig_msem == NULL); 1690 p_sig_msem = (msemaphore*)os::reserve_memory(sizeof(msemaphore), NULL); 1691 guarantee(p_sig_msem, "Cannot allocate memory for memory semaphore"); 1692 guarantee(::msem_init(p_sig_msem, 0) == p_sig_msem, "msem_init failed"); 1693 } 1694 } 1695 1696 static void local_sem_post() { 1697 static bool warn_only_once = false; 1698 if (os::Aix::on_aix()) { 1699 int rc = ::sem_post(&sig_sem); 1700 if (rc == -1 && !warn_only_once) { 1701 trcVerbose("sem_post failed (errno = %d, %s)", errno, os::errno_name(errno)); 1702 warn_only_once = true; 1703 } 1704 } else { 1705 guarantee0(p_sig_msem != NULL); 1706 int rc = ::msem_unlock(p_sig_msem, 0); 1707 if (rc == -1 && !warn_only_once) { 1708 trcVerbose("msem_unlock failed (errno = %d, %s)", errno, os::errno_name(errno)); 1709 warn_only_once = true; 1710 } 1711 } 1712 } 1713 1714 static void local_sem_wait() { 1715 static bool warn_only_once = false; 1716 if (os::Aix::on_aix()) { 1717 int rc = ::sem_wait(&sig_sem); 1718 if (rc == -1 && !warn_only_once) { 1719 trcVerbose("sem_wait failed (errno = %d, %s)", errno, os::errno_name(errno)); 1720 warn_only_once = true; 1721 } 1722 } else { 1723 guarantee0(p_sig_msem != NULL); // must init before use 1724 int rc = ::msem_lock(p_sig_msem, 0); 1725 if (rc == -1 && !warn_only_once) { 1726 trcVerbose("msem_lock failed (errno = %d, %s)", errno, os::errno_name(errno)); 1727 warn_only_once = true; 1728 } 1729 } 1730 } 1731 1732 void os::signal_init_pd() { 1733 // Initialize signal structures 1734 ::memset((void*)pending_signals, 0, sizeof(pending_signals)); 1735 1736 // Initialize signal semaphore 1737 local_sem_init(); 1738 } 1739 1740 void os::signal_notify(int sig) { 1741 Atomic::inc(&pending_signals[sig]); 1742 local_sem_post(); 1743 } 1744 1745 static int check_pending_signals(bool wait) { 1746 Atomic::store(0, &sigint_count); 1747 for (;;) { 1748 for (int i = 0; i < NSIG + 1; i++) { 1749 jint n = pending_signals[i]; 1750 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 1751 return i; 1752 } 1753 } 1754 if (!wait) { 1755 return -1; 1756 } 1757 JavaThread *thread = JavaThread::current(); 1758 ThreadBlockInVM tbivm(thread); 1759 1760 bool threadIsSuspended; 1761 do { 1762 thread->set_suspend_equivalent(); 1763 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 1764 1765 local_sem_wait(); 1766 1767 // were we externally suspended while we were waiting? 1768 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 1769 if (threadIsSuspended) { 1770 // 1771 // The semaphore has been incremented, but while we were waiting 1772 // another thread suspended us. We don't want to continue running 1773 // while suspended because that would surprise the thread that 1774 // suspended us. 1775 // 1776 1777 local_sem_post(); 1778 1779 thread->java_suspend_self(); 1780 } 1781 } while (threadIsSuspended); 1782 } 1783 } 1784 1785 int os::signal_lookup() { 1786 return check_pending_signals(false); 1787 } 1788 1789 int os::signal_wait() { 1790 return check_pending_signals(true); 1791 } 1792 1793 //////////////////////////////////////////////////////////////////////////////// 1794 // Virtual Memory 1795 1796 // We need to keep small simple bookkeeping for os::reserve_memory and friends. 1797 1798 #define VMEM_MAPPED 1 1799 #define VMEM_SHMATED 2 1800 1801 struct vmembk_t { 1802 int type; // 1 - mmap, 2 - shmat 1803 char* addr; 1804 size_t size; // Real size, may be larger than usersize. 1805 size_t pagesize; // page size of area 1806 vmembk_t* next; 1807 1808 bool contains_addr(char* p) const { 1809 return p >= addr && p < (addr + size); 1810 } 1811 1812 bool contains_range(char* p, size_t s) const { 1813 return contains_addr(p) && contains_addr(p + s - 1); 1814 } 1815 1816 void print_on(outputStream* os) const { 1817 os->print("[" PTR_FORMAT " - " PTR_FORMAT "] (" UINTX_FORMAT 1818 " bytes, %d %s pages), %s", 1819 addr, addr + size - 1, size, size / pagesize, describe_pagesize(pagesize), 1820 (type == VMEM_SHMATED ? "shmat" : "mmap") 1821 ); 1822 } 1823 1824 // Check that range is a sub range of memory block (or equal to memory block); 1825 // also check that range is fully page aligned to the page size if the block. 1826 void assert_is_valid_subrange(char* p, size_t s) const { 1827 if (!contains_range(p, s)) { 1828 trcVerbose("[" PTR_FORMAT " - " PTR_FORMAT "] is not a sub " 1829 "range of [" PTR_FORMAT " - " PTR_FORMAT "].", 1830 p, p + s, addr, addr + size); 1831 guarantee0(false); 1832 } 1833 if (!is_aligned_to(p, pagesize) || !is_aligned_to(p + s, pagesize)) { 1834 trcVerbose("range [" PTR_FORMAT " - " PTR_FORMAT "] is not" 1835 " aligned to pagesize (%lu)", p, p + s, (unsigned long) pagesize); 1836 guarantee0(false); 1837 } 1838 } 1839 }; 1840 1841 static struct { 1842 vmembk_t* first; 1843 MiscUtils::CritSect cs; 1844 } vmem; 1845 1846 static void vmembk_add(char* addr, size_t size, size_t pagesize, int type) { 1847 vmembk_t* p = (vmembk_t*) ::malloc(sizeof(vmembk_t)); 1848 assert0(p); 1849 if (p) { 1850 MiscUtils::AutoCritSect lck(&vmem.cs); 1851 p->addr = addr; p->size = size; 1852 p->pagesize = pagesize; 1853 p->type = type; 1854 p->next = vmem.first; 1855 vmem.first = p; 1856 } 1857 } 1858 1859 static vmembk_t* vmembk_find(char* addr) { 1860 MiscUtils::AutoCritSect lck(&vmem.cs); 1861 for (vmembk_t* p = vmem.first; p; p = p->next) { 1862 if (p->addr <= addr && (p->addr + p->size) > addr) { 1863 return p; 1864 } 1865 } 1866 return NULL; 1867 } 1868 1869 static void vmembk_remove(vmembk_t* p0) { 1870 MiscUtils::AutoCritSect lck(&vmem.cs); 1871 assert0(p0); 1872 assert0(vmem.first); // List should not be empty. 1873 for (vmembk_t** pp = &(vmem.first); *pp; pp = &((*pp)->next)) { 1874 if (*pp == p0) { 1875 *pp = p0->next; 1876 ::free(p0); 1877 return; 1878 } 1879 } 1880 assert0(false); // Not found? 1881 } 1882 1883 static void vmembk_print_on(outputStream* os) { 1884 MiscUtils::AutoCritSect lck(&vmem.cs); 1885 for (vmembk_t* vmi = vmem.first; vmi; vmi = vmi->next) { 1886 vmi->print_on(os); 1887 os->cr(); 1888 } 1889 } 1890 1891 // Reserve and attach a section of System V memory. 1892 // If <requested_addr> is not NULL, function will attempt to attach the memory at the given 1893 // address. Failing that, it will attach the memory anywhere. 1894 // If <requested_addr> is NULL, function will attach the memory anywhere. 1895 // 1896 // <alignment_hint> is being ignored by this function. It is very probable however that the 1897 // alignment requirements are met anyway, because shmat() attaches at 256M boundaries. 1898 // Should this be not enogh, we can put more work into it. 1899 static char* reserve_shmated_memory ( 1900 size_t bytes, 1901 char* requested_addr, 1902 size_t alignment_hint) { 1903 1904 trcVerbose("reserve_shmated_memory " UINTX_FORMAT " bytes, wishaddress " 1905 PTR_FORMAT ", alignment_hint " UINTX_FORMAT "...", 1906 bytes, requested_addr, alignment_hint); 1907 1908 // Either give me wish address or wish alignment but not both. 1909 assert0(!(requested_addr != NULL && alignment_hint != 0)); 1910 1911 // We must prevent anyone from attaching too close to the 1912 // BRK because that may cause malloc OOM. 1913 if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) { 1914 trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. " 1915 "Will attach anywhere.", requested_addr); 1916 // Act like the OS refused to attach there. 1917 requested_addr = NULL; 1918 } 1919 1920 // For old AS/400's (V5R4 and older) we should not even be here - System V shared memory is not 1921 // really supported (max size 4GB), so reserve_mmapped_memory should have been used instead. 1922 if (os::Aix::on_pase_V5R4_or_older()) { 1923 ShouldNotReachHere(); 1924 } 1925 1926 // Align size of shm up to 64K to avoid errors if we later try to change the page size. 1927 const size_t size = align_size_up(bytes, SIZE_64K); 1928 1929 // Reserve the shared segment. 1930 int shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | S_IRUSR | S_IWUSR); 1931 if (shmid == -1) { 1932 trcVerbose("shmget(.., " UINTX_FORMAT ", ..) failed (errno: %d).", size, errno); 1933 return NULL; 1934 } 1935 1936 // Important note: 1937 // It is very important that we, upon leaving this function, do not leave a shm segment alive. 1938 // We must right after attaching it remove it from the system. System V shm segments are global and 1939 // survive the process. 1940 // So, from here on: Do not assert, do not return, until we have called shmctl(IPC_RMID) (A). 1941 1942 struct shmid_ds shmbuf; 1943 memset(&shmbuf, 0, sizeof(shmbuf)); 1944 shmbuf.shm_pagesize = SIZE_64K; 1945 if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) != 0) { 1946 trcVerbose("Failed to set page size (need " UINTX_FORMAT " 64K pages) - shmctl failed with %d.", 1947 size / SIZE_64K, errno); 1948 // I want to know if this ever happens. 1949 assert(false, "failed to set page size for shmat"); 1950 } 1951 1952 // Now attach the shared segment. 1953 // Note that I attach with SHM_RND - which means that the requested address is rounded down, if 1954 // needed, to the next lowest segment boundary. Otherwise the attach would fail if the address 1955 // were not a segment boundary. 1956 char* const addr = (char*) shmat(shmid, requested_addr, SHM_RND); 1957 const int errno_shmat = errno; 1958 1959 // (A) Right after shmat and before handing shmat errors delete the shm segment. 1960 if (::shmctl(shmid, IPC_RMID, NULL) == -1) { 1961 trcVerbose("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno); 1962 assert(false, "failed to remove shared memory segment!"); 1963 } 1964 1965 // Handle shmat error. If we failed to attach, just return. 1966 if (addr == (char*)-1) { 1967 trcVerbose("Failed to attach segment at " PTR_FORMAT " (%d).", requested_addr, errno_shmat); 1968 return NULL; 1969 } 1970 1971 // Just for info: query the real page size. In case setting the page size did not 1972 // work (see above), the system may have given us something other then 4K (LDR_CNTRL). 1973 const size_t real_pagesize = os::Aix::query_pagesize(addr); 1974 if (real_pagesize != shmbuf.shm_pagesize) { 1975 trcVerbose("pagesize is, surprisingly, %h.", real_pagesize); 1976 } 1977 1978 if (addr) { 1979 trcVerbose("shm-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes, " UINTX_FORMAT " %s pages)", 1980 addr, addr + size - 1, size, size/real_pagesize, describe_pagesize(real_pagesize)); 1981 } else { 1982 if (requested_addr != NULL) { 1983 trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at with address " PTR_FORMAT ".", size, requested_addr); 1984 } else { 1985 trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at any address.", size); 1986 } 1987 } 1988 1989 // book-keeping 1990 vmembk_add(addr, size, real_pagesize, VMEM_SHMATED); 1991 assert0(is_aligned_to(addr, os::vm_page_size())); 1992 1993 return addr; 1994 } 1995 1996 static bool release_shmated_memory(char* addr, size_t size) { 1997 1998 trcVerbose("release_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].", 1999 addr, addr + size - 1); 2000 2001 bool rc = false; 2002 2003 // TODO: is there a way to verify shm size without doing bookkeeping? 2004 if (::shmdt(addr) != 0) { 2005 trcVerbose("error (%d).", errno); 2006 } else { 2007 trcVerbose("ok."); 2008 rc = true; 2009 } 2010 return rc; 2011 } 2012 2013 static bool uncommit_shmated_memory(char* addr, size_t size) { 2014 trcVerbose("uncommit_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].", 2015 addr, addr + size - 1); 2016 2017 const bool rc = my_disclaim64(addr, size); 2018 2019 if (!rc) { 2020 trcVerbose("my_disclaim64(" PTR_FORMAT ", " UINTX_FORMAT ") failed.\n", addr, size); 2021 return false; 2022 } 2023 return true; 2024 } 2025 2026 //////////////////////////////// mmap-based routines ///////////////////////////////// 2027 2028 // Reserve memory via mmap. 2029 // If <requested_addr> is given, an attempt is made to attach at the given address. 2030 // Failing that, memory is allocated at any address. 2031 // If <alignment_hint> is given and <requested_addr> is NULL, an attempt is made to 2032 // allocate at an address aligned with the given alignment. Failing that, memory 2033 // is aligned anywhere. 2034 static char* reserve_mmaped_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { 2035 trcVerbose("reserve_mmaped_memory " UINTX_FORMAT " bytes, wishaddress " PTR_FORMAT ", " 2036 "alignment_hint " UINTX_FORMAT "...", 2037 bytes, requested_addr, alignment_hint); 2038 2039 // If a wish address is given, but not aligned to 4K page boundary, mmap will fail. 2040 if (requested_addr && !is_aligned_to(requested_addr, os::vm_page_size()) != 0) { 2041 trcVerbose("Wish address " PTR_FORMAT " not aligned to page boundary.", requested_addr); 2042 return NULL; 2043 } 2044 2045 // We must prevent anyone from attaching too close to the 2046 // BRK because that may cause malloc OOM. 2047 if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) { 2048 trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. " 2049 "Will attach anywhere.", requested_addr); 2050 // Act like the OS refused to attach there. 2051 requested_addr = NULL; 2052 } 2053 2054 // Specify one or the other but not both. 2055 assert0(!(requested_addr != NULL && alignment_hint > 0)); 2056 2057 // In 64K mode, we claim the global page size (os::vm_page_size()) 2058 // is 64K. This is one of the few points where that illusion may 2059 // break, because mmap() will always return memory aligned to 4K. So 2060 // we must ensure we only ever return memory aligned to 64k. 2061 if (alignment_hint) { 2062 alignment_hint = lcm(alignment_hint, os::vm_page_size()); 2063 } else { 2064 alignment_hint = os::vm_page_size(); 2065 } 2066 2067 // Size shall always be a multiple of os::vm_page_size (esp. in 64K mode). 2068 const size_t size = align_size_up(bytes, os::vm_page_size()); 2069 2070 // alignment: Allocate memory large enough to include an aligned range of the right size and 2071 // cut off the leading and trailing waste pages. 2072 assert0(alignment_hint != 0 && is_aligned_to(alignment_hint, os::vm_page_size())); // see above 2073 const size_t extra_size = size + alignment_hint; 2074 2075 // Note: MAP_SHARED (instead of MAP_PRIVATE) needed to be able to 2076 // later use msync(MS_INVALIDATE) (see os::uncommit_memory). 2077 int flags = MAP_ANONYMOUS | MAP_SHARED; 2078 2079 // MAP_FIXED is needed to enforce requested_addr - manpage is vague about what 2080 // it means if wishaddress is given but MAP_FIXED is not set. 2081 // 2082 // Important! Behaviour differs depending on whether SPEC1170 mode is active or not. 2083 // SPEC1170 mode active: behaviour like POSIX, MAP_FIXED will clobber existing mappings. 2084 // SPEC1170 mode not active: behaviour, unlike POSIX, is that no existing mappings will 2085 // get clobbered. 2086 if (requested_addr != NULL) { 2087 if (!os::Aix::xpg_sus_mode()) { // not SPEC1170 Behaviour 2088 flags |= MAP_FIXED; 2089 } 2090 } 2091 2092 char* addr = (char*)::mmap(requested_addr, extra_size, 2093 PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0); 2094 2095 if (addr == MAP_FAILED) { 2096 trcVerbose("mmap(" PTR_FORMAT ", " UINTX_FORMAT ", ..) failed (%d)", requested_addr, size, errno); 2097 return NULL; 2098 } 2099 2100 // Handle alignment. 2101 char* const addr_aligned = (char *)align_ptr_up(addr, alignment_hint); 2102 const size_t waste_pre = addr_aligned - addr; 2103 char* const addr_aligned_end = addr_aligned + size; 2104 const size_t waste_post = extra_size - waste_pre - size; 2105 if (waste_pre > 0) { 2106 ::munmap(addr, waste_pre); 2107 } 2108 if (waste_post > 0) { 2109 ::munmap(addr_aligned_end, waste_post); 2110 } 2111 addr = addr_aligned; 2112 2113 if (addr) { 2114 trcVerbose("mmap-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes)", 2115 addr, addr + bytes, bytes); 2116 } else { 2117 if (requested_addr != NULL) { 2118 trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at wish address " PTR_FORMAT ".", bytes, requested_addr); 2119 } else { 2120 trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at any address.", bytes); 2121 } 2122 } 2123 2124 // bookkeeping 2125 vmembk_add(addr, size, SIZE_4K, VMEM_MAPPED); 2126 2127 // Test alignment, see above. 2128 assert0(is_aligned_to(addr, os::vm_page_size())); 2129 2130 return addr; 2131 } 2132 2133 static bool release_mmaped_memory(char* addr, size_t size) { 2134 assert0(is_aligned_to(addr, os::vm_page_size())); 2135 assert0(is_aligned_to(size, os::vm_page_size())); 2136 2137 trcVerbose("release_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].", 2138 addr, addr + size - 1); 2139 bool rc = false; 2140 2141 if (::munmap(addr, size) != 0) { 2142 trcVerbose("failed (%d)\n", errno); 2143 rc = false; 2144 } else { 2145 trcVerbose("ok."); 2146 rc = true; 2147 } 2148 2149 return rc; 2150 } 2151 2152 static bool uncommit_mmaped_memory(char* addr, size_t size) { 2153 2154 assert0(is_aligned_to(addr, os::vm_page_size())); 2155 assert0(is_aligned_to(size, os::vm_page_size())); 2156 2157 trcVerbose("uncommit_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].", 2158 addr, addr + size - 1); 2159 bool rc = false; 2160 2161 // Uncommit mmap memory with msync MS_INVALIDATE. 2162 if (::msync(addr, size, MS_INVALIDATE) != 0) { 2163 trcVerbose("failed (%d)\n", errno); 2164 rc = false; 2165 } else { 2166 trcVerbose("ok."); 2167 rc = true; 2168 } 2169 2170 return rc; 2171 } 2172 2173 int os::vm_page_size() { 2174 // Seems redundant as all get out. 2175 assert(os::Aix::page_size() != -1, "must call os::init"); 2176 return os::Aix::page_size(); 2177 } 2178 2179 // Aix allocates memory by pages. 2180 int os::vm_allocation_granularity() { 2181 assert(os::Aix::page_size() != -1, "must call os::init"); 2182 return os::Aix::page_size(); 2183 } 2184 2185 #ifdef PRODUCT 2186 static void warn_fail_commit_memory(char* addr, size_t size, bool exec, 2187 int err) { 2188 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT 2189 ", %d) failed; error='%s' (errno=%d)", addr, size, exec, 2190 os::errno_name(err), err); 2191 } 2192 #endif 2193 2194 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec, 2195 const char* mesg) { 2196 assert(mesg != NULL, "mesg must be specified"); 2197 if (!pd_commit_memory(addr, size, exec)) { 2198 // Add extra info in product mode for vm_exit_out_of_memory(): 2199 PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);) 2200 vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg); 2201 } 2202 } 2203 2204 bool os::pd_commit_memory(char* addr, size_t size, bool exec) { 2205 2206 assert(is_aligned_to(addr, os::vm_page_size()), 2207 "addr " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")", 2208 p2i(addr), os::vm_page_size()); 2209 assert(is_aligned_to(size, os::vm_page_size()), 2210 "size " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")", 2211 size, os::vm_page_size()); 2212 2213 vmembk_t* const vmi = vmembk_find(addr); 2214 guarantee0(vmi); 2215 vmi->assert_is_valid_subrange(addr, size); 2216 2217 trcVerbose("commit_memory [" PTR_FORMAT " - " PTR_FORMAT "].", addr, addr + size - 1); 2218 2219 if (UseExplicitCommit) { 2220 // AIX commits memory on touch. So, touch all pages to be committed. 2221 for (char* p = addr; p < (addr + size); p += SIZE_4K) { 2222 *p = '\0'; 2223 } 2224 } 2225 2226 return true; 2227 } 2228 2229 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) { 2230 return pd_commit_memory(addr, size, exec); 2231 } 2232 2233 void os::pd_commit_memory_or_exit(char* addr, size_t size, 2234 size_t alignment_hint, bool exec, 2235 const char* mesg) { 2236 // Alignment_hint is ignored on this OS. 2237 pd_commit_memory_or_exit(addr, size, exec, mesg); 2238 } 2239 2240 bool os::pd_uncommit_memory(char* addr, size_t size) { 2241 assert(is_aligned_to(addr, os::vm_page_size()), 2242 "addr " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")", 2243 p2i(addr), os::vm_page_size()); 2244 assert(is_aligned_to(size, os::vm_page_size()), 2245 "size " PTR_FORMAT " not aligned to vm_page_size (" PTR_FORMAT ")", 2246 size, os::vm_page_size()); 2247 2248 // Dynamically do different things for mmap/shmat. 2249 const vmembk_t* const vmi = vmembk_find(addr); 2250 guarantee0(vmi); 2251 vmi->assert_is_valid_subrange(addr, size); 2252 2253 if (vmi->type == VMEM_SHMATED) { 2254 return uncommit_shmated_memory(addr, size); 2255 } else { 2256 return uncommit_mmaped_memory(addr, size); 2257 } 2258 } 2259 2260 bool os::pd_create_stack_guard_pages(char* addr, size_t size) { 2261 // Do not call this; no need to commit stack pages on AIX. 2262 ShouldNotReachHere(); 2263 return true; 2264 } 2265 2266 bool os::remove_stack_guard_pages(char* addr, size_t size) { 2267 // Do not call this; no need to commit stack pages on AIX. 2268 ShouldNotReachHere(); 2269 return true; 2270 } 2271 2272 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { 2273 } 2274 2275 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { 2276 } 2277 2278 void os::numa_make_global(char *addr, size_t bytes) { 2279 } 2280 2281 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { 2282 } 2283 2284 bool os::numa_topology_changed() { 2285 return false; 2286 } 2287 2288 size_t os::numa_get_groups_num() { 2289 return 1; 2290 } 2291 2292 int os::numa_get_group_id() { 2293 return 0; 2294 } 2295 2296 size_t os::numa_get_leaf_groups(int *ids, size_t size) { 2297 if (size > 0) { 2298 ids[0] = 0; 2299 return 1; 2300 } 2301 return 0; 2302 } 2303 2304 bool os::get_page_info(char *start, page_info* info) { 2305 return false; 2306 } 2307 2308 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 2309 return end; 2310 } 2311 2312 // Reserves and attaches a shared memory segment. 2313 // Will assert if a wish address is given and could not be obtained. 2314 char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) { 2315 2316 // All other Unices do a mmap(MAP_FIXED) if the addr is given, 2317 // thereby clobbering old mappings at that place. That is probably 2318 // not intended, never used and almost certainly an error were it 2319 // ever be used this way (to try attaching at a specified address 2320 // without clobbering old mappings an alternate API exists, 2321 // os::attempt_reserve_memory_at()). 2322 // Instead of mimicking the dangerous coding of the other platforms, here I 2323 // just ignore the request address (release) or assert(debug). 2324 assert0(requested_addr == NULL); 2325 2326 // Always round to os::vm_page_size(), which may be larger than 4K. 2327 bytes = align_size_up(bytes, os::vm_page_size()); 2328 const size_t alignment_hint0 = 2329 alignment_hint ? align_size_up(alignment_hint, os::vm_page_size()) : 0; 2330 2331 // In 4K mode always use mmap. 2332 // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted. 2333 if (os::vm_page_size() == SIZE_4K) { 2334 return reserve_mmaped_memory(bytes, requested_addr, alignment_hint); 2335 } else { 2336 if (bytes >= Use64KPagesThreshold) { 2337 return reserve_shmated_memory(bytes, requested_addr, alignment_hint); 2338 } else { 2339 return reserve_mmaped_memory(bytes, requested_addr, alignment_hint); 2340 } 2341 } 2342 } 2343 2344 bool os::pd_release_memory(char* addr, size_t size) { 2345 2346 // Dynamically do different things for mmap/shmat. 2347 vmembk_t* const vmi = vmembk_find(addr); 2348 guarantee0(vmi); 2349 2350 // Always round to os::vm_page_size(), which may be larger than 4K. 2351 size = align_size_up(size, os::vm_page_size()); 2352 addr = (char *)align_ptr_up(addr, os::vm_page_size()); 2353 2354 bool rc = false; 2355 bool remove_bookkeeping = false; 2356 if (vmi->type == VMEM_SHMATED) { 2357 // For shmatted memory, we do: 2358 // - If user wants to release the whole range, release the memory (shmdt). 2359 // - If user only wants to release a partial range, uncommit (disclaim) that 2360 // range. That way, at least, we do not use memory anymore (bust still page 2361 // table space). 2362 vmi->assert_is_valid_subrange(addr, size); 2363 if (addr == vmi->addr && size == vmi->size) { 2364 rc = release_shmated_memory(addr, size); 2365 remove_bookkeeping = true; 2366 } else { 2367 rc = uncommit_shmated_memory(addr, size); 2368 } 2369 } else { 2370 // User may unmap partial regions but region has to be fully contained. 2371 #ifdef ASSERT 2372 vmi->assert_is_valid_subrange(addr, size); 2373 #endif 2374 rc = release_mmaped_memory(addr, size); 2375 remove_bookkeeping = true; 2376 } 2377 2378 // update bookkeeping 2379 if (rc && remove_bookkeeping) { 2380 vmembk_remove(vmi); 2381 } 2382 2383 return rc; 2384 } 2385 2386 static bool checked_mprotect(char* addr, size_t size, int prot) { 2387 2388 // Little problem here: if SPEC1170 behaviour is off, mprotect() on AIX will 2389 // not tell me if protection failed when trying to protect an un-protectable range. 2390 // 2391 // This means if the memory was allocated using shmget/shmat, protection wont work 2392 // but mprotect will still return 0: 2393 // 2394 // See http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/mprotect.htm 2395 2396 bool rc = ::mprotect(addr, size, prot) == 0 ? true : false; 2397 2398 if (!rc) { 2399 const char* const s_errno = os::errno_name(errno); 2400 warning("mprotect(" PTR_FORMAT "-" PTR_FORMAT ", 0x%X) failed (%s).", addr, addr + size, prot, s_errno); 2401 return false; 2402 } 2403 2404 // mprotect success check 2405 // 2406 // Mprotect said it changed the protection but can I believe it? 2407 // 2408 // To be sure I need to check the protection afterwards. Try to 2409 // read from protected memory and check whether that causes a segfault. 2410 // 2411 if (!os::Aix::xpg_sus_mode()) { 2412 2413 if (CanUseSafeFetch32()) { 2414 2415 const bool read_protected = 2416 (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 && 2417 SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false; 2418 2419 if (prot & PROT_READ) { 2420 rc = !read_protected; 2421 } else { 2422 rc = read_protected; 2423 } 2424 2425 if (!rc) { 2426 if (os::Aix::on_pase()) { 2427 // There is an issue on older PASE systems where mprotect() will return success but the 2428 // memory will not be protected. 2429 // This has nothing to do with the problem of using mproect() on SPEC1170 incompatible 2430 // machines; we only see it rarely, when using mprotect() to protect the guard page of 2431 // a stack. It is an OS error. 2432 // 2433 // A valid strategy is just to try again. This usually works. :-/ 2434 2435 ::usleep(1000); 2436 if (::mprotect(addr, size, prot) == 0) { 2437 const bool read_protected_2 = 2438 (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 && 2439 SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false; 2440 rc = true; 2441 } 2442 } 2443 } 2444 } 2445 } 2446 2447 assert(rc == true, "mprotect failed."); 2448 2449 return rc; 2450 } 2451 2452 // Set protections specified 2453 bool os::protect_memory(char* addr, size_t size, ProtType prot, bool is_committed) { 2454 unsigned int p = 0; 2455 switch (prot) { 2456 case MEM_PROT_NONE: p = PROT_NONE; break; 2457 case MEM_PROT_READ: p = PROT_READ; break; 2458 case MEM_PROT_RW: p = PROT_READ|PROT_WRITE; break; 2459 case MEM_PROT_RWX: p = PROT_READ|PROT_WRITE|PROT_EXEC; break; 2460 default: 2461 ShouldNotReachHere(); 2462 } 2463 // is_committed is unused. 2464 return checked_mprotect(addr, size, p); 2465 } 2466 2467 bool os::guard_memory(char* addr, size_t size) { 2468 return checked_mprotect(addr, size, PROT_NONE); 2469 } 2470 2471 bool os::unguard_memory(char* addr, size_t size) { 2472 return checked_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC); 2473 } 2474 2475 // Large page support 2476 2477 static size_t _large_page_size = 0; 2478 2479 // Enable large page support if OS allows that. 2480 void os::large_page_init() { 2481 return; // Nothing to do. See query_multipage_support and friends. 2482 } 2483 2484 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) { 2485 // reserve_memory_special() is used to allocate large paged memory. On AIX, we implement 2486 // 64k paged memory reservation using the normal memory allocation paths (os::reserve_memory()), 2487 // so this is not needed. 2488 assert(false, "should not be called on AIX"); 2489 return NULL; 2490 } 2491 2492 bool os::release_memory_special(char* base, size_t bytes) { 2493 // Detaching the SHM segment will also delete it, see reserve_memory_special(). 2494 Unimplemented(); 2495 return false; 2496 } 2497 2498 size_t os::large_page_size() { 2499 return _large_page_size; 2500 } 2501 2502 bool os::can_commit_large_page_memory() { 2503 // Does not matter, we do not support huge pages. 2504 return false; 2505 } 2506 2507 bool os::can_execute_large_page_memory() { 2508 // Does not matter, we do not support huge pages. 2509 return false; 2510 } 2511 2512 // Reserve memory at an arbitrary address, only if that area is 2513 // available (and not reserved for something else). 2514 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2515 char* addr = NULL; 2516 2517 // Always round to os::vm_page_size(), which may be larger than 4K. 2518 bytes = align_size_up(bytes, os::vm_page_size()); 2519 2520 // In 4K mode always use mmap. 2521 // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted. 2522 if (os::vm_page_size() == SIZE_4K) { 2523 return reserve_mmaped_memory(bytes, requested_addr, 0); 2524 } else { 2525 if (bytes >= Use64KPagesThreshold) { 2526 return reserve_shmated_memory(bytes, requested_addr, 0); 2527 } else { 2528 return reserve_mmaped_memory(bytes, requested_addr, 0); 2529 } 2530 } 2531 2532 return addr; 2533 } 2534 2535 size_t os::read(int fd, void *buf, unsigned int nBytes) { 2536 return ::read(fd, buf, nBytes); 2537 } 2538 2539 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) { 2540 return ::pread(fd, buf, nBytes, offset); 2541 } 2542 2543 void os::naked_short_sleep(jlong ms) { 2544 struct timespec req; 2545 2546 assert(ms < 1000, "Un-interruptable sleep, short time use only"); 2547 req.tv_sec = 0; 2548 if (ms > 0) { 2549 req.tv_nsec = (ms % 1000) * 1000000; 2550 } 2551 else { 2552 req.tv_nsec = 1; 2553 } 2554 2555 nanosleep(&req, NULL); 2556 2557 return; 2558 } 2559 2560 // Sleep forever; naked call to OS-specific sleep; use with CAUTION 2561 void os::infinite_sleep() { 2562 while (true) { // sleep forever ... 2563 ::sleep(100); // ... 100 seconds at a time 2564 } 2565 } 2566 2567 // Used to convert frequent JVM_Yield() to nops 2568 bool os::dont_yield() { 2569 return DontYieldALot; 2570 } 2571 2572 void os::naked_yield() { 2573 sched_yield(); 2574 } 2575 2576 //////////////////////////////////////////////////////////////////////////////// 2577 // thread priority support 2578 2579 // From AIX manpage to pthread_setschedparam 2580 // (see: http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp? 2581 // topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_setschedparam.htm): 2582 // 2583 // "If schedpolicy is SCHED_OTHER, then sched_priority must be in the 2584 // range from 40 to 80, where 40 is the least favored priority and 80 2585 // is the most favored." 2586 // 2587 // (Actually, I doubt this even has an impact on AIX, as we do kernel 2588 // scheduling there; however, this still leaves iSeries.) 2589 // 2590 // We use the same values for AIX and PASE. 2591 int os::java_to_os_priority[CriticalPriority + 1] = { 2592 54, // 0 Entry should never be used 2593 2594 55, // 1 MinPriority 2595 55, // 2 2596 56, // 3 2597 2598 56, // 4 2599 57, // 5 NormPriority 2600 57, // 6 2601 2602 58, // 7 2603 58, // 8 2604 59, // 9 NearMaxPriority 2605 2606 60, // 10 MaxPriority 2607 2608 60 // 11 CriticalPriority 2609 }; 2610 2611 OSReturn os::set_native_priority(Thread* thread, int newpri) { 2612 if (!UseThreadPriorities) return OS_OK; 2613 pthread_t thr = thread->osthread()->pthread_id(); 2614 int policy = SCHED_OTHER; 2615 struct sched_param param; 2616 param.sched_priority = newpri; 2617 int ret = pthread_setschedparam(thr, policy, ¶m); 2618 2619 if (ret != 0) { 2620 trcVerbose("Could not change priority for thread %d to %d (error %d, %s)", 2621 (int)thr, newpri, ret, os::errno_name(ret)); 2622 } 2623 return (ret == 0) ? OS_OK : OS_ERR; 2624 } 2625 2626 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) { 2627 if (!UseThreadPriorities) { 2628 *priority_ptr = java_to_os_priority[NormPriority]; 2629 return OS_OK; 2630 } 2631 pthread_t thr = thread->osthread()->pthread_id(); 2632 int policy = SCHED_OTHER; 2633 struct sched_param param; 2634 int ret = pthread_getschedparam(thr, &policy, ¶m); 2635 *priority_ptr = param.sched_priority; 2636 2637 return (ret == 0) ? OS_OK : OS_ERR; 2638 } 2639 2640 // Hint to the underlying OS that a task switch would not be good. 2641 // Void return because it's a hint and can fail. 2642 void os::hint_no_preempt() {} 2643 2644 //////////////////////////////////////////////////////////////////////////////// 2645 // suspend/resume support 2646 2647 // the low-level signal-based suspend/resume support is a remnant from the 2648 // old VM-suspension that used to be for java-suspension, safepoints etc, 2649 // within hotspot. Now there is a single use-case for this: 2650 // - calling get_thread_pc() on the VMThread by the flat-profiler task 2651 // that runs in the watcher thread. 2652 // The remaining code is greatly simplified from the more general suspension 2653 // code that used to be used. 2654 // 2655 // The protocol is quite simple: 2656 // - suspend: 2657 // - sends a signal to the target thread 2658 // - polls the suspend state of the osthread using a yield loop 2659 // - target thread signal handler (SR_handler) sets suspend state 2660 // and blocks in sigsuspend until continued 2661 // - resume: 2662 // - sets target osthread state to continue 2663 // - sends signal to end the sigsuspend loop in the SR_handler 2664 // 2665 // Note that the SR_lock plays no role in this suspend/resume protocol, 2666 // but is checked for NULL in SR_handler as a thread termination indicator. 2667 // 2668 2669 static void resume_clear_context(OSThread *osthread) { 2670 osthread->set_ucontext(NULL); 2671 osthread->set_siginfo(NULL); 2672 } 2673 2674 static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) { 2675 osthread->set_ucontext(context); 2676 osthread->set_siginfo(siginfo); 2677 } 2678 2679 // 2680 // Handler function invoked when a thread's execution is suspended or 2681 // resumed. We have to be careful that only async-safe functions are 2682 // called here (Note: most pthread functions are not async safe and 2683 // should be avoided.) 2684 // 2685 // Note: sigwait() is a more natural fit than sigsuspend() from an 2686 // interface point of view, but sigwait() prevents the signal hander 2687 // from being run. libpthread would get very confused by not having 2688 // its signal handlers run and prevents sigwait()'s use with the 2689 // mutex granting granting signal. 2690 // 2691 // Currently only ever called on the VMThread and JavaThreads (PC sampling). 2692 // 2693 static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) { 2694 // Save and restore errno to avoid confusing native code with EINTR 2695 // after sigsuspend. 2696 int old_errno = errno; 2697 2698 Thread* thread = Thread::current_or_null_safe(); 2699 assert(thread != NULL, "Missing current thread in SR_handler"); 2700 2701 // On some systems we have seen signal delivery get "stuck" until the signal 2702 // mask is changed as part of thread termination. Check that the current thread 2703 // has not already terminated (via SR_lock()) - else the following assertion 2704 // will fail because the thread is no longer a JavaThread as the ~JavaThread 2705 // destructor has completed. 2706 2707 if (thread->SR_lock() == NULL) { 2708 return; 2709 } 2710 2711 assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread"); 2712 2713 OSThread* osthread = thread->osthread(); 2714 2715 os::SuspendResume::State current = osthread->sr.state(); 2716 if (current == os::SuspendResume::SR_SUSPEND_REQUEST) { 2717 suspend_save_context(osthread, siginfo, context); 2718 2719 // attempt to switch the state, we assume we had a SUSPEND_REQUEST 2720 os::SuspendResume::State state = osthread->sr.suspended(); 2721 if (state == os::SuspendResume::SR_SUSPENDED) { 2722 sigset_t suspend_set; // signals for sigsuspend() 2723 2724 // get current set of blocked signals and unblock resume signal 2725 pthread_sigmask(SIG_BLOCK, NULL, &suspend_set); 2726 sigdelset(&suspend_set, SR_signum); 2727 2728 // wait here until we are resumed 2729 while (1) { 2730 sigsuspend(&suspend_set); 2731 2732 os::SuspendResume::State result = osthread->sr.running(); 2733 if (result == os::SuspendResume::SR_RUNNING) { 2734 break; 2735 } 2736 } 2737 2738 } else if (state == os::SuspendResume::SR_RUNNING) { 2739 // request was cancelled, continue 2740 } else { 2741 ShouldNotReachHere(); 2742 } 2743 2744 resume_clear_context(osthread); 2745 } else if (current == os::SuspendResume::SR_RUNNING) { 2746 // request was cancelled, continue 2747 } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) { 2748 // ignore 2749 } else { 2750 ShouldNotReachHere(); 2751 } 2752 2753 errno = old_errno; 2754 } 2755 2756 static int SR_initialize() { 2757 struct sigaction act; 2758 char *s; 2759 // Get signal number to use for suspend/resume 2760 if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) { 2761 int sig = ::strtol(s, 0, 10); 2762 if (sig > MAX2(SIGSEGV, SIGBUS) && // See 4355769. 2763 sig < NSIG) { // Must be legal signal and fit into sigflags[]. 2764 SR_signum = sig; 2765 } else { 2766 warning("You set _JAVA_SR_SIGNUM=%d. It must be in range [%d, %d]. Using %d instead.", 2767 sig, MAX2(SIGSEGV, SIGBUS)+1, NSIG-1, SR_signum); 2768 } 2769 } 2770 2771 assert(SR_signum > SIGSEGV && SR_signum > SIGBUS, 2772 "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769"); 2773 2774 sigemptyset(&SR_sigset); 2775 sigaddset(&SR_sigset, SR_signum); 2776 2777 // Set up signal handler for suspend/resume. 2778 act.sa_flags = SA_RESTART|SA_SIGINFO; 2779 act.sa_handler = (void (*)(int)) SR_handler; 2780 2781 // SR_signum is blocked by default. 2782 pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask); 2783 2784 if (sigaction(SR_signum, &act, 0) == -1) { 2785 return -1; 2786 } 2787 2788 // Save signal flag 2789 os::Aix::set_our_sigflags(SR_signum, act.sa_flags); 2790 return 0; 2791 } 2792 2793 static int SR_finalize() { 2794 return 0; 2795 } 2796 2797 static int sr_notify(OSThread* osthread) { 2798 int status = pthread_kill(osthread->pthread_id(), SR_signum); 2799 assert_status(status == 0, status, "pthread_kill"); 2800 return status; 2801 } 2802 2803 // "Randomly" selected value for how long we want to spin 2804 // before bailing out on suspending a thread, also how often 2805 // we send a signal to a thread we want to resume 2806 static const int RANDOMLY_LARGE_INTEGER = 1000000; 2807 static const int RANDOMLY_LARGE_INTEGER2 = 100; 2808 2809 // returns true on success and false on error - really an error is fatal 2810 // but this seems the normal response to library errors 2811 static bool do_suspend(OSThread* osthread) { 2812 assert(osthread->sr.is_running(), "thread should be running"); 2813 // mark as suspended and send signal 2814 2815 if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) { 2816 // failed to switch, state wasn't running? 2817 ShouldNotReachHere(); 2818 return false; 2819 } 2820 2821 if (sr_notify(osthread) != 0) { 2822 // try to cancel, switch to running 2823 2824 os::SuspendResume::State result = osthread->sr.cancel_suspend(); 2825 if (result == os::SuspendResume::SR_RUNNING) { 2826 // cancelled 2827 return false; 2828 } else if (result == os::SuspendResume::SR_SUSPENDED) { 2829 // somehow managed to suspend 2830 return true; 2831 } else { 2832 ShouldNotReachHere(); 2833 return false; 2834 } 2835 } 2836 2837 // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED 2838 2839 for (int n = 0; !osthread->sr.is_suspended(); n++) { 2840 for (int i = 0; i < RANDOMLY_LARGE_INTEGER2 && !osthread->sr.is_suspended(); i++) { 2841 os::naked_yield(); 2842 } 2843 2844 // timeout, try to cancel the request 2845 if (n >= RANDOMLY_LARGE_INTEGER) { 2846 os::SuspendResume::State cancelled = osthread->sr.cancel_suspend(); 2847 if (cancelled == os::SuspendResume::SR_RUNNING) { 2848 return false; 2849 } else if (cancelled == os::SuspendResume::SR_SUSPENDED) { 2850 return true; 2851 } else { 2852 ShouldNotReachHere(); 2853 return false; 2854 } 2855 } 2856 } 2857 2858 guarantee(osthread->sr.is_suspended(), "Must be suspended"); 2859 return true; 2860 } 2861 2862 static void do_resume(OSThread* osthread) { 2863 //assert(osthread->sr.is_suspended(), "thread should be suspended"); 2864 2865 if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) { 2866 // failed to switch to WAKEUP_REQUEST 2867 ShouldNotReachHere(); 2868 return; 2869 } 2870 2871 while (!osthread->sr.is_running()) { 2872 if (sr_notify(osthread) == 0) { 2873 for (int n = 0; n < RANDOMLY_LARGE_INTEGER && !osthread->sr.is_running(); n++) { 2874 for (int i = 0; i < 100 && !osthread->sr.is_running(); i++) { 2875 os::naked_yield(); 2876 } 2877 } 2878 } else { 2879 ShouldNotReachHere(); 2880 } 2881 } 2882 2883 guarantee(osthread->sr.is_running(), "Must be running!"); 2884 } 2885 2886 /////////////////////////////////////////////////////////////////////////////////// 2887 // signal handling (except suspend/resume) 2888 2889 // This routine may be used by user applications as a "hook" to catch signals. 2890 // The user-defined signal handler must pass unrecognized signals to this 2891 // routine, and if it returns true (non-zero), then the signal handler must 2892 // return immediately. If the flag "abort_if_unrecognized" is true, then this 2893 // routine will never retun false (zero), but instead will execute a VM panic 2894 // routine kill the process. 2895 // 2896 // If this routine returns false, it is OK to call it again. This allows 2897 // the user-defined signal handler to perform checks either before or after 2898 // the VM performs its own checks. Naturally, the user code would be making 2899 // a serious error if it tried to handle an exception (such as a null check 2900 // or breakpoint) that the VM was generating for its own correct operation. 2901 // 2902 // This routine may recognize any of the following kinds of signals: 2903 // SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1. 2904 // It should be consulted by handlers for any of those signals. 2905 // 2906 // The caller of this routine must pass in the three arguments supplied 2907 // to the function referred to in the "sa_sigaction" (not the "sa_handler") 2908 // field of the structure passed to sigaction(). This routine assumes that 2909 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART. 2910 // 2911 // Note that the VM will print warnings if it detects conflicting signal 2912 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers". 2913 // 2914 extern "C" JNIEXPORT int 2915 JVM_handle_aix_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized); 2916 2917 // Set thread signal mask (for some reason on AIX sigthreadmask() seems 2918 // to be the thing to call; documentation is not terribly clear about whether 2919 // pthread_sigmask also works, and if it does, whether it does the same. 2920 bool set_thread_signal_mask(int how, const sigset_t* set, sigset_t* oset) { 2921 const int rc = ::pthread_sigmask(how, set, oset); 2922 // return value semantics differ slightly for error case: 2923 // pthread_sigmask returns error number, sigthreadmask -1 and sets global errno 2924 // (so, pthread_sigmask is more theadsafe for error handling) 2925 // But success is always 0. 2926 return rc == 0 ? true : false; 2927 } 2928 2929 // Function to unblock all signals which are, according 2930 // to POSIX, typical program error signals. If they happen while being blocked, 2931 // they typically will bring down the process immediately. 2932 bool unblock_program_error_signals() { 2933 sigset_t set; 2934 ::sigemptyset(&set); 2935 ::sigaddset(&set, SIGILL); 2936 ::sigaddset(&set, SIGBUS); 2937 ::sigaddset(&set, SIGFPE); 2938 ::sigaddset(&set, SIGSEGV); 2939 return set_thread_signal_mask(SIG_UNBLOCK, &set, NULL); 2940 } 2941 2942 // Renamed from 'signalHandler' to avoid collision with other shared libs. 2943 void javaSignalHandler(int sig, siginfo_t* info, void* uc) { 2944 assert(info != NULL && uc != NULL, "it must be old kernel"); 2945 2946 // Never leave program error signals blocked; 2947 // on all our platforms they would bring down the process immediately when 2948 // getting raised while being blocked. 2949 unblock_program_error_signals(); 2950 2951 int orig_errno = errno; // Preserve errno value over signal handler. 2952 JVM_handle_aix_signal(sig, info, uc, true); 2953 errno = orig_errno; 2954 } 2955 2956 // This boolean allows users to forward their own non-matching signals 2957 // to JVM_handle_aix_signal, harmlessly. 2958 bool os::Aix::signal_handlers_are_installed = false; 2959 2960 // For signal-chaining 2961 struct sigaction sigact[NSIG]; 2962 sigset_t sigs; 2963 bool os::Aix::libjsig_is_loaded = false; 2964 typedef struct sigaction *(*get_signal_t)(int); 2965 get_signal_t os::Aix::get_signal_action = NULL; 2966 2967 struct sigaction* os::Aix::get_chained_signal_action(int sig) { 2968 struct sigaction *actp = NULL; 2969 2970 if (libjsig_is_loaded) { 2971 // Retrieve the old signal handler from libjsig 2972 actp = (*get_signal_action)(sig); 2973 } 2974 if (actp == NULL) { 2975 // Retrieve the preinstalled signal handler from jvm 2976 actp = get_preinstalled_handler(sig); 2977 } 2978 2979 return actp; 2980 } 2981 2982 static bool call_chained_handler(struct sigaction *actp, int sig, 2983 siginfo_t *siginfo, void *context) { 2984 // Call the old signal handler 2985 if (actp->sa_handler == SIG_DFL) { 2986 // It's more reasonable to let jvm treat it as an unexpected exception 2987 // instead of taking the default action. 2988 return false; 2989 } else if (actp->sa_handler != SIG_IGN) { 2990 if ((actp->sa_flags & SA_NODEFER) == 0) { 2991 // automaticlly block the signal 2992 sigaddset(&(actp->sa_mask), sig); 2993 } 2994 2995 sa_handler_t hand = NULL; 2996 sa_sigaction_t sa = NULL; 2997 bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0; 2998 // retrieve the chained handler 2999 if (siginfo_flag_set) { 3000 sa = actp->sa_sigaction; 3001 } else { 3002 hand = actp->sa_handler; 3003 } 3004 3005 if ((actp->sa_flags & SA_RESETHAND) != 0) { 3006 actp->sa_handler = SIG_DFL; 3007 } 3008 3009 // try to honor the signal mask 3010 sigset_t oset; 3011 pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset); 3012 3013 // call into the chained handler 3014 if (siginfo_flag_set) { 3015 (*sa)(sig, siginfo, context); 3016 } else { 3017 (*hand)(sig); 3018 } 3019 3020 // restore the signal mask 3021 pthread_sigmask(SIG_SETMASK, &oset, 0); 3022 } 3023 // Tell jvm's signal handler the signal is taken care of. 3024 return true; 3025 } 3026 3027 bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) { 3028 bool chained = false; 3029 // signal-chaining 3030 if (UseSignalChaining) { 3031 struct sigaction *actp = get_chained_signal_action(sig); 3032 if (actp != NULL) { 3033 chained = call_chained_handler(actp, sig, siginfo, context); 3034 } 3035 } 3036 return chained; 3037 } 3038 3039 struct sigaction* os::Aix::get_preinstalled_handler(int sig) { 3040 if (sigismember(&sigs, sig)) { 3041 return &sigact[sig]; 3042 } 3043 return NULL; 3044 } 3045 3046 void os::Aix::save_preinstalled_handler(int sig, struct sigaction& oldAct) { 3047 assert(sig > 0 && sig < NSIG, "vm signal out of expected range"); 3048 sigact[sig] = oldAct; 3049 sigaddset(&sigs, sig); 3050 } 3051 3052 // for diagnostic 3053 int sigflags[NSIG]; 3054 3055 int os::Aix::get_our_sigflags(int sig) { 3056 assert(sig > 0 && sig < NSIG, "vm signal out of expected range"); 3057 return sigflags[sig]; 3058 } 3059 3060 void os::Aix::set_our_sigflags(int sig, int flags) { 3061 assert(sig > 0 && sig < NSIG, "vm signal out of expected range"); 3062 if (sig > 0 && sig < NSIG) { 3063 sigflags[sig] = flags; 3064 } 3065 } 3066 3067 void os::Aix::set_signal_handler(int sig, bool set_installed) { 3068 // Check for overwrite. 3069 struct sigaction oldAct; 3070 sigaction(sig, (struct sigaction*)NULL, &oldAct); 3071 3072 void* oldhand = oldAct.sa_sigaction 3073 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 3074 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 3075 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) && 3076 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) && 3077 oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) { 3078 if (AllowUserSignalHandlers || !set_installed) { 3079 // Do not overwrite; user takes responsibility to forward to us. 3080 return; 3081 } else if (UseSignalChaining) { 3082 // save the old handler in jvm 3083 save_preinstalled_handler(sig, oldAct); 3084 // libjsig also interposes the sigaction() call below and saves the 3085 // old sigaction on it own. 3086 } else { 3087 fatal("Encountered unexpected pre-existing sigaction handler " 3088 "%#lx for signal %d.", (long)oldhand, sig); 3089 } 3090 } 3091 3092 struct sigaction sigAct; 3093 sigfillset(&(sigAct.sa_mask)); 3094 if (!set_installed) { 3095 sigAct.sa_handler = SIG_DFL; 3096 sigAct.sa_flags = SA_RESTART; 3097 } else { 3098 sigAct.sa_sigaction = javaSignalHandler; 3099 sigAct.sa_flags = SA_SIGINFO|SA_RESTART; 3100 } 3101 // Save flags, which are set by ours 3102 assert(sig > 0 && sig < NSIG, "vm signal out of expected range"); 3103 sigflags[sig] = sigAct.sa_flags; 3104 3105 int ret = sigaction(sig, &sigAct, &oldAct); 3106 assert(ret == 0, "check"); 3107 3108 void* oldhand2 = oldAct.sa_sigaction 3109 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction) 3110 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler); 3111 assert(oldhand2 == oldhand, "no concurrent signal handler installation"); 3112 } 3113 3114 // install signal handlers for signals that HotSpot needs to 3115 // handle in order to support Java-level exception handling. 3116 void os::Aix::install_signal_handlers() { 3117 if (!signal_handlers_are_installed) { 3118 signal_handlers_are_installed = true; 3119 3120 // signal-chaining 3121 typedef void (*signal_setting_t)(); 3122 signal_setting_t begin_signal_setting = NULL; 3123 signal_setting_t end_signal_setting = NULL; 3124 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 3125 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting")); 3126 if (begin_signal_setting != NULL) { 3127 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t, 3128 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting")); 3129 get_signal_action = CAST_TO_FN_PTR(get_signal_t, 3130 dlsym(RTLD_DEFAULT, "JVM_get_signal_action")); 3131 libjsig_is_loaded = true; 3132 assert(UseSignalChaining, "should enable signal-chaining"); 3133 } 3134 if (libjsig_is_loaded) { 3135 // Tell libjsig jvm is setting signal handlers. 3136 (*begin_signal_setting)(); 3137 } 3138 3139 ::sigemptyset(&sigs); 3140 set_signal_handler(SIGSEGV, true); 3141 set_signal_handler(SIGPIPE, true); 3142 set_signal_handler(SIGBUS, true); 3143 set_signal_handler(SIGILL, true); 3144 set_signal_handler(SIGFPE, true); 3145 set_signal_handler(SIGTRAP, true); 3146 set_signal_handler(SIGXFSZ, true); 3147 set_signal_handler(SIGDANGER, true); 3148 3149 if (libjsig_is_loaded) { 3150 // Tell libjsig jvm finishes setting signal handlers. 3151 (*end_signal_setting)(); 3152 } 3153 3154 // We don't activate signal checker if libjsig is in place, we trust ourselves 3155 // and if UserSignalHandler is installed all bets are off. 3156 // Log that signal checking is off only if -verbose:jni is specified. 3157 if (CheckJNICalls) { 3158 if (libjsig_is_loaded) { 3159 tty->print_cr("Info: libjsig is activated, all active signal checking is disabled"); 3160 check_signals = false; 3161 } 3162 if (AllowUserSignalHandlers) { 3163 tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled"); 3164 check_signals = false; 3165 } 3166 // Need to initialize check_signal_done. 3167 ::sigemptyset(&check_signal_done); 3168 } 3169 } 3170 } 3171 3172 static const char* get_signal_handler_name(address handler, 3173 char* buf, int buflen) { 3174 int offset; 3175 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset); 3176 if (found) { 3177 // skip directory names 3178 const char *p1, *p2; 3179 p1 = buf; 3180 size_t len = strlen(os::file_separator()); 3181 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len; 3182 // The way os::dll_address_to_library_name is implemented on Aix 3183 // right now, it always returns -1 for the offset which is not 3184 // terribly informative. 3185 // Will fix that. For now, omit the offset. 3186 jio_snprintf(buf, buflen, "%s", p1); 3187 } else { 3188 jio_snprintf(buf, buflen, PTR_FORMAT, handler); 3189 } 3190 return buf; 3191 } 3192 3193 static void print_signal_handler(outputStream* st, int sig, 3194 char* buf, size_t buflen) { 3195 struct sigaction sa; 3196 sigaction(sig, NULL, &sa); 3197 3198 st->print("%s: ", os::exception_name(sig, buf, buflen)); 3199 3200 address handler = (sa.sa_flags & SA_SIGINFO) 3201 ? CAST_FROM_FN_PTR(address, sa.sa_sigaction) 3202 : CAST_FROM_FN_PTR(address, sa.sa_handler); 3203 3204 if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) { 3205 st->print("SIG_DFL"); 3206 } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) { 3207 st->print("SIG_IGN"); 3208 } else { 3209 st->print("[%s]", get_signal_handler_name(handler, buf, buflen)); 3210 } 3211 3212 // Print readable mask. 3213 st->print(", sa_mask[0]="); 3214 os::Posix::print_signal_set_short(st, &sa.sa_mask); 3215 3216 address rh = VMError::get_resetted_sighandler(sig); 3217 // May be, handler was resetted by VMError? 3218 if (rh != NULL) { 3219 handler = rh; 3220 sa.sa_flags = VMError::get_resetted_sigflags(sig); 3221 } 3222 3223 // Print textual representation of sa_flags. 3224 st->print(", sa_flags="); 3225 os::Posix::print_sa_flags(st, sa.sa_flags); 3226 3227 // Check: is it our handler? 3228 if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler) || 3229 handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) { 3230 // It is our signal handler. 3231 // Check for flags, reset system-used one! 3232 if ((int)sa.sa_flags != os::Aix::get_our_sigflags(sig)) { 3233 st->print(", flags was changed from " PTR32_FORMAT ", consider using jsig library", 3234 os::Aix::get_our_sigflags(sig)); 3235 } 3236 } 3237 st->cr(); 3238 } 3239 3240 #define DO_SIGNAL_CHECK(sig) \ 3241 if (!sigismember(&check_signal_done, sig)) \ 3242 os::Aix::check_signal_handler(sig) 3243 3244 // This method is a periodic task to check for misbehaving JNI applications 3245 // under CheckJNI, we can add any periodic checks here 3246 3247 void os::run_periodic_checks() { 3248 3249 if (check_signals == false) return; 3250 3251 // SEGV and BUS if overridden could potentially prevent 3252 // generation of hs*.log in the event of a crash, debugging 3253 // such a case can be very challenging, so we absolutely 3254 // check the following for a good measure: 3255 DO_SIGNAL_CHECK(SIGSEGV); 3256 DO_SIGNAL_CHECK(SIGILL); 3257 DO_SIGNAL_CHECK(SIGFPE); 3258 DO_SIGNAL_CHECK(SIGBUS); 3259 DO_SIGNAL_CHECK(SIGPIPE); 3260 DO_SIGNAL_CHECK(SIGXFSZ); 3261 if (UseSIGTRAP) { 3262 DO_SIGNAL_CHECK(SIGTRAP); 3263 } 3264 DO_SIGNAL_CHECK(SIGDANGER); 3265 3266 // ReduceSignalUsage allows the user to override these handlers 3267 // see comments at the very top and jvm_solaris.h 3268 if (!ReduceSignalUsage) { 3269 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL); 3270 DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL); 3271 DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL); 3272 DO_SIGNAL_CHECK(BREAK_SIGNAL); 3273 } 3274 3275 DO_SIGNAL_CHECK(SR_signum); 3276 } 3277 3278 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *); 3279 3280 static os_sigaction_t os_sigaction = NULL; 3281 3282 void os::Aix::check_signal_handler(int sig) { 3283 char buf[O_BUFLEN]; 3284 address jvmHandler = NULL; 3285 3286 struct sigaction act; 3287 if (os_sigaction == NULL) { 3288 // only trust the default sigaction, in case it has been interposed 3289 os_sigaction = CAST_TO_FN_PTR(os_sigaction_t, dlsym(RTLD_DEFAULT, "sigaction")); 3290 if (os_sigaction == NULL) return; 3291 } 3292 3293 os_sigaction(sig, (struct sigaction*)NULL, &act); 3294 3295 address thisHandler = (act.sa_flags & SA_SIGINFO) 3296 ? CAST_FROM_FN_PTR(address, act.sa_sigaction) 3297 : CAST_FROM_FN_PTR(address, act.sa_handler); 3298 3299 switch(sig) { 3300 case SIGSEGV: 3301 case SIGBUS: 3302 case SIGFPE: 3303 case SIGPIPE: 3304 case SIGILL: 3305 case SIGXFSZ: 3306 jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler); 3307 break; 3308 3309 case SHUTDOWN1_SIGNAL: 3310 case SHUTDOWN2_SIGNAL: 3311 case SHUTDOWN3_SIGNAL: 3312 case BREAK_SIGNAL: 3313 jvmHandler = (address)user_handler(); 3314 break; 3315 3316 default: 3317 if (sig == SR_signum) { 3318 jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler); 3319 } else { 3320 return; 3321 } 3322 break; 3323 } 3324 3325 if (thisHandler != jvmHandler) { 3326 tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN)); 3327 tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN)); 3328 tty->print_cr(" found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN)); 3329 // No need to check this sig any longer 3330 sigaddset(&check_signal_done, sig); 3331 // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN 3332 if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) { 3333 tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell", 3334 exception_name(sig, buf, O_BUFLEN)); 3335 } 3336 } else if (os::Aix::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Aix::get_our_sigflags(sig)) { 3337 tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN)); 3338 tty->print("expected:"); 3339 os::Posix::print_sa_flags(tty, os::Aix::get_our_sigflags(sig)); 3340 tty->cr(); 3341 tty->print(" found:"); 3342 os::Posix::print_sa_flags(tty, act.sa_flags); 3343 tty->cr(); 3344 // No need to check this sig any longer 3345 sigaddset(&check_signal_done, sig); 3346 } 3347 3348 // Dump all the signal 3349 if (sigismember(&check_signal_done, sig)) { 3350 print_signal_handlers(tty, buf, O_BUFLEN); 3351 } 3352 } 3353 3354 // To install functions for atexit system call 3355 extern "C" { 3356 static void perfMemory_exit_helper() { 3357 perfMemory_exit(); 3358 } 3359 } 3360 3361 // This is called _before_ the most of global arguments have been parsed. 3362 void os::init(void) { 3363 // This is basic, we want to know if that ever changes. 3364 // (Shared memory boundary is supposed to be a 256M aligned.) 3365 assert(SHMLBA == ((uint64_t)0x10000000ULL)/*256M*/, "unexpected"); 3366 3367 // Record process break at startup. 3368 g_brk_at_startup = (address) ::sbrk(0); 3369 assert(g_brk_at_startup != (address) -1, "sbrk failed"); 3370 3371 // First off, we need to know whether we run on AIX or PASE, and 3372 // the OS level we run on. 3373 os::Aix::initialize_os_info(); 3374 3375 // Scan environment (SPEC1170 behaviour, etc). 3376 os::Aix::scan_environment(); 3377 3378 // Probe multipage support. 3379 query_multipage_support(); 3380 3381 // Act like we only have one page size by eliminating corner cases which 3382 // we did not support very well anyway. 3383 // We have two input conditions: 3384 // 1) Data segment page size. This is controlled by linker setting (datapsize) on the 3385 // launcher, and/or by LDR_CNTRL environment variable. The latter overrules the linker 3386 // setting. 3387 // Data segment page size is important for us because it defines the thread stack page 3388 // size, which is needed for guard page handling, stack banging etc. 3389 // 2) The ability to allocate 64k pages dynamically. If this is a given, java heap can 3390 // and should be allocated with 64k pages. 3391 // 3392 // So, we do the following: 3393 // LDR_CNTRL can_use_64K_pages_dynamically what we do remarks 3394 // 4K no 4K old systems (aix 5.2, as/400 v5r4) or new systems with AME activated 3395 // 4k yes 64k (treat 4k stacks as 64k) different loader than java and standard settings 3396 // 64k no --- AIX 5.2 ? --- 3397 // 64k yes 64k new systems and standard java loader (we set datapsize=64k when linking) 3398 3399 // We explicitly leave no option to change page size, because only upgrading would work, 3400 // not downgrading (if stack page size is 64k you cannot pretend its 4k). 3401 3402 if (g_multipage_support.datapsize == SIZE_4K) { 3403 // datapsize = 4K. Data segment, thread stacks are 4K paged. 3404 if (g_multipage_support.can_use_64K_pages) { 3405 // .. but we are able to use 64K pages dynamically. 3406 // This would be typical for java launchers which are not linked 3407 // with datapsize=64K (like, any other launcher but our own). 3408 // 3409 // In this case it would be smart to allocate the java heap with 64K 3410 // to get the performance benefit, and to fake 64k pages for the 3411 // data segment (when dealing with thread stacks). 3412 // 3413 // However, leave a possibility to downgrade to 4K, using 3414 // -XX:-Use64KPages. 3415 if (Use64KPages) { 3416 trcVerbose("64K page mode (faked for data segment)"); 3417 Aix::_page_size = SIZE_64K; 3418 } else { 3419 trcVerbose("4K page mode (Use64KPages=off)"); 3420 Aix::_page_size = SIZE_4K; 3421 } 3422 } else { 3423 // .. and not able to allocate 64k pages dynamically. Here, just 3424 // fall back to 4K paged mode and use mmap for everything. 3425 trcVerbose("4K page mode"); 3426 Aix::_page_size = SIZE_4K; 3427 FLAG_SET_ERGO(bool, Use64KPages, false); 3428 } 3429 } else { 3430 // datapsize = 64k. Data segment, thread stacks are 64k paged. 3431 // This normally means that we can allocate 64k pages dynamically. 3432 // (There is one special case where this may be false: EXTSHM=on. 3433 // but we decided to not support that mode). 3434 assert0(g_multipage_support.can_use_64K_pages); 3435 Aix::_page_size = SIZE_64K; 3436 trcVerbose("64K page mode"); 3437 FLAG_SET_ERGO(bool, Use64KPages, true); 3438 } 3439 3440 // For now UseLargePages is just ignored. 3441 FLAG_SET_ERGO(bool, UseLargePages, false); 3442 _page_sizes[0] = 0; 3443 3444 // debug trace 3445 trcVerbose("os::vm_page_size %s", describe_pagesize(os::vm_page_size())); 3446 3447 // Next, we need to initialize libo4 and libperfstat libraries. 3448 if (os::Aix::on_pase()) { 3449 os::Aix::initialize_libo4(); 3450 } else { 3451 os::Aix::initialize_libperfstat(); 3452 } 3453 3454 // Reset the perfstat information provided by ODM. 3455 if (os::Aix::on_aix()) { 3456 libperfstat::perfstat_reset(); 3457 } 3458 3459 // Now initialze basic system properties. Note that for some of the values we 3460 // need libperfstat etc. 3461 os::Aix::initialize_system_info(); 3462 3463 clock_tics_per_sec = sysconf(_SC_CLK_TCK); 3464 3465 init_random(1234567); 3466 3467 ThreadCritical::initialize(); 3468 3469 // Main_thread points to the aboriginal thread. 3470 Aix::_main_thread = pthread_self(); 3471 3472 initial_time_count = os::elapsed_counter(); 3473 } 3474 3475 // This is called _after_ the global arguments have been parsed. 3476 jint os::init_2(void) { 3477 3478 if (os::Aix::on_pase()) { 3479 trcVerbose("Running on PASE."); 3480 } else { 3481 trcVerbose("Running on AIX (not PASE)."); 3482 } 3483 3484 trcVerbose("processor count: %d", os::_processor_count); 3485 trcVerbose("physical memory: %lu", Aix::_physical_memory); 3486 3487 // Initially build up the loaded dll map. 3488 LoadedLibraries::reload(); 3489 if (Verbose) { 3490 trcVerbose("Loaded Libraries: "); 3491 LoadedLibraries::print(tty); 3492 } 3493 3494 const int page_size = Aix::page_size(); 3495 const int map_size = page_size; 3496 3497 address map_address = (address) MAP_FAILED; 3498 const int prot = PROT_READ; 3499 const int flags = MAP_PRIVATE|MAP_ANONYMOUS; 3500 3501 // Use optimized addresses for the polling page, 3502 // e.g. map it to a special 32-bit address. 3503 if (OptimizePollingPageLocation) { 3504 // architecture-specific list of address wishes: 3505 address address_wishes[] = { 3506 // AIX: addresses lower than 0x30000000 don't seem to work on AIX. 3507 // PPC64: all address wishes are non-negative 32 bit values where 3508 // the lower 16 bits are all zero. we can load these addresses 3509 // with a single ppc_lis instruction. 3510 (address) 0x30000000, (address) 0x31000000, 3511 (address) 0x32000000, (address) 0x33000000, 3512 (address) 0x40000000, (address) 0x41000000, 3513 (address) 0x42000000, (address) 0x43000000, 3514 (address) 0x50000000, (address) 0x51000000, 3515 (address) 0x52000000, (address) 0x53000000, 3516 (address) 0x60000000, (address) 0x61000000, 3517 (address) 0x62000000, (address) 0x63000000 3518 }; 3519 int address_wishes_length = sizeof(address_wishes)/sizeof(address); 3520 3521 // iterate over the list of address wishes: 3522 for (int i=0; i<address_wishes_length; i++) { 3523 // Try to map with current address wish. 3524 // AIX: AIX needs MAP_FIXED if we provide an address and mmap will 3525 // fail if the address is already mapped. 3526 map_address = (address) ::mmap(address_wishes[i] - (ssize_t)page_size, 3527 map_size, prot, 3528 flags | MAP_FIXED, 3529 -1, 0); 3530 trcVerbose("SafePoint Polling Page address: %p (wish) => %p", 3531 address_wishes[i], map_address + (ssize_t)page_size); 3532 3533 if (map_address + (ssize_t)page_size == address_wishes[i]) { 3534 // Map succeeded and map_address is at wished address, exit loop. 3535 break; 3536 } 3537 3538 if (map_address != (address) MAP_FAILED) { 3539 // Map succeeded, but polling_page is not at wished address, unmap and continue. 3540 ::munmap(map_address, map_size); 3541 map_address = (address) MAP_FAILED; 3542 } 3543 // Map failed, continue loop. 3544 } 3545 } // end OptimizePollingPageLocation 3546 3547 if (map_address == (address) MAP_FAILED) { 3548 map_address = (address) ::mmap(NULL, map_size, prot, flags, -1, 0); 3549 } 3550 guarantee(map_address != MAP_FAILED, "os::init_2: failed to allocate polling page"); 3551 os::set_polling_page(map_address); 3552 3553 if (!UseMembar) { 3554 address mem_serialize_page = (address) ::mmap(NULL, Aix::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); 3555 guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page"); 3556 os::set_memory_serialize_page(mem_serialize_page); 3557 3558 trcVerbose("Memory Serialize Page address: %p - %p, size %IX (%IB)", 3559 mem_serialize_page, mem_serialize_page + Aix::page_size(), 3560 Aix::page_size(), Aix::page_size()); 3561 } 3562 3563 // initialize suspend/resume support - must do this before signal_sets_init() 3564 if (SR_initialize() != 0) { 3565 perror("SR_initialize failed"); 3566 return JNI_ERR; 3567 } 3568 3569 Aix::signal_sets_init(); 3570 Aix::install_signal_handlers(); 3571 3572 // Check and sets minimum stack sizes against command line options 3573 if (Posix::set_minimum_stack_sizes() == JNI_ERR) { 3574 return JNI_ERR; 3575 } 3576 3577 if (UseNUMA) { 3578 UseNUMA = false; 3579 warning("NUMA optimizations are not available on this OS."); 3580 } 3581 3582 if (MaxFDLimit) { 3583 // Set the number of file descriptors to max. print out error 3584 // if getrlimit/setrlimit fails but continue regardless. 3585 struct rlimit nbr_files; 3586 int status = getrlimit(RLIMIT_NOFILE, &nbr_files); 3587 if (status != 0) { 3588 log_info(os)("os::init_2 getrlimit failed: %s", os::strerror(errno)); 3589 } else { 3590 nbr_files.rlim_cur = nbr_files.rlim_max; 3591 status = setrlimit(RLIMIT_NOFILE, &nbr_files); 3592 if (status != 0) { 3593 log_info(os)("os::init_2 setrlimit failed: %s", os::strerror(errno)); 3594 } 3595 } 3596 } 3597 3598 if (PerfAllowAtExitRegistration) { 3599 // Only register atexit functions if PerfAllowAtExitRegistration is set. 3600 // At exit functions can be delayed until process exit time, which 3601 // can be problematic for embedded VM situations. Embedded VMs should 3602 // call DestroyJavaVM() to assure that VM resources are released. 3603 3604 // Note: perfMemory_exit_helper atexit function may be removed in 3605 // the future if the appropriate cleanup code can be added to the 3606 // VM_Exit VMOperation's doit method. 3607 if (atexit(perfMemory_exit_helper) != 0) { 3608 warning("os::init_2 atexit(perfMemory_exit_helper) failed"); 3609 } 3610 } 3611 3612 return JNI_OK; 3613 } 3614 3615 // Mark the polling page as unreadable 3616 void os::make_polling_page_unreadable(void) { 3617 if (!guard_memory((char*)_polling_page, Aix::page_size())) { 3618 fatal("Could not disable polling page"); 3619 } 3620 }; 3621 3622 // Mark the polling page as readable 3623 void os::make_polling_page_readable(void) { 3624 // Changed according to os_linux.cpp. 3625 if (!checked_mprotect((char *)_polling_page, Aix::page_size(), PROT_READ)) { 3626 fatal("Could not enable polling page at " PTR_FORMAT, _polling_page); 3627 } 3628 }; 3629 3630 int os::active_processor_count() { 3631 int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN); 3632 assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check"); 3633 return online_cpus; 3634 } 3635 3636 void os::set_native_thread_name(const char *name) { 3637 // Not yet implemented. 3638 return; 3639 } 3640 3641 bool os::distribute_processes(uint length, uint* distribution) { 3642 // Not yet implemented. 3643 return false; 3644 } 3645 3646 bool os::bind_to_processor(uint processor_id) { 3647 // Not yet implemented. 3648 return false; 3649 } 3650 3651 void os::SuspendedThreadTask::internal_do_task() { 3652 if (do_suspend(_thread->osthread())) { 3653 SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext()); 3654 do_task(context); 3655 do_resume(_thread->osthread()); 3656 } 3657 } 3658 3659 class PcFetcher : public os::SuspendedThreadTask { 3660 public: 3661 PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {} 3662 ExtendedPC result(); 3663 protected: 3664 void do_task(const os::SuspendedThreadTaskContext& context); 3665 private: 3666 ExtendedPC _epc; 3667 }; 3668 3669 ExtendedPC PcFetcher::result() { 3670 guarantee(is_done(), "task is not done yet."); 3671 return _epc; 3672 } 3673 3674 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) { 3675 Thread* thread = context.thread(); 3676 OSThread* osthread = thread->osthread(); 3677 if (osthread->ucontext() != NULL) { 3678 _epc = os::Aix::ucontext_get_pc((const ucontext_t *) context.ucontext()); 3679 } else { 3680 // NULL context is unexpected, double-check this is the VMThread. 3681 guarantee(thread->is_VM_thread(), "can only be called for VMThread"); 3682 } 3683 } 3684 3685 // Suspends the target using the signal mechanism and then grabs the PC before 3686 // resuming the target. Used by the flat-profiler only 3687 ExtendedPC os::get_thread_pc(Thread* thread) { 3688 // Make sure that it is called by the watcher for the VMThread. 3689 assert(Thread::current()->is_Watcher_thread(), "Must be watcher"); 3690 assert(thread->is_VM_thread(), "Can only be called for VMThread"); 3691 3692 PcFetcher fetcher(thread); 3693 fetcher.run(); 3694 return fetcher.result(); 3695 } 3696 3697 //////////////////////////////////////////////////////////////////////////////// 3698 // debug support 3699 3700 bool os::find(address addr, outputStream* st) { 3701 3702 st->print(PTR_FORMAT ": ", addr); 3703 3704 loaded_module_t lm; 3705 if (LoadedLibraries::find_for_text_address(addr, &lm) != NULL || 3706 LoadedLibraries::find_for_data_address(addr, &lm) != NULL) { 3707 st->print_cr("%s", lm.path); 3708 return true; 3709 } 3710 3711 return false; 3712 } 3713 3714 //////////////////////////////////////////////////////////////////////////////// 3715 // misc 3716 3717 // This does not do anything on Aix. This is basically a hook for being 3718 // able to use structured exception handling (thread-local exception filters) 3719 // on, e.g., Win32. 3720 void 3721 os::os_exception_wrapper(java_call_t f, JavaValue* value, const methodHandle& method, 3722 JavaCallArguments* args, Thread* thread) { 3723 f(value, method, args, thread); 3724 } 3725 3726 void os::print_statistics() { 3727 } 3728 3729 bool os::message_box(const char* title, const char* message) { 3730 int i; 3731 fdStream err(defaultStream::error_fd()); 3732 for (i = 0; i < 78; i++) err.print_raw("="); 3733 err.cr(); 3734 err.print_raw_cr(title); 3735 for (i = 0; i < 78; i++) err.print_raw("-"); 3736 err.cr(); 3737 err.print_raw_cr(message); 3738 for (i = 0; i < 78; i++) err.print_raw("="); 3739 err.cr(); 3740 3741 char buf[16]; 3742 // Prevent process from exiting upon "read error" without consuming all CPU 3743 while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); } 3744 3745 return buf[0] == 'y' || buf[0] == 'Y'; 3746 } 3747 3748 int os::stat(const char *path, struct stat *sbuf) { 3749 char pathbuf[MAX_PATH]; 3750 if (strlen(path) > MAX_PATH - 1) { 3751 errno = ENAMETOOLONG; 3752 return -1; 3753 } 3754 os::native_path(strcpy(pathbuf, path)); 3755 return ::stat(pathbuf, sbuf); 3756 } 3757 3758 // Is a (classpath) directory empty? 3759 bool os::dir_is_empty(const char* path) { 3760 DIR *dir = NULL; 3761 struct dirent *ptr; 3762 3763 dir = opendir(path); 3764 if (dir == NULL) return true; 3765 3766 /* Scan the directory */ 3767 bool result = true; 3768 char buf[sizeof(struct dirent) + MAX_PATH]; 3769 while (result && (ptr = ::readdir(dir)) != NULL) { 3770 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) { 3771 result = false; 3772 } 3773 } 3774 closedir(dir); 3775 return result; 3776 } 3777 3778 // This code originates from JDK's sysOpen and open64_w 3779 // from src/solaris/hpi/src/system_md.c 3780 3781 int os::open(const char *path, int oflag, int mode) { 3782 3783 if (strlen(path) > MAX_PATH - 1) { 3784 errno = ENAMETOOLONG; 3785 return -1; 3786 } 3787 int fd; 3788 3789 fd = ::open64(path, oflag, mode); 3790 if (fd == -1) return -1; 3791 3792 // If the open succeeded, the file might still be a directory. 3793 { 3794 struct stat64 buf64; 3795 int ret = ::fstat64(fd, &buf64); 3796 int st_mode = buf64.st_mode; 3797 3798 if (ret != -1) { 3799 if ((st_mode & S_IFMT) == S_IFDIR) { 3800 errno = EISDIR; 3801 ::close(fd); 3802 return -1; 3803 } 3804 } else { 3805 ::close(fd); 3806 return -1; 3807 } 3808 } 3809 3810 // All file descriptors that are opened in the JVM and not 3811 // specifically destined for a subprocess should have the 3812 // close-on-exec flag set. If we don't set it, then careless 3rd 3813 // party native code might fork and exec without closing all 3814 // appropriate file descriptors (e.g. as we do in closeDescriptors in 3815 // UNIXProcess.c), and this in turn might: 3816 // 3817 // - cause end-of-file to fail to be detected on some file 3818 // descriptors, resulting in mysterious hangs, or 3819 // 3820 // - might cause an fopen in the subprocess to fail on a system 3821 // suffering from bug 1085341. 3822 // 3823 // (Yes, the default setting of the close-on-exec flag is a Unix 3824 // design flaw.) 3825 // 3826 // See: 3827 // 1085341: 32-bit stdio routines should support file descriptors >255 3828 // 4843136: (process) pipe file descriptor from Runtime.exec not being closed 3829 // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9 3830 #ifdef FD_CLOEXEC 3831 { 3832 int flags = ::fcntl(fd, F_GETFD); 3833 if (flags != -1) 3834 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC); 3835 } 3836 #endif 3837 3838 return fd; 3839 } 3840 3841 // create binary file, rewriting existing file if required 3842 int os::create_binary_file(const char* path, bool rewrite_existing) { 3843 int oflags = O_WRONLY | O_CREAT; 3844 if (!rewrite_existing) { 3845 oflags |= O_EXCL; 3846 } 3847 return ::open64(path, oflags, S_IREAD | S_IWRITE); 3848 } 3849 3850 // return current position of file pointer 3851 jlong os::current_file_offset(int fd) { 3852 return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR); 3853 } 3854 3855 // move file pointer to the specified offset 3856 jlong os::seek_to_file_offset(int fd, jlong offset) { 3857 return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET); 3858 } 3859 3860 // This code originates from JDK's sysAvailable 3861 // from src/solaris/hpi/src/native_threads/src/sys_api_td.c 3862 3863 int os::available(int fd, jlong *bytes) { 3864 jlong cur, end; 3865 int mode; 3866 struct stat64 buf64; 3867 3868 if (::fstat64(fd, &buf64) >= 0) { 3869 mode = buf64.st_mode; 3870 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) { 3871 int n; 3872 if (::ioctl(fd, FIONREAD, &n) >= 0) { 3873 *bytes = n; 3874 return 1; 3875 } 3876 } 3877 } 3878 if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) { 3879 return 0; 3880 } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) { 3881 return 0; 3882 } else if (::lseek64(fd, cur, SEEK_SET) == -1) { 3883 return 0; 3884 } 3885 *bytes = end - cur; 3886 return 1; 3887 } 3888 3889 // Map a block of memory. 3890 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, 3891 char *addr, size_t bytes, bool read_only, 3892 bool allow_exec) { 3893 int prot; 3894 int flags = MAP_PRIVATE; 3895 3896 if (read_only) { 3897 prot = PROT_READ; 3898 flags = MAP_SHARED; 3899 } else { 3900 prot = PROT_READ | PROT_WRITE; 3901 flags = MAP_PRIVATE; 3902 } 3903 3904 if (allow_exec) { 3905 prot |= PROT_EXEC; 3906 } 3907 3908 if (addr != NULL) { 3909 flags |= MAP_FIXED; 3910 } 3911 3912 // Allow anonymous mappings if 'fd' is -1. 3913 if (fd == -1) { 3914 flags |= MAP_ANONYMOUS; 3915 } 3916 3917 char* mapped_address = (char*)::mmap(addr, (size_t)bytes, prot, flags, 3918 fd, file_offset); 3919 if (mapped_address == MAP_FAILED) { 3920 return NULL; 3921 } 3922 return mapped_address; 3923 } 3924 3925 // Remap a block of memory. 3926 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, 3927 char *addr, size_t bytes, bool read_only, 3928 bool allow_exec) { 3929 // same as map_memory() on this OS 3930 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 3931 allow_exec); 3932 } 3933 3934 // Unmap a block of memory. 3935 bool os::pd_unmap_memory(char* addr, size_t bytes) { 3936 return munmap(addr, bytes) == 0; 3937 } 3938 3939 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 3940 // are used by JVM M&M and JVMTI to get user+sys or user CPU time 3941 // of a thread. 3942 // 3943 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns 3944 // the fast estimate available on the platform. 3945 3946 jlong os::current_thread_cpu_time() { 3947 // return user + sys since the cost is the same 3948 const jlong n = os::thread_cpu_time(Thread::current(), true /* user + sys */); 3949 assert(n >= 0, "negative CPU time"); 3950 return n; 3951 } 3952 3953 jlong os::thread_cpu_time(Thread* thread) { 3954 // consistent with what current_thread_cpu_time() returns 3955 const jlong n = os::thread_cpu_time(thread, true /* user + sys */); 3956 assert(n >= 0, "negative CPU time"); 3957 return n; 3958 } 3959 3960 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 3961 const jlong n = os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 3962 assert(n >= 0, "negative CPU time"); 3963 return n; 3964 } 3965 3966 static bool thread_cpu_time_unchecked(Thread* thread, jlong* p_sys_time, jlong* p_user_time) { 3967 bool error = false; 3968 3969 jlong sys_time = 0; 3970 jlong user_time = 0; 3971 3972 // Reimplemented using getthrds64(). 3973 // 3974 // Works like this: 3975 // For the thread in question, get the kernel thread id. Then get the 3976 // kernel thread statistics using that id. 3977 // 3978 // This only works of course when no pthread scheduling is used, 3979 // i.e. there is a 1:1 relationship to kernel threads. 3980 // On AIX, see AIXTHREAD_SCOPE variable. 3981 3982 pthread_t pthtid = thread->osthread()->pthread_id(); 3983 3984 // retrieve kernel thread id for the pthread: 3985 tid64_t tid = 0; 3986 struct __pthrdsinfo pinfo; 3987 // I just love those otherworldly IBM APIs which force me to hand down 3988 // dummy buffers for stuff I dont care for... 3989 char dummy[1]; 3990 int dummy_size = sizeof(dummy); 3991 if (pthread_getthrds_np(&pthtid, PTHRDSINFO_QUERY_TID, &pinfo, sizeof(pinfo), 3992 dummy, &dummy_size) == 0) { 3993 tid = pinfo.__pi_tid; 3994 } else { 3995 tty->print_cr("pthread_getthrds_np failed."); 3996 error = true; 3997 } 3998 3999 // retrieve kernel timing info for that kernel thread 4000 if (!error) { 4001 struct thrdentry64 thrdentry; 4002 if (getthrds64(getpid(), &thrdentry, sizeof(thrdentry), &tid, 1) == 1) { 4003 sys_time = thrdentry.ti_ru.ru_stime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_stime.tv_usec * 1000LL; 4004 user_time = thrdentry.ti_ru.ru_utime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_utime.tv_usec * 1000LL; 4005 } else { 4006 tty->print_cr("pthread_getthrds_np failed."); 4007 error = true; 4008 } 4009 } 4010 4011 if (p_sys_time) { 4012 *p_sys_time = sys_time; 4013 } 4014 4015 if (p_user_time) { 4016 *p_user_time = user_time; 4017 } 4018 4019 if (error) { 4020 return false; 4021 } 4022 4023 return true; 4024 } 4025 4026 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) { 4027 jlong sys_time; 4028 jlong user_time; 4029 4030 if (!thread_cpu_time_unchecked(thread, &sys_time, &user_time)) { 4031 return -1; 4032 } 4033 4034 return user_sys_cpu_time ? sys_time + user_time : user_time; 4035 } 4036 4037 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 4038 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 4039 info_ptr->may_skip_backward = false; // elapsed time not wall time 4040 info_ptr->may_skip_forward = false; // elapsed time not wall time 4041 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 4042 } 4043 4044 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 4045 info_ptr->max_value = ALL_64_BITS; // will not wrap in less than 64 bits 4046 info_ptr->may_skip_backward = false; // elapsed time not wall time 4047 info_ptr->may_skip_forward = false; // elapsed time not wall time 4048 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 4049 } 4050 4051 bool os::is_thread_cpu_time_supported() { 4052 return true; 4053 } 4054 4055 // System loadavg support. Returns -1 if load average cannot be obtained. 4056 // For now just return the system wide load average (no processor sets). 4057 int os::loadavg(double values[], int nelem) { 4058 4059 guarantee(nelem >= 0 && nelem <= 3, "argument error"); 4060 guarantee(values, "argument error"); 4061 4062 if (os::Aix::on_pase()) { 4063 4064 // AS/400 PASE: use libo4 porting library 4065 double v[3] = { 0.0, 0.0, 0.0 }; 4066 4067 if (libo4::get_load_avg(v, v + 1, v + 2)) { 4068 for (int i = 0; i < nelem; i ++) { 4069 values[i] = v[i]; 4070 } 4071 return nelem; 4072 } else { 4073 return -1; 4074 } 4075 4076 } else { 4077 4078 // AIX: use libperfstat 4079 libperfstat::cpuinfo_t ci; 4080 if (libperfstat::get_cpuinfo(&ci)) { 4081 for (int i = 0; i < nelem; i++) { 4082 values[i] = ci.loadavg[i]; 4083 } 4084 } else { 4085 return -1; 4086 } 4087 return nelem; 4088 } 4089 } 4090 4091 void os::pause() { 4092 char filename[MAX_PATH]; 4093 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 4094 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 4095 } else { 4096 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 4097 } 4098 4099 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 4100 if (fd != -1) { 4101 struct stat buf; 4102 ::close(fd); 4103 while (::stat(filename, &buf) == 0) { 4104 (void)::poll(NULL, 0, 100); 4105 } 4106 } else { 4107 trcVerbose("Could not open pause file '%s', continuing immediately.", filename); 4108 } 4109 } 4110 4111 bool os::Aix::is_primordial_thread() { 4112 if (pthread_self() == (pthread_t)1) { 4113 return true; 4114 } else { 4115 return false; 4116 } 4117 } 4118 4119 // OS recognitions (PASE/AIX, OS level) call this before calling any 4120 // one of Aix::on_pase(), Aix::os_version() static 4121 void os::Aix::initialize_os_info() { 4122 4123 assert(_on_pase == -1 && _os_version == 0, "already called."); 4124 4125 struct utsname uts; 4126 memset(&uts, 0, sizeof(uts)); 4127 strcpy(uts.sysname, "?"); 4128 if (::uname(&uts) == -1) { 4129 trcVerbose("uname failed (%d)", errno); 4130 guarantee(0, "Could not determine whether we run on AIX or PASE"); 4131 } else { 4132 trcVerbose("uname says: sysname \"%s\" version \"%s\" release \"%s\" " 4133 "node \"%s\" machine \"%s\"\n", 4134 uts.sysname, uts.version, uts.release, uts.nodename, uts.machine); 4135 const int major = atoi(uts.version); 4136 assert(major > 0, "invalid OS version"); 4137 const int minor = atoi(uts.release); 4138 assert(minor > 0, "invalid OS release"); 4139 _os_version = (major << 24) | (minor << 16); 4140 char ver_str[20] = {0}; 4141 char *name_str = "unknown OS"; 4142 if (strcmp(uts.sysname, "OS400") == 0) { 4143 // We run on AS/400 PASE. We do not support versions older than V5R4M0. 4144 _on_pase = 1; 4145 if (os_version_short() < 0x0504) { 4146 trcVerbose("OS/400 releases older than V5R4M0 not supported."); 4147 assert(false, "OS/400 release too old."); 4148 } 4149 name_str = "OS/400 (pase)"; 4150 jio_snprintf(ver_str, sizeof(ver_str), "%u.%u", major, minor); 4151 } else if (strcmp(uts.sysname, "AIX") == 0) { 4152 // We run on AIX. We do not support versions older than AIX 5.3. 4153 _on_pase = 0; 4154 // Determine detailed AIX version: Version, Release, Modification, Fix Level. 4155 odmWrapper::determine_os_kernel_version(&_os_version); 4156 if (os_version_short() < 0x0503) { 4157 trcVerbose("AIX release older than AIX 5.3 not supported."); 4158 assert(false, "AIX release too old."); 4159 } 4160 name_str = "AIX"; 4161 jio_snprintf(ver_str, sizeof(ver_str), "%u.%u.%u.%u", 4162 major, minor, (_os_version >> 8) & 0xFF, _os_version & 0xFF); 4163 } else { 4164 assert(false, name_str); 4165 } 4166 trcVerbose("We run on %s %s", name_str, ver_str); 4167 } 4168 4169 guarantee(_on_pase != -1 && _os_version, "Could not determine AIX/OS400 release"); 4170 } // end: os::Aix::initialize_os_info() 4171 4172 // Scan environment for important settings which might effect the VM. 4173 // Trace out settings. Warn about invalid settings and/or correct them. 4174 // 4175 // Must run after os::Aix::initialue_os_info(). 4176 void os::Aix::scan_environment() { 4177 4178 char* p; 4179 int rc; 4180 4181 // Warn explicity if EXTSHM=ON is used. That switch changes how 4182 // System V shared memory behaves. One effect is that page size of 4183 // shared memory cannot be change dynamically, effectivly preventing 4184 // large pages from working. 4185 // This switch was needed on AIX 32bit, but on AIX 64bit the general 4186 // recommendation is (in OSS notes) to switch it off. 4187 p = ::getenv("EXTSHM"); 4188 trcVerbose("EXTSHM=%s.", p ? p : "<unset>"); 4189 if (p && strcasecmp(p, "ON") == 0) { 4190 _extshm = 1; 4191 trcVerbose("*** Unsupported mode! Please remove EXTSHM from your environment! ***"); 4192 if (!AllowExtshm) { 4193 // We allow under certain conditions the user to continue. However, we want this 4194 // to be a fatal error by default. On certain AIX systems, leaving EXTSHM=ON means 4195 // that the VM is not able to allocate 64k pages for the heap. 4196 // We do not want to run with reduced performance. 4197 vm_exit_during_initialization("EXTSHM is ON. Please remove EXTSHM from your environment."); 4198 } 4199 } else { 4200 _extshm = 0; 4201 } 4202 4203 // SPEC1170 behaviour: will change the behaviour of a number of POSIX APIs. 4204 // Not tested, not supported. 4205 // 4206 // Note that it might be worth the trouble to test and to require it, if only to 4207 // get useful return codes for mprotect. 4208 // 4209 // Note: Setting XPG_SUS_ENV in the process is too late. Must be set earlier (before 4210 // exec() ? before loading the libjvm ? ....) 4211 p = ::getenv("XPG_SUS_ENV"); 4212 trcVerbose("XPG_SUS_ENV=%s.", p ? p : "<unset>"); 4213 if (p && strcmp(p, "ON") == 0) { 4214 _xpg_sus_mode = 1; 4215 trcVerbose("Unsupported setting: XPG_SUS_ENV=ON"); 4216 // This is not supported. Worst of all, it changes behaviour of mmap MAP_FIXED to 4217 // clobber address ranges. If we ever want to support that, we have to do some 4218 // testing first. 4219 guarantee(false, "XPG_SUS_ENV=ON not supported"); 4220 } else { 4221 _xpg_sus_mode = 0; 4222 } 4223 4224 if (os::Aix::on_pase()) { 4225 p = ::getenv("QIBM_MULTI_THREADED"); 4226 trcVerbose("QIBM_MULTI_THREADED=%s.", p ? p : "<unset>"); 4227 } 4228 4229 p = ::getenv("LDR_CNTRL"); 4230 trcVerbose("LDR_CNTRL=%s.", p ? p : "<unset>"); 4231 if (os::Aix::on_pase() && os::Aix::os_version_short() == 0x0701) { 4232 if (p && ::strstr(p, "TEXTPSIZE")) { 4233 trcVerbose("*** WARNING - LDR_CNTRL contains TEXTPSIZE. " 4234 "you may experience hangs or crashes on OS/400 V7R1."); 4235 } 4236 } 4237 4238 p = ::getenv("AIXTHREAD_GUARDPAGES"); 4239 trcVerbose("AIXTHREAD_GUARDPAGES=%s.", p ? p : "<unset>"); 4240 4241 } // end: os::Aix::scan_environment() 4242 4243 // PASE: initialize the libo4 library (PASE porting library). 4244 void os::Aix::initialize_libo4() { 4245 guarantee(os::Aix::on_pase(), "OS/400 only."); 4246 if (!libo4::init()) { 4247 trcVerbose("libo4 initialization failed."); 4248 assert(false, "libo4 initialization failed"); 4249 } else { 4250 trcVerbose("libo4 initialized."); 4251 } 4252 } 4253 4254 // AIX: initialize the libperfstat library. 4255 void os::Aix::initialize_libperfstat() { 4256 assert(os::Aix::on_aix(), "AIX only"); 4257 if (!libperfstat::init()) { 4258 trcVerbose("libperfstat initialization failed."); 4259 assert(false, "libperfstat initialization failed"); 4260 } else { 4261 trcVerbose("libperfstat initialized."); 4262 } 4263 } 4264 4265 ///////////////////////////////////////////////////////////////////////////// 4266 // thread stack 4267 4268 // Function to query the current stack size using pthread_getthrds_np. 4269 static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size) { 4270 // This only works when invoked on a pthread. As we agreed not to use 4271 // primordial threads anyway, I assert here. 4272 guarantee(!os::Aix::is_primordial_thread(), "not allowed on the primordial thread"); 4273 4274 // Information about this api can be found (a) in the pthread.h header and 4275 // (b) in http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_getthrds_np.htm 4276 // 4277 // The use of this API to find out the current stack is kind of undefined. 4278 // But after a lot of tries and asking IBM about it, I concluded that it is safe 4279 // enough for cases where I let the pthread library create its stacks. For cases 4280 // where I create an own stack and pass this to pthread_create, it seems not to 4281 // work (the returned stack size in that case is 0). 4282 4283 pthread_t tid = pthread_self(); 4284 struct __pthrdsinfo pinfo; 4285 char dummy[1]; // Just needed to satisfy pthread_getthrds_np. 4286 int dummy_size = sizeof(dummy); 4287 4288 memset(&pinfo, 0, sizeof(pinfo)); 4289 4290 const int rc = pthread_getthrds_np(&tid, PTHRDSINFO_QUERY_ALL, &pinfo, 4291 sizeof(pinfo), dummy, &dummy_size); 4292 4293 if (rc != 0) { 4294 assert0(false); 4295 trcVerbose("pthread_getthrds_np failed (%d)", rc); 4296 return false; 4297 } 4298 guarantee0(pinfo.__pi_stackend); 4299 4300 // The following may happen when invoking pthread_getthrds_np on a pthread 4301 // running on a user provided stack (when handing down a stack to pthread 4302 // create, see pthread_attr_setstackaddr). 4303 // Not sure what to do then. 4304 4305 guarantee0(pinfo.__pi_stacksize); 4306 4307 // Note: we get three values from pthread_getthrds_np: 4308 // __pi_stackaddr, __pi_stacksize, __pi_stackend 4309 // 4310 // high addr --------------------- 4311 // 4312 // | pthread internal data, like ~2K 4313 // | 4314 // | --------------------- __pi_stackend (usually not page aligned, (xxxxF890)) 4315 // | 4316 // | 4317 // | 4318 // | 4319 // | 4320 // | 4321 // | --------------------- (__pi_stackend - __pi_stacksize) 4322 // | 4323 // | padding to align the following AIX guard pages, if enabled. 4324 // | 4325 // V --------------------- __pi_stackaddr 4326 // 4327 // low addr AIX guard pages, if enabled (AIXTHREAD_GUARDPAGES > 0) 4328 // 4329 4330 address stack_base = (address)(pinfo.__pi_stackend); 4331 address stack_low_addr = (address)align_ptr_up(pinfo.__pi_stackaddr, 4332 os::vm_page_size()); 4333 size_t stack_size = stack_base - stack_low_addr; 4334 4335 if (p_stack_base) { 4336 *p_stack_base = stack_base; 4337 } 4338 4339 if (p_stack_size) { 4340 *p_stack_size = stack_size; 4341 } 4342 4343 return true; 4344 } 4345 4346 // Get the current stack base from the OS (actually, the pthread library). 4347 address os::current_stack_base() { 4348 address p; 4349 query_stack_dimensions(&p, 0); 4350 return p; 4351 } 4352 4353 // Get the current stack size from the OS (actually, the pthread library). 4354 size_t os::current_stack_size() { 4355 size_t s; 4356 query_stack_dimensions(0, &s); 4357 return s; 4358 } 4359 4360 // Refer to the comments in os_solaris.cpp park-unpark. 4361 4362 // utility to compute the abstime argument to timedwait: 4363 // millis is the relative timeout time 4364 // abstime will be the absolute timeout time 4365 // TODO: replace compute_abstime() with unpackTime() 4366 4367 static struct timespec* compute_abstime(timespec* abstime, jlong millis) { 4368 if (millis < 0) millis = 0; 4369 struct timeval now; 4370 int status = gettimeofday(&now, NULL); 4371 assert(status == 0, "gettimeofday"); 4372 jlong seconds = millis / 1000; 4373 millis %= 1000; 4374 if (seconds > 50000000) { // see man cond_timedwait(3T) 4375 seconds = 50000000; 4376 } 4377 abstime->tv_sec = now.tv_sec + seconds; 4378 long usec = now.tv_usec + millis * 1000; 4379 if (usec >= 1000000) { 4380 abstime->tv_sec += 1; 4381 usec -= 1000000; 4382 } 4383 abstime->tv_nsec = usec * 1000; 4384 return abstime; 4385 } 4386 4387 // Test-and-clear _Event, always leaves _Event set to 0, returns immediately. 4388 // Conceptually TryPark() should be equivalent to park(0). 4389 4390 int os::PlatformEvent::TryPark() { 4391 for (;;) { 4392 const int v = _Event; 4393 guarantee ((v == 0) || (v == 1), "invariant"); 4394 if (Atomic::cmpxchg (0, &_Event, v) == v) return v; 4395 } 4396 } 4397 4398 void os::PlatformEvent::park() { // AKA "down()" 4399 // Invariant: Only the thread associated with the Event/PlatformEvent 4400 // may call park(). 4401 // TODO: assert that _Assoc != NULL or _Assoc == Self 4402 int v; 4403 for (;;) { 4404 v = _Event; 4405 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break; 4406 } 4407 guarantee (v >= 0, "invariant"); 4408 if (v == 0) { 4409 // Do this the hard way by blocking ... 4410 int status = pthread_mutex_lock(_mutex); 4411 assert_status(status == 0, status, "mutex_lock"); 4412 guarantee (_nParked == 0, "invariant"); 4413 ++ _nParked; 4414 while (_Event < 0) { 4415 status = pthread_cond_wait(_cond, _mutex); 4416 assert_status(status == 0 || status == ETIMEDOUT, status, "cond_timedwait"); 4417 } 4418 -- _nParked; 4419 4420 // In theory we could move the ST of 0 into _Event past the unlock(), 4421 // but then we'd need a MEMBAR after the ST. 4422 _Event = 0; 4423 status = pthread_mutex_unlock(_mutex); 4424 assert_status(status == 0, status, "mutex_unlock"); 4425 } 4426 guarantee (_Event >= 0, "invariant"); 4427 } 4428 4429 int os::PlatformEvent::park(jlong millis) { 4430 guarantee (_nParked == 0, "invariant"); 4431 4432 int v; 4433 for (;;) { 4434 v = _Event; 4435 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break; 4436 } 4437 guarantee (v >= 0, "invariant"); 4438 if (v != 0) return OS_OK; 4439 4440 // We do this the hard way, by blocking the thread. 4441 // Consider enforcing a minimum timeout value. 4442 struct timespec abst; 4443 compute_abstime(&abst, millis); 4444 4445 int ret = OS_TIMEOUT; 4446 int status = pthread_mutex_lock(_mutex); 4447 assert_status(status == 0, status, "mutex_lock"); 4448 guarantee (_nParked == 0, "invariant"); 4449 ++_nParked; 4450 4451 // Object.wait(timo) will return because of 4452 // (a) notification 4453 // (b) timeout 4454 // (c) thread.interrupt 4455 // 4456 // Thread.interrupt and object.notify{All} both call Event::set. 4457 // That is, we treat thread.interrupt as a special case of notification. 4458 // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false. 4459 // We assume all ETIME returns are valid. 4460 // 4461 // TODO: properly differentiate simultaneous notify+interrupt. 4462 // In that case, we should propagate the notify to another waiter. 4463 4464 while (_Event < 0) { 4465 status = pthread_cond_timedwait(_cond, _mutex, &abst); 4466 assert_status(status == 0 || status == ETIMEDOUT, 4467 status, "cond_timedwait"); 4468 if (!FilterSpuriousWakeups) break; // previous semantics 4469 if (status == ETIMEDOUT) break; 4470 // We consume and ignore EINTR and spurious wakeups. 4471 } 4472 --_nParked; 4473 if (_Event >= 0) { 4474 ret = OS_OK; 4475 } 4476 _Event = 0; 4477 status = pthread_mutex_unlock(_mutex); 4478 assert_status(status == 0, status, "mutex_unlock"); 4479 assert (_nParked == 0, "invariant"); 4480 return ret; 4481 } 4482 4483 void os::PlatformEvent::unpark() { 4484 int v, AnyWaiters; 4485 for (;;) { 4486 v = _Event; 4487 if (v > 0) { 4488 // The LD of _Event could have reordered or be satisfied 4489 // by a read-aside from this processor's write buffer. 4490 // To avoid problems execute a barrier and then 4491 // ratify the value. 4492 OrderAccess::fence(); 4493 if (_Event == v) return; 4494 continue; 4495 } 4496 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break; 4497 } 4498 if (v < 0) { 4499 // Wait for the thread associated with the event to vacate 4500 int status = pthread_mutex_lock(_mutex); 4501 assert_status(status == 0, status, "mutex_lock"); 4502 AnyWaiters = _nParked; 4503 4504 if (AnyWaiters != 0) { 4505 // We intentional signal *after* dropping the lock 4506 // to avoid a common class of futile wakeups. 4507 status = pthread_cond_signal(_cond); 4508 assert_status(status == 0, status, "cond_signal"); 4509 } 4510 // Mutex should be locked for pthread_cond_signal(_cond). 4511 status = pthread_mutex_unlock(_mutex); 4512 assert_status(status == 0, status, "mutex_unlock"); 4513 } 4514 4515 // Note that we signal() _after dropping the lock for "immortal" Events. 4516 // This is safe and avoids a common class of futile wakeups. In rare 4517 // circumstances this can cause a thread to return prematurely from 4518 // cond_{timed}wait() but the spurious wakeup is benign and the victim will 4519 // simply re-test the condition and re-park itself. 4520 } 4521 4522 4523 // JSR166 4524 // ------------------------------------------------------- 4525 4526 // 4527 // The solaris and linux implementations of park/unpark are fairly 4528 // conservative for now, but can be improved. They currently use a 4529 // mutex/condvar pair, plus a a count. 4530 // Park decrements count if > 0, else does a condvar wait. Unpark 4531 // sets count to 1 and signals condvar. Only one thread ever waits 4532 // on the condvar. Contention seen when trying to park implies that someone 4533 // is unparking you, so don't wait. And spurious returns are fine, so there 4534 // is no need to track notifications. 4535 // 4536 4537 #define MAX_SECS 100000000 4538 // 4539 // This code is common to linux and solaris and will be moved to a 4540 // common place in dolphin. 4541 // 4542 // The passed in time value is either a relative time in nanoseconds 4543 // or an absolute time in milliseconds. Either way it has to be unpacked 4544 // into suitable seconds and nanoseconds components and stored in the 4545 // given timespec structure. 4546 // Given time is a 64-bit value and the time_t used in the timespec is only 4547 // a signed-32-bit value (except on 64-bit Linux) we have to watch for 4548 // overflow if times way in the future are given. Further on Solaris versions 4549 // prior to 10 there is a restriction (see cond_timedwait) that the specified 4550 // number of seconds, in abstime, is less than current_time + 100,000,000. 4551 // As it will be 28 years before "now + 100000000" will overflow we can 4552 // ignore overflow and just impose a hard-limit on seconds using the value 4553 // of "now + 100,000,000". This places a limit on the timeout of about 3.17 4554 // years from "now". 4555 // 4556 4557 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) { 4558 assert (time > 0, "convertTime"); 4559 4560 struct timeval now; 4561 int status = gettimeofday(&now, NULL); 4562 assert(status == 0, "gettimeofday"); 4563 4564 time_t max_secs = now.tv_sec + MAX_SECS; 4565 4566 if (isAbsolute) { 4567 jlong secs = time / 1000; 4568 if (secs > max_secs) { 4569 absTime->tv_sec = max_secs; 4570 } 4571 else { 4572 absTime->tv_sec = secs; 4573 } 4574 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC; 4575 } 4576 else { 4577 jlong secs = time / NANOSECS_PER_SEC; 4578 if (secs >= MAX_SECS) { 4579 absTime->tv_sec = max_secs; 4580 absTime->tv_nsec = 0; 4581 } 4582 else { 4583 absTime->tv_sec = now.tv_sec + secs; 4584 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000; 4585 if (absTime->tv_nsec >= NANOSECS_PER_SEC) { 4586 absTime->tv_nsec -= NANOSECS_PER_SEC; 4587 ++absTime->tv_sec; // note: this must be <= max_secs 4588 } 4589 } 4590 } 4591 assert(absTime->tv_sec >= 0, "tv_sec < 0"); 4592 assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs"); 4593 assert(absTime->tv_nsec >= 0, "tv_nsec < 0"); 4594 assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec"); 4595 } 4596 4597 void Parker::park(bool isAbsolute, jlong time) { 4598 // Optional fast-path check: 4599 // Return immediately if a permit is available. 4600 if (_counter > 0) { 4601 _counter = 0; 4602 OrderAccess::fence(); 4603 return; 4604 } 4605 4606 Thread* thread = Thread::current(); 4607 assert(thread->is_Java_thread(), "Must be JavaThread"); 4608 JavaThread *jt = (JavaThread *)thread; 4609 4610 // Optional optimization -- avoid state transitions if there's an interrupt pending. 4611 // Check interrupt before trying to wait 4612 if (Thread::is_interrupted(thread, false)) { 4613 return; 4614 } 4615 4616 // Next, demultiplex/decode time arguments 4617 timespec absTime; 4618 if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all 4619 return; 4620 } 4621 if (time > 0) { 4622 unpackTime(&absTime, isAbsolute, time); 4623 } 4624 4625 // Enter safepoint region 4626 // Beware of deadlocks such as 6317397. 4627 // The per-thread Parker:: mutex is a classic leaf-lock. 4628 // In particular a thread must never block on the Threads_lock while 4629 // holding the Parker:: mutex. If safepoints are pending both the 4630 // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock. 4631 ThreadBlockInVM tbivm(jt); 4632 4633 // Don't wait if cannot get lock since interference arises from 4634 // unblocking. Also. check interrupt before trying wait 4635 if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) { 4636 return; 4637 } 4638 4639 int status; 4640 if (_counter > 0) { // no wait needed 4641 _counter = 0; 4642 status = pthread_mutex_unlock(_mutex); 4643 assert (status == 0, "invariant"); 4644 OrderAccess::fence(); 4645 return; 4646 } 4647 4648 #ifdef ASSERT 4649 // Don't catch signals while blocked; let the running threads have the signals. 4650 // (This allows a debugger to break into the running thread.) 4651 sigset_t oldsigs; 4652 sigset_t* allowdebug_blocked = os::Aix::allowdebug_blocked_signals(); 4653 pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs); 4654 #endif 4655 4656 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 4657 jt->set_suspend_equivalent(); 4658 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 4659 4660 if (time == 0) { 4661 status = pthread_cond_wait (_cond, _mutex); 4662 } else { 4663 status = pthread_cond_timedwait (_cond, _mutex, &absTime); 4664 } 4665 assert_status(status == 0 || status == EINTR || 4666 status == ETIME || status == ETIMEDOUT, 4667 status, "cond_timedwait"); 4668 4669 #ifdef ASSERT 4670 pthread_sigmask(SIG_SETMASK, &oldsigs, NULL); 4671 #endif 4672 4673 _counter = 0; 4674 status = pthread_mutex_unlock(_mutex); 4675 assert_status(status == 0, status, "invariant"); 4676 // If externally suspended while waiting, re-suspend 4677 if (jt->handle_special_suspend_equivalent_condition()) { 4678 jt->java_suspend_self(); 4679 } 4680 4681 OrderAccess::fence(); 4682 } 4683 4684 void Parker::unpark() { 4685 int s, status; 4686 status = pthread_mutex_lock(_mutex); 4687 assert (status == 0, "invariant"); 4688 s = _counter; 4689 _counter = 1; 4690 if (s < 1) { 4691 status = pthread_mutex_unlock(_mutex); 4692 assert (status == 0, "invariant"); 4693 status = pthread_cond_signal (_cond); 4694 assert (status == 0, "invariant"); 4695 } else { 4696 pthread_mutex_unlock(_mutex); 4697 assert (status == 0, "invariant"); 4698 } 4699 } 4700 4701 extern char** environ; 4702 4703 // Run the specified command in a separate process. Return its exit value, 4704 // or -1 on failure (e.g. can't fork a new process). 4705 // Unlike system(), this function can be called from signal handler. It 4706 // doesn't block SIGINT et al. 4707 int os::fork_and_exec(char* cmd) { 4708 char * argv[4] = {"sh", "-c", cmd, NULL}; 4709 4710 pid_t pid = fork(); 4711 4712 if (pid < 0) { 4713 // fork failed 4714 return -1; 4715 4716 } else if (pid == 0) { 4717 // child process 4718 4719 // Try to be consistent with system(), which uses "/usr/bin/sh" on AIX. 4720 execve("/usr/bin/sh", argv, environ); 4721 4722 // execve failed 4723 _exit(-1); 4724 4725 } else { 4726 // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't 4727 // care about the actual exit code, for now. 4728 4729 int status; 4730 4731 // Wait for the child process to exit. This returns immediately if 4732 // the child has already exited. */ 4733 while (waitpid(pid, &status, 0) < 0) { 4734 switch (errno) { 4735 case ECHILD: return 0; 4736 case EINTR: break; 4737 default: return -1; 4738 } 4739 } 4740 4741 if (WIFEXITED(status)) { 4742 // The child exited normally; get its exit code. 4743 return WEXITSTATUS(status); 4744 } else if (WIFSIGNALED(status)) { 4745 // The child exited because of a signal. 4746 // The best value to return is 0x80 + signal number, 4747 // because that is what all Unix shells do, and because 4748 // it allows callers to distinguish between process exit and 4749 // process death by signal. 4750 return 0x80 + WTERMSIG(status); 4751 } else { 4752 // Unknown exit code; pass it through. 4753 return status; 4754 } 4755 } 4756 return -1; 4757 } 4758 4759 // is_headless_jre() 4760 // 4761 // Test for the existence of xawt/libmawt.so or libawt_xawt.so 4762 // in order to report if we are running in a headless jre. 4763 // 4764 // Since JDK8 xawt/libmawt.so is moved into the same directory 4765 // as libawt.so, and renamed libawt_xawt.so 4766 bool os::is_headless_jre() { 4767 struct stat statbuf; 4768 char buf[MAXPATHLEN]; 4769 char libmawtpath[MAXPATHLEN]; 4770 const char *xawtstr = "/xawt/libmawt.so"; 4771 const char *new_xawtstr = "/libawt_xawt.so"; 4772 4773 char *p; 4774 4775 // Get path to libjvm.so 4776 os::jvm_path(buf, sizeof(buf)); 4777 4778 // Get rid of libjvm.so 4779 p = strrchr(buf, '/'); 4780 if (p == NULL) return false; 4781 else *p = '\0'; 4782 4783 // Get rid of client or server 4784 p = strrchr(buf, '/'); 4785 if (p == NULL) return false; 4786 else *p = '\0'; 4787 4788 // check xawt/libmawt.so 4789 strcpy(libmawtpath, buf); 4790 strcat(libmawtpath, xawtstr); 4791 if (::stat(libmawtpath, &statbuf) == 0) return false; 4792 4793 // check libawt_xawt.so 4794 strcpy(libmawtpath, buf); 4795 strcat(libmawtpath, new_xawtstr); 4796 if (::stat(libmawtpath, &statbuf) == 0) return false; 4797 4798 return true; 4799 } 4800 4801 // Get the default path to the core file 4802 // Returns the length of the string 4803 int os::get_core_path(char* buffer, size_t bufferSize) { 4804 const char* p = get_current_directory(buffer, bufferSize); 4805 4806 if (p == NULL) { 4807 assert(p != NULL, "failed to get current directory"); 4808 return 0; 4809 } 4810 4811 jio_snprintf(buffer, bufferSize, "%s/core or core.%d", 4812 p, current_process_id()); 4813 4814 return strlen(buffer); 4815 } 4816 4817 #ifndef PRODUCT 4818 void TestReserveMemorySpecial_test() { 4819 // No tests available for this platform 4820 } 4821 #endif 4822 4823 bool os::start_debugging(char *buf, int buflen) { 4824 int len = (int)strlen(buf); 4825 char *p = &buf[len]; 4826 4827 jio_snprintf(p, buflen -len, 4828 "\n\n" 4829 "Do you want to debug the problem?\n\n" 4830 "To debug, run 'dbx -a %d'; then switch to thread tid " INTX_FORMAT ", k-tid " INTX_FORMAT "\n" 4831 "Enter 'yes' to launch dbx automatically (PATH must include dbx)\n" 4832 "Otherwise, press RETURN to abort...", 4833 os::current_process_id(), 4834 os::current_thread_id(), thread_self()); 4835 4836 bool yes = os::message_box("Unexpected Error", buf); 4837 4838 if (yes) { 4839 // yes, user asked VM to launch debugger 4840 jio_snprintf(buf, buflen, "dbx -a %d", os::current_process_id()); 4841 4842 os::fork_and_exec(buf); 4843 yes = false; 4844 } 4845 return yes; 4846 } 4847 4848 static inline time_t get_mtime(const char* filename) { 4849 struct stat st; 4850 int ret = os::stat(filename, &st); 4851 assert(ret == 0, "failed to stat() file '%s': %s", filename, strerror(errno)); 4852 return st.st_mtime; 4853 } 4854 4855 int os::compare_file_modified_times(const char* file1, const char* file2) { 4856 time_t t1 = get_mtime(file1); 4857 time_t t2 = get_mtime(file2); 4858 return t1 - t2; 4859 }