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