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