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