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