os_windows.cpp revision 9639:f0dcbc6e99b1
1/* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25// Must be at least Windows Vista or Server 2008 to use InitOnceExecuteOnce 26#define _WIN32_WINNT 0x0600 27 28// no precompiled headers 29#include "classfile/classLoader.hpp" 30#include "classfile/systemDictionary.hpp" 31#include "classfile/vmSymbols.hpp" 32#include "code/icBuffer.hpp" 33#include "code/vtableStubs.hpp" 34#include "compiler/compileBroker.hpp" 35#include "compiler/disassembler.hpp" 36#include "interpreter/interpreter.hpp" 37#include "jvm_windows.h" 38#include "memory/allocation.inline.hpp" 39#include "memory/filemap.hpp" 40#include "mutex_windows.inline.hpp" 41#include "oops/oop.inline.hpp" 42#include "os_share_windows.hpp" 43#include "os_windows.inline.hpp" 44#include "prims/jniFastGetField.hpp" 45#include "prims/jvm.h" 46#include "prims/jvm_misc.hpp" 47#include "runtime/arguments.hpp" 48#include "runtime/atomic.inline.hpp" 49#include "runtime/extendedPC.hpp" 50#include "runtime/globals.hpp" 51#include "runtime/interfaceSupport.hpp" 52#include "runtime/java.hpp" 53#include "runtime/javaCalls.hpp" 54#include "runtime/mutexLocker.hpp" 55#include "runtime/objectMonitor.hpp" 56#include "runtime/orderAccess.inline.hpp" 57#include "runtime/osThread.hpp" 58#include "runtime/perfMemory.hpp" 59#include "runtime/sharedRuntime.hpp" 60#include "runtime/statSampler.hpp" 61#include "runtime/stubRoutines.hpp" 62#include "runtime/thread.inline.hpp" 63#include "runtime/threadCritical.hpp" 64#include "runtime/timer.hpp" 65#include "runtime/vm_version.hpp" 66#include "semaphore_windows.hpp" 67#include "services/attachListener.hpp" 68#include "services/memTracker.hpp" 69#include "services/runtimeService.hpp" 70#include "utilities/decoder.hpp" 71#include "utilities/defaultStream.hpp" 72#include "utilities/events.hpp" 73#include "utilities/growableArray.hpp" 74#include "utilities/vmError.hpp" 75 76#ifdef _DEBUG 77#include <crtdbg.h> 78#endif 79 80 81#include <windows.h> 82#include <sys/types.h> 83#include <sys/stat.h> 84#include <sys/timeb.h> 85#include <objidl.h> 86#include <shlobj.h> 87 88#include <malloc.h> 89#include <signal.h> 90#include <direct.h> 91#include <errno.h> 92#include <fcntl.h> 93#include <io.h> 94#include <process.h> // For _beginthreadex(), _endthreadex() 95#include <imagehlp.h> // For os::dll_address_to_function_name 96// for enumerating dll libraries 97#include <vdmdbg.h> 98 99// for timer info max values which include all bits 100#define ALL_64_BITS CONST64(-1) 101 102// For DLL loading/load error detection 103// Values of PE COFF 104#define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c 105#define IMAGE_FILE_SIGNATURE_LENGTH 4 106 107static HANDLE main_process; 108static HANDLE main_thread; 109static int main_thread_id; 110 111static FILETIME process_creation_time; 112static FILETIME process_exit_time; 113static FILETIME process_user_time; 114static FILETIME process_kernel_time; 115 116#ifdef _M_IA64 117 #define __CPU__ ia64 118#else 119 #ifdef _M_AMD64 120 #define __CPU__ amd64 121 #else 122 #define __CPU__ i486 123 #endif 124#endif 125 126// save DLL module handle, used by GetModuleFileName 127 128HINSTANCE vm_lib_handle; 129 130BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) { 131 switch (reason) { 132 case DLL_PROCESS_ATTACH: 133 vm_lib_handle = hinst; 134 if (ForceTimeHighResolution) { 135 timeBeginPeriod(1L); 136 } 137 break; 138 case DLL_PROCESS_DETACH: 139 if (ForceTimeHighResolution) { 140 timeEndPeriod(1L); 141 } 142 break; 143 default: 144 break; 145 } 146 return true; 147} 148 149static inline double fileTimeAsDouble(FILETIME* time) { 150 const double high = (double) ((unsigned int) ~0); 151 const double split = 10000000.0; 152 double result = (time->dwLowDateTime / split) + 153 time->dwHighDateTime * (high/split); 154 return result; 155} 156 157// Implementation of os 158 159bool os::unsetenv(const char* name) { 160 assert(name != NULL, "Null pointer"); 161 return (SetEnvironmentVariable(name, NULL) == TRUE); 162} 163 164// No setuid programs under Windows. 165bool os::have_special_privileges() { 166 return false; 167} 168 169 170// This method is a periodic task to check for misbehaving JNI applications 171// under CheckJNI, we can add any periodic checks here. 172// For Windows at the moment does nothing 173void os::run_periodic_checks() { 174 return; 175} 176 177// previous UnhandledExceptionFilter, if there is one 178static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL; 179 180LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo); 181 182void os::init_system_properties_values() { 183 // sysclasspath, java_home, dll_dir 184 { 185 char *home_path; 186 char *dll_path; 187 char *pslash; 188 char *bin = "\\bin"; 189 char home_dir[MAX_PATH + 1]; 190 char *alt_home_dir = ::getenv("_ALT_JAVA_HOME_DIR"); 191 192 if (alt_home_dir != NULL) { 193 strncpy(home_dir, alt_home_dir, MAX_PATH + 1); 194 home_dir[MAX_PATH] = '\0'; 195 } else { 196 os::jvm_path(home_dir, sizeof(home_dir)); 197 // Found the full path to jvm.dll. 198 // Now cut the path to <java_home>/jre if we can. 199 *(strrchr(home_dir, '\\')) = '\0'; // get rid of \jvm.dll 200 pslash = strrchr(home_dir, '\\'); 201 if (pslash != NULL) { 202 *pslash = '\0'; // get rid of \{client|server} 203 pslash = strrchr(home_dir, '\\'); 204 if (pslash != NULL) { 205 *pslash = '\0'; // get rid of \bin 206 } 207 } 208 } 209 210 home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal); 211 if (home_path == NULL) { 212 return; 213 } 214 strcpy(home_path, home_dir); 215 Arguments::set_java_home(home_path); 216 FREE_C_HEAP_ARRAY(char, home_path); 217 218 dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1, 219 mtInternal); 220 if (dll_path == NULL) { 221 return; 222 } 223 strcpy(dll_path, home_dir); 224 strcat(dll_path, bin); 225 Arguments::set_dll_dir(dll_path); 226 FREE_C_HEAP_ARRAY(char, dll_path); 227 228 if (!set_boot_path('\\', ';')) { 229 return; 230 } 231 } 232 233// library_path 234#define EXT_DIR "\\lib\\ext" 235#define BIN_DIR "\\bin" 236#define PACKAGE_DIR "\\Sun\\Java" 237 { 238 // Win32 library search order (See the documentation for LoadLibrary): 239 // 240 // 1. The directory from which application is loaded. 241 // 2. The system wide Java Extensions directory (Java only) 242 // 3. System directory (GetSystemDirectory) 243 // 4. Windows directory (GetWindowsDirectory) 244 // 5. The PATH environment variable 245 // 6. The current directory 246 247 char *library_path; 248 char tmp[MAX_PATH]; 249 char *path_str = ::getenv("PATH"); 250 251 library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) + 252 sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10, mtInternal); 253 254 library_path[0] = '\0'; 255 256 GetModuleFileName(NULL, tmp, sizeof(tmp)); 257 *(strrchr(tmp, '\\')) = '\0'; 258 strcat(library_path, tmp); 259 260 GetWindowsDirectory(tmp, sizeof(tmp)); 261 strcat(library_path, ";"); 262 strcat(library_path, tmp); 263 strcat(library_path, PACKAGE_DIR BIN_DIR); 264 265 GetSystemDirectory(tmp, sizeof(tmp)); 266 strcat(library_path, ";"); 267 strcat(library_path, tmp); 268 269 GetWindowsDirectory(tmp, sizeof(tmp)); 270 strcat(library_path, ";"); 271 strcat(library_path, tmp); 272 273 if (path_str) { 274 strcat(library_path, ";"); 275 strcat(library_path, path_str); 276 } 277 278 strcat(library_path, ";."); 279 280 Arguments::set_library_path(library_path); 281 FREE_C_HEAP_ARRAY(char, library_path); 282 } 283 284 // Default extensions directory 285 { 286 char path[MAX_PATH]; 287 char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1]; 288 GetWindowsDirectory(path, MAX_PATH); 289 sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR, 290 path, PACKAGE_DIR, EXT_DIR); 291 Arguments::set_ext_dirs(buf); 292 } 293 #undef EXT_DIR 294 #undef BIN_DIR 295 #undef PACKAGE_DIR 296 297#ifndef _WIN64 298 // set our UnhandledExceptionFilter and save any previous one 299 prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception); 300#endif 301 302 // Done 303 return; 304} 305 306void os::breakpoint() { 307 DebugBreak(); 308} 309 310// Invoked from the BREAKPOINT Macro 311extern "C" void breakpoint() { 312 os::breakpoint(); 313} 314 315// RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP. 316// So far, this method is only used by Native Memory Tracking, which is 317// only supported on Windows XP or later. 318// 319int os::get_native_stack(address* stack, int frames, int toSkip) { 320#ifdef _NMT_NOINLINE_ 321 toSkip++; 322#endif 323 int captured = Kernel32Dll::RtlCaptureStackBackTrace(toSkip + 1, frames, 324 (PVOID*)stack, NULL); 325 for (int index = captured; index < frames; index ++) { 326 stack[index] = NULL; 327 } 328 return captured; 329} 330 331 332// os::current_stack_base() 333// 334// Returns the base of the stack, which is the stack's 335// starting address. This function must be called 336// while running on the stack of the thread being queried. 337 338address os::current_stack_base() { 339 MEMORY_BASIC_INFORMATION minfo; 340 address stack_bottom; 341 size_t stack_size; 342 343 VirtualQuery(&minfo, &minfo, sizeof(minfo)); 344 stack_bottom = (address)minfo.AllocationBase; 345 stack_size = minfo.RegionSize; 346 347 // Add up the sizes of all the regions with the same 348 // AllocationBase. 349 while (1) { 350 VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo)); 351 if (stack_bottom == (address)minfo.AllocationBase) { 352 stack_size += minfo.RegionSize; 353 } else { 354 break; 355 } 356 } 357 358#ifdef _M_IA64 359 // IA64 has memory and register stacks 360 // 361 // This is the stack layout you get on NT/IA64 if you specify 1MB stack limit 362 // at thread creation (1MB backing store growing upwards, 1MB memory stack 363 // growing downwards, 2MB summed up) 364 // 365 // ... 366 // ------- top of stack (high address) ----- 367 // | 368 // | 1MB 369 // | Backing Store (Register Stack) 370 // | 371 // | / \ 372 // | | 373 // | | 374 // | | 375 // ------------------------ stack base ----- 376 // | 1MB 377 // | Memory Stack 378 // | 379 // | | 380 // | | 381 // | | 382 // | \ / 383 // | 384 // ----- bottom of stack (low address) ----- 385 // ... 386 387 stack_size = stack_size / 2; 388#endif 389 return stack_bottom + stack_size; 390} 391 392size_t os::current_stack_size() { 393 size_t sz; 394 MEMORY_BASIC_INFORMATION minfo; 395 VirtualQuery(&minfo, &minfo, sizeof(minfo)); 396 sz = (size_t)os::current_stack_base() - (size_t)minfo.AllocationBase; 397 return sz; 398} 399 400struct tm* os::localtime_pd(const time_t* clock, struct tm* res) { 401 const struct tm* time_struct_ptr = localtime(clock); 402 if (time_struct_ptr != NULL) { 403 *res = *time_struct_ptr; 404 return res; 405 } 406 return NULL; 407} 408 409LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo); 410 411// Thread start routine for all new Java threads 412static unsigned __stdcall java_start(Thread* thread) { 413 // Try to randomize the cache line index of hot stack frames. 414 // This helps when threads of the same stack traces evict each other's 415 // cache lines. The threads can be either from the same JVM instance, or 416 // from different JVM instances. The benefit is especially true for 417 // processors with hyperthreading technology. 418 static int counter = 0; 419 int pid = os::current_process_id(); 420 _alloca(((pid ^ counter++) & 7) * 128); 421 422 OSThread* osthr = thread->osthread(); 423 assert(osthr->get_state() == RUNNABLE, "invalid os thread state"); 424 425 if (UseNUMA) { 426 int lgrp_id = os::numa_get_group_id(); 427 if (lgrp_id != -1) { 428 thread->set_lgrp_id(lgrp_id); 429 } 430 } 431 432 // Diagnostic code to investigate JDK-6573254 433 int res = 30115; // non-java thread 434 if (thread->is_Java_thread()) { 435 res = 20115; // java thread 436 } 437 438 // Install a win32 structured exception handler around every thread created 439 // by VM, so VM can generate error dump when an exception occurred in non- 440 // Java thread (e.g. VM thread). 441 __try { 442 thread->run(); 443 } __except(topLevelExceptionFilter( 444 (_EXCEPTION_POINTERS*)_exception_info())) { 445 // Nothing to do. 446 } 447 448 // One less thread is executing 449 // When the VMThread gets here, the main thread may have already exited 450 // which frees the CodeHeap containing the Atomic::add code 451 if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) { 452 Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count); 453 } 454 455 // Thread must not return from exit_process_or_thread(), but if it does, 456 // let it proceed to exit normally 457 return (unsigned)os::win32::exit_process_or_thread(os::win32::EPT_THREAD, res); 458} 459 460static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle, 461 int thread_id) { 462 // Allocate the OSThread object 463 OSThread* osthread = new OSThread(NULL, NULL); 464 if (osthread == NULL) return NULL; 465 466 // Initialize support for Java interrupts 467 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL); 468 if (interrupt_event == NULL) { 469 delete osthread; 470 return NULL; 471 } 472 osthread->set_interrupt_event(interrupt_event); 473 474 // Store info on the Win32 thread into the OSThread 475 osthread->set_thread_handle(thread_handle); 476 osthread->set_thread_id(thread_id); 477 478 if (UseNUMA) { 479 int lgrp_id = os::numa_get_group_id(); 480 if (lgrp_id != -1) { 481 thread->set_lgrp_id(lgrp_id); 482 } 483 } 484 485 // Initial thread state is INITIALIZED, not SUSPENDED 486 osthread->set_state(INITIALIZED); 487 488 return osthread; 489} 490 491 492bool os::create_attached_thread(JavaThread* thread) { 493#ifdef ASSERT 494 thread->verify_not_published(); 495#endif 496 HANDLE thread_h; 497 if (!DuplicateHandle(main_process, GetCurrentThread(), GetCurrentProcess(), 498 &thread_h, THREAD_ALL_ACCESS, false, 0)) { 499 fatal("DuplicateHandle failed\n"); 500 } 501 OSThread* osthread = create_os_thread(thread, thread_h, 502 (int)current_thread_id()); 503 if (osthread == NULL) { 504 return false; 505 } 506 507 // Initial thread state is RUNNABLE 508 osthread->set_state(RUNNABLE); 509 510 thread->set_osthread(osthread); 511 return true; 512} 513 514bool os::create_main_thread(JavaThread* thread) { 515#ifdef ASSERT 516 thread->verify_not_published(); 517#endif 518 if (_starting_thread == NULL) { 519 _starting_thread = create_os_thread(thread, main_thread, main_thread_id); 520 if (_starting_thread == NULL) { 521 return false; 522 } 523 } 524 525 // The primordial thread is runnable from the start) 526 _starting_thread->set_state(RUNNABLE); 527 528 thread->set_osthread(_starting_thread); 529 return true; 530} 531 532// Allocate and initialize a new OSThread 533bool os::create_thread(Thread* thread, ThreadType thr_type, 534 size_t stack_size) { 535 unsigned thread_id; 536 537 // Allocate the OSThread object 538 OSThread* osthread = new OSThread(NULL, NULL); 539 if (osthread == NULL) { 540 return false; 541 } 542 543 // Initialize support for Java interrupts 544 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL); 545 if (interrupt_event == NULL) { 546 delete osthread; 547 return NULL; 548 } 549 osthread->set_interrupt_event(interrupt_event); 550 osthread->set_interrupted(false); 551 552 thread->set_osthread(osthread); 553 554 if (stack_size == 0) { 555 switch (thr_type) { 556 case os::java_thread: 557 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss 558 if (JavaThread::stack_size_at_create() > 0) { 559 stack_size = JavaThread::stack_size_at_create(); 560 } 561 break; 562 case os::compiler_thread: 563 if (CompilerThreadStackSize > 0) { 564 stack_size = (size_t)(CompilerThreadStackSize * K); 565 break; 566 } // else fall through: 567 // use VMThreadStackSize if CompilerThreadStackSize is not defined 568 case os::vm_thread: 569 case os::pgc_thread: 570 case os::cgc_thread: 571 case os::watcher_thread: 572 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K); 573 break; 574 } 575 } 576 577 // Create the Win32 thread 578 // 579 // Contrary to what MSDN document says, "stack_size" in _beginthreadex() 580 // does not specify stack size. Instead, it specifies the size of 581 // initially committed space. The stack size is determined by 582 // PE header in the executable. If the committed "stack_size" is larger 583 // than default value in the PE header, the stack is rounded up to the 584 // nearest multiple of 1MB. For example if the launcher has default 585 // stack size of 320k, specifying any size less than 320k does not 586 // affect the actual stack size at all, it only affects the initial 587 // commitment. On the other hand, specifying 'stack_size' larger than 588 // default value may cause significant increase in memory usage, because 589 // not only the stack space will be rounded up to MB, but also the 590 // entire space is committed upfront. 591 // 592 // Finally Windows XP added a new flag 'STACK_SIZE_PARAM_IS_A_RESERVATION' 593 // for CreateThread() that can treat 'stack_size' as stack size. However we 594 // are not supposed to call CreateThread() directly according to MSDN 595 // document because JVM uses C runtime library. The good news is that the 596 // flag appears to work with _beginthredex() as well. 597 598#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION 599 #define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000) 600#endif 601 602 HANDLE thread_handle = 603 (HANDLE)_beginthreadex(NULL, 604 (unsigned)stack_size, 605 (unsigned (__stdcall *)(void*)) java_start, 606 thread, 607 CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION, 608 &thread_id); 609 if (thread_handle == NULL) { 610 // perhaps STACK_SIZE_PARAM_IS_A_RESERVATION is not supported, try again 611 // without the flag. 612 thread_handle = 613 (HANDLE)_beginthreadex(NULL, 614 (unsigned)stack_size, 615 (unsigned (__stdcall *)(void*)) java_start, 616 thread, 617 CREATE_SUSPENDED, 618 &thread_id); 619 } 620 if (thread_handle == NULL) { 621 // Need to clean up stuff we've allocated so far 622 CloseHandle(osthread->interrupt_event()); 623 thread->set_osthread(NULL); 624 delete osthread; 625 return NULL; 626 } 627 628 Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count); 629 630 // Store info on the Win32 thread into the OSThread 631 osthread->set_thread_handle(thread_handle); 632 osthread->set_thread_id(thread_id); 633 634 // Initial thread state is INITIALIZED, not SUSPENDED 635 osthread->set_state(INITIALIZED); 636 637 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain 638 return true; 639} 640 641 642// Free Win32 resources related to the OSThread 643void os::free_thread(OSThread* osthread) { 644 assert(osthread != NULL, "osthread not set"); 645 CloseHandle(osthread->thread_handle()); 646 CloseHandle(osthread->interrupt_event()); 647 delete osthread; 648} 649 650static jlong first_filetime; 651static jlong initial_performance_count; 652static jlong performance_frequency; 653 654 655jlong as_long(LARGE_INTEGER x) { 656 jlong result = 0; // initialization to avoid warning 657 set_high(&result, x.HighPart); 658 set_low(&result, x.LowPart); 659 return result; 660} 661 662 663jlong os::elapsed_counter() { 664 LARGE_INTEGER count; 665 if (win32::_has_performance_count) { 666 QueryPerformanceCounter(&count); 667 return as_long(count) - initial_performance_count; 668 } else { 669 FILETIME wt; 670 GetSystemTimeAsFileTime(&wt); 671 return (jlong_from(wt.dwHighDateTime, wt.dwLowDateTime) - first_filetime); 672 } 673} 674 675 676jlong os::elapsed_frequency() { 677 if (win32::_has_performance_count) { 678 return performance_frequency; 679 } else { 680 // the FILETIME time is the number of 100-nanosecond intervals since January 1,1601. 681 return 10000000; 682 } 683} 684 685 686julong os::available_memory() { 687 return win32::available_memory(); 688} 689 690julong os::win32::available_memory() { 691 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect 692 // value if total memory is larger than 4GB 693 MEMORYSTATUSEX ms; 694 ms.dwLength = sizeof(ms); 695 GlobalMemoryStatusEx(&ms); 696 697 return (julong)ms.ullAvailPhys; 698} 699 700julong os::physical_memory() { 701 return win32::physical_memory(); 702} 703 704bool os::has_allocatable_memory_limit(julong* limit) { 705 MEMORYSTATUSEX ms; 706 ms.dwLength = sizeof(ms); 707 GlobalMemoryStatusEx(&ms); 708#ifdef _LP64 709 *limit = (julong)ms.ullAvailVirtual; 710 return true; 711#else 712 // Limit to 1400m because of the 2gb address space wall 713 *limit = MIN2((julong)1400*M, (julong)ms.ullAvailVirtual); 714 return true; 715#endif 716} 717 718// VC6 lacks DWORD_PTR 719#if _MSC_VER < 1300 720typedef UINT_PTR DWORD_PTR; 721#endif 722 723int os::active_processor_count() { 724 DWORD_PTR lpProcessAffinityMask = 0; 725 DWORD_PTR lpSystemAffinityMask = 0; 726 int proc_count = processor_count(); 727 if (proc_count <= sizeof(UINT_PTR) * BitsPerByte && 728 GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) { 729 // Nof active processors is number of bits in process affinity mask 730 int bitcount = 0; 731 while (lpProcessAffinityMask != 0) { 732 lpProcessAffinityMask = lpProcessAffinityMask & (lpProcessAffinityMask-1); 733 bitcount++; 734 } 735 return bitcount; 736 } else { 737 return proc_count; 738 } 739} 740 741void os::set_native_thread_name(const char *name) { 742 743 // See: http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx 744 // 745 // Note that unfortunately this only works if the process 746 // is already attached to a debugger; debugger must observe 747 // the exception below to show the correct name. 748 749 const DWORD MS_VC_EXCEPTION = 0x406D1388; 750 struct { 751 DWORD dwType; // must be 0x1000 752 LPCSTR szName; // pointer to name (in user addr space) 753 DWORD dwThreadID; // thread ID (-1=caller thread) 754 DWORD dwFlags; // reserved for future use, must be zero 755 } info; 756 757 info.dwType = 0x1000; 758 info.szName = name; 759 info.dwThreadID = -1; 760 info.dwFlags = 0; 761 762 __try { 763 RaiseException (MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(DWORD), (const ULONG_PTR*)&info ); 764 } __except(EXCEPTION_CONTINUE_EXECUTION) {} 765} 766 767bool os::distribute_processes(uint length, uint* distribution) { 768 // Not yet implemented. 769 return false; 770} 771 772bool os::bind_to_processor(uint processor_id) { 773 // Not yet implemented. 774 return false; 775} 776 777void os::win32::initialize_performance_counter() { 778 LARGE_INTEGER count; 779 if (QueryPerformanceFrequency(&count)) { 780 win32::_has_performance_count = 1; 781 performance_frequency = as_long(count); 782 QueryPerformanceCounter(&count); 783 initial_performance_count = as_long(count); 784 } else { 785 win32::_has_performance_count = 0; 786 FILETIME wt; 787 GetSystemTimeAsFileTime(&wt); 788 first_filetime = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime); 789 } 790} 791 792 793double os::elapsedTime() { 794 return (double) elapsed_counter() / (double) elapsed_frequency(); 795} 796 797 798// Windows format: 799// The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. 800// Java format: 801// Java standards require the number of milliseconds since 1/1/1970 802 803// Constant offset - calculated using offset() 804static jlong _offset = 116444736000000000; 805// Fake time counter for reproducible results when debugging 806static jlong fake_time = 0; 807 808#ifdef ASSERT 809// Just to be safe, recalculate the offset in debug mode 810static jlong _calculated_offset = 0; 811static int _has_calculated_offset = 0; 812 813jlong offset() { 814 if (_has_calculated_offset) return _calculated_offset; 815 SYSTEMTIME java_origin; 816 java_origin.wYear = 1970; 817 java_origin.wMonth = 1; 818 java_origin.wDayOfWeek = 0; // ignored 819 java_origin.wDay = 1; 820 java_origin.wHour = 0; 821 java_origin.wMinute = 0; 822 java_origin.wSecond = 0; 823 java_origin.wMilliseconds = 0; 824 FILETIME jot; 825 if (!SystemTimeToFileTime(&java_origin, &jot)) { 826 fatal("Error = %d\nWindows error", GetLastError()); 827 } 828 _calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime); 829 _has_calculated_offset = 1; 830 assert(_calculated_offset == _offset, "Calculated and constant time offsets must be equal"); 831 return _calculated_offset; 832} 833#else 834jlong offset() { 835 return _offset; 836} 837#endif 838 839jlong windows_to_java_time(FILETIME wt) { 840 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime); 841 return (a - offset()) / 10000; 842} 843 844// Returns time ticks in (10th of micro seconds) 845jlong windows_to_time_ticks(FILETIME wt) { 846 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime); 847 return (a - offset()); 848} 849 850FILETIME java_to_windows_time(jlong l) { 851 jlong a = (l * 10000) + offset(); 852 FILETIME result; 853 result.dwHighDateTime = high(a); 854 result.dwLowDateTime = low(a); 855 return result; 856} 857 858bool os::supports_vtime() { return true; } 859bool os::enable_vtime() { return false; } 860bool os::vtime_enabled() { return false; } 861 862double os::elapsedVTime() { 863 FILETIME created; 864 FILETIME exited; 865 FILETIME kernel; 866 FILETIME user; 867 if (GetThreadTimes(GetCurrentThread(), &created, &exited, &kernel, &user) != 0) { 868 // the resolution of windows_to_java_time() should be sufficient (ms) 869 return (double) (windows_to_java_time(kernel) + windows_to_java_time(user)) / MILLIUNITS; 870 } else { 871 return elapsedTime(); 872 } 873} 874 875jlong os::javaTimeMillis() { 876 if (UseFakeTimers) { 877 return fake_time++; 878 } else { 879 FILETIME wt; 880 GetSystemTimeAsFileTime(&wt); 881 return windows_to_java_time(wt); 882 } 883} 884 885void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) { 886 FILETIME wt; 887 GetSystemTimeAsFileTime(&wt); 888 jlong ticks = windows_to_time_ticks(wt); // 10th of micros 889 jlong secs = jlong(ticks / 10000000); // 10000 * 1000 890 seconds = secs; 891 nanos = jlong(ticks - (secs*10000000)) * 100; 892} 893 894jlong os::javaTimeNanos() { 895 if (!win32::_has_performance_count) { 896 return javaTimeMillis() * NANOSECS_PER_MILLISEC; // the best we can do. 897 } else { 898 LARGE_INTEGER current_count; 899 QueryPerformanceCounter(¤t_count); 900 double current = as_long(current_count); 901 double freq = performance_frequency; 902 jlong time = (jlong)((current/freq) * NANOSECS_PER_SEC); 903 return time; 904 } 905} 906 907void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { 908 if (!win32::_has_performance_count) { 909 // javaTimeMillis() doesn't have much percision, 910 // but it is not going to wrap -- so all 64 bits 911 info_ptr->max_value = ALL_64_BITS; 912 913 // this is a wall clock timer, so may skip 914 info_ptr->may_skip_backward = true; 915 info_ptr->may_skip_forward = true; 916 } else { 917 jlong freq = performance_frequency; 918 if (freq < NANOSECS_PER_SEC) { 919 // the performance counter is 64 bits and we will 920 // be multiplying it -- so no wrap in 64 bits 921 info_ptr->max_value = ALL_64_BITS; 922 } else if (freq > NANOSECS_PER_SEC) { 923 // use the max value the counter can reach to 924 // determine the max value which could be returned 925 julong max_counter = (julong)ALL_64_BITS; 926 info_ptr->max_value = (jlong)(max_counter / (freq / NANOSECS_PER_SEC)); 927 } else { 928 // the performance counter is 64 bits and we will 929 // be using it directly -- so no wrap in 64 bits 930 info_ptr->max_value = ALL_64_BITS; 931 } 932 933 // using a counter, so no skipping 934 info_ptr->may_skip_backward = false; 935 info_ptr->may_skip_forward = false; 936 } 937 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time 938} 939 940char* os::local_time_string(char *buf, size_t buflen) { 941 SYSTEMTIME st; 942 GetLocalTime(&st); 943 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d", 944 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); 945 return buf; 946} 947 948bool os::getTimesSecs(double* process_real_time, 949 double* process_user_time, 950 double* process_system_time) { 951 HANDLE h_process = GetCurrentProcess(); 952 FILETIME create_time, exit_time, kernel_time, user_time; 953 BOOL result = GetProcessTimes(h_process, 954 &create_time, 955 &exit_time, 956 &kernel_time, 957 &user_time); 958 if (result != 0) { 959 FILETIME wt; 960 GetSystemTimeAsFileTime(&wt); 961 jlong rtc_millis = windows_to_java_time(wt); 962 jlong user_millis = windows_to_java_time(user_time); 963 jlong system_millis = windows_to_java_time(kernel_time); 964 *process_real_time = ((double) rtc_millis) / ((double) MILLIUNITS); 965 *process_user_time = ((double) user_millis) / ((double) MILLIUNITS); 966 *process_system_time = ((double) system_millis) / ((double) MILLIUNITS); 967 return true; 968 } else { 969 return false; 970 } 971} 972 973void os::shutdown() { 974 // allow PerfMemory to attempt cleanup of any persistent resources 975 perfMemory_exit(); 976 977 // flush buffered output, finish log files 978 ostream_abort(); 979 980 // Check for abort hook 981 abort_hook_t abort_hook = Arguments::abort_hook(); 982 if (abort_hook != NULL) { 983 abort_hook(); 984 } 985} 986 987 988static BOOL (WINAPI *_MiniDumpWriteDump)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, 989 PMINIDUMP_EXCEPTION_INFORMATION, 990 PMINIDUMP_USER_STREAM_INFORMATION, 991 PMINIDUMP_CALLBACK_INFORMATION); 992 993static HANDLE dumpFile = NULL; 994 995// Check if dump file can be created. 996void os::check_dump_limit(char* buffer, size_t buffsz) { 997 bool status = true; 998 if (!FLAG_IS_DEFAULT(CreateCoredumpOnCrash) && !CreateCoredumpOnCrash) { 999 jio_snprintf(buffer, buffsz, "CreateCoredumpOnCrash is disabled from command line"); 1000 status = false; 1001 } 1002 1003#ifndef ASSERT 1004 if (!os::win32::is_windows_server() && FLAG_IS_DEFAULT(CreateCoredumpOnCrash)) { 1005 jio_snprintf(buffer, buffsz, "Minidumps are not enabled by default on client versions of Windows"); 1006 status = false; 1007 } 1008#endif 1009 1010 if (status) { 1011 const char* cwd = get_current_directory(NULL, 0); 1012 int pid = current_process_id(); 1013 if (cwd != NULL) { 1014 jio_snprintf(buffer, buffsz, "%s\\hs_err_pid%u.mdmp", cwd, pid); 1015 } else { 1016 jio_snprintf(buffer, buffsz, ".\\hs_err_pid%u.mdmp", pid); 1017 } 1018 1019 if (dumpFile == NULL && 1020 (dumpFile = CreateFile(buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) 1021 == INVALID_HANDLE_VALUE) { 1022 jio_snprintf(buffer, buffsz, "Failed to create minidump file (0x%x).", GetLastError()); 1023 status = false; 1024 } 1025 } 1026 VMError::record_coredump_status(buffer, status); 1027} 1028 1029void os::abort(bool dump_core, void* siginfo, void* context) { 1030 HINSTANCE dbghelp; 1031 EXCEPTION_POINTERS ep; 1032 MINIDUMP_EXCEPTION_INFORMATION mei; 1033 MINIDUMP_EXCEPTION_INFORMATION* pmei; 1034 1035 HANDLE hProcess = GetCurrentProcess(); 1036 DWORD processId = GetCurrentProcessId(); 1037 MINIDUMP_TYPE dumpType; 1038 1039 shutdown(); 1040 if (!dump_core || dumpFile == NULL) { 1041 if (dumpFile != NULL) { 1042 CloseHandle(dumpFile); 1043 } 1044 win32::exit_process_or_thread(win32::EPT_PROCESS, 1); 1045 } 1046 1047 dbghelp = os::win32::load_Windows_dll("DBGHELP.DLL", NULL, 0); 1048 1049 if (dbghelp == NULL) { 1050 jio_fprintf(stderr, "Failed to load dbghelp.dll\n"); 1051 CloseHandle(dumpFile); 1052 win32::exit_process_or_thread(win32::EPT_PROCESS, 1); 1053 } 1054 1055 _MiniDumpWriteDump = 1056 CAST_TO_FN_PTR(BOOL(WINAPI *)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, 1057 PMINIDUMP_EXCEPTION_INFORMATION, 1058 PMINIDUMP_USER_STREAM_INFORMATION, 1059 PMINIDUMP_CALLBACK_INFORMATION), 1060 GetProcAddress(dbghelp, 1061 "MiniDumpWriteDump")); 1062 1063 if (_MiniDumpWriteDump == NULL) { 1064 jio_fprintf(stderr, "Failed to find MiniDumpWriteDump() in module dbghelp.dll.\n"); 1065 CloseHandle(dumpFile); 1066 win32::exit_process_or_thread(win32::EPT_PROCESS, 1); 1067 } 1068 1069 dumpType = (MINIDUMP_TYPE)(MiniDumpWithFullMemory | MiniDumpWithHandleData); 1070 1071 // Older versions of dbghelp.h do not contain all the dumptypes we want, dbghelp.h with 1072 // API_VERSION_NUMBER 11 or higher contains the ones we want though 1073#if API_VERSION_NUMBER >= 11 1074 dumpType = (MINIDUMP_TYPE)(dumpType | MiniDumpWithFullMemoryInfo | MiniDumpWithThreadInfo | 1075 MiniDumpWithUnloadedModules); 1076#endif 1077 1078 if (siginfo != NULL && context != NULL) { 1079 ep.ContextRecord = (PCONTEXT) context; 1080 ep.ExceptionRecord = (PEXCEPTION_RECORD) siginfo; 1081 1082 mei.ThreadId = GetCurrentThreadId(); 1083 mei.ExceptionPointers = &ep; 1084 pmei = &mei; 1085 } else { 1086 pmei = NULL; 1087 } 1088 1089 // Older versions of dbghelp.dll (the one shipped with Win2003 for example) may not support all 1090 // the dump types we really want. If first call fails, lets fall back to just use MiniDumpWithFullMemory then. 1091 if (_MiniDumpWriteDump(hProcess, processId, dumpFile, dumpType, pmei, NULL, NULL) == false && 1092 _MiniDumpWriteDump(hProcess, processId, dumpFile, (MINIDUMP_TYPE)MiniDumpWithFullMemory, pmei, NULL, NULL) == false) { 1093 jio_fprintf(stderr, "Call to MiniDumpWriteDump() failed (Error 0x%x)\n", GetLastError()); 1094 } 1095 CloseHandle(dumpFile); 1096 win32::exit_process_or_thread(win32::EPT_PROCESS, 1); 1097} 1098 1099// Die immediately, no exit hook, no abort hook, no cleanup. 1100void os::die() { 1101 win32::exit_process_or_thread(win32::EPT_PROCESS_DIE, -1); 1102} 1103 1104// Directory routines copied from src/win32/native/java/io/dirent_md.c 1105// * dirent_md.c 1.15 00/02/02 1106// 1107// The declarations for DIR and struct dirent are in jvm_win32.h. 1108 1109// Caller must have already run dirname through JVM_NativePath, which removes 1110// duplicate slashes and converts all instances of '/' into '\\'. 1111 1112DIR * os::opendir(const char *dirname) { 1113 assert(dirname != NULL, "just checking"); // hotspot change 1114 DIR *dirp = (DIR *)malloc(sizeof(DIR), mtInternal); 1115 DWORD fattr; // hotspot change 1116 char alt_dirname[4] = { 0, 0, 0, 0 }; 1117 1118 if (dirp == 0) { 1119 errno = ENOMEM; 1120 return 0; 1121 } 1122 1123 // Win32 accepts "\" in its POSIX stat(), but refuses to treat it 1124 // as a directory in FindFirstFile(). We detect this case here and 1125 // prepend the current drive name. 1126 // 1127 if (dirname[1] == '\0' && dirname[0] == '\\') { 1128 alt_dirname[0] = _getdrive() + 'A' - 1; 1129 alt_dirname[1] = ':'; 1130 alt_dirname[2] = '\\'; 1131 alt_dirname[3] = '\0'; 1132 dirname = alt_dirname; 1133 } 1134 1135 dirp->path = (char *)malloc(strlen(dirname) + 5, mtInternal); 1136 if (dirp->path == 0) { 1137 free(dirp); 1138 errno = ENOMEM; 1139 return 0; 1140 } 1141 strcpy(dirp->path, dirname); 1142 1143 fattr = GetFileAttributes(dirp->path); 1144 if (fattr == 0xffffffff) { 1145 free(dirp->path); 1146 free(dirp); 1147 errno = ENOENT; 1148 return 0; 1149 } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) { 1150 free(dirp->path); 1151 free(dirp); 1152 errno = ENOTDIR; 1153 return 0; 1154 } 1155 1156 // Append "*.*", or possibly "\\*.*", to path 1157 if (dirp->path[1] == ':' && 1158 (dirp->path[2] == '\0' || 1159 (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) { 1160 // No '\\' needed for cases like "Z:" or "Z:\" 1161 strcat(dirp->path, "*.*"); 1162 } else { 1163 strcat(dirp->path, "\\*.*"); 1164 } 1165 1166 dirp->handle = FindFirstFile(dirp->path, &dirp->find_data); 1167 if (dirp->handle == INVALID_HANDLE_VALUE) { 1168 if (GetLastError() != ERROR_FILE_NOT_FOUND) { 1169 free(dirp->path); 1170 free(dirp); 1171 errno = EACCES; 1172 return 0; 1173 } 1174 } 1175 return dirp; 1176} 1177 1178// parameter dbuf unused on Windows 1179struct dirent * os::readdir(DIR *dirp, dirent *dbuf) { 1180 assert(dirp != NULL, "just checking"); // hotspot change 1181 if (dirp->handle == INVALID_HANDLE_VALUE) { 1182 return 0; 1183 } 1184 1185 strcpy(dirp->dirent.d_name, dirp->find_data.cFileName); 1186 1187 if (!FindNextFile(dirp->handle, &dirp->find_data)) { 1188 if (GetLastError() == ERROR_INVALID_HANDLE) { 1189 errno = EBADF; 1190 return 0; 1191 } 1192 FindClose(dirp->handle); 1193 dirp->handle = INVALID_HANDLE_VALUE; 1194 } 1195 1196 return &dirp->dirent; 1197} 1198 1199int os::closedir(DIR *dirp) { 1200 assert(dirp != NULL, "just checking"); // hotspot change 1201 if (dirp->handle != INVALID_HANDLE_VALUE) { 1202 if (!FindClose(dirp->handle)) { 1203 errno = EBADF; 1204 return -1; 1205 } 1206 dirp->handle = INVALID_HANDLE_VALUE; 1207 } 1208 free(dirp->path); 1209 free(dirp); 1210 return 0; 1211} 1212 1213// This must be hard coded because it's the system's temporary 1214// directory not the java application's temp directory, ala java.io.tmpdir. 1215const char* os::get_temp_directory() { 1216 static char path_buf[MAX_PATH]; 1217 if (GetTempPath(MAX_PATH, path_buf) > 0) { 1218 return path_buf; 1219 } else { 1220 path_buf[0] = '\0'; 1221 return path_buf; 1222 } 1223} 1224 1225static bool file_exists(const char* filename) { 1226 if (filename == NULL || strlen(filename) == 0) { 1227 return false; 1228 } 1229 return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES; 1230} 1231 1232bool os::dll_build_name(char *buffer, size_t buflen, 1233 const char* pname, const char* fname) { 1234 bool retval = false; 1235 const size_t pnamelen = pname ? strlen(pname) : 0; 1236 const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0; 1237 1238 // Return error on buffer overflow. 1239 if (pnamelen + strlen(fname) + 10 > buflen) { 1240 return retval; 1241 } 1242 1243 if (pnamelen == 0) { 1244 jio_snprintf(buffer, buflen, "%s.dll", fname); 1245 retval = true; 1246 } else if (c == ':' || c == '\\') { 1247 jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname); 1248 retval = true; 1249 } else if (strchr(pname, *os::path_separator()) != NULL) { 1250 int n; 1251 char** pelements = split_path(pname, &n); 1252 if (pelements == NULL) { 1253 return false; 1254 } 1255 for (int i = 0; i < n; i++) { 1256 char* path = pelements[i]; 1257 // Really shouldn't be NULL, but check can't hurt 1258 size_t plen = (path == NULL) ? 0 : strlen(path); 1259 if (plen == 0) { 1260 continue; // skip the empty path values 1261 } 1262 const char lastchar = path[plen - 1]; 1263 if (lastchar == ':' || lastchar == '\\') { 1264 jio_snprintf(buffer, buflen, "%s%s.dll", path, fname); 1265 } else { 1266 jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname); 1267 } 1268 if (file_exists(buffer)) { 1269 retval = true; 1270 break; 1271 } 1272 } 1273 // release the storage 1274 for (int i = 0; i < n; i++) { 1275 if (pelements[i] != NULL) { 1276 FREE_C_HEAP_ARRAY(char, pelements[i]); 1277 } 1278 } 1279 if (pelements != NULL) { 1280 FREE_C_HEAP_ARRAY(char*, pelements); 1281 } 1282 } else { 1283 jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname); 1284 retval = true; 1285 } 1286 return retval; 1287} 1288 1289// Needs to be in os specific directory because windows requires another 1290// header file <direct.h> 1291const char* os::get_current_directory(char *buf, size_t buflen) { 1292 int n = static_cast<int>(buflen); 1293 if (buflen > INT_MAX) n = INT_MAX; 1294 return _getcwd(buf, n); 1295} 1296 1297//----------------------------------------------------------- 1298// Helper functions for fatal error handler 1299#ifdef _WIN64 1300// Helper routine which returns true if address in 1301// within the NTDLL address space. 1302// 1303static bool _addr_in_ntdll(address addr) { 1304 HMODULE hmod; 1305 MODULEINFO minfo; 1306 1307 hmod = GetModuleHandle("NTDLL.DLL"); 1308 if (hmod == NULL) return false; 1309 if (!os::PSApiDll::GetModuleInformation(GetCurrentProcess(), hmod, 1310 &minfo, sizeof(MODULEINFO))) { 1311 return false; 1312 } 1313 1314 if ((addr >= minfo.lpBaseOfDll) && 1315 (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage))) { 1316 return true; 1317 } else { 1318 return false; 1319 } 1320} 1321#endif 1322 1323struct _modinfo { 1324 address addr; 1325 char* full_path; // point to a char buffer 1326 int buflen; // size of the buffer 1327 address base_addr; 1328}; 1329 1330static int _locate_module_by_addr(const char * mod_fname, address base_addr, 1331 address top_address, void * param) { 1332 struct _modinfo *pmod = (struct _modinfo *)param; 1333 if (!pmod) return -1; 1334 1335 if (base_addr <= pmod->addr && 1336 top_address > pmod->addr) { 1337 // if a buffer is provided, copy path name to the buffer 1338 if (pmod->full_path) { 1339 jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname); 1340 } 1341 pmod->base_addr = base_addr; 1342 return 1; 1343 } 1344 return 0; 1345} 1346 1347bool os::dll_address_to_library_name(address addr, char* buf, 1348 int buflen, int* offset) { 1349 // buf is not optional, but offset is optional 1350 assert(buf != NULL, "sanity check"); 1351 1352// NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always 1353// return the full path to the DLL file, sometimes it returns path 1354// to the corresponding PDB file (debug info); sometimes it only 1355// returns partial path, which makes life painful. 1356 1357 struct _modinfo mi; 1358 mi.addr = addr; 1359 mi.full_path = buf; 1360 mi.buflen = buflen; 1361 if (get_loaded_modules_info(_locate_module_by_addr, (void *)&mi)) { 1362 // buf already contains path name 1363 if (offset) *offset = addr - mi.base_addr; 1364 return true; 1365 } 1366 1367 buf[0] = '\0'; 1368 if (offset) *offset = -1; 1369 return false; 1370} 1371 1372bool os::dll_address_to_function_name(address addr, char *buf, 1373 int buflen, int *offset, 1374 bool demangle) { 1375 // buf is not optional, but offset is optional 1376 assert(buf != NULL, "sanity check"); 1377 1378 if (Decoder::decode(addr, buf, buflen, offset, demangle)) { 1379 return true; 1380 } 1381 if (offset != NULL) *offset = -1; 1382 buf[0] = '\0'; 1383 return false; 1384} 1385 1386// save the start and end address of jvm.dll into param[0] and param[1] 1387static int _locate_jvm_dll(const char* mod_fname, address base_addr, 1388 address top_address, void * param) { 1389 if (!param) return -1; 1390 1391 if (base_addr <= (address)_locate_jvm_dll && 1392 top_address > (address)_locate_jvm_dll) { 1393 ((address*)param)[0] = base_addr; 1394 ((address*)param)[1] = top_address; 1395 return 1; 1396 } 1397 return 0; 1398} 1399 1400address vm_lib_location[2]; // start and end address of jvm.dll 1401 1402// check if addr is inside jvm.dll 1403bool os::address_is_in_vm(address addr) { 1404 if (!vm_lib_location[0] || !vm_lib_location[1]) { 1405 if (!get_loaded_modules_info(_locate_jvm_dll, (void *)vm_lib_location)) { 1406 assert(false, "Can't find jvm module."); 1407 return false; 1408 } 1409 } 1410 1411 return (vm_lib_location[0] <= addr) && (addr < vm_lib_location[1]); 1412} 1413 1414// print module info; param is outputStream* 1415static int _print_module(const char* fname, address base_address, 1416 address top_address, void* param) { 1417 if (!param) return -1; 1418 1419 outputStream* st = (outputStream*)param; 1420 1421 st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base_address, top_address, fname); 1422 return 0; 1423} 1424 1425// Loads .dll/.so and 1426// in case of error it checks if .dll/.so was built for the 1427// same architecture as Hotspot is running on 1428void * os::dll_load(const char *name, char *ebuf, int ebuflen) { 1429 void * result = LoadLibrary(name); 1430 if (result != NULL) { 1431 return result; 1432 } 1433 1434 DWORD errcode = GetLastError(); 1435 if (errcode == ERROR_MOD_NOT_FOUND) { 1436 strncpy(ebuf, "Can't find dependent libraries", ebuflen - 1); 1437 ebuf[ebuflen - 1] = '\0'; 1438 return NULL; 1439 } 1440 1441 // Parsing dll below 1442 // If we can read dll-info and find that dll was built 1443 // for an architecture other than Hotspot is running in 1444 // - then print to buffer "DLL was built for a different architecture" 1445 // else call os::lasterror to obtain system error message 1446 1447 // Read system error message into ebuf 1448 // It may or may not be overwritten below (in the for loop and just above) 1449 lasterror(ebuf, (size_t) ebuflen); 1450 ebuf[ebuflen - 1] = '\0'; 1451 int fd = ::open(name, O_RDONLY | O_BINARY, 0); 1452 if (fd < 0) { 1453 return NULL; 1454 } 1455 1456 uint32_t signature_offset; 1457 uint16_t lib_arch = 0; 1458 bool failed_to_get_lib_arch = 1459 ( // Go to position 3c in the dll 1460 (os::seek_to_file_offset(fd, IMAGE_FILE_PTR_TO_SIGNATURE) < 0) 1461 || 1462 // Read location of signature 1463 (sizeof(signature_offset) != 1464 (os::read(fd, (void*)&signature_offset, sizeof(signature_offset)))) 1465 || 1466 // Go to COFF File Header in dll 1467 // that is located after "signature" (4 bytes long) 1468 (os::seek_to_file_offset(fd, 1469 signature_offset + IMAGE_FILE_SIGNATURE_LENGTH) < 0) 1470 || 1471 // Read field that contains code of architecture 1472 // that dll was built for 1473 (sizeof(lib_arch) != (os::read(fd, (void*)&lib_arch, sizeof(lib_arch)))) 1474 ); 1475 1476 ::close(fd); 1477 if (failed_to_get_lib_arch) { 1478 // file i/o error - report os::lasterror(...) msg 1479 return NULL; 1480 } 1481 1482 typedef struct { 1483 uint16_t arch_code; 1484 char* arch_name; 1485 } arch_t; 1486 1487 static const arch_t arch_array[] = { 1488 {IMAGE_FILE_MACHINE_I386, (char*)"IA 32"}, 1489 {IMAGE_FILE_MACHINE_AMD64, (char*)"AMD 64"}, 1490 {IMAGE_FILE_MACHINE_IA64, (char*)"IA 64"} 1491 }; 1492#if (defined _M_IA64) 1493 static const uint16_t running_arch = IMAGE_FILE_MACHINE_IA64; 1494#elif (defined _M_AMD64) 1495 static const uint16_t running_arch = IMAGE_FILE_MACHINE_AMD64; 1496#elif (defined _M_IX86) 1497 static const uint16_t running_arch = IMAGE_FILE_MACHINE_I386; 1498#else 1499 #error Method os::dll_load requires that one of following \ 1500 is defined :_M_IA64,_M_AMD64 or _M_IX86 1501#endif 1502 1503 1504 // Obtain a string for printf operation 1505 // lib_arch_str shall contain string what platform this .dll was built for 1506 // running_arch_str shall string contain what platform Hotspot was built for 1507 char *running_arch_str = NULL, *lib_arch_str = NULL; 1508 for (unsigned int i = 0; i < ARRAY_SIZE(arch_array); i++) { 1509 if (lib_arch == arch_array[i].arch_code) { 1510 lib_arch_str = arch_array[i].arch_name; 1511 } 1512 if (running_arch == arch_array[i].arch_code) { 1513 running_arch_str = arch_array[i].arch_name; 1514 } 1515 } 1516 1517 assert(running_arch_str, 1518 "Didn't find running architecture code in arch_array"); 1519 1520 // If the architecture is right 1521 // but some other error took place - report os::lasterror(...) msg 1522 if (lib_arch == running_arch) { 1523 return NULL; 1524 } 1525 1526 if (lib_arch_str != NULL) { 1527 ::_snprintf(ebuf, ebuflen - 1, 1528 "Can't load %s-bit .dll on a %s-bit platform", 1529 lib_arch_str, running_arch_str); 1530 } else { 1531 // don't know what architecture this dll was build for 1532 ::_snprintf(ebuf, ebuflen - 1, 1533 "Can't load this .dll (machine code=0x%x) on a %s-bit platform", 1534 lib_arch, running_arch_str); 1535 } 1536 1537 return NULL; 1538} 1539 1540void os::print_dll_info(outputStream *st) { 1541 st->print_cr("Dynamic libraries:"); 1542 get_loaded_modules_info(_print_module, (void *)st); 1543} 1544 1545int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) { 1546 HANDLE hProcess; 1547 1548# define MAX_NUM_MODULES 128 1549 HMODULE modules[MAX_NUM_MODULES]; 1550 static char filename[MAX_PATH]; 1551 int result = 0; 1552 1553 if (!os::PSApiDll::PSApiAvailable()) { 1554 return 0; 1555 } 1556 1557 int pid = os::current_process_id(); 1558 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 1559 FALSE, pid); 1560 if (hProcess == NULL) return 0; 1561 1562 DWORD size_needed; 1563 if (!os::PSApiDll::EnumProcessModules(hProcess, modules, 1564 sizeof(modules), &size_needed)) { 1565 CloseHandle(hProcess); 1566 return 0; 1567 } 1568 1569 // number of modules that are currently loaded 1570 int num_modules = size_needed / sizeof(HMODULE); 1571 1572 for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) { 1573 // Get Full pathname: 1574 if (!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i], 1575 filename, sizeof(filename))) { 1576 filename[0] = '\0'; 1577 } 1578 1579 MODULEINFO modinfo; 1580 if (!os::PSApiDll::GetModuleInformation(hProcess, modules[i], 1581 &modinfo, sizeof(modinfo))) { 1582 modinfo.lpBaseOfDll = NULL; 1583 modinfo.SizeOfImage = 0; 1584 } 1585 1586 // Invoke callback function 1587 result = callback(filename, (address)modinfo.lpBaseOfDll, 1588 (address)((u8)modinfo.lpBaseOfDll + (u8)modinfo.SizeOfImage), param); 1589 if (result) break; 1590 } 1591 1592 CloseHandle(hProcess); 1593 return result; 1594} 1595 1596#ifndef PRODUCT 1597bool os::get_host_name(char* buf, size_t buflen) { 1598 DWORD size = (DWORD)buflen; 1599 return (GetComputerNameEx(ComputerNameDnsHostname, buf, &size) == TRUE); 1600} 1601#endif // PRODUCT 1602 1603void os::get_summary_os_info(char* buf, size_t buflen) { 1604 stringStream sst(buf, buflen); 1605 os::win32::print_windows_version(&sst); 1606 // chop off newline character 1607 char* nl = strchr(buf, '\n'); 1608 if (nl != NULL) *nl = '\0'; 1609} 1610 1611int os::log_vsnprintf(char* buf, size_t len, const char* fmt, va_list args) { 1612 int ret = vsnprintf(buf, len, fmt, args); 1613 // Get the correct buffer size if buf is too small 1614 if (ret < 0) { 1615 return _vscprintf(fmt, args); 1616 } 1617 return ret; 1618} 1619 1620void os::print_os_info_brief(outputStream* st) { 1621 os::print_os_info(st); 1622} 1623 1624void os::print_os_info(outputStream* st) { 1625#ifdef ASSERT 1626 char buffer[1024]; 1627 st->print("HostName: "); 1628 if (get_host_name(buffer, sizeof(buffer))) { 1629 st->print("%s ", buffer); 1630 } else { 1631 st->print("N/A "); 1632 } 1633#endif 1634 st->print("OS:"); 1635 os::win32::print_windows_version(st); 1636} 1637 1638void os::win32::print_windows_version(outputStream* st) { 1639 OSVERSIONINFOEX osvi; 1640 VS_FIXEDFILEINFO *file_info; 1641 TCHAR kernel32_path[MAX_PATH]; 1642 UINT len, ret; 1643 1644 // Use the GetVersionEx information to see if we're on a server or 1645 // workstation edition of Windows. Starting with Windows 8.1 we can't 1646 // trust the OS version information returned by this API. 1647 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); 1648 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 1649 if (!GetVersionEx((OSVERSIONINFO *)&osvi)) { 1650 st->print_cr("Call to GetVersionEx failed"); 1651 return; 1652 } 1653 bool is_workstation = (osvi.wProductType == VER_NT_WORKSTATION); 1654 1655 // Get the full path to \Windows\System32\kernel32.dll and use that for 1656 // determining what version of Windows we're running on. 1657 len = MAX_PATH - (UINT)strlen("\\kernel32.dll") - 1; 1658 ret = GetSystemDirectory(kernel32_path, len); 1659 if (ret == 0 || ret > len) { 1660 st->print_cr("Call to GetSystemDirectory failed"); 1661 return; 1662 } 1663 strncat(kernel32_path, "\\kernel32.dll", MAX_PATH - ret); 1664 1665 DWORD version_size = GetFileVersionInfoSize(kernel32_path, NULL); 1666 if (version_size == 0) { 1667 st->print_cr("Call to GetFileVersionInfoSize failed"); 1668 return; 1669 } 1670 1671 LPTSTR version_info = (LPTSTR)os::malloc(version_size, mtInternal); 1672 if (version_info == NULL) { 1673 st->print_cr("Failed to allocate version_info"); 1674 return; 1675 } 1676 1677 if (!GetFileVersionInfo(kernel32_path, NULL, version_size, version_info)) { 1678 os::free(version_info); 1679 st->print_cr("Call to GetFileVersionInfo failed"); 1680 return; 1681 } 1682 1683 if (!VerQueryValue(version_info, TEXT("\\"), (LPVOID*)&file_info, &len)) { 1684 os::free(version_info); 1685 st->print_cr("Call to VerQueryValue failed"); 1686 return; 1687 } 1688 1689 int major_version = HIWORD(file_info->dwProductVersionMS); 1690 int minor_version = LOWORD(file_info->dwProductVersionMS); 1691 int build_number = HIWORD(file_info->dwProductVersionLS); 1692 int build_minor = LOWORD(file_info->dwProductVersionLS); 1693 int os_vers = major_version * 1000 + minor_version; 1694 os::free(version_info); 1695 1696 st->print(" Windows "); 1697 switch (os_vers) { 1698 1699 case 6000: 1700 if (is_workstation) { 1701 st->print("Vista"); 1702 } else { 1703 st->print("Server 2008"); 1704 } 1705 break; 1706 1707 case 6001: 1708 if (is_workstation) { 1709 st->print("7"); 1710 } else { 1711 st->print("Server 2008 R2"); 1712 } 1713 break; 1714 1715 case 6002: 1716 if (is_workstation) { 1717 st->print("8"); 1718 } else { 1719 st->print("Server 2012"); 1720 } 1721 break; 1722 1723 case 6003: 1724 if (is_workstation) { 1725 st->print("8.1"); 1726 } else { 1727 st->print("Server 2012 R2"); 1728 } 1729 break; 1730 1731 case 10000: 1732 if (is_workstation) { 1733 st->print("10"); 1734 } else { 1735 // The server version name of Windows 10 is not known at this time 1736 st->print("%d.%d", major_version, minor_version); 1737 } 1738 break; 1739 1740 default: 1741 // Unrecognized windows, print out its major and minor versions 1742 st->print("%d.%d", major_version, minor_version); 1743 break; 1744 } 1745 1746 // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could 1747 // find out whether we are running on 64 bit processor or not 1748 SYSTEM_INFO si; 1749 ZeroMemory(&si, sizeof(SYSTEM_INFO)); 1750 os::Kernel32Dll::GetNativeSystemInfo(&si); 1751 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) { 1752 st->print(" , 64 bit"); 1753 } 1754 1755 st->print(" Build %d", build_number); 1756 st->print(" (%d.%d.%d.%d)", major_version, minor_version, build_number, build_minor); 1757 st->cr(); 1758} 1759 1760void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) { 1761 // Nothing to do for now. 1762} 1763 1764void os::get_summary_cpu_info(char* buf, size_t buflen) { 1765 HKEY key; 1766 DWORD status = RegOpenKey(HKEY_LOCAL_MACHINE, 1767 "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", &key); 1768 if (status == ERROR_SUCCESS) { 1769 DWORD size = (DWORD)buflen; 1770 status = RegQueryValueEx(key, "ProcessorNameString", NULL, NULL, (byte*)buf, &size); 1771 if (status != ERROR_SUCCESS) { 1772 strncpy(buf, "## __CPU__", buflen); 1773 } 1774 RegCloseKey(key); 1775 } else { 1776 // Put generic cpu info to return 1777 strncpy(buf, "## __CPU__", buflen); 1778 } 1779} 1780 1781void os::print_memory_info(outputStream* st) { 1782 st->print("Memory:"); 1783 st->print(" %dk page", os::vm_page_size()>>10); 1784 1785 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect 1786 // value if total memory is larger than 4GB 1787 MEMORYSTATUSEX ms; 1788 ms.dwLength = sizeof(ms); 1789 GlobalMemoryStatusEx(&ms); 1790 1791 st->print(", physical %uk", os::physical_memory() >> 10); 1792 st->print("(%uk free)", os::available_memory() >> 10); 1793 1794 st->print(", swap %uk", ms.ullTotalPageFile >> 10); 1795 st->print("(%uk free)", ms.ullAvailPageFile >> 10); 1796 st->cr(); 1797} 1798 1799void os::print_siginfo(outputStream *st, void *siginfo) { 1800 EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo; 1801 st->print("siginfo:"); 1802 st->print(" ExceptionCode=0x%x", er->ExceptionCode); 1803 1804 if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 1805 er->NumberParameters >= 2) { 1806 switch (er->ExceptionInformation[0]) { 1807 case 0: st->print(", reading address"); break; 1808 case 1: st->print(", writing address"); break; 1809 default: st->print(", ExceptionInformation=" INTPTR_FORMAT, 1810 er->ExceptionInformation[0]); 1811 } 1812 st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]); 1813 } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR && 1814 er->NumberParameters >= 2 && UseSharedSpaces) { 1815 FileMapInfo* mapinfo = FileMapInfo::current_info(); 1816 if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) { 1817 st->print("\n\nError accessing class data sharing archive." \ 1818 " Mapped file inaccessible during execution, " \ 1819 " possible disk/network problem."); 1820 } 1821 } else { 1822 int num = er->NumberParameters; 1823 if (num > 0) { 1824 st->print(", ExceptionInformation="); 1825 for (int i = 0; i < num; i++) { 1826 st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]); 1827 } 1828 } 1829 } 1830 st->cr(); 1831} 1832 1833void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 1834 // do nothing 1835} 1836 1837static char saved_jvm_path[MAX_PATH] = {0}; 1838 1839// Find the full path to the current module, jvm.dll 1840void os::jvm_path(char *buf, jint buflen) { 1841 // Error checking. 1842 if (buflen < MAX_PATH) { 1843 assert(false, "must use a large-enough buffer"); 1844 buf[0] = '\0'; 1845 return; 1846 } 1847 // Lazy resolve the path to current module. 1848 if (saved_jvm_path[0] != 0) { 1849 strcpy(buf, saved_jvm_path); 1850 return; 1851 } 1852 1853 buf[0] = '\0'; 1854 if (Arguments::sun_java_launcher_is_altjvm()) { 1855 // Support for the java launcher's '-XXaltjvm=<path>' option. Check 1856 // for a JAVA_HOME environment variable and fix up the path so it 1857 // looks like jvm.dll is installed there (append a fake suffix 1858 // hotspot/jvm.dll). 1859 char* java_home_var = ::getenv("JAVA_HOME"); 1860 if (java_home_var != NULL && java_home_var[0] != 0 && 1861 strlen(java_home_var) < (size_t)buflen) { 1862 strncpy(buf, java_home_var, buflen); 1863 1864 // determine if this is a legacy image or modules image 1865 // modules image doesn't have "jre" subdirectory 1866 size_t len = strlen(buf); 1867 char* jrebin_p = buf + len; 1868 jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\"); 1869 if (0 != _access(buf, 0)) { 1870 jio_snprintf(jrebin_p, buflen-len, "\\bin\\"); 1871 } 1872 len = strlen(buf); 1873 jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll"); 1874 } 1875 } 1876 1877 if (buf[0] == '\0') { 1878 GetModuleFileName(vm_lib_handle, buf, buflen); 1879 } 1880 strncpy(saved_jvm_path, buf, MAX_PATH); 1881 saved_jvm_path[MAX_PATH - 1] = '\0'; 1882} 1883 1884 1885void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 1886#ifndef _WIN64 1887 st->print("_"); 1888#endif 1889} 1890 1891 1892void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 1893#ifndef _WIN64 1894 st->print("@%d", args_size * sizeof(int)); 1895#endif 1896} 1897 1898// This method is a copy of JDK's sysGetLastErrorString 1899// from src/windows/hpi/src/system_md.c 1900 1901size_t os::lasterror(char* buf, size_t len) { 1902 DWORD errval; 1903 1904 if ((errval = GetLastError()) != 0) { 1905 // DOS error 1906 size_t n = (size_t)FormatMessage( 1907 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 1908 NULL, 1909 errval, 1910 0, 1911 buf, 1912 (DWORD)len, 1913 NULL); 1914 if (n > 3) { 1915 // Drop final '.', CR, LF 1916 if (buf[n - 1] == '\n') n--; 1917 if (buf[n - 1] == '\r') n--; 1918 if (buf[n - 1] == '.') n--; 1919 buf[n] = '\0'; 1920 } 1921 return n; 1922 } 1923 1924 if (errno != 0) { 1925 // C runtime error that has no corresponding DOS error code 1926 const char* s = strerror(errno); 1927 size_t n = strlen(s); 1928 if (n >= len) n = len - 1; 1929 strncpy(buf, s, n); 1930 buf[n] = '\0'; 1931 return n; 1932 } 1933 1934 return 0; 1935} 1936 1937int os::get_last_error() { 1938 DWORD error = GetLastError(); 1939 if (error == 0) { 1940 error = errno; 1941 } 1942 return (int)error; 1943} 1944 1945WindowsSemaphore::WindowsSemaphore(uint value) { 1946 _semaphore = ::CreateSemaphore(NULL, value, LONG_MAX, NULL); 1947 1948 guarantee(_semaphore != NULL, "CreateSemaphore failed with error code: %lu", GetLastError()); 1949} 1950 1951WindowsSemaphore::~WindowsSemaphore() { 1952 ::CloseHandle(_semaphore); 1953} 1954 1955void WindowsSemaphore::signal(uint count) { 1956 if (count > 0) { 1957 BOOL ret = ::ReleaseSemaphore(_semaphore, count, NULL); 1958 1959 assert(ret != 0, "ReleaseSemaphore failed with error code: %lu", GetLastError()); 1960 } 1961} 1962 1963void WindowsSemaphore::wait() { 1964 DWORD ret = ::WaitForSingleObject(_semaphore, INFINITE); 1965 assert(ret != WAIT_FAILED, "WaitForSingleObject failed with error code: %lu", GetLastError()); 1966 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject failed with return value: %lu", ret); 1967} 1968 1969// sun.misc.Signal 1970// NOTE that this is a workaround for an apparent kernel bug where if 1971// a signal handler for SIGBREAK is installed then that signal handler 1972// takes priority over the console control handler for CTRL_CLOSE_EVENT. 1973// See bug 4416763. 1974static void (*sigbreakHandler)(int) = NULL; 1975 1976static void UserHandler(int sig, void *siginfo, void *context) { 1977 os::signal_notify(sig); 1978 // We need to reinstate the signal handler each time... 1979 os::signal(sig, (void*)UserHandler); 1980} 1981 1982void* os::user_handler() { 1983 return (void*) UserHandler; 1984} 1985 1986void* os::signal(int signal_number, void* handler) { 1987 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) { 1988 void (*oldHandler)(int) = sigbreakHandler; 1989 sigbreakHandler = (void (*)(int)) handler; 1990 return (void*) oldHandler; 1991 } else { 1992 return (void*)::signal(signal_number, (void (*)(int))handler); 1993 } 1994} 1995 1996void os::signal_raise(int signal_number) { 1997 raise(signal_number); 1998} 1999 2000// The Win32 C runtime library maps all console control events other than ^C 2001// into SIGBREAK, which makes it impossible to distinguish ^BREAK from close, 2002// logoff, and shutdown events. We therefore install our own console handler 2003// that raises SIGTERM for the latter cases. 2004// 2005static BOOL WINAPI consoleHandler(DWORD event) { 2006 switch (event) { 2007 case CTRL_C_EVENT: 2008 if (is_error_reported()) { 2009 // Ctrl-C is pressed during error reporting, likely because the error 2010 // handler fails to abort. Let VM die immediately. 2011 os::die(); 2012 } 2013 2014 os::signal_raise(SIGINT); 2015 return TRUE; 2016 break; 2017 case CTRL_BREAK_EVENT: 2018 if (sigbreakHandler != NULL) { 2019 (*sigbreakHandler)(SIGBREAK); 2020 } 2021 return TRUE; 2022 break; 2023 case CTRL_LOGOFF_EVENT: { 2024 // Don't terminate JVM if it is running in a non-interactive session, 2025 // such as a service process. 2026 USEROBJECTFLAGS flags; 2027 HANDLE handle = GetProcessWindowStation(); 2028 if (handle != NULL && 2029 GetUserObjectInformation(handle, UOI_FLAGS, &flags, 2030 sizeof(USEROBJECTFLAGS), NULL)) { 2031 // If it is a non-interactive session, let next handler to deal 2032 // with it. 2033 if ((flags.dwFlags & WSF_VISIBLE) == 0) { 2034 return FALSE; 2035 } 2036 } 2037 } 2038 case CTRL_CLOSE_EVENT: 2039 case CTRL_SHUTDOWN_EVENT: 2040 os::signal_raise(SIGTERM); 2041 return TRUE; 2042 break; 2043 default: 2044 break; 2045 } 2046 return FALSE; 2047} 2048 2049// The following code is moved from os.cpp for making this 2050// code platform specific, which it is by its very nature. 2051 2052// Return maximum OS signal used + 1 for internal use only 2053// Used as exit signal for signal_thread 2054int os::sigexitnum_pd() { 2055 return NSIG; 2056} 2057 2058// a counter for each possible signal value, including signal_thread exit signal 2059static volatile jint pending_signals[NSIG+1] = { 0 }; 2060static HANDLE sig_sem = NULL; 2061 2062void os::signal_init_pd() { 2063 // Initialize signal structures 2064 memset((void*)pending_signals, 0, sizeof(pending_signals)); 2065 2066 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL); 2067 2068 // Programs embedding the VM do not want it to attempt to receive 2069 // events like CTRL_LOGOFF_EVENT, which are used to implement the 2070 // shutdown hooks mechanism introduced in 1.3. For example, when 2071 // the VM is run as part of a Windows NT service (i.e., a servlet 2072 // engine in a web server), the correct behavior is for any console 2073 // control handler to return FALSE, not TRUE, because the OS's 2074 // "final" handler for such events allows the process to continue if 2075 // it is a service (while terminating it if it is not a service). 2076 // To make this behavior uniform and the mechanism simpler, we 2077 // completely disable the VM's usage of these console events if -Xrs 2078 // (=ReduceSignalUsage) is specified. This means, for example, that 2079 // the CTRL-BREAK thread dump mechanism is also disabled in this 2080 // case. See bugs 4323062, 4345157, and related bugs. 2081 2082 if (!ReduceSignalUsage) { 2083 // Add a CTRL-C handler 2084 SetConsoleCtrlHandler(consoleHandler, TRUE); 2085 } 2086} 2087 2088void os::signal_notify(int signal_number) { 2089 BOOL ret; 2090 if (sig_sem != NULL) { 2091 Atomic::inc(&pending_signals[signal_number]); 2092 ret = ::ReleaseSemaphore(sig_sem, 1, NULL); 2093 assert(ret != 0, "ReleaseSemaphore() failed"); 2094 } 2095} 2096 2097static int check_pending_signals(bool wait_for_signal) { 2098 DWORD ret; 2099 while (true) { 2100 for (int i = 0; i < NSIG + 1; i++) { 2101 jint n = pending_signals[i]; 2102 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 2103 return i; 2104 } 2105 } 2106 if (!wait_for_signal) { 2107 return -1; 2108 } 2109 2110 JavaThread *thread = JavaThread::current(); 2111 2112 ThreadBlockInVM tbivm(thread); 2113 2114 bool threadIsSuspended; 2115 do { 2116 thread->set_suspend_equivalent(); 2117 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 2118 ret = ::WaitForSingleObject(sig_sem, INFINITE); 2119 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed"); 2120 2121 // were we externally suspended while we were waiting? 2122 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 2123 if (threadIsSuspended) { 2124 // The semaphore has been incremented, but while we were waiting 2125 // another thread suspended us. We don't want to continue running 2126 // while suspended because that would surprise the thread that 2127 // suspended us. 2128 ret = ::ReleaseSemaphore(sig_sem, 1, NULL); 2129 assert(ret != 0, "ReleaseSemaphore() failed"); 2130 2131 thread->java_suspend_self(); 2132 } 2133 } while (threadIsSuspended); 2134 } 2135} 2136 2137int os::signal_lookup() { 2138 return check_pending_signals(false); 2139} 2140 2141int os::signal_wait() { 2142 return check_pending_signals(true); 2143} 2144 2145// Implicit OS exception handling 2146 2147LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, 2148 address handler) { 2149 JavaThread* thread = JavaThread::current(); 2150 // Save pc in thread 2151#ifdef _M_IA64 2152 // Do not blow up if no thread info available. 2153 if (thread) { 2154 // Saving PRECISE pc (with slot information) in thread. 2155 uint64_t precise_pc = (uint64_t) exceptionInfo->ExceptionRecord->ExceptionAddress; 2156 // Convert precise PC into "Unix" format 2157 precise_pc = (precise_pc & 0xFFFFFFFFFFFFFFF0) | ((precise_pc & 0xF) >> 2); 2158 thread->set_saved_exception_pc((address)precise_pc); 2159 } 2160 // Set pc to handler 2161 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler; 2162 // Clear out psr.ri (= Restart Instruction) in order to continue 2163 // at the beginning of the target bundle. 2164 exceptionInfo->ContextRecord->StIPSR &= 0xFFFFF9FFFFFFFFFF; 2165 assert(((DWORD64)handler & 0xF) == 0, "Target address must point to the beginning of a bundle!"); 2166#else 2167 #ifdef _M_AMD64 2168 // Do not blow up if no thread info available. 2169 if (thread) { 2170 thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Rip); 2171 } 2172 // Set pc to handler 2173 exceptionInfo->ContextRecord->Rip = (DWORD64)handler; 2174 #else 2175 // Do not blow up if no thread info available. 2176 if (thread) { 2177 thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Eip); 2178 } 2179 // Set pc to handler 2180 exceptionInfo->ContextRecord->Eip = (DWORD)(DWORD_PTR)handler; 2181 #endif 2182#endif 2183 2184 // Continue the execution 2185 return EXCEPTION_CONTINUE_EXECUTION; 2186} 2187 2188 2189// Used for PostMortemDump 2190extern "C" void safepoints(); 2191extern "C" void find(int x); 2192extern "C" void events(); 2193 2194// According to Windows API documentation, an illegal instruction sequence should generate 2195// the 0xC000001C exception code. However, real world experience shows that occasionnaly 2196// the execution of an illegal instruction can generate the exception code 0xC000001E. This 2197// seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems). 2198 2199#define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E 2200 2201// From "Execution Protection in the Windows Operating System" draft 0.35 2202// Once a system header becomes available, the "real" define should be 2203// included or copied here. 2204#define EXCEPTION_INFO_EXEC_VIOLATION 0x08 2205 2206// Handle NAT Bit consumption on IA64. 2207#ifdef _M_IA64 2208 #define EXCEPTION_REG_NAT_CONSUMPTION STATUS_REG_NAT_CONSUMPTION 2209#endif 2210 2211// Windows Vista/2008 heap corruption check 2212#define EXCEPTION_HEAP_CORRUPTION 0xC0000374 2213 2214#define def_excpt(val) #val, val 2215 2216struct siglabel { 2217 char *name; 2218 int number; 2219}; 2220 2221// All Visual C++ exceptions thrown from code generated by the Microsoft Visual 2222// C++ compiler contain this error code. Because this is a compiler-generated 2223// error, the code is not listed in the Win32 API header files. 2224// The code is actually a cryptic mnemonic device, with the initial "E" 2225// standing for "exception" and the final 3 bytes (0x6D7363) representing the 2226// ASCII values of "msc". 2227 2228#define EXCEPTION_UNCAUGHT_CXX_EXCEPTION 0xE06D7363 2229 2230 2231struct siglabel exceptlabels[] = { 2232 def_excpt(EXCEPTION_ACCESS_VIOLATION), 2233 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT), 2234 def_excpt(EXCEPTION_BREAKPOINT), 2235 def_excpt(EXCEPTION_SINGLE_STEP), 2236 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED), 2237 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND), 2238 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO), 2239 def_excpt(EXCEPTION_FLT_INEXACT_RESULT), 2240 def_excpt(EXCEPTION_FLT_INVALID_OPERATION), 2241 def_excpt(EXCEPTION_FLT_OVERFLOW), 2242 def_excpt(EXCEPTION_FLT_STACK_CHECK), 2243 def_excpt(EXCEPTION_FLT_UNDERFLOW), 2244 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO), 2245 def_excpt(EXCEPTION_INT_OVERFLOW), 2246 def_excpt(EXCEPTION_PRIV_INSTRUCTION), 2247 def_excpt(EXCEPTION_IN_PAGE_ERROR), 2248 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION), 2249 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2), 2250 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION), 2251 def_excpt(EXCEPTION_STACK_OVERFLOW), 2252 def_excpt(EXCEPTION_INVALID_DISPOSITION), 2253 def_excpt(EXCEPTION_GUARD_PAGE), 2254 def_excpt(EXCEPTION_INVALID_HANDLE), 2255 def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION), 2256 def_excpt(EXCEPTION_HEAP_CORRUPTION), 2257#ifdef _M_IA64 2258 def_excpt(EXCEPTION_REG_NAT_CONSUMPTION), 2259#endif 2260 NULL, 0 2261}; 2262 2263const char* os::exception_name(int exception_code, char *buf, size_t size) { 2264 for (int i = 0; exceptlabels[i].name != NULL; i++) { 2265 if (exceptlabels[i].number == exception_code) { 2266 jio_snprintf(buf, size, "%s", exceptlabels[i].name); 2267 return buf; 2268 } 2269 } 2270 2271 return NULL; 2272} 2273 2274//----------------------------------------------------------------------------- 2275LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { 2276 // handle exception caused by idiv; should only happen for -MinInt/-1 2277 // (division by zero is handled explicitly) 2278#ifdef _M_IA64 2279 assert(0, "Fix Handle_IDiv_Exception"); 2280#else 2281 #ifdef _M_AMD64 2282 PCONTEXT ctx = exceptionInfo->ContextRecord; 2283 address pc = (address)ctx->Rip; 2284 assert(pc[0] >= Assembler::REX && pc[0] <= Assembler::REX_WRXB && pc[1] == 0xF7 || pc[0] == 0xF7, "not an idiv opcode"); 2285 assert(pc[0] >= Assembler::REX && pc[0] <= Assembler::REX_WRXB && (pc[2] & ~0x7) == 0xF8 || (pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands"); 2286 if (pc[0] == 0xF7) { 2287 // set correct result values and continue after idiv instruction 2288 ctx->Rip = (DWORD64)pc + 2; // idiv reg, reg is 2 bytes 2289 } else { 2290 ctx->Rip = (DWORD64)pc + 3; // REX idiv reg, reg is 3 bytes 2291 } 2292 // Do not set ctx->Rax as it already contains the correct value (either 32 or 64 bit, depending on the operation) 2293 // this is the case because the exception only happens for -MinValue/-1 and -MinValue is always in rax because of the 2294 // idiv opcode (0xF7). 2295 ctx->Rdx = (DWORD)0; // remainder 2296 // Continue the execution 2297 #else 2298 PCONTEXT ctx = exceptionInfo->ContextRecord; 2299 address pc = (address)ctx->Eip; 2300 assert(pc[0] == 0xF7, "not an idiv opcode"); 2301 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands"); 2302 assert(ctx->Eax == min_jint, "unexpected idiv exception"); 2303 // set correct result values and continue after idiv instruction 2304 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes 2305 ctx->Eax = (DWORD)min_jint; // result 2306 ctx->Edx = (DWORD)0; // remainder 2307 // Continue the execution 2308 #endif 2309#endif 2310 return EXCEPTION_CONTINUE_EXECUTION; 2311} 2312 2313//----------------------------------------------------------------------------- 2314LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { 2315 PCONTEXT ctx = exceptionInfo->ContextRecord; 2316#ifndef _WIN64 2317 // handle exception caused by native method modifying control word 2318 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2319 2320 switch (exception_code) { 2321 case EXCEPTION_FLT_DENORMAL_OPERAND: 2322 case EXCEPTION_FLT_DIVIDE_BY_ZERO: 2323 case EXCEPTION_FLT_INEXACT_RESULT: 2324 case EXCEPTION_FLT_INVALID_OPERATION: 2325 case EXCEPTION_FLT_OVERFLOW: 2326 case EXCEPTION_FLT_STACK_CHECK: 2327 case EXCEPTION_FLT_UNDERFLOW: 2328 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std()); 2329 if (fp_control_word != ctx->FloatSave.ControlWord) { 2330 // Restore FPCW and mask out FLT exceptions 2331 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0; 2332 // Mask out pending FLT exceptions 2333 ctx->FloatSave.StatusWord &= 0xffffff00; 2334 return EXCEPTION_CONTINUE_EXECUTION; 2335 } 2336 } 2337 2338 if (prev_uef_handler != NULL) { 2339 // We didn't handle this exception so pass it to the previous 2340 // UnhandledExceptionFilter. 2341 return (prev_uef_handler)(exceptionInfo); 2342 } 2343#else // !_WIN64 2344 // On Windows, the mxcsr control bits are non-volatile across calls 2345 // See also CR 6192333 2346 // 2347 jint MxCsr = INITIAL_MXCSR; 2348 // we can't use StubRoutines::addr_mxcsr_std() 2349 // because in Win64 mxcsr is not saved there 2350 if (MxCsr != ctx->MxCsr) { 2351 ctx->MxCsr = MxCsr; 2352 return EXCEPTION_CONTINUE_EXECUTION; 2353 } 2354#endif // !_WIN64 2355 2356 return EXCEPTION_CONTINUE_SEARCH; 2357} 2358 2359static inline void report_error(Thread* t, DWORD exception_code, 2360 address addr, void* siginfo, void* context) { 2361 VMError::report_and_die(t, exception_code, addr, siginfo, context); 2362 2363 // If UseOsErrorReporting, this will return here and save the error file 2364 // somewhere where we can find it in the minidump. 2365} 2366 2367//----------------------------------------------------------------------------- 2368LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) { 2369 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH; 2370 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2371#ifdef _M_IA64 2372 // On Itanium, we need the "precise pc", which has the slot number coded 2373 // into the least 4 bits: 0000=slot0, 0100=slot1, 1000=slot2 (Windows format). 2374 address pc = (address) exceptionInfo->ExceptionRecord->ExceptionAddress; 2375 // Convert the pc to "Unix format", which has the slot number coded 2376 // into the least 2 bits: 0000=slot0, 0001=slot1, 0010=slot2 2377 // This is needed for IA64 because "relocation" / "implicit null check" / "poll instruction" 2378 // information is saved in the Unix format. 2379 address pc_unix_format = (address) ((((uint64_t)pc) & 0xFFFFFFFFFFFFFFF0) | ((((uint64_t)pc) & 0xF) >> 2)); 2380#else 2381 #ifdef _M_AMD64 2382 address pc = (address) exceptionInfo->ContextRecord->Rip; 2383 #else 2384 address pc = (address) exceptionInfo->ContextRecord->Eip; 2385 #endif 2386#endif 2387 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady 2388 2389 // Handle SafeFetch32 and SafeFetchN exceptions. 2390 if (StubRoutines::is_safefetch_fault(pc)) { 2391 return Handle_Exception(exceptionInfo, StubRoutines::continuation_for_safefetch_fault(pc)); 2392 } 2393 2394#ifndef _WIN64 2395 // Execution protection violation - win32 running on AMD64 only 2396 // Handled first to avoid misdiagnosis as a "normal" access violation; 2397 // This is safe to do because we have a new/unique ExceptionInformation 2398 // code for this condition. 2399 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2400 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2401 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0]; 2402 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2403 2404 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) { 2405 int page_size = os::vm_page_size(); 2406 2407 // Make sure the pc and the faulting address are sane. 2408 // 2409 // If an instruction spans a page boundary, and the page containing 2410 // the beginning of the instruction is executable but the following 2411 // page is not, the pc and the faulting address might be slightly 2412 // different - we still want to unguard the 2nd page in this case. 2413 // 2414 // 15 bytes seems to be a (very) safe value for max instruction size. 2415 bool pc_is_near_addr = 2416 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15); 2417 bool instr_spans_page_boundary = 2418 (align_size_down((intptr_t) pc ^ (intptr_t) addr, 2419 (intptr_t) page_size) > 0); 2420 2421 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) { 2422 static volatile address last_addr = 2423 (address) os::non_memory_address_word(); 2424 2425 // In conservative mode, don't unguard unless the address is in the VM 2426 if (UnguardOnExecutionViolation > 0 && addr != last_addr && 2427 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) { 2428 2429 // Set memory to RWX and retry 2430 address page_start = 2431 (address) align_size_down((intptr_t) addr, (intptr_t) page_size); 2432 bool res = os::protect_memory((char*) page_start, page_size, 2433 os::MEM_PROT_RWX); 2434 2435 if (PrintMiscellaneous && Verbose) { 2436 char buf[256]; 2437 jio_snprintf(buf, sizeof(buf), "Execution protection violation " 2438 "at " INTPTR_FORMAT 2439 ", unguarding " INTPTR_FORMAT ": %s", addr, 2440 page_start, (res ? "success" : strerror(errno))); 2441 tty->print_raw_cr(buf); 2442 } 2443 2444 // Set last_addr so if we fault again at the same address, we don't 2445 // end up in an endless loop. 2446 // 2447 // There are two potential complications here. Two threads trapping 2448 // at the same address at the same time could cause one of the 2449 // threads to think it already unguarded, and abort the VM. Likely 2450 // very rare. 2451 // 2452 // The other race involves two threads alternately trapping at 2453 // different addresses and failing to unguard the page, resulting in 2454 // an endless loop. This condition is probably even more unlikely 2455 // than the first. 2456 // 2457 // Although both cases could be avoided by using locks or thread 2458 // local last_addr, these solutions are unnecessary complication: 2459 // this handler is a best-effort safety net, not a complete solution. 2460 // It is disabled by default and should only be used as a workaround 2461 // in case we missed any no-execute-unsafe VM code. 2462 2463 last_addr = addr; 2464 2465 return EXCEPTION_CONTINUE_EXECUTION; 2466 } 2467 } 2468 2469 // Last unguard failed or not unguarding 2470 tty->print_raw_cr("Execution protection violation"); 2471 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord, 2472 exceptionInfo->ContextRecord); 2473 return EXCEPTION_CONTINUE_SEARCH; 2474 } 2475 } 2476#endif // _WIN64 2477 2478 // Check to see if we caught the safepoint code in the 2479 // process of write protecting the memory serialization page. 2480 // It write enables the page immediately after protecting it 2481 // so just return. 2482 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2483 JavaThread* thread = (JavaThread*) t; 2484 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2485 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2486 if (os::is_memory_serialize_page(thread, addr)) { 2487 // Block current thread until the memory serialize page permission restored. 2488 os::block_on_serialize_page_trap(); 2489 return EXCEPTION_CONTINUE_EXECUTION; 2490 } 2491 } 2492 2493 if ((exception_code == EXCEPTION_ACCESS_VIOLATION) && 2494 VM_Version::is_cpuinfo_segv_addr(pc)) { 2495 // Verify that OS save/restore AVX registers. 2496 return Handle_Exception(exceptionInfo, VM_Version::cpuinfo_cont_addr()); 2497 } 2498 2499 if (t != NULL && t->is_Java_thread()) { 2500 JavaThread* thread = (JavaThread*) t; 2501 bool in_java = thread->thread_state() == _thread_in_Java; 2502 2503 // Handle potential stack overflows up front. 2504 if (exception_code == EXCEPTION_STACK_OVERFLOW) { 2505 if (os::uses_stack_guard_pages()) { 2506#ifdef _M_IA64 2507 // Use guard page for register stack. 2508 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2509 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2510 // Check for a register stack overflow on Itanium 2511 if (thread->addr_inside_register_stack_red_zone(addr)) { 2512 // Fatal red zone violation happens if the Java program 2513 // catches a StackOverflow error and does so much processing 2514 // that it runs beyond the unprotected yellow guard zone. As 2515 // a result, we are out of here. 2516 fatal("ERROR: Unrecoverable stack overflow happened. JVM will exit."); 2517 } else if(thread->addr_inside_register_stack(addr)) { 2518 // Disable the yellow zone which sets the state that 2519 // we've got a stack overflow problem. 2520 if (thread->stack_yellow_zone_enabled()) { 2521 thread->disable_stack_yellow_zone(); 2522 } 2523 // Give us some room to process the exception. 2524 thread->disable_register_stack_guard(); 2525 // Tracing with +Verbose. 2526 if (Verbose) { 2527 tty->print_cr("SOF Compiled Register Stack overflow at " INTPTR_FORMAT " (SIGSEGV)", pc); 2528 tty->print_cr("Register Stack access at " INTPTR_FORMAT, addr); 2529 tty->print_cr("Register Stack base " INTPTR_FORMAT, thread->register_stack_base()); 2530 tty->print_cr("Register Stack [" INTPTR_FORMAT "," INTPTR_FORMAT "]", 2531 thread->register_stack_base(), 2532 thread->register_stack_base() + thread->stack_size()); 2533 } 2534 2535 // Reguard the permanent register stack red zone just to be sure. 2536 // We saw Windows silently disabling this without telling us. 2537 thread->enable_register_stack_red_zone(); 2538 2539 return Handle_Exception(exceptionInfo, 2540 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2541 } 2542#endif 2543 if (thread->stack_yellow_zone_enabled()) { 2544 // Yellow zone violation. The o/s has unprotected the first yellow 2545 // zone page for us. Note: must call disable_stack_yellow_zone to 2546 // update the enabled status, even if the zone contains only one page. 2547 thread->disable_stack_yellow_zone(); 2548 // If not in java code, return and hope for the best. 2549 return in_java 2550 ? Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)) 2551 : EXCEPTION_CONTINUE_EXECUTION; 2552 } else { 2553 // Fatal red zone violation. 2554 thread->disable_stack_red_zone(); 2555 tty->print_raw_cr("An unrecoverable stack overflow has occurred."); 2556 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2557 exceptionInfo->ContextRecord); 2558 return EXCEPTION_CONTINUE_SEARCH; 2559 } 2560 } else if (in_java) { 2561 // JVM-managed guard pages cannot be used on win95/98. The o/s provides 2562 // a one-time-only guard page, which it has released to us. The next 2563 // stack overflow on this thread will result in an ACCESS_VIOLATION. 2564 return Handle_Exception(exceptionInfo, 2565 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2566 } else { 2567 // Can only return and hope for the best. Further stack growth will 2568 // result in an ACCESS_VIOLATION. 2569 return EXCEPTION_CONTINUE_EXECUTION; 2570 } 2571 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2572 // Either stack overflow or null pointer exception. 2573 if (in_java) { 2574 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2575 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2576 address stack_end = thread->stack_base() - thread->stack_size(); 2577 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) { 2578 // Stack overflow. 2579 assert(!os::uses_stack_guard_pages(), 2580 "should be caught by red zone code above."); 2581 return Handle_Exception(exceptionInfo, 2582 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2583 } 2584 // Check for safepoint polling and implicit null 2585 // We only expect null pointers in the stubs (vtable) 2586 // the rest are checked explicitly now. 2587 CodeBlob* cb = CodeCache::find_blob(pc); 2588 if (cb != NULL) { 2589 if (os::is_poll_address(addr)) { 2590 address stub = SharedRuntime::get_poll_stub(pc); 2591 return Handle_Exception(exceptionInfo, stub); 2592 } 2593 } 2594 { 2595#ifdef _WIN64 2596 // If it's a legal stack address map the entire region in 2597 // 2598 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2599 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2600 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base()) { 2601 addr = (address)((uintptr_t)addr & 2602 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1))); 2603 os::commit_memory((char *)addr, thread->stack_base() - addr, 2604 !ExecMem); 2605 return EXCEPTION_CONTINUE_EXECUTION; 2606 } else 2607#endif 2608 { 2609 // Null pointer exception. 2610#ifdef _M_IA64 2611 // Process implicit null checks in compiled code. Note: Implicit null checks 2612 // can happen even if "ImplicitNullChecks" is disabled, e.g. in vtable stubs. 2613 if (CodeCache::contains((void*) pc_unix_format) && !MacroAssembler::needs_explicit_null_check((intptr_t) addr)) { 2614 CodeBlob *cb = CodeCache::find_blob_unsafe(pc_unix_format); 2615 // Handle implicit null check in UEP method entry 2616 if (cb && (cb->is_frame_complete_at(pc) || 2617 (cb->is_nmethod() && ((nmethod *)cb)->inlinecache_check_contains(pc)))) { 2618 if (Verbose) { 2619 intptr_t *bundle_start = (intptr_t*) ((intptr_t) pc_unix_format & 0xFFFFFFFFFFFFFFF0); 2620 tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGSEGV)", pc_unix_format); 2621 tty->print_cr(" to addr " INTPTR_FORMAT, addr); 2622 tty->print_cr(" bundle is " INTPTR_FORMAT " (high), " INTPTR_FORMAT " (low)", 2623 *(bundle_start + 1), *bundle_start); 2624 } 2625 return Handle_Exception(exceptionInfo, 2626 SharedRuntime::continuation_for_implicit_exception(thread, pc_unix_format, SharedRuntime::IMPLICIT_NULL)); 2627 } 2628 } 2629 2630 // Implicit null checks were processed above. Hence, we should not reach 2631 // here in the usual case => die! 2632 if (Verbose) tty->print_raw_cr("Access violation, possible null pointer exception"); 2633 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2634 exceptionInfo->ContextRecord); 2635 return EXCEPTION_CONTINUE_SEARCH; 2636 2637#else // !IA64 2638 2639 // Windows 98 reports faulting addresses incorrectly 2640 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) || 2641 !os::win32::is_nt()) { 2642 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); 2643 if (stub != NULL) return Handle_Exception(exceptionInfo, stub); 2644 } 2645 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2646 exceptionInfo->ContextRecord); 2647 return EXCEPTION_CONTINUE_SEARCH; 2648#endif 2649 } 2650 } 2651 } 2652 2653#ifdef _WIN64 2654 // Special care for fast JNI field accessors. 2655 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks 2656 // in and the heap gets shrunk before the field access. 2657 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2658 address addr = JNI_FastGetField::find_slowcase_pc(pc); 2659 if (addr != (address)-1) { 2660 return Handle_Exception(exceptionInfo, addr); 2661 } 2662 } 2663#endif 2664 2665 // Stack overflow or null pointer exception in native code. 2666 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2667 exceptionInfo->ContextRecord); 2668 return EXCEPTION_CONTINUE_SEARCH; 2669 } // /EXCEPTION_ACCESS_VIOLATION 2670 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 2671#if defined _M_IA64 2672 else if ((exception_code == EXCEPTION_ILLEGAL_INSTRUCTION || 2673 exception_code == EXCEPTION_ILLEGAL_INSTRUCTION_2)) { 2674 M37 handle_wrong_method_break(0, NativeJump::HANDLE_WRONG_METHOD, PR0); 2675 2676 // Compiled method patched to be non entrant? Following conditions must apply: 2677 // 1. must be first instruction in bundle 2678 // 2. must be a break instruction with appropriate code 2679 if ((((uint64_t) pc & 0x0F) == 0) && 2680 (((IPF_Bundle*) pc)->get_slot0() == handle_wrong_method_break.bits())) { 2681 return Handle_Exception(exceptionInfo, 2682 (address)SharedRuntime::get_handle_wrong_method_stub()); 2683 } 2684 } // /EXCEPTION_ILLEGAL_INSTRUCTION 2685#endif 2686 2687 2688 if (in_java) { 2689 switch (exception_code) { 2690 case EXCEPTION_INT_DIVIDE_BY_ZERO: 2691 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO)); 2692 2693 case EXCEPTION_INT_OVERFLOW: 2694 return Handle_IDiv_Exception(exceptionInfo); 2695 2696 } // switch 2697 } 2698 if (((thread->thread_state() == _thread_in_Java) || 2699 (thread->thread_state() == _thread_in_native)) && 2700 exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION) { 2701 LONG result=Handle_FLT_Exception(exceptionInfo); 2702 if (result==EXCEPTION_CONTINUE_EXECUTION) return result; 2703 } 2704 } 2705 2706 if (exception_code != EXCEPTION_BREAKPOINT) { 2707 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2708 exceptionInfo->ContextRecord); 2709 } 2710 return EXCEPTION_CONTINUE_SEARCH; 2711} 2712 2713#ifndef _WIN64 2714// Special care for fast JNI accessors. 2715// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and 2716// the heap gets shrunk before the field access. 2717// Need to install our own structured exception handler since native code may 2718// install its own. 2719LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) { 2720 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2721 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2722 address pc = (address) exceptionInfo->ContextRecord->Eip; 2723 address addr = JNI_FastGetField::find_slowcase_pc(pc); 2724 if (addr != (address)-1) { 2725 return Handle_Exception(exceptionInfo, addr); 2726 } 2727 } 2728 return EXCEPTION_CONTINUE_SEARCH; 2729} 2730 2731#define DEFINE_FAST_GETFIELD(Return, Fieldname, Result) \ 2732 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, \ 2733 jobject obj, \ 2734 jfieldID fieldID) { \ 2735 __try { \ 2736 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, \ 2737 obj, \ 2738 fieldID); \ 2739 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*) \ 2740 _exception_info())) { \ 2741 } \ 2742 return 0; \ 2743 } 2744 2745DEFINE_FAST_GETFIELD(jboolean, bool, Boolean) 2746DEFINE_FAST_GETFIELD(jbyte, byte, Byte) 2747DEFINE_FAST_GETFIELD(jchar, char, Char) 2748DEFINE_FAST_GETFIELD(jshort, short, Short) 2749DEFINE_FAST_GETFIELD(jint, int, Int) 2750DEFINE_FAST_GETFIELD(jlong, long, Long) 2751DEFINE_FAST_GETFIELD(jfloat, float, Float) 2752DEFINE_FAST_GETFIELD(jdouble, double, Double) 2753 2754address os::win32::fast_jni_accessor_wrapper(BasicType type) { 2755 switch (type) { 2756 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper; 2757 case T_BYTE: return (address)jni_fast_GetByteField_wrapper; 2758 case T_CHAR: return (address)jni_fast_GetCharField_wrapper; 2759 case T_SHORT: return (address)jni_fast_GetShortField_wrapper; 2760 case T_INT: return (address)jni_fast_GetIntField_wrapper; 2761 case T_LONG: return (address)jni_fast_GetLongField_wrapper; 2762 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper; 2763 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper; 2764 default: ShouldNotReachHere(); 2765 } 2766 return (address)-1; 2767} 2768#endif 2769 2770// Virtual Memory 2771 2772int os::vm_page_size() { return os::win32::vm_page_size(); } 2773int os::vm_allocation_granularity() { 2774 return os::win32::vm_allocation_granularity(); 2775} 2776 2777// Windows large page support is available on Windows 2003. In order to use 2778// large page memory, the administrator must first assign additional privilege 2779// to the user: 2780// + select Control Panel -> Administrative Tools -> Local Security Policy 2781// + select Local Policies -> User Rights Assignment 2782// + double click "Lock pages in memory", add users and/or groups 2783// + reboot 2784// Note the above steps are needed for administrator as well, as administrators 2785// by default do not have the privilege to lock pages in memory. 2786// 2787// Note about Windows 2003: although the API supports committing large page 2788// memory on a page-by-page basis and VirtualAlloc() returns success under this 2789// scenario, I found through experiment it only uses large page if the entire 2790// memory region is reserved and committed in a single VirtualAlloc() call. 2791// This makes Windows large page support more or less like Solaris ISM, in 2792// that the entire heap must be committed upfront. This probably will change 2793// in the future, if so the code below needs to be revisited. 2794 2795#ifndef MEM_LARGE_PAGES 2796 #define MEM_LARGE_PAGES 0x20000000 2797#endif 2798 2799static HANDLE _hProcess; 2800static HANDLE _hToken; 2801 2802// Container for NUMA node list info 2803class NUMANodeListHolder { 2804 private: 2805 int *_numa_used_node_list; // allocated below 2806 int _numa_used_node_count; 2807 2808 void free_node_list() { 2809 if (_numa_used_node_list != NULL) { 2810 FREE_C_HEAP_ARRAY(int, _numa_used_node_list); 2811 } 2812 } 2813 2814 public: 2815 NUMANodeListHolder() { 2816 _numa_used_node_count = 0; 2817 _numa_used_node_list = NULL; 2818 // do rest of initialization in build routine (after function pointers are set up) 2819 } 2820 2821 ~NUMANodeListHolder() { 2822 free_node_list(); 2823 } 2824 2825 bool build() { 2826 DWORD_PTR proc_aff_mask; 2827 DWORD_PTR sys_aff_mask; 2828 if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false; 2829 ULONG highest_node_number; 2830 if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false; 2831 free_node_list(); 2832 _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal); 2833 for (unsigned int i = 0; i <= highest_node_number; i++) { 2834 ULONGLONG proc_mask_numa_node; 2835 if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false; 2836 if ((proc_aff_mask & proc_mask_numa_node)!=0) { 2837 _numa_used_node_list[_numa_used_node_count++] = i; 2838 } 2839 } 2840 return (_numa_used_node_count > 1); 2841 } 2842 2843 int get_count() { return _numa_used_node_count; } 2844 int get_node_list_entry(int n) { 2845 // for indexes out of range, returns -1 2846 return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1); 2847 } 2848 2849} numa_node_list_holder; 2850 2851 2852 2853static size_t _large_page_size = 0; 2854 2855static bool resolve_functions_for_large_page_init() { 2856 return os::Kernel32Dll::GetLargePageMinimumAvailable() && 2857 os::Advapi32Dll::AdvapiAvailable(); 2858} 2859 2860static bool request_lock_memory_privilege() { 2861 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, 2862 os::current_process_id()); 2863 2864 LUID luid; 2865 if (_hProcess != NULL && 2866 os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) && 2867 os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) { 2868 2869 TOKEN_PRIVILEGES tp; 2870 tp.PrivilegeCount = 1; 2871 tp.Privileges[0].Luid = luid; 2872 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 2873 2874 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the 2875 // privilege. Check GetLastError() too. See MSDN document. 2876 if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) && 2877 (GetLastError() == ERROR_SUCCESS)) { 2878 return true; 2879 } 2880 } 2881 2882 return false; 2883} 2884 2885static void cleanup_after_large_page_init() { 2886 if (_hProcess) CloseHandle(_hProcess); 2887 _hProcess = NULL; 2888 if (_hToken) CloseHandle(_hToken); 2889 _hToken = NULL; 2890} 2891 2892static bool numa_interleaving_init() { 2893 bool success = false; 2894 bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving); 2895 2896 // print a warning if UseNUMAInterleaving flag is specified on command line 2897 bool warn_on_failure = use_numa_interleaving_specified; 2898#define WARN(msg) if (warn_on_failure) { warning(msg); } 2899 2900 // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages) 2901 size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity(); 2902 NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity); 2903 2904 if (os::Kernel32Dll::NumaCallsAvailable()) { 2905 if (numa_node_list_holder.build()) { 2906 if (PrintMiscellaneous && Verbose) { 2907 tty->print("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count()); 2908 for (int i = 0; i < numa_node_list_holder.get_count(); i++) { 2909 tty->print("%d ", numa_node_list_holder.get_node_list_entry(i)); 2910 } 2911 tty->print("\n"); 2912 } 2913 success = true; 2914 } else { 2915 WARN("Process does not cover multiple NUMA nodes."); 2916 } 2917 } else { 2918 WARN("NUMA Interleaving is not supported by the operating system."); 2919 } 2920 if (!success) { 2921 if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag."); 2922 } 2923 return success; 2924#undef WARN 2925} 2926 2927// this routine is used whenever we need to reserve a contiguous VA range 2928// but we need to make separate VirtualAlloc calls for each piece of the range 2929// Reasons for doing this: 2930// * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise) 2931// * UseNUMAInterleaving requires a separate node for each piece 2932static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, 2933 DWORD prot, 2934 bool should_inject_error = false) { 2935 char * p_buf; 2936 // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size 2937 size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity(); 2938 size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size; 2939 2940 // first reserve enough address space in advance since we want to be 2941 // able to break a single contiguous virtual address range into multiple 2942 // large page commits but WS2003 does not allow reserving large page space 2943 // so we just use 4K pages for reserve, this gives us a legal contiguous 2944 // address space. then we will deallocate that reservation, and re alloc 2945 // using large pages 2946 const size_t size_of_reserve = bytes + chunk_size; 2947 if (bytes > size_of_reserve) { 2948 // Overflowed. 2949 return NULL; 2950 } 2951 p_buf = (char *) VirtualAlloc(addr, 2952 size_of_reserve, // size of Reserve 2953 MEM_RESERVE, 2954 PAGE_READWRITE); 2955 // If reservation failed, return NULL 2956 if (p_buf == NULL) return NULL; 2957 MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC); 2958 os::release_memory(p_buf, bytes + chunk_size); 2959 2960 // we still need to round up to a page boundary (in case we are using large pages) 2961 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size) 2962 // instead we handle this in the bytes_to_rq computation below 2963 p_buf = (char *) align_size_up((size_t)p_buf, page_size); 2964 2965 // now go through and allocate one chunk at a time until all bytes are 2966 // allocated 2967 size_t bytes_remaining = bytes; 2968 // An overflow of align_size_up() would have been caught above 2969 // in the calculation of size_of_reserve. 2970 char * next_alloc_addr = p_buf; 2971 HANDLE hProc = GetCurrentProcess(); 2972 2973#ifdef ASSERT 2974 // Variable for the failure injection 2975 long ran_num = os::random(); 2976 size_t fail_after = ran_num % bytes; 2977#endif 2978 2979 int count=0; 2980 while (bytes_remaining) { 2981 // select bytes_to_rq to get to the next chunk_size boundary 2982 2983 size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size)); 2984 // Note allocate and commit 2985 char * p_new; 2986 2987#ifdef ASSERT 2988 bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after); 2989#else 2990 const bool inject_error_now = false; 2991#endif 2992 2993 if (inject_error_now) { 2994 p_new = NULL; 2995 } else { 2996 if (!UseNUMAInterleaving) { 2997 p_new = (char *) VirtualAlloc(next_alloc_addr, 2998 bytes_to_rq, 2999 flags, 3000 prot); 3001 } else { 3002 // get the next node to use from the used_node_list 3003 assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected"); 3004 DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count()); 3005 p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc, 3006 next_alloc_addr, 3007 bytes_to_rq, 3008 flags, 3009 prot, 3010 node); 3011 } 3012 } 3013 3014 if (p_new == NULL) { 3015 // Free any allocated pages 3016 if (next_alloc_addr > p_buf) { 3017 // Some memory was committed so release it. 3018 size_t bytes_to_release = bytes - bytes_remaining; 3019 // NMT has yet to record any individual blocks, so it 3020 // need to create a dummy 'reserve' record to match 3021 // the release. 3022 MemTracker::record_virtual_memory_reserve((address)p_buf, 3023 bytes_to_release, CALLER_PC); 3024 os::release_memory(p_buf, bytes_to_release); 3025 } 3026#ifdef ASSERT 3027 if (should_inject_error) { 3028 if (TracePageSizes && Verbose) { 3029 tty->print_cr("Reserving pages individually failed."); 3030 } 3031 } 3032#endif 3033 return NULL; 3034 } 3035 3036 bytes_remaining -= bytes_to_rq; 3037 next_alloc_addr += bytes_to_rq; 3038 count++; 3039 } 3040 // Although the memory is allocated individually, it is returned as one. 3041 // NMT records it as one block. 3042 if ((flags & MEM_COMMIT) != 0) { 3043 MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC); 3044 } else { 3045 MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC); 3046 } 3047 3048 // made it this far, success 3049 return p_buf; 3050} 3051 3052 3053 3054void os::large_page_init() { 3055 if (!UseLargePages) return; 3056 3057 // print a warning if any large page related flag is specified on command line 3058 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || 3059 !FLAG_IS_DEFAULT(LargePageSizeInBytes); 3060 bool success = false; 3061 3062#define WARN(msg) if (warn_on_failure) { warning(msg); } 3063 if (resolve_functions_for_large_page_init()) { 3064 if (request_lock_memory_privilege()) { 3065 size_t s = os::Kernel32Dll::GetLargePageMinimum(); 3066 if (s) { 3067#if defined(IA32) || defined(AMD64) 3068 if (s > 4*M || LargePageSizeInBytes > 4*M) { 3069 WARN("JVM cannot use large pages bigger than 4mb."); 3070 } else { 3071#endif 3072 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) { 3073 _large_page_size = LargePageSizeInBytes; 3074 } else { 3075 _large_page_size = s; 3076 } 3077 success = true; 3078#if defined(IA32) || defined(AMD64) 3079 } 3080#endif 3081 } else { 3082 WARN("Large page is not supported by the processor."); 3083 } 3084 } else { 3085 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory."); 3086 } 3087 } else { 3088 WARN("Large page is not supported by the operating system."); 3089 } 3090#undef WARN 3091 3092 const size_t default_page_size = (size_t) vm_page_size(); 3093 if (success && _large_page_size > default_page_size) { 3094 _page_sizes[0] = _large_page_size; 3095 _page_sizes[1] = default_page_size; 3096 _page_sizes[2] = 0; 3097 } 3098 3099 cleanup_after_large_page_init(); 3100 UseLargePages = success; 3101} 3102 3103// On win32, one cannot release just a part of reserved memory, it's an 3104// all or nothing deal. When we split a reservation, we must break the 3105// reservation into two reservations. 3106void os::pd_split_reserved_memory(char *base, size_t size, size_t split, 3107 bool realloc) { 3108 if (size > 0) { 3109 release_memory(base, size); 3110 if (realloc) { 3111 reserve_memory(split, base); 3112 } 3113 if (size != split) { 3114 reserve_memory(size - split, base + split); 3115 } 3116 } 3117} 3118 3119// Multiple threads can race in this code but it's not possible to unmap small sections of 3120// virtual space to get requested alignment, like posix-like os's. 3121// Windows prevents multiple thread from remapping over each other so this loop is thread-safe. 3122char* os::reserve_memory_aligned(size_t size, size_t alignment) { 3123 assert((alignment & (os::vm_allocation_granularity() - 1)) == 0, 3124 "Alignment must be a multiple of allocation granularity (page size)"); 3125 assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned"); 3126 3127 size_t extra_size = size + alignment; 3128 assert(extra_size >= size, "overflow, size is too large to allow alignment"); 3129 3130 char* aligned_base = NULL; 3131 3132 do { 3133 char* extra_base = os::reserve_memory(extra_size, NULL, alignment); 3134 if (extra_base == NULL) { 3135 return NULL; 3136 } 3137 // Do manual alignment 3138 aligned_base = (char*) align_size_up((uintptr_t) extra_base, alignment); 3139 3140 os::release_memory(extra_base, extra_size); 3141 3142 aligned_base = os::reserve_memory(size, aligned_base); 3143 3144 } while (aligned_base == NULL); 3145 3146 return aligned_base; 3147} 3148 3149char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 3150 assert((size_t)addr % os::vm_allocation_granularity() == 0, 3151 "reserve alignment"); 3152 assert(bytes % os::vm_page_size() == 0, "reserve page size"); 3153 char* res; 3154 // note that if UseLargePages is on, all the areas that require interleaving 3155 // will go thru reserve_memory_special rather than thru here. 3156 bool use_individual = (UseNUMAInterleaving && !UseLargePages); 3157 if (!use_individual) { 3158 res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE); 3159 } else { 3160 elapsedTimer reserveTimer; 3161 if (Verbose && PrintMiscellaneous) reserveTimer.start(); 3162 // in numa interleaving, we have to allocate pages individually 3163 // (well really chunks of NUMAInterleaveGranularity size) 3164 res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE); 3165 if (res == NULL) { 3166 warning("NUMA page allocation failed"); 3167 } 3168 if (Verbose && PrintMiscellaneous) { 3169 reserveTimer.stop(); 3170 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes, 3171 reserveTimer.milliseconds(), reserveTimer.ticks()); 3172 } 3173 } 3174 assert(res == NULL || addr == NULL || addr == res, 3175 "Unexpected address from reserve."); 3176 3177 return res; 3178} 3179 3180// Reserve memory at an arbitrary address, only if that area is 3181// available (and not reserved for something else). 3182char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 3183 // Windows os::reserve_memory() fails of the requested address range is 3184 // not avilable. 3185 return reserve_memory(bytes, requested_addr); 3186} 3187 3188size_t os::large_page_size() { 3189 return _large_page_size; 3190} 3191 3192bool os::can_commit_large_page_memory() { 3193 // Windows only uses large page memory when the entire region is reserved 3194 // and committed in a single VirtualAlloc() call. This may change in the 3195 // future, but with Windows 2003 it's not possible to commit on demand. 3196 return false; 3197} 3198 3199bool os::can_execute_large_page_memory() { 3200 return true; 3201} 3202 3203char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr, 3204 bool exec) { 3205 assert(UseLargePages, "only for large pages"); 3206 3207 if (!is_size_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) { 3208 return NULL; // Fallback to small pages. 3209 } 3210 3211 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 3212 const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES; 3213 3214 // with large pages, there are two cases where we need to use Individual Allocation 3215 // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003) 3216 // 2) NUMA Interleaving is enabled, in which case we use a different node for each page 3217 if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) { 3218 if (TracePageSizes && Verbose) { 3219 tty->print_cr("Reserving large pages individually."); 3220 } 3221 char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError); 3222 if (p_buf == NULL) { 3223 // give an appropriate warning message 3224 if (UseNUMAInterleaving) { 3225 warning("NUMA large page allocation failed, UseLargePages flag ignored"); 3226 } 3227 if (UseLargePagesIndividualAllocation) { 3228 warning("Individually allocated large pages failed, " 3229 "use -XX:-UseLargePagesIndividualAllocation to turn off"); 3230 } 3231 return NULL; 3232 } 3233 3234 return p_buf; 3235 3236 } else { 3237 if (TracePageSizes && Verbose) { 3238 tty->print_cr("Reserving large pages in a single large chunk."); 3239 } 3240 // normal policy just allocate it all at once 3241 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES; 3242 char * res = (char *)VirtualAlloc(addr, bytes, flag, prot); 3243 if (res != NULL) { 3244 MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, CALLER_PC); 3245 } 3246 3247 return res; 3248 } 3249} 3250 3251bool os::release_memory_special(char* base, size_t bytes) { 3252 assert(base != NULL, "Sanity check"); 3253 return release_memory(base, bytes); 3254} 3255 3256void os::print_statistics() { 3257} 3258 3259static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) { 3260 int err = os::get_last_error(); 3261 char buf[256]; 3262 size_t buf_len = os::lasterror(buf, sizeof(buf)); 3263 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT 3264 ", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes, 3265 exec, buf_len != 0 ? buf : "<no_error_string>", err); 3266} 3267 3268bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) { 3269 if (bytes == 0) { 3270 // Don't bother the OS with noops. 3271 return true; 3272 } 3273 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries"); 3274 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks"); 3275 // Don't attempt to print anything if the OS call fails. We're 3276 // probably low on resources, so the print itself may cause crashes. 3277 3278 // unless we have NUMAInterleaving enabled, the range of a commit 3279 // is always within a reserve covered by a single VirtualAlloc 3280 // in that case we can just do a single commit for the requested size 3281 if (!UseNUMAInterleaving) { 3282 if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) { 3283 NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);) 3284 return false; 3285 } 3286 if (exec) { 3287 DWORD oldprot; 3288 // Windows doc says to use VirtualProtect to get execute permissions 3289 if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) { 3290 NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);) 3291 return false; 3292 } 3293 } 3294 return true; 3295 } else { 3296 3297 // when NUMAInterleaving is enabled, the commit might cover a range that 3298 // came from multiple VirtualAlloc reserves (using allocate_pages_individually). 3299 // VirtualQuery can help us determine that. The RegionSize that VirtualQuery 3300 // returns represents the number of bytes that can be committed in one step. 3301 size_t bytes_remaining = bytes; 3302 char * next_alloc_addr = addr; 3303 while (bytes_remaining > 0) { 3304 MEMORY_BASIC_INFORMATION alloc_info; 3305 VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info)); 3306 size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize); 3307 if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, 3308 PAGE_READWRITE) == NULL) { 3309 NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq, 3310 exec);) 3311 return false; 3312 } 3313 if (exec) { 3314 DWORD oldprot; 3315 if (!VirtualProtect(next_alloc_addr, bytes_to_rq, 3316 PAGE_EXECUTE_READWRITE, &oldprot)) { 3317 NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq, 3318 exec);) 3319 return false; 3320 } 3321 } 3322 bytes_remaining -= bytes_to_rq; 3323 next_alloc_addr += bytes_to_rq; 3324 } 3325 } 3326 // if we made it this far, return true 3327 return true; 3328} 3329 3330bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, 3331 bool exec) { 3332 // alignment_hint is ignored on this OS 3333 return pd_commit_memory(addr, size, exec); 3334} 3335 3336void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec, 3337 const char* mesg) { 3338 assert(mesg != NULL, "mesg must be specified"); 3339 if (!pd_commit_memory(addr, size, exec)) { 3340 warn_fail_commit_memory(addr, size, exec); 3341 vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg); 3342 } 3343} 3344 3345void os::pd_commit_memory_or_exit(char* addr, size_t size, 3346 size_t alignment_hint, bool exec, 3347 const char* mesg) { 3348 // alignment_hint is ignored on this OS 3349 pd_commit_memory_or_exit(addr, size, exec, mesg); 3350} 3351 3352bool os::pd_uncommit_memory(char* addr, size_t bytes) { 3353 if (bytes == 0) { 3354 // Don't bother the OS with noops. 3355 return true; 3356 } 3357 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries"); 3358 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks"); 3359 return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0); 3360} 3361 3362bool os::pd_release_memory(char* addr, size_t bytes) { 3363 return VirtualFree(addr, 0, MEM_RELEASE) != 0; 3364} 3365 3366bool os::pd_create_stack_guard_pages(char* addr, size_t size) { 3367 return os::commit_memory(addr, size, !ExecMem); 3368} 3369 3370bool os::remove_stack_guard_pages(char* addr, size_t size) { 3371 return os::uncommit_memory(addr, size); 3372} 3373 3374// Set protections specified 3375bool os::protect_memory(char* addr, size_t bytes, ProtType prot, 3376 bool is_committed) { 3377 unsigned int p = 0; 3378 switch (prot) { 3379 case MEM_PROT_NONE: p = PAGE_NOACCESS; break; 3380 case MEM_PROT_READ: p = PAGE_READONLY; break; 3381 case MEM_PROT_RW: p = PAGE_READWRITE; break; 3382 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break; 3383 default: 3384 ShouldNotReachHere(); 3385 } 3386 3387 DWORD old_status; 3388 3389 // Strange enough, but on Win32 one can change protection only for committed 3390 // memory, not a big deal anyway, as bytes less or equal than 64K 3391 if (!is_committed) { 3392 commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX, 3393 "cannot commit protection page"); 3394 } 3395 // One cannot use os::guard_memory() here, as on Win32 guard page 3396 // have different (one-shot) semantics, from MSDN on PAGE_GUARD: 3397 // 3398 // Pages in the region become guard pages. Any attempt to access a guard page 3399 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off 3400 // the guard page status. Guard pages thus act as a one-time access alarm. 3401 return VirtualProtect(addr, bytes, p, &old_status) != 0; 3402} 3403 3404bool os::guard_memory(char* addr, size_t bytes) { 3405 DWORD old_status; 3406 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0; 3407} 3408 3409bool os::unguard_memory(char* addr, size_t bytes) { 3410 DWORD old_status; 3411 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0; 3412} 3413 3414void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } 3415void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { } 3416void os::numa_make_global(char *addr, size_t bytes) { } 3417void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { } 3418bool os::numa_topology_changed() { return false; } 3419size_t os::numa_get_groups_num() { return MAX2(numa_node_list_holder.get_count(), 1); } 3420int os::numa_get_group_id() { return 0; } 3421size_t os::numa_get_leaf_groups(int *ids, size_t size) { 3422 if (numa_node_list_holder.get_count() == 0 && size > 0) { 3423 // Provide an answer for UMA systems 3424 ids[0] = 0; 3425 return 1; 3426 } else { 3427 // check for size bigger than actual groups_num 3428 size = MIN2(size, numa_get_groups_num()); 3429 for (int i = 0; i < (int)size; i++) { 3430 ids[i] = numa_node_list_holder.get_node_list_entry(i); 3431 } 3432 return size; 3433 } 3434} 3435 3436bool os::get_page_info(char *start, page_info* info) { 3437 return false; 3438} 3439 3440char *os::scan_pages(char *start, char* end, page_info* page_expected, 3441 page_info* page_found) { 3442 return end; 3443} 3444 3445char* os::non_memory_address_word() { 3446 // Must never look like an address returned by reserve_memory, 3447 // even in its subfields (as defined by the CPU immediate fields, 3448 // if the CPU splits constants across multiple instructions). 3449 return (char*)-1; 3450} 3451 3452#define MAX_ERROR_COUNT 100 3453#define SYS_THREAD_ERROR 0xffffffffUL 3454 3455void os::pd_start_thread(Thread* thread) { 3456 DWORD ret = ResumeThread(thread->osthread()->thread_handle()); 3457 // Returns previous suspend state: 3458 // 0: Thread was not suspended 3459 // 1: Thread is running now 3460 // >1: Thread is still suspended. 3461 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back 3462} 3463 3464class HighResolutionInterval : public CHeapObj<mtThread> { 3465 // The default timer resolution seems to be 10 milliseconds. 3466 // (Where is this written down?) 3467 // If someone wants to sleep for only a fraction of the default, 3468 // then we set the timer resolution down to 1 millisecond for 3469 // the duration of their interval. 3470 // We carefully set the resolution back, since otherwise we 3471 // seem to incur an overhead (3%?) that we don't need. 3472 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time. 3473 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod(). 3474 // Alternatively, we could compute the relative error (503/500 = .6%) and only use 3475 // timeBeginPeriod() if the relative error exceeded some threshold. 3476 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and 3477 // to decreased efficiency related to increased timer "tick" rates. We want to minimize 3478 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high 3479 // resolution timers running. 3480 private: 3481 jlong resolution; 3482 public: 3483 HighResolutionInterval(jlong ms) { 3484 resolution = ms % 10L; 3485 if (resolution != 0) { 3486 MMRESULT result = timeBeginPeriod(1L); 3487 } 3488 } 3489 ~HighResolutionInterval() { 3490 if (resolution != 0) { 3491 MMRESULT result = timeEndPeriod(1L); 3492 } 3493 resolution = 0L; 3494 } 3495}; 3496 3497int os::sleep(Thread* thread, jlong ms, bool interruptable) { 3498 jlong limit = (jlong) MAXDWORD; 3499 3500 while (ms > limit) { 3501 int res; 3502 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) { 3503 return res; 3504 } 3505 ms -= limit; 3506 } 3507 3508 assert(thread == Thread::current(), "thread consistency check"); 3509 OSThread* osthread = thread->osthread(); 3510 OSThreadWaitState osts(osthread, false /* not Object.wait() */); 3511 int result; 3512 if (interruptable) { 3513 assert(thread->is_Java_thread(), "must be java thread"); 3514 JavaThread *jt = (JavaThread *) thread; 3515 ThreadBlockInVM tbivm(jt); 3516 3517 jt->set_suspend_equivalent(); 3518 // cleared by handle_special_suspend_equivalent_condition() or 3519 // java_suspend_self() via check_and_wait_while_suspended() 3520 3521 HANDLE events[1]; 3522 events[0] = osthread->interrupt_event(); 3523 HighResolutionInterval *phri=NULL; 3524 if (!ForceTimeHighResolution) { 3525 phri = new HighResolutionInterval(ms); 3526 } 3527 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) { 3528 result = OS_TIMEOUT; 3529 } else { 3530 ResetEvent(osthread->interrupt_event()); 3531 osthread->set_interrupted(false); 3532 result = OS_INTRPT; 3533 } 3534 delete phri; //if it is NULL, harmless 3535 3536 // were we externally suspended while we were waiting? 3537 jt->check_and_wait_while_suspended(); 3538 } else { 3539 assert(!thread->is_Java_thread(), "must not be java thread"); 3540 Sleep((long) ms); 3541 result = OS_TIMEOUT; 3542 } 3543 return result; 3544} 3545 3546// Short sleep, direct OS call. 3547// 3548// ms = 0, means allow others (if any) to run. 3549// 3550void os::naked_short_sleep(jlong ms) { 3551 assert(ms < 1000, "Un-interruptable sleep, short time use only"); 3552 Sleep(ms); 3553} 3554 3555// Sleep forever; naked call to OS-specific sleep; use with CAUTION 3556void os::infinite_sleep() { 3557 while (true) { // sleep forever ... 3558 Sleep(100000); // ... 100 seconds at a time 3559 } 3560} 3561 3562typedef BOOL (WINAPI * STTSignature)(void); 3563 3564void os::naked_yield() { 3565 // Use either SwitchToThread() or Sleep(0) 3566 // Consider passing back the return value from SwitchToThread(). 3567 if (os::Kernel32Dll::SwitchToThreadAvailable()) { 3568 SwitchToThread(); 3569 } else { 3570 Sleep(0); 3571 } 3572} 3573 3574// Win32 only gives you access to seven real priorities at a time, 3575// so we compress Java's ten down to seven. It would be better 3576// if we dynamically adjusted relative priorities. 3577 3578int os::java_to_os_priority[CriticalPriority + 1] = { 3579 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3580 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3581 THREAD_PRIORITY_LOWEST, // 2 3582 THREAD_PRIORITY_BELOW_NORMAL, // 3 3583 THREAD_PRIORITY_BELOW_NORMAL, // 4 3584 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3585 THREAD_PRIORITY_NORMAL, // 6 3586 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3587 THREAD_PRIORITY_ABOVE_NORMAL, // 8 3588 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3589 THREAD_PRIORITY_HIGHEST, // 10 MaxPriority 3590 THREAD_PRIORITY_HIGHEST // 11 CriticalPriority 3591}; 3592 3593int prio_policy1[CriticalPriority + 1] = { 3594 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3595 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3596 THREAD_PRIORITY_LOWEST, // 2 3597 THREAD_PRIORITY_BELOW_NORMAL, // 3 3598 THREAD_PRIORITY_BELOW_NORMAL, // 4 3599 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3600 THREAD_PRIORITY_ABOVE_NORMAL, // 6 3601 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3602 THREAD_PRIORITY_HIGHEST, // 8 3603 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3604 THREAD_PRIORITY_TIME_CRITICAL, // 10 MaxPriority 3605 THREAD_PRIORITY_TIME_CRITICAL // 11 CriticalPriority 3606}; 3607 3608static int prio_init() { 3609 // If ThreadPriorityPolicy is 1, switch tables 3610 if (ThreadPriorityPolicy == 1) { 3611 int i; 3612 for (i = 0; i < CriticalPriority + 1; i++) { 3613 os::java_to_os_priority[i] = prio_policy1[i]; 3614 } 3615 } 3616 if (UseCriticalJavaThreadPriority) { 3617 os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority]; 3618 } 3619 return 0; 3620} 3621 3622OSReturn os::set_native_priority(Thread* thread, int priority) { 3623 if (!UseThreadPriorities) return OS_OK; 3624 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0; 3625 return ret ? OS_OK : OS_ERR; 3626} 3627 3628OSReturn os::get_native_priority(const Thread* const thread, 3629 int* priority_ptr) { 3630 if (!UseThreadPriorities) { 3631 *priority_ptr = java_to_os_priority[NormPriority]; 3632 return OS_OK; 3633 } 3634 int os_prio = GetThreadPriority(thread->osthread()->thread_handle()); 3635 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) { 3636 assert(false, "GetThreadPriority failed"); 3637 return OS_ERR; 3638 } 3639 *priority_ptr = os_prio; 3640 return OS_OK; 3641} 3642 3643 3644// Hint to the underlying OS that a task switch would not be good. 3645// Void return because it's a hint and can fail. 3646void os::hint_no_preempt() {} 3647 3648void os::interrupt(Thread* thread) { 3649 assert(!thread->is_Java_thread() || Thread::current() == thread || 3650 Threads_lock->owned_by_self(), 3651 "possibility of dangling Thread pointer"); 3652 3653 OSThread* osthread = thread->osthread(); 3654 osthread->set_interrupted(true); 3655 // More than one thread can get here with the same value of osthread, 3656 // resulting in multiple notifications. We do, however, want the store 3657 // to interrupted() to be visible to other threads before we post 3658 // the interrupt event. 3659 OrderAccess::release(); 3660 SetEvent(osthread->interrupt_event()); 3661 // For JSR166: unpark after setting status 3662 if (thread->is_Java_thread()) { 3663 ((JavaThread*)thread)->parker()->unpark(); 3664 } 3665 3666 ParkEvent * ev = thread->_ParkEvent; 3667 if (ev != NULL) ev->unpark(); 3668} 3669 3670 3671bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 3672 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3673 "possibility of dangling Thread pointer"); 3674 3675 OSThread* osthread = thread->osthread(); 3676 // There is no synchronization between the setting of the interrupt 3677 // and it being cleared here. It is critical - see 6535709 - that 3678 // we only clear the interrupt state, and reset the interrupt event, 3679 // if we are going to report that we were indeed interrupted - else 3680 // an interrupt can be "lost", leading to spurious wakeups or lost wakeups 3681 // depending on the timing. By checking thread interrupt event to see 3682 // if the thread gets real interrupt thus prevent spurious wakeup. 3683 bool interrupted = osthread->interrupted() && (WaitForSingleObject(osthread->interrupt_event(), 0) == WAIT_OBJECT_0); 3684 if (interrupted && clear_interrupted) { 3685 osthread->set_interrupted(false); 3686 ResetEvent(osthread->interrupt_event()); 3687 } // Otherwise leave the interrupted state alone 3688 3689 return interrupted; 3690} 3691 3692// Get's a pc (hint) for a running thread. Currently used only for profiling. 3693ExtendedPC os::get_thread_pc(Thread* thread) { 3694 CONTEXT context; 3695 context.ContextFlags = CONTEXT_CONTROL; 3696 HANDLE handle = thread->osthread()->thread_handle(); 3697#ifdef _M_IA64 3698 assert(0, "Fix get_thread_pc"); 3699 return ExtendedPC(NULL); 3700#else 3701 if (GetThreadContext(handle, &context)) { 3702#ifdef _M_AMD64 3703 return ExtendedPC((address) context.Rip); 3704#else 3705 return ExtendedPC((address) context.Eip); 3706#endif 3707 } else { 3708 return ExtendedPC(NULL); 3709 } 3710#endif 3711} 3712 3713// GetCurrentThreadId() returns DWORD 3714intx os::current_thread_id() { return GetCurrentThreadId(); } 3715 3716static int _initial_pid = 0; 3717 3718int os::current_process_id() { 3719 return (_initial_pid ? _initial_pid : _getpid()); 3720} 3721 3722int os::win32::_vm_page_size = 0; 3723int os::win32::_vm_allocation_granularity = 0; 3724int os::win32::_processor_type = 0; 3725// Processor level is not available on non-NT systems, use vm_version instead 3726int os::win32::_processor_level = 0; 3727julong os::win32::_physical_memory = 0; 3728size_t os::win32::_default_stack_size = 0; 3729 3730intx os::win32::_os_thread_limit = 0; 3731volatile intx os::win32::_os_thread_count = 0; 3732 3733bool os::win32::_is_nt = false; 3734bool os::win32::_is_windows_2003 = false; 3735bool os::win32::_is_windows_server = false; 3736 3737// 6573254 3738// Currently, the bug is observed across all the supported Windows releases, 3739// including the latest one (as of this writing - Windows Server 2012 R2) 3740bool os::win32::_has_exit_bug = true; 3741bool os::win32::_has_performance_count = 0; 3742 3743void os::win32::initialize_system_info() { 3744 SYSTEM_INFO si; 3745 GetSystemInfo(&si); 3746 _vm_page_size = si.dwPageSize; 3747 _vm_allocation_granularity = si.dwAllocationGranularity; 3748 _processor_type = si.dwProcessorType; 3749 _processor_level = si.wProcessorLevel; 3750 set_processor_count(si.dwNumberOfProcessors); 3751 3752 MEMORYSTATUSEX ms; 3753 ms.dwLength = sizeof(ms); 3754 3755 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual, 3756 // dwMemoryLoad (% of memory in use) 3757 GlobalMemoryStatusEx(&ms); 3758 _physical_memory = ms.ullTotalPhys; 3759 3760 OSVERSIONINFOEX oi; 3761 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 3762 GetVersionEx((OSVERSIONINFO*)&oi); 3763 switch (oi.dwPlatformId) { 3764 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break; 3765 case VER_PLATFORM_WIN32_NT: 3766 _is_nt = true; 3767 { 3768 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion; 3769 if (os_vers == 5002) { 3770 _is_windows_2003 = true; 3771 } 3772 if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER || 3773 oi.wProductType == VER_NT_SERVER) { 3774 _is_windows_server = true; 3775 } 3776 } 3777 break; 3778 default: fatal("Unknown platform"); 3779 } 3780 3781 _default_stack_size = os::current_stack_size(); 3782 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size"); 3783 assert((_default_stack_size & (_vm_page_size - 1)) == 0, 3784 "stack size not a multiple of page size"); 3785 3786 initialize_performance_counter(); 3787} 3788 3789 3790HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, 3791 int ebuflen) { 3792 char path[MAX_PATH]; 3793 DWORD size; 3794 DWORD pathLen = (DWORD)sizeof(path); 3795 HINSTANCE result = NULL; 3796 3797 // only allow library name without path component 3798 assert(strchr(name, '\\') == NULL, "path not allowed"); 3799 assert(strchr(name, ':') == NULL, "path not allowed"); 3800 if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) { 3801 jio_snprintf(ebuf, ebuflen, 3802 "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name); 3803 return NULL; 3804 } 3805 3806 // search system directory 3807 if ((size = GetSystemDirectory(path, pathLen)) > 0) { 3808 if (size >= pathLen) { 3809 return NULL; // truncated 3810 } 3811 if (jio_snprintf(path + size, pathLen - size, "\\%s", name) == -1) { 3812 return NULL; // truncated 3813 } 3814 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) { 3815 return result; 3816 } 3817 } 3818 3819 // try Windows directory 3820 if ((size = GetWindowsDirectory(path, pathLen)) > 0) { 3821 if (size >= pathLen) { 3822 return NULL; // truncated 3823 } 3824 if (jio_snprintf(path + size, pathLen - size, "\\%s", name) == -1) { 3825 return NULL; // truncated 3826 } 3827 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) { 3828 return result; 3829 } 3830 } 3831 3832 jio_snprintf(ebuf, ebuflen, 3833 "os::win32::load_windows_dll() cannot load %s from system directories.", name); 3834 return NULL; 3835} 3836 3837#define EXIT_TIMEOUT 300000 /* 5 minutes */ 3838 3839static BOOL CALLBACK init_crit_sect_call(PINIT_ONCE, PVOID pcrit_sect, PVOID*) { 3840 InitializeCriticalSection((CRITICAL_SECTION*)pcrit_sect); 3841 return TRUE; 3842} 3843 3844int os::win32::exit_process_or_thread(Ept what, int exit_code) { 3845 // Basic approach: 3846 // - Each exiting thread registers its intent to exit and then does so. 3847 // - A thread trying to terminate the process must wait for all 3848 // threads currently exiting to complete their exit. 3849 3850 if (os::win32::has_exit_bug()) { 3851 // The array holds handles of the threads that have started exiting by calling 3852 // _endthreadex(). 3853 // Should be large enough to avoid blocking the exiting thread due to lack of 3854 // a free slot. 3855 static HANDLE handles[MAXIMUM_WAIT_OBJECTS]; 3856 static int handle_count = 0; 3857 3858 static INIT_ONCE init_once_crit_sect = INIT_ONCE_STATIC_INIT; 3859 static CRITICAL_SECTION crit_sect; 3860 static volatile jint process_exiting = 0; 3861 int i, j; 3862 DWORD res; 3863 HANDLE hproc, hthr; 3864 3865 // The first thread that reached this point, initializes the critical section. 3866 if (!InitOnceExecuteOnce(&init_once_crit_sect, init_crit_sect_call, &crit_sect, NULL)) { 3867 warning("crit_sect initialization failed in %s: %d\n", __FILE__, __LINE__); 3868 } else if (OrderAccess::load_acquire(&process_exiting) == 0) { 3869 EnterCriticalSection(&crit_sect); 3870 3871 if (what == EPT_THREAD && OrderAccess::load_acquire(&process_exiting) == 0) { 3872 // Remove from the array those handles of the threads that have completed exiting. 3873 for (i = 0, j = 0; i < handle_count; ++i) { 3874 res = WaitForSingleObject(handles[i], 0 /* don't wait */); 3875 if (res == WAIT_TIMEOUT) { 3876 handles[j++] = handles[i]; 3877 } else { 3878 if (res == WAIT_FAILED) { 3879 warning("WaitForSingleObject failed (%u) in %s: %d\n", 3880 GetLastError(), __FILE__, __LINE__); 3881 } 3882 // Don't keep the handle, if we failed waiting for it. 3883 CloseHandle(handles[i]); 3884 } 3885 } 3886 3887 // If there's no free slot in the array of the kept handles, we'll have to 3888 // wait until at least one thread completes exiting. 3889 if ((handle_count = j) == MAXIMUM_WAIT_OBJECTS) { 3890 // Raise the priority of the oldest exiting thread to increase its chances 3891 // to complete sooner. 3892 SetThreadPriority(handles[0], THREAD_PRIORITY_ABOVE_NORMAL); 3893 res = WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, handles, FALSE, EXIT_TIMEOUT); 3894 if (res >= WAIT_OBJECT_0 && res < (WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS)) { 3895 i = (res - WAIT_OBJECT_0); 3896 handle_count = MAXIMUM_WAIT_OBJECTS - 1; 3897 for (; i < handle_count; ++i) { 3898 handles[i] = handles[i + 1]; 3899 } 3900 } else { 3901 warning("WaitForMultipleObjects %s (%u) in %s: %d\n", 3902 (res == WAIT_FAILED ? "failed" : "timed out"), 3903 GetLastError(), __FILE__, __LINE__); 3904 // Don't keep handles, if we failed waiting for them. 3905 for (i = 0; i < MAXIMUM_WAIT_OBJECTS; ++i) { 3906 CloseHandle(handles[i]); 3907 } 3908 handle_count = 0; 3909 } 3910 } 3911 3912 // Store a duplicate of the current thread handle in the array of handles. 3913 hproc = GetCurrentProcess(); 3914 hthr = GetCurrentThread(); 3915 if (!DuplicateHandle(hproc, hthr, hproc, &handles[handle_count], 3916 0, FALSE, DUPLICATE_SAME_ACCESS)) { 3917 warning("DuplicateHandle failed (%u) in %s: %d\n", 3918 GetLastError(), __FILE__, __LINE__); 3919 } else { 3920 ++handle_count; 3921 } 3922 3923 // The current exiting thread has stored its handle in the array, and now 3924 // should leave the critical section before calling _endthreadex(). 3925 3926 } else if (what != EPT_THREAD) { 3927 if (handle_count > 0) { 3928 // Before ending the process, make sure all the threads that had called 3929 // _endthreadex() completed. 3930 3931 // Set the priority level of the current thread to the same value as 3932 // the priority level of exiting threads. 3933 // This is to ensure it will be given a fair chance to execute if 3934 // the timeout expires. 3935 hthr = GetCurrentThread(); 3936 SetThreadPriority(hthr, THREAD_PRIORITY_ABOVE_NORMAL); 3937 for (i = 0; i < handle_count; ++i) { 3938 SetThreadPriority(handles[i], THREAD_PRIORITY_ABOVE_NORMAL); 3939 } 3940 res = WaitForMultipleObjects(handle_count, handles, TRUE, EXIT_TIMEOUT); 3941 if (res == WAIT_FAILED || res == WAIT_TIMEOUT) { 3942 warning("WaitForMultipleObjects %s (%u) in %s: %d\n", 3943 (res == WAIT_FAILED ? "failed" : "timed out"), 3944 GetLastError(), __FILE__, __LINE__); 3945 } 3946 for (i = 0; i < handle_count; ++i) { 3947 CloseHandle(handles[i]); 3948 } 3949 handle_count = 0; 3950 } 3951 3952 OrderAccess::release_store(&process_exiting, 1); 3953 } 3954 3955 LeaveCriticalSection(&crit_sect); 3956 } 3957 3958 if (what == EPT_THREAD) { 3959 while (OrderAccess::load_acquire(&process_exiting) != 0) { 3960 // Some other thread is about to call exit(), so we 3961 // don't let the current thread proceed to _endthreadex() 3962 SuspendThread(GetCurrentThread()); 3963 // Avoid busy-wait loop, if SuspendThread() failed. 3964 Sleep(EXIT_TIMEOUT); 3965 } 3966 } 3967 } 3968 3969 // We are here if either 3970 // - there's no 'race at exit' bug on this OS release; 3971 // - initialization of the critical section failed (unlikely); 3972 // - the current thread has stored its handle and left the critical section; 3973 // - the process-exiting thread has raised the flag and left the critical section. 3974 if (what == EPT_THREAD) { 3975 _endthreadex((unsigned)exit_code); 3976 } else if (what == EPT_PROCESS) { 3977 ::exit(exit_code); 3978 } else { 3979 _exit(exit_code); 3980 } 3981 3982 // Should not reach here 3983 return exit_code; 3984} 3985 3986#undef EXIT_TIMEOUT 3987 3988void os::win32::setmode_streams() { 3989 _setmode(_fileno(stdin), _O_BINARY); 3990 _setmode(_fileno(stdout), _O_BINARY); 3991 _setmode(_fileno(stderr), _O_BINARY); 3992} 3993 3994 3995bool os::is_debugger_attached() { 3996 return IsDebuggerPresent() ? true : false; 3997} 3998 3999 4000void os::wait_for_keypress_at_exit(void) { 4001 if (PauseAtExit) { 4002 fprintf(stderr, "Press any key to continue...\n"); 4003 fgetc(stdin); 4004 } 4005} 4006 4007 4008bool os::message_box(const char* title, const char* message) { 4009 int result = MessageBox(NULL, message, title, 4010 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY); 4011 return result == IDYES; 4012} 4013 4014int os::allocate_thread_local_storage() { 4015 return TlsAlloc(); 4016} 4017 4018 4019void os::free_thread_local_storage(int index) { 4020 TlsFree(index); 4021} 4022 4023 4024void os::thread_local_storage_at_put(int index, void* value) { 4025 TlsSetValue(index, value); 4026 assert(thread_local_storage_at(index) == value, "Just checking"); 4027} 4028 4029 4030void* os::thread_local_storage_at(int index) { 4031 return TlsGetValue(index); 4032} 4033 4034 4035#ifndef PRODUCT 4036#ifndef _WIN64 4037// Helpers to check whether NX protection is enabled 4038int nx_exception_filter(_EXCEPTION_POINTERS *pex) { 4039 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 4040 pex->ExceptionRecord->NumberParameters > 0 && 4041 pex->ExceptionRecord->ExceptionInformation[0] == 4042 EXCEPTION_INFO_EXEC_VIOLATION) { 4043 return EXCEPTION_EXECUTE_HANDLER; 4044 } 4045 return EXCEPTION_CONTINUE_SEARCH; 4046} 4047 4048void nx_check_protection() { 4049 // If NX is enabled we'll get an exception calling into code on the stack 4050 char code[] = { (char)0xC3 }; // ret 4051 void *code_ptr = (void *)code; 4052 __try { 4053 __asm call code_ptr 4054 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) { 4055 tty->print_raw_cr("NX protection detected."); 4056 } 4057} 4058#endif // _WIN64 4059#endif // PRODUCT 4060 4061// this is called _before_ the global arguments have been parsed 4062void os::init(void) { 4063 _initial_pid = _getpid(); 4064 4065 init_random(1234567); 4066 4067 win32::initialize_system_info(); 4068 win32::setmode_streams(); 4069 init_page_sizes((size_t) win32::vm_page_size()); 4070 4071 // This may be overridden later when argument processing is done. 4072 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation, 4073 os::win32::is_windows_2003()); 4074 4075 // Initialize main_process and main_thread 4076 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle 4077 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process, 4078 &main_thread, THREAD_ALL_ACCESS, false, 0)) { 4079 fatal("DuplicateHandle failed\n"); 4080 } 4081 main_thread_id = (int) GetCurrentThreadId(); 4082} 4083 4084// To install functions for atexit processing 4085extern "C" { 4086 static void perfMemory_exit_helper() { 4087 perfMemory_exit(); 4088 } 4089} 4090 4091static jint initSock(); 4092 4093// this is called _after_ the global arguments have been parsed 4094jint os::init_2(void) { 4095 // Allocate a single page and mark it as readable for safepoint polling 4096 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY); 4097 guarantee(polling_page != NULL, "Reserve Failed for polling page"); 4098 4099 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY); 4100 guarantee(return_page != NULL, "Commit Failed for polling page"); 4101 4102 os::set_polling_page(polling_page); 4103 4104#ifndef PRODUCT 4105 if (Verbose && PrintMiscellaneous) { 4106 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", 4107 (intptr_t)polling_page); 4108 } 4109#endif 4110 4111 if (!UseMembar) { 4112 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE); 4113 guarantee(mem_serialize_page != NULL, "Reserve Failed for memory serialize page"); 4114 4115 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE); 4116 guarantee(return_page != NULL, "Commit Failed for memory serialize page"); 4117 4118 os::set_memory_serialize_page(mem_serialize_page); 4119 4120#ifndef PRODUCT 4121 if (Verbose && PrintMiscellaneous) { 4122 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", 4123 (intptr_t)mem_serialize_page); 4124 } 4125#endif 4126 } 4127 4128 // Setup Windows Exceptions 4129 4130 // for debugging float code generation bugs 4131 if (ForceFloatExceptions) { 4132#ifndef _WIN64 4133 static long fp_control_word = 0; 4134 __asm { fstcw fp_control_word } 4135 // see Intel PPro Manual, Vol. 2, p 7-16 4136 const long precision = 0x20; 4137 const long underflow = 0x10; 4138 const long overflow = 0x08; 4139 const long zero_div = 0x04; 4140 const long denorm = 0x02; 4141 const long invalid = 0x01; 4142 fp_control_word |= invalid; 4143 __asm { fldcw fp_control_word } 4144#endif 4145 } 4146 4147 // If stack_commit_size is 0, windows will reserve the default size, 4148 // but only commit a small portion of it. 4149 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size()); 4150 size_t default_reserve_size = os::win32::default_stack_size(); 4151 size_t actual_reserve_size = stack_commit_size; 4152 if (stack_commit_size < default_reserve_size) { 4153 // If stack_commit_size == 0, we want this too 4154 actual_reserve_size = default_reserve_size; 4155 } 4156 4157 // Check minimum allowable stack size for thread creation and to initialize 4158 // the java system classes, including StackOverflowError - depends on page 4159 // size. Add a page for compiler2 recursion in main thread. 4160 // Add in 2*BytesPerWord times page size to account for VM stack during 4161 // class initialization depending on 32 or 64 bit VM. 4162 size_t min_stack_allowed = 4163 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ 4164 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size(); 4165 if (actual_reserve_size < min_stack_allowed) { 4166 tty->print_cr("\nThe stack size specified is too small, " 4167 "Specify at least %dk", 4168 min_stack_allowed / K); 4169 return JNI_ERR; 4170 } 4171 4172 JavaThread::set_stack_size_at_create(stack_commit_size); 4173 4174 // Calculate theoretical max. size of Threads to guard gainst artifical 4175 // out-of-memory situations, where all available address-space has been 4176 // reserved by thread stacks. 4177 assert(actual_reserve_size != 0, "Must have a stack"); 4178 4179 // Calculate the thread limit when we should start doing Virtual Memory 4180 // banging. Currently when the threads will have used all but 200Mb of space. 4181 // 4182 // TODO: consider performing a similar calculation for commit size instead 4183 // as reserve size, since on a 64-bit platform we'll run into that more 4184 // often than running out of virtual memory space. We can use the 4185 // lower value of the two calculations as the os_thread_limit. 4186 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K); 4187 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size); 4188 4189 // at exit methods are called in the reverse order of their registration. 4190 // there is no limit to the number of functions registered. atexit does 4191 // not set errno. 4192 4193 if (PerfAllowAtExitRegistration) { 4194 // only register atexit functions if PerfAllowAtExitRegistration is set. 4195 // atexit functions can be delayed until process exit time, which 4196 // can be problematic for embedded VM situations. Embedded VMs should 4197 // call DestroyJavaVM() to assure that VM resources are released. 4198 4199 // note: perfMemory_exit_helper atexit function may be removed in 4200 // the future if the appropriate cleanup code can be added to the 4201 // VM_Exit VMOperation's doit method. 4202 if (atexit(perfMemory_exit_helper) != 0) { 4203 warning("os::init_2 atexit(perfMemory_exit_helper) failed"); 4204 } 4205 } 4206 4207#ifndef _WIN64 4208 // Print something if NX is enabled (win32 on AMD64) 4209 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection()); 4210#endif 4211 4212 // initialize thread priority policy 4213 prio_init(); 4214 4215 if (UseNUMA && !ForceNUMA) { 4216 UseNUMA = false; // We don't fully support this yet 4217 } 4218 4219 if (UseNUMAInterleaving) { 4220 // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag 4221 bool success = numa_interleaving_init(); 4222 if (!success) UseNUMAInterleaving = false; 4223 } 4224 4225 if (initSock() != JNI_OK) { 4226 return JNI_ERR; 4227 } 4228 4229 return JNI_OK; 4230} 4231 4232// Mark the polling page as unreadable 4233void os::make_polling_page_unreadable(void) { 4234 DWORD old_status; 4235 if (!VirtualProtect((char *)_polling_page, os::vm_page_size(), 4236 PAGE_NOACCESS, &old_status)) { 4237 fatal("Could not disable polling page"); 4238 } 4239} 4240 4241// Mark the polling page as readable 4242void os::make_polling_page_readable(void) { 4243 DWORD old_status; 4244 if (!VirtualProtect((char *)_polling_page, os::vm_page_size(), 4245 PAGE_READONLY, &old_status)) { 4246 fatal("Could not enable polling page"); 4247 } 4248} 4249 4250 4251int os::stat(const char *path, struct stat *sbuf) { 4252 char pathbuf[MAX_PATH]; 4253 if (strlen(path) > MAX_PATH - 1) { 4254 errno = ENAMETOOLONG; 4255 return -1; 4256 } 4257 os::native_path(strcpy(pathbuf, path)); 4258 int ret = ::stat(pathbuf, sbuf); 4259 if (sbuf != NULL && UseUTCFileTimestamp) { 4260 // Fix for 6539723. st_mtime returned from stat() is dependent on 4261 // the system timezone and so can return different values for the 4262 // same file if/when daylight savings time changes. This adjustment 4263 // makes sure the same timestamp is returned regardless of the TZ. 4264 // 4265 // See: 4266 // http://msdn.microsoft.com/library/ 4267 // default.asp?url=/library/en-us/sysinfo/base/ 4268 // time_zone_information_str.asp 4269 // and 4270 // http://msdn.microsoft.com/library/default.asp?url= 4271 // /library/en-us/sysinfo/base/settimezoneinformation.asp 4272 // 4273 // NOTE: there is a insidious bug here: If the timezone is changed 4274 // after the call to stat() but before 'GetTimeZoneInformation()', then 4275 // the adjustment we do here will be wrong and we'll return the wrong 4276 // value (which will likely end up creating an invalid class data 4277 // archive). Absent a better API for this, or some time zone locking 4278 // mechanism, we'll have to live with this risk. 4279 TIME_ZONE_INFORMATION tz; 4280 DWORD tzid = GetTimeZoneInformation(&tz); 4281 int daylightBias = 4282 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias; 4283 sbuf->st_mtime += (tz.Bias + daylightBias) * 60; 4284 } 4285 return ret; 4286} 4287 4288 4289#define FT2INT64(ft) \ 4290 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime)) 4291 4292 4293// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 4294// are used by JVM M&M and JVMTI to get user+sys or user CPU time 4295// of a thread. 4296// 4297// current_thread_cpu_time() and thread_cpu_time(Thread*) returns 4298// the fast estimate available on the platform. 4299 4300// current_thread_cpu_time() is not optimized for Windows yet 4301jlong os::current_thread_cpu_time() { 4302 // return user + sys since the cost is the same 4303 return os::thread_cpu_time(Thread::current(), true /* user+sys */); 4304} 4305 4306jlong os::thread_cpu_time(Thread* thread) { 4307 // consistent with what current_thread_cpu_time() returns. 4308 return os::thread_cpu_time(thread, true /* user+sys */); 4309} 4310 4311jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 4312 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 4313} 4314 4315jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) { 4316 // This code is copy from clasic VM -> hpi::sysThreadCPUTime 4317 // If this function changes, os::is_thread_cpu_time_supported() should too 4318 if (os::win32::is_nt()) { 4319 FILETIME CreationTime; 4320 FILETIME ExitTime; 4321 FILETIME KernelTime; 4322 FILETIME UserTime; 4323 4324 if (GetThreadTimes(thread->osthread()->thread_handle(), &CreationTime, 4325 &ExitTime, &KernelTime, &UserTime) == 0) { 4326 return -1; 4327 } else if (user_sys_cpu_time) { 4328 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100; 4329 } else { 4330 return FT2INT64(UserTime) * 100; 4331 } 4332 } else { 4333 return (jlong) timeGetTime() * 1000000; 4334 } 4335} 4336 4337void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 4338 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 4339 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 4340 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 4341 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 4342} 4343 4344void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 4345 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 4346 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 4347 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 4348 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 4349} 4350 4351bool os::is_thread_cpu_time_supported() { 4352 // see os::thread_cpu_time 4353 if (os::win32::is_nt()) { 4354 FILETIME CreationTime; 4355 FILETIME ExitTime; 4356 FILETIME KernelTime; 4357 FILETIME UserTime; 4358 4359 if (GetThreadTimes(GetCurrentThread(), &CreationTime, &ExitTime, 4360 &KernelTime, &UserTime) == 0) { 4361 return false; 4362 } else { 4363 return true; 4364 } 4365 } else { 4366 return false; 4367 } 4368} 4369 4370// Windows does't provide a loadavg primitive so this is stubbed out for now. 4371// It does have primitives (PDH API) to get CPU usage and run queue length. 4372// "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length" 4373// If we wanted to implement loadavg on Windows, we have a few options: 4374// 4375// a) Query CPU usage and run queue length and "fake" an answer by 4376// returning the CPU usage if it's under 100%, and the run queue 4377// length otherwise. It turns out that querying is pretty slow 4378// on Windows, on the order of 200 microseconds on a fast machine. 4379// Note that on the Windows the CPU usage value is the % usage 4380// since the last time the API was called (and the first call 4381// returns 100%), so we'd have to deal with that as well. 4382// 4383// b) Sample the "fake" answer using a sampling thread and store 4384// the answer in a global variable. The call to loadavg would 4385// just return the value of the global, avoiding the slow query. 4386// 4387// c) Sample a better answer using exponential decay to smooth the 4388// value. This is basically the algorithm used by UNIX kernels. 4389// 4390// Note that sampling thread starvation could affect both (b) and (c). 4391int os::loadavg(double loadavg[], int nelem) { 4392 return -1; 4393} 4394 4395 4396// DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield() 4397bool os::dont_yield() { 4398 return DontYieldALot; 4399} 4400 4401// This method is a slightly reworked copy of JDK's sysOpen 4402// from src/windows/hpi/src/sys_api_md.c 4403 4404int os::open(const char *path, int oflag, int mode) { 4405 char pathbuf[MAX_PATH]; 4406 4407 if (strlen(path) > MAX_PATH - 1) { 4408 errno = ENAMETOOLONG; 4409 return -1; 4410 } 4411 os::native_path(strcpy(pathbuf, path)); 4412 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode); 4413} 4414 4415FILE* os::open(int fd, const char* mode) { 4416 return ::_fdopen(fd, mode); 4417} 4418 4419// Is a (classpath) directory empty? 4420bool os::dir_is_empty(const char* path) { 4421 WIN32_FIND_DATA fd; 4422 HANDLE f = FindFirstFile(path, &fd); 4423 if (f == INVALID_HANDLE_VALUE) { 4424 return true; 4425 } 4426 FindClose(f); 4427 return false; 4428} 4429 4430// create binary file, rewriting existing file if required 4431int os::create_binary_file(const char* path, bool rewrite_existing) { 4432 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY; 4433 if (!rewrite_existing) { 4434 oflags |= _O_EXCL; 4435 } 4436 return ::open(path, oflags, _S_IREAD | _S_IWRITE); 4437} 4438 4439// return current position of file pointer 4440jlong os::current_file_offset(int fd) { 4441 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR); 4442} 4443 4444// move file pointer to the specified offset 4445jlong os::seek_to_file_offset(int fd, jlong offset) { 4446 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET); 4447} 4448 4449 4450jlong os::lseek(int fd, jlong offset, int whence) { 4451 return (jlong) ::_lseeki64(fd, offset, whence); 4452} 4453 4454size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) { 4455 OVERLAPPED ov; 4456 DWORD nread; 4457 BOOL result; 4458 4459 ZeroMemory(&ov, sizeof(ov)); 4460 ov.Offset = (DWORD)offset; 4461 ov.OffsetHigh = (DWORD)(offset >> 32); 4462 4463 HANDLE h = (HANDLE)::_get_osfhandle(fd); 4464 4465 result = ReadFile(h, (LPVOID)buf, nBytes, &nread, &ov); 4466 4467 return result ? nread : 0; 4468} 4469 4470 4471// This method is a slightly reworked copy of JDK's sysNativePath 4472// from src/windows/hpi/src/path_md.c 4473 4474// Convert a pathname to native format. On win32, this involves forcing all 4475// separators to be '\\' rather than '/' (both are legal inputs, but Win95 4476// sometimes rejects '/') and removing redundant separators. The input path is 4477// assumed to have been converted into the character encoding used by the local 4478// system. Because this might be a double-byte encoding, care is taken to 4479// treat double-byte lead characters correctly. 4480// 4481// This procedure modifies the given path in place, as the result is never 4482// longer than the original. There is no error return; this operation always 4483// succeeds. 4484char * os::native_path(char *path) { 4485 char *src = path, *dst = path, *end = path; 4486 char *colon = NULL; // If a drive specifier is found, this will 4487 // point to the colon following the drive letter 4488 4489 // Assumption: '/', '\\', ':', and drive letters are never lead bytes 4490 assert(((!::IsDBCSLeadByte('/')) && (!::IsDBCSLeadByte('\\')) 4491 && (!::IsDBCSLeadByte(':'))), "Illegal lead byte"); 4492 4493 // Check for leading separators 4494#define isfilesep(c) ((c) == '/' || (c) == '\\') 4495 while (isfilesep(*src)) { 4496 src++; 4497 } 4498 4499 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') { 4500 // Remove leading separators if followed by drive specifier. This 4501 // hack is necessary to support file URLs containing drive 4502 // specifiers (e.g., "file://c:/path"). As a side effect, 4503 // "/c:/path" can be used as an alternative to "c:/path". 4504 *dst++ = *src++; 4505 colon = dst; 4506 *dst++ = ':'; 4507 src++; 4508 } else { 4509 src = path; 4510 if (isfilesep(src[0]) && isfilesep(src[1])) { 4511 // UNC pathname: Retain first separator; leave src pointed at 4512 // second separator so that further separators will be collapsed 4513 // into the second separator. The result will be a pathname 4514 // beginning with "\\\\" followed (most likely) by a host name. 4515 src = dst = path + 1; 4516 path[0] = '\\'; // Force first separator to '\\' 4517 } 4518 } 4519 4520 end = dst; 4521 4522 // Remove redundant separators from remainder of path, forcing all 4523 // separators to be '\\' rather than '/'. Also, single byte space 4524 // characters are removed from the end of the path because those 4525 // are not legal ending characters on this operating system. 4526 // 4527 while (*src != '\0') { 4528 if (isfilesep(*src)) { 4529 *dst++ = '\\'; src++; 4530 while (isfilesep(*src)) src++; 4531 if (*src == '\0') { 4532 // Check for trailing separator 4533 end = dst; 4534 if (colon == dst - 2) break; // "z:\\" 4535 if (dst == path + 1) break; // "\\" 4536 if (dst == path + 2 && isfilesep(path[0])) { 4537 // "\\\\" is not collapsed to "\\" because "\\\\" marks the 4538 // beginning of a UNC pathname. Even though it is not, by 4539 // itself, a valid UNC pathname, we leave it as is in order 4540 // to be consistent with the path canonicalizer as well 4541 // as the win32 APIs, which treat this case as an invalid 4542 // UNC pathname rather than as an alias for the root 4543 // directory of the current drive. 4544 break; 4545 } 4546 end = --dst; // Path does not denote a root directory, so 4547 // remove trailing separator 4548 break; 4549 } 4550 end = dst; 4551 } else { 4552 if (::IsDBCSLeadByte(*src)) { // Copy a double-byte character 4553 *dst++ = *src++; 4554 if (*src) *dst++ = *src++; 4555 end = dst; 4556 } else { // Copy a single-byte character 4557 char c = *src++; 4558 *dst++ = c; 4559 // Space is not a legal ending character 4560 if (c != ' ') end = dst; 4561 } 4562 } 4563 } 4564 4565 *end = '\0'; 4566 4567 // For "z:", add "." to work around a bug in the C runtime library 4568 if (colon == dst - 1) { 4569 path[2] = '.'; 4570 path[3] = '\0'; 4571 } 4572 4573 return path; 4574} 4575 4576// This code is a copy of JDK's sysSetLength 4577// from src/windows/hpi/src/sys_api_md.c 4578 4579int os::ftruncate(int fd, jlong length) { 4580 HANDLE h = (HANDLE)::_get_osfhandle(fd); 4581 long high = (long)(length >> 32); 4582 DWORD ret; 4583 4584 if (h == (HANDLE)(-1)) { 4585 return -1; 4586 } 4587 4588 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN); 4589 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) { 4590 return -1; 4591 } 4592 4593 if (::SetEndOfFile(h) == FALSE) { 4594 return -1; 4595 } 4596 4597 return 0; 4598} 4599 4600 4601// This code is a copy of JDK's sysSync 4602// from src/windows/hpi/src/sys_api_md.c 4603// except for the legacy workaround for a bug in Win 98 4604 4605int os::fsync(int fd) { 4606 HANDLE handle = (HANDLE)::_get_osfhandle(fd); 4607 4608 if ((!::FlushFileBuffers(handle)) && 4609 (GetLastError() != ERROR_ACCESS_DENIED)) { 4610 // from winerror.h 4611 return -1; 4612 } 4613 return 0; 4614} 4615 4616static int nonSeekAvailable(int, long *); 4617static int stdinAvailable(int, long *); 4618 4619#define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR) 4620#define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO) 4621 4622// This code is a copy of JDK's sysAvailable 4623// from src/windows/hpi/src/sys_api_md.c 4624 4625int os::available(int fd, jlong *bytes) { 4626 jlong cur, end; 4627 struct _stati64 stbuf64; 4628 4629 if (::_fstati64(fd, &stbuf64) >= 0) { 4630 int mode = stbuf64.st_mode; 4631 if (S_ISCHR(mode) || S_ISFIFO(mode)) { 4632 int ret; 4633 long lpbytes; 4634 if (fd == 0) { 4635 ret = stdinAvailable(fd, &lpbytes); 4636 } else { 4637 ret = nonSeekAvailable(fd, &lpbytes); 4638 } 4639 (*bytes) = (jlong)(lpbytes); 4640 return ret; 4641 } 4642 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) { 4643 return FALSE; 4644 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) { 4645 return FALSE; 4646 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) { 4647 return FALSE; 4648 } 4649 *bytes = end - cur; 4650 return TRUE; 4651 } else { 4652 return FALSE; 4653 } 4654} 4655 4656// This code is a copy of JDK's nonSeekAvailable 4657// from src/windows/hpi/src/sys_api_md.c 4658 4659static int nonSeekAvailable(int fd, long *pbytes) { 4660 // This is used for available on non-seekable devices 4661 // (like both named and anonymous pipes, such as pipes 4662 // connected to an exec'd process). 4663 // Standard Input is a special case. 4664 HANDLE han; 4665 4666 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) { 4667 return FALSE; 4668 } 4669 4670 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) { 4671 // PeekNamedPipe fails when at EOF. In that case we 4672 // simply make *pbytes = 0 which is consistent with the 4673 // behavior we get on Solaris when an fd is at EOF. 4674 // The only alternative is to raise an Exception, 4675 // which isn't really warranted. 4676 // 4677 if (::GetLastError() != ERROR_BROKEN_PIPE) { 4678 return FALSE; 4679 } 4680 *pbytes = 0; 4681 } 4682 return TRUE; 4683} 4684 4685#define MAX_INPUT_EVENTS 2000 4686 4687// This code is a copy of JDK's stdinAvailable 4688// from src/windows/hpi/src/sys_api_md.c 4689 4690static int stdinAvailable(int fd, long *pbytes) { 4691 HANDLE han; 4692 DWORD numEventsRead = 0; // Number of events read from buffer 4693 DWORD numEvents = 0; // Number of events in buffer 4694 DWORD i = 0; // Loop index 4695 DWORD curLength = 0; // Position marker 4696 DWORD actualLength = 0; // Number of bytes readable 4697 BOOL error = FALSE; // Error holder 4698 INPUT_RECORD *lpBuffer; // Pointer to records of input events 4699 4700 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) { 4701 return FALSE; 4702 } 4703 4704 // Construct an array of input records in the console buffer 4705 error = ::GetNumberOfConsoleInputEvents(han, &numEvents); 4706 if (error == 0) { 4707 return nonSeekAvailable(fd, pbytes); 4708 } 4709 4710 // lpBuffer must fit into 64K or else PeekConsoleInput fails 4711 if (numEvents > MAX_INPUT_EVENTS) { 4712 numEvents = MAX_INPUT_EVENTS; 4713 } 4714 4715 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal); 4716 if (lpBuffer == NULL) { 4717 return FALSE; 4718 } 4719 4720 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead); 4721 if (error == 0) { 4722 os::free(lpBuffer); 4723 return FALSE; 4724 } 4725 4726 // Examine input records for the number of bytes available 4727 for (i=0; i<numEvents; i++) { 4728 if (lpBuffer[i].EventType == KEY_EVENT) { 4729 4730 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *) 4731 &(lpBuffer[i].Event); 4732 if (keyRecord->bKeyDown == TRUE) { 4733 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar); 4734 curLength++; 4735 if (*keyPressed == '\r') { 4736 actualLength = curLength; 4737 } 4738 } 4739 } 4740 } 4741 4742 if (lpBuffer != NULL) { 4743 os::free(lpBuffer); 4744 } 4745 4746 *pbytes = (long) actualLength; 4747 return TRUE; 4748} 4749 4750// Map a block of memory. 4751char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, 4752 char *addr, size_t bytes, bool read_only, 4753 bool allow_exec) { 4754 HANDLE hFile; 4755 char* base; 4756 4757 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, 4758 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 4759 if (hFile == NULL) { 4760 if (PrintMiscellaneous && Verbose) { 4761 DWORD err = GetLastError(); 4762 tty->print_cr("CreateFile() failed: GetLastError->%ld.", err); 4763 } 4764 return NULL; 4765 } 4766 4767 if (allow_exec) { 4768 // CreateFileMapping/MapViewOfFileEx can't map executable memory 4769 // unless it comes from a PE image (which the shared archive is not.) 4770 // Even VirtualProtect refuses to give execute access to mapped memory 4771 // that was not previously executable. 4772 // 4773 // Instead, stick the executable region in anonymous memory. Yuck. 4774 // Penalty is that ~4 pages will not be shareable - in the future 4775 // we might consider DLLizing the shared archive with a proper PE 4776 // header so that mapping executable + sharing is possible. 4777 4778 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE, 4779 PAGE_READWRITE); 4780 if (base == NULL) { 4781 if (PrintMiscellaneous && Verbose) { 4782 DWORD err = GetLastError(); 4783 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err); 4784 } 4785 CloseHandle(hFile); 4786 return NULL; 4787 } 4788 4789 DWORD bytes_read; 4790 OVERLAPPED overlapped; 4791 overlapped.Offset = (DWORD)file_offset; 4792 overlapped.OffsetHigh = 0; 4793 overlapped.hEvent = NULL; 4794 // ReadFile guarantees that if the return value is true, the requested 4795 // number of bytes were read before returning. 4796 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0; 4797 if (!res) { 4798 if (PrintMiscellaneous && Verbose) { 4799 DWORD err = GetLastError(); 4800 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err); 4801 } 4802 release_memory(base, bytes); 4803 CloseHandle(hFile); 4804 return NULL; 4805 } 4806 } else { 4807 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0, 4808 NULL /* file_name */); 4809 if (hMap == NULL) { 4810 if (PrintMiscellaneous && Verbose) { 4811 DWORD err = GetLastError(); 4812 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.", err); 4813 } 4814 CloseHandle(hFile); 4815 return NULL; 4816 } 4817 4818 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY; 4819 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset, 4820 (DWORD)bytes, addr); 4821 if (base == NULL) { 4822 if (PrintMiscellaneous && Verbose) { 4823 DWORD err = GetLastError(); 4824 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err); 4825 } 4826 CloseHandle(hMap); 4827 CloseHandle(hFile); 4828 return NULL; 4829 } 4830 4831 if (CloseHandle(hMap) == 0) { 4832 if (PrintMiscellaneous && Verbose) { 4833 DWORD err = GetLastError(); 4834 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err); 4835 } 4836 CloseHandle(hFile); 4837 return base; 4838 } 4839 } 4840 4841 if (allow_exec) { 4842 DWORD old_protect; 4843 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE; 4844 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0; 4845 4846 if (!res) { 4847 if (PrintMiscellaneous && Verbose) { 4848 DWORD err = GetLastError(); 4849 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err); 4850 } 4851 // Don't consider this a hard error, on IA32 even if the 4852 // VirtualProtect fails, we should still be able to execute 4853 CloseHandle(hFile); 4854 return base; 4855 } 4856 } 4857 4858 if (CloseHandle(hFile) == 0) { 4859 if (PrintMiscellaneous && Verbose) { 4860 DWORD err = GetLastError(); 4861 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err); 4862 } 4863 return base; 4864 } 4865 4866 return base; 4867} 4868 4869 4870// Remap a block of memory. 4871char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset, 4872 char *addr, size_t bytes, bool read_only, 4873 bool allow_exec) { 4874 // This OS does not allow existing memory maps to be remapped so we 4875 // have to unmap the memory before we remap it. 4876 if (!os::unmap_memory(addr, bytes)) { 4877 return NULL; 4878 } 4879 4880 // There is a very small theoretical window between the unmap_memory() 4881 // call above and the map_memory() call below where a thread in native 4882 // code may be able to access an address that is no longer mapped. 4883 4884 return os::map_memory(fd, file_name, file_offset, addr, bytes, 4885 read_only, allow_exec); 4886} 4887 4888 4889// Unmap a block of memory. 4890// Returns true=success, otherwise false. 4891 4892bool os::pd_unmap_memory(char* addr, size_t bytes) { 4893 MEMORY_BASIC_INFORMATION mem_info; 4894 if (VirtualQuery(addr, &mem_info, sizeof(mem_info)) == 0) { 4895 if (PrintMiscellaneous && Verbose) { 4896 DWORD err = GetLastError(); 4897 tty->print_cr("VirtualQuery() failed: GetLastError->%ld.", err); 4898 } 4899 return false; 4900 } 4901 4902 // Executable memory was not mapped using CreateFileMapping/MapViewOfFileEx. 4903 // Instead, executable region was allocated using VirtualAlloc(). See 4904 // pd_map_memory() above. 4905 // 4906 // The following flags should match the 'exec_access' flages used for 4907 // VirtualProtect() in pd_map_memory(). 4908 if (mem_info.Protect == PAGE_EXECUTE_READ || 4909 mem_info.Protect == PAGE_EXECUTE_READWRITE) { 4910 return pd_release_memory(addr, bytes); 4911 } 4912 4913 BOOL result = UnmapViewOfFile(addr); 4914 if (result == 0) { 4915 if (PrintMiscellaneous && Verbose) { 4916 DWORD err = GetLastError(); 4917 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err); 4918 } 4919 return false; 4920 } 4921 return true; 4922} 4923 4924void os::pause() { 4925 char filename[MAX_PATH]; 4926 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 4927 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 4928 } else { 4929 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 4930 } 4931 4932 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 4933 if (fd != -1) { 4934 struct stat buf; 4935 ::close(fd); 4936 while (::stat(filename, &buf) == 0) { 4937 Sleep(100); 4938 } 4939 } else { 4940 jio_fprintf(stderr, 4941 "Could not open pause file '%s', continuing immediately.\n", filename); 4942 } 4943} 4944 4945os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() { 4946 assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread"); 4947} 4948 4949// See the caveats for this class in os_windows.hpp 4950// Protects the callback call so that raised OS EXCEPTIONS causes a jump back 4951// into this method and returns false. If no OS EXCEPTION was raised, returns 4952// true. 4953// The callback is supposed to provide the method that should be protected. 4954// 4955bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) { 4956 assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread"); 4957 assert(!WatcherThread::watcher_thread()->has_crash_protection(), 4958 "crash_protection already set?"); 4959 4960 bool success = true; 4961 __try { 4962 WatcherThread::watcher_thread()->set_crash_protection(this); 4963 cb.call(); 4964 } __except(EXCEPTION_EXECUTE_HANDLER) { 4965 // only for protection, nothing to do 4966 success = false; 4967 } 4968 WatcherThread::watcher_thread()->set_crash_protection(NULL); 4969 return success; 4970} 4971 4972// An Event wraps a win32 "CreateEvent" kernel handle. 4973// 4974// We have a number of choices regarding "CreateEvent" win32 handle leakage: 4975// 4976// 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle 4977// field, and call CloseHandle() on the win32 event handle. Unpark() would 4978// need to be modified to tolerate finding a NULL (invalid) win32 event handle. 4979// In addition, an unpark() operation might fetch the handle field, but the 4980// event could recycle between the fetch and the SetEvent() operation. 4981// SetEvent() would either fail because the handle was invalid, or inadvertently work, 4982// as the win32 handle value had been recycled. In an ideal world calling SetEvent() 4983// on an stale but recycled handle would be harmless, but in practice this might 4984// confuse other non-Sun code, so it's not a viable approach. 4985// 4986// 2: Once a win32 event handle is associated with an Event, it remains associated 4987// with the Event. The event handle is never closed. This could be construed 4988// as handle leakage, but only up to the maximum # of threads that have been extant 4989// at any one time. This shouldn't be an issue, as windows platforms typically 4990// permit a process to have hundreds of thousands of open handles. 4991// 4992// 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList 4993// and release unused handles. 4994// 4995// 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle. 4996// It's not clear, however, that we wouldn't be trading one type of leak for another. 4997// 4998// 5. Use an RCU-like mechanism (Read-Copy Update). 4999// Or perhaps something similar to Maged Michael's "Hazard pointers". 5000// 5001// We use (2). 5002// 5003// TODO-FIXME: 5004// 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation. 5005// 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks 5006// to recover from (or at least detect) the dreaded Windows 841176 bug. 5007// 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent 5008// into a single win32 CreateEvent() handle. 5009// 5010// Assumption: 5011// Only one parker can exist on an event, which is why we allocate 5012// them per-thread. Multiple unparkers can coexist. 5013// 5014// _Event transitions in park() 5015// -1 => -1 : illegal 5016// 1 => 0 : pass - return immediately 5017// 0 => -1 : block; then set _Event to 0 before returning 5018// 5019// _Event transitions in unpark() 5020// 0 => 1 : just return 5021// 1 => 1 : just return 5022// -1 => either 0 or 1; must signal target thread 5023// That is, we can safely transition _Event from -1 to either 5024// 0 or 1. 5025// 5026// _Event serves as a restricted-range semaphore. 5027// -1 : thread is blocked, i.e. there is a waiter 5028// 0 : neutral: thread is running or ready, 5029// could have been signaled after a wait started 5030// 1 : signaled - thread is running or ready 5031// 5032// Another possible encoding of _Event would be with 5033// explicit "PARKED" == 01b and "SIGNALED" == 10b bits. 5034// 5035 5036int os::PlatformEvent::park(jlong Millis) { 5037 // Transitions for _Event: 5038 // -1 => -1 : illegal 5039 // 1 => 0 : pass - return immediately 5040 // 0 => -1 : block; then set _Event to 0 before returning 5041 5042 guarantee(_ParkHandle != NULL , "Invariant"); 5043 guarantee(Millis > 0 , "Invariant"); 5044 5045 // CONSIDER: defer assigning a CreateEvent() handle to the Event until 5046 // the initial park() operation. 5047 // Consider: use atomic decrement instead of CAS-loop 5048 5049 int v; 5050 for (;;) { 5051 v = _Event; 5052 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break; 5053 } 5054 guarantee((v == 0) || (v == 1), "invariant"); 5055 if (v != 0) return OS_OK; 5056 5057 // Do this the hard way by blocking ... 5058 // TODO: consider a brief spin here, gated on the success of recent 5059 // spin attempts by this thread. 5060 // 5061 // We decompose long timeouts into series of shorter timed waits. 5062 // Evidently large timo values passed in WaitForSingleObject() are problematic on some 5063 // versions of Windows. See EventWait() for details. This may be superstition. Or not. 5064 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time 5065 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from 5066 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend 5067 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv == 5068 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate 5069 // for the already waited time. This policy does not admit any new outcomes. 5070 // In the future, however, we might want to track the accumulated wait time and 5071 // adjust Millis accordingly if we encounter a spurious wakeup. 5072 5073 const int MAXTIMEOUT = 0x10000000; 5074 DWORD rv = WAIT_TIMEOUT; 5075 while (_Event < 0 && Millis > 0) { 5076 DWORD prd = Millis; // set prd = MAX (Millis, MAXTIMEOUT) 5077 if (Millis > MAXTIMEOUT) { 5078 prd = MAXTIMEOUT; 5079 } 5080 rv = ::WaitForSingleObject(_ParkHandle, prd); 5081 assert(rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed"); 5082 if (rv == WAIT_TIMEOUT) { 5083 Millis -= prd; 5084 } 5085 } 5086 v = _Event; 5087 _Event = 0; 5088 // see comment at end of os::PlatformEvent::park() below: 5089 OrderAccess::fence(); 5090 // If we encounter a nearly simultanous timeout expiry and unpark() 5091 // we return OS_OK indicating we awoke via unpark(). 5092 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however. 5093 return (v >= 0) ? OS_OK : OS_TIMEOUT; 5094} 5095 5096void os::PlatformEvent::park() { 5097 // Transitions for _Event: 5098 // -1 => -1 : illegal 5099 // 1 => 0 : pass - return immediately 5100 // 0 => -1 : block; then set _Event to 0 before returning 5101 5102 guarantee(_ParkHandle != NULL, "Invariant"); 5103 // Invariant: Only the thread associated with the Event/PlatformEvent 5104 // may call park(). 5105 // Consider: use atomic decrement instead of CAS-loop 5106 int v; 5107 for (;;) { 5108 v = _Event; 5109 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break; 5110 } 5111 guarantee((v == 0) || (v == 1), "invariant"); 5112 if (v != 0) return; 5113 5114 // Do this the hard way by blocking ... 5115 // TODO: consider a brief spin here, gated on the success of recent 5116 // spin attempts by this thread. 5117 while (_Event < 0) { 5118 DWORD rv = ::WaitForSingleObject(_ParkHandle, INFINITE); 5119 assert(rv == WAIT_OBJECT_0, "WaitForSingleObject failed"); 5120 } 5121 5122 // Usually we'll find _Event == 0 at this point, but as 5123 // an optional optimization we clear it, just in case can 5124 // multiple unpark() operations drove _Event up to 1. 5125 _Event = 0; 5126 OrderAccess::fence(); 5127 guarantee(_Event >= 0, "invariant"); 5128} 5129 5130void os::PlatformEvent::unpark() { 5131 guarantee(_ParkHandle != NULL, "Invariant"); 5132 5133 // Transitions for _Event: 5134 // 0 => 1 : just return 5135 // 1 => 1 : just return 5136 // -1 => either 0 or 1; must signal target thread 5137 // That is, we can safely transition _Event from -1 to either 5138 // 0 or 1. 5139 // See also: "Semaphores in Plan 9" by Mullender & Cox 5140 // 5141 // Note: Forcing a transition from "-1" to "1" on an unpark() means 5142 // that it will take two back-to-back park() calls for the owning 5143 // thread to block. This has the benefit of forcing a spurious return 5144 // from the first park() call after an unpark() call which will help 5145 // shake out uses of park() and unpark() without condition variables. 5146 5147 if (Atomic::xchg(1, &_Event) >= 0) return; 5148 5149 ::SetEvent(_ParkHandle); 5150} 5151 5152 5153// JSR166 5154// ------------------------------------------------------- 5155 5156// The Windows implementation of Park is very straightforward: Basic 5157// operations on Win32 Events turn out to have the right semantics to 5158// use them directly. We opportunistically resuse the event inherited 5159// from Monitor. 5160 5161void Parker::park(bool isAbsolute, jlong time) { 5162 guarantee(_ParkEvent != NULL, "invariant"); 5163 // First, demultiplex/decode time arguments 5164 if (time < 0) { // don't wait 5165 return; 5166 } else if (time == 0 && !isAbsolute) { 5167 time = INFINITE; 5168 } else if (isAbsolute) { 5169 time -= os::javaTimeMillis(); // convert to relative time 5170 if (time <= 0) { // already elapsed 5171 return; 5172 } 5173 } else { // relative 5174 time /= 1000000; // Must coarsen from nanos to millis 5175 if (time == 0) { // Wait for the minimal time unit if zero 5176 time = 1; 5177 } 5178 } 5179 5180 JavaThread* thread = (JavaThread*)(Thread::current()); 5181 assert(thread->is_Java_thread(), "Must be JavaThread"); 5182 JavaThread *jt = (JavaThread *)thread; 5183 5184 // Don't wait if interrupted or already triggered 5185 if (Thread::is_interrupted(thread, false) || 5186 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) { 5187 ResetEvent(_ParkEvent); 5188 return; 5189 } else { 5190 ThreadBlockInVM tbivm(jt); 5191 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 5192 jt->set_suspend_equivalent(); 5193 5194 WaitForSingleObject(_ParkEvent, time); 5195 ResetEvent(_ParkEvent); 5196 5197 // If externally suspended while waiting, re-suspend 5198 if (jt->handle_special_suspend_equivalent_condition()) { 5199 jt->java_suspend_self(); 5200 } 5201 } 5202} 5203 5204void Parker::unpark() { 5205 guarantee(_ParkEvent != NULL, "invariant"); 5206 SetEvent(_ParkEvent); 5207} 5208 5209// Run the specified command in a separate process. Return its exit value, 5210// or -1 on failure (e.g. can't create a new process). 5211int os::fork_and_exec(char* cmd) { 5212 STARTUPINFO si; 5213 PROCESS_INFORMATION pi; 5214 5215 memset(&si, 0, sizeof(si)); 5216 si.cb = sizeof(si); 5217 memset(&pi, 0, sizeof(pi)); 5218 BOOL rslt = CreateProcess(NULL, // executable name - use command line 5219 cmd, // command line 5220 NULL, // process security attribute 5221 NULL, // thread security attribute 5222 TRUE, // inherits system handles 5223 0, // no creation flags 5224 NULL, // use parent's environment block 5225 NULL, // use parent's starting directory 5226 &si, // (in) startup information 5227 &pi); // (out) process information 5228 5229 if (rslt) { 5230 // Wait until child process exits. 5231 WaitForSingleObject(pi.hProcess, INFINITE); 5232 5233 DWORD exit_code; 5234 GetExitCodeProcess(pi.hProcess, &exit_code); 5235 5236 // Close process and thread handles. 5237 CloseHandle(pi.hProcess); 5238 CloseHandle(pi.hThread); 5239 5240 return (int)exit_code; 5241 } else { 5242 return -1; 5243 } 5244} 5245 5246//-------------------------------------------------------------------------------------------------- 5247// Non-product code 5248 5249static int mallocDebugIntervalCounter = 0; 5250static int mallocDebugCounter = 0; 5251bool os::check_heap(bool force) { 5252 if (++mallocDebugCounter < MallocVerifyStart && !force) return true; 5253 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) { 5254 // Note: HeapValidate executes two hardware breakpoints when it finds something 5255 // wrong; at these points, eax contains the address of the offending block (I think). 5256 // To get to the exlicit error message(s) below, just continue twice. 5257 // 5258 // Note: we want to check the CRT heap, which is not necessarily located in the 5259 // process default heap. 5260 HANDLE heap = (HANDLE) _get_heap_handle(); 5261 if (!heap) { 5262 return true; 5263 } 5264 5265 // If we fail to lock the heap, then gflags.exe has been used 5266 // or some other special heap flag has been set that prevents 5267 // locking. We don't try to walk a heap we can't lock. 5268 if (HeapLock(heap) != 0) { 5269 PROCESS_HEAP_ENTRY phe; 5270 phe.lpData = NULL; 5271 while (HeapWalk(heap, &phe) != 0) { 5272 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) && 5273 !HeapValidate(heap, 0, phe.lpData)) { 5274 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter); 5275 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData); 5276 HeapUnlock(heap); 5277 fatal("corrupted C heap"); 5278 } 5279 } 5280 DWORD err = GetLastError(); 5281 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) { 5282 HeapUnlock(heap); 5283 fatal("heap walk aborted with error %d", err); 5284 } 5285 HeapUnlock(heap); 5286 } 5287 mallocDebugIntervalCounter = 0; 5288 } 5289 return true; 5290} 5291 5292 5293bool os::find(address addr, outputStream* st) { 5294 // Nothing yet 5295 return false; 5296} 5297 5298LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) { 5299 DWORD exception_code = e->ExceptionRecord->ExceptionCode; 5300 5301 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 5302 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow(); 5303 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord; 5304 address addr = (address) exceptionRecord->ExceptionInformation[1]; 5305 5306 if (os::is_memory_serialize_page(thread, addr)) { 5307 return EXCEPTION_CONTINUE_EXECUTION; 5308 } 5309 } 5310 5311 return EXCEPTION_CONTINUE_SEARCH; 5312} 5313 5314// We don't build a headless jre for Windows 5315bool os::is_headless_jre() { return false; } 5316 5317static jint initSock() { 5318 WSADATA wsadata; 5319 5320 if (!os::WinSock2Dll::WinSock2Available()) { 5321 jio_fprintf(stderr, "Could not load Winsock (error: %d)\n", 5322 ::GetLastError()); 5323 return JNI_ERR; 5324 } 5325 5326 if (os::WinSock2Dll::WSAStartup(MAKEWORD(2,2), &wsadata) != 0) { 5327 jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n", 5328 ::GetLastError()); 5329 return JNI_ERR; 5330 } 5331 return JNI_OK; 5332} 5333 5334struct hostent* os::get_host_by_name(char* name) { 5335 return (struct hostent*)os::WinSock2Dll::gethostbyname(name); 5336} 5337 5338int os::socket_close(int fd) { 5339 return ::closesocket(fd); 5340} 5341 5342int os::socket(int domain, int type, int protocol) { 5343 return ::socket(domain, type, protocol); 5344} 5345 5346int os::connect(int fd, struct sockaddr* him, socklen_t len) { 5347 return ::connect(fd, him, len); 5348} 5349 5350int os::recv(int fd, char* buf, size_t nBytes, uint flags) { 5351 return ::recv(fd, buf, (int)nBytes, flags); 5352} 5353 5354int os::send(int fd, char* buf, size_t nBytes, uint flags) { 5355 return ::send(fd, buf, (int)nBytes, flags); 5356} 5357 5358int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) { 5359 return ::send(fd, buf, (int)nBytes, flags); 5360} 5361 5362// WINDOWS CONTEXT Flags for THREAD_SAMPLING 5363#if defined(IA32) 5364 #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS) 5365#elif defined (AMD64) 5366 #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT) 5367#endif 5368 5369// returns true if thread could be suspended, 5370// false otherwise 5371static bool do_suspend(HANDLE* h) { 5372 if (h != NULL) { 5373 if (SuspendThread(*h) != ~0) { 5374 return true; 5375 } 5376 } 5377 return false; 5378} 5379 5380// resume the thread 5381// calling resume on an active thread is a no-op 5382static void do_resume(HANDLE* h) { 5383 if (h != NULL) { 5384 ResumeThread(*h); 5385 } 5386} 5387 5388// retrieve a suspend/resume context capable handle 5389// from the tid. Caller validates handle return value. 5390void get_thread_handle_for_extended_context(HANDLE* h, 5391 OSThread::thread_id_t tid) { 5392 if (h != NULL) { 5393 *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid); 5394 } 5395} 5396 5397// Thread sampling implementation 5398// 5399void os::SuspendedThreadTask::internal_do_task() { 5400 CONTEXT ctxt; 5401 HANDLE h = NULL; 5402 5403 // get context capable handle for thread 5404 get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id()); 5405 5406 // sanity 5407 if (h == NULL || h == INVALID_HANDLE_VALUE) { 5408 return; 5409 } 5410 5411 // suspend the thread 5412 if (do_suspend(&h)) { 5413 ctxt.ContextFlags = sampling_context_flags; 5414 // get thread context 5415 GetThreadContext(h, &ctxt); 5416 SuspendedThreadTaskContext context(_thread, &ctxt); 5417 // pass context to Thread Sampling impl 5418 do_task(context); 5419 // resume thread 5420 do_resume(&h); 5421 } 5422 5423 // close handle 5424 CloseHandle(h); 5425} 5426 5427 5428// Kernel32 API 5429typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void); 5430typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn)(HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD); 5431typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn)(PULONG); 5432typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn)(UCHAR, PULONGLONG); 5433typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG); 5434 5435GetLargePageMinimum_Fn os::Kernel32Dll::_GetLargePageMinimum = NULL; 5436VirtualAllocExNuma_Fn os::Kernel32Dll::_VirtualAllocExNuma = NULL; 5437GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL; 5438GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL; 5439RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL; 5440 5441 5442BOOL os::Kernel32Dll::initialized = FALSE; 5443SIZE_T os::Kernel32Dll::GetLargePageMinimum() { 5444 assert(initialized && _GetLargePageMinimum != NULL, 5445 "GetLargePageMinimumAvailable() not yet called"); 5446 return _GetLargePageMinimum(); 5447} 5448 5449BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() { 5450 if (!initialized) { 5451 initialize(); 5452 } 5453 return _GetLargePageMinimum != NULL; 5454} 5455 5456BOOL os::Kernel32Dll::NumaCallsAvailable() { 5457 if (!initialized) { 5458 initialize(); 5459 } 5460 return _VirtualAllocExNuma != NULL; 5461} 5462 5463LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, 5464 SIZE_T bytes, DWORD flags, 5465 DWORD prot, DWORD node) { 5466 assert(initialized && _VirtualAllocExNuma != NULL, 5467 "NUMACallsAvailable() not yet called"); 5468 5469 return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node); 5470} 5471 5472BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) { 5473 assert(initialized && _GetNumaHighestNodeNumber != NULL, 5474 "NUMACallsAvailable() not yet called"); 5475 5476 return _GetNumaHighestNodeNumber(ptr_highest_node_number); 5477} 5478 5479BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, 5480 PULONGLONG proc_mask) { 5481 assert(initialized && _GetNumaNodeProcessorMask != NULL, 5482 "NUMACallsAvailable() not yet called"); 5483 5484 return _GetNumaNodeProcessorMask(node, proc_mask); 5485} 5486 5487USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip, 5488 ULONG FrameToCapture, 5489 PVOID* BackTrace, 5490 PULONG BackTraceHash) { 5491 if (!initialized) { 5492 initialize(); 5493 } 5494 5495 if (_RtlCaptureStackBackTrace != NULL) { 5496 return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture, 5497 BackTrace, BackTraceHash); 5498 } else { 5499 return 0; 5500 } 5501} 5502 5503void os::Kernel32Dll::initializeCommon() { 5504 if (!initialized) { 5505 HMODULE handle = ::GetModuleHandle("Kernel32.dll"); 5506 assert(handle != NULL, "Just check"); 5507 _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum"); 5508 _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma"); 5509 _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber"); 5510 _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask"); 5511 _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace"); 5512 initialized = TRUE; 5513 } 5514} 5515 5516bool os::start_debugging(char *buf, int buflen) { 5517 int len = (int)strlen(buf); 5518 char *p = &buf[len]; 5519 5520 jio_snprintf(p, buflen-len, 5521 "\n\n" 5522 "Do you want to debug the problem?\n\n" 5523 "To debug, attach Visual Studio to process %d; then switch to thread 0x%x\n" 5524 "Select 'Yes' to launch Visual Studio automatically (PATH must include msdev)\n" 5525 "Otherwise, select 'No' to abort...", 5526 os::current_process_id(), os::current_thread_id()); 5527 5528 bool yes = os::message_box("Unexpected Error", buf); 5529 5530 if (yes) { 5531 // os::breakpoint() calls DebugBreak(), which causes a breakpoint 5532 // exception. If VM is running inside a debugger, the debugger will 5533 // catch the exception. Otherwise, the breakpoint exception will reach 5534 // the default windows exception handler, which can spawn a debugger and 5535 // automatically attach to the dying VM. 5536 os::breakpoint(); 5537 yes = false; 5538 } 5539 return yes; 5540} 5541 5542#ifndef JDK6_OR_EARLIER 5543 5544void os::Kernel32Dll::initialize() { 5545 initializeCommon(); 5546} 5547 5548 5549// Kernel32 API 5550inline BOOL os::Kernel32Dll::SwitchToThread() { 5551 return ::SwitchToThread(); 5552} 5553 5554inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() { 5555 return true; 5556} 5557 5558// Help tools 5559inline BOOL os::Kernel32Dll::HelpToolsAvailable() { 5560 return true; 5561} 5562 5563inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags, 5564 DWORD th32ProcessId) { 5565 return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId); 5566} 5567 5568inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot, 5569 LPMODULEENTRY32 lpme) { 5570 return ::Module32First(hSnapshot, lpme); 5571} 5572 5573inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot, 5574 LPMODULEENTRY32 lpme) { 5575 return ::Module32Next(hSnapshot, lpme); 5576} 5577 5578inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) { 5579 ::GetNativeSystemInfo(lpSystemInfo); 5580} 5581 5582// PSAPI API 5583inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, 5584 HMODULE *lpModule, DWORD cb, 5585 LPDWORD lpcbNeeded) { 5586 return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded); 5587} 5588 5589inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, 5590 HMODULE hModule, 5591 LPTSTR lpFilename, 5592 DWORD nSize) { 5593 return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize); 5594} 5595 5596inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, 5597 HMODULE hModule, 5598 LPMODULEINFO lpmodinfo, 5599 DWORD cb) { 5600 return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb); 5601} 5602 5603inline BOOL os::PSApiDll::PSApiAvailable() { 5604 return true; 5605} 5606 5607 5608// WinSock2 API 5609inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, 5610 LPWSADATA lpWSAData) { 5611 return ::WSAStartup(wVersionRequested, lpWSAData); 5612} 5613 5614inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) { 5615 return ::gethostbyname(name); 5616} 5617 5618inline BOOL os::WinSock2Dll::WinSock2Available() { 5619 return true; 5620} 5621 5622// Advapi API 5623inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle, 5624 BOOL DisableAllPrivileges, 5625 PTOKEN_PRIVILEGES NewState, 5626 DWORD BufferLength, 5627 PTOKEN_PRIVILEGES PreviousState, 5628 PDWORD ReturnLength) { 5629 return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState, 5630 BufferLength, PreviousState, ReturnLength); 5631} 5632 5633inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, 5634 DWORD DesiredAccess, 5635 PHANDLE TokenHandle) { 5636 return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle); 5637} 5638 5639inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, 5640 LPCTSTR lpName, 5641 PLUID lpLuid) { 5642 return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid); 5643} 5644 5645inline BOOL os::Advapi32Dll::AdvapiAvailable() { 5646 return true; 5647} 5648 5649void* os::get_default_process_handle() { 5650 return (void*)GetModuleHandle(NULL); 5651} 5652 5653// Builds a platform dependent Agent_OnLoad_<lib_name> function name 5654// which is used to find statically linked in agents. 5655// Additionally for windows, takes into account __stdcall names. 5656// Parameters: 5657// sym_name: Symbol in library we are looking for 5658// lib_name: Name of library to look in, NULL for shared libs. 5659// is_absolute_path == true if lib_name is absolute path to agent 5660// such as "C:/a/b/L.dll" 5661// == false if only the base name of the library is passed in 5662// such as "L" 5663char* os::build_agent_function_name(const char *sym_name, const char *lib_name, 5664 bool is_absolute_path) { 5665 char *agent_entry_name; 5666 size_t len; 5667 size_t name_len; 5668 size_t prefix_len = strlen(JNI_LIB_PREFIX); 5669 size_t suffix_len = strlen(JNI_LIB_SUFFIX); 5670 const char *start; 5671 5672 if (lib_name != NULL) { 5673 len = name_len = strlen(lib_name); 5674 if (is_absolute_path) { 5675 // Need to strip path, prefix and suffix 5676 if ((start = strrchr(lib_name, *os::file_separator())) != NULL) { 5677 lib_name = ++start; 5678 } else { 5679 // Need to check for drive prefix 5680 if ((start = strchr(lib_name, ':')) != NULL) { 5681 lib_name = ++start; 5682 } 5683 } 5684 if (len <= (prefix_len + suffix_len)) { 5685 return NULL; 5686 } 5687 lib_name += prefix_len; 5688 name_len = strlen(lib_name) - suffix_len; 5689 } 5690 } 5691 len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2; 5692 agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread); 5693 if (agent_entry_name == NULL) { 5694 return NULL; 5695 } 5696 if (lib_name != NULL) { 5697 const char *p = strrchr(sym_name, '@'); 5698 if (p != NULL && p != sym_name) { 5699 // sym_name == _Agent_OnLoad@XX 5700 strncpy(agent_entry_name, sym_name, (p - sym_name)); 5701 agent_entry_name[(p-sym_name)] = '\0'; 5702 // agent_entry_name == _Agent_OnLoad 5703 strcat(agent_entry_name, "_"); 5704 strncat(agent_entry_name, lib_name, name_len); 5705 strcat(agent_entry_name, p); 5706 // agent_entry_name == _Agent_OnLoad_lib_name@XX 5707 } else { 5708 strcpy(agent_entry_name, sym_name); 5709 strcat(agent_entry_name, "_"); 5710 strncat(agent_entry_name, lib_name, name_len); 5711 } 5712 } else { 5713 strcpy(agent_entry_name, sym_name); 5714 } 5715 return agent_entry_name; 5716} 5717 5718#else 5719// Kernel32 API 5720typedef BOOL (WINAPI* SwitchToThread_Fn)(void); 5721typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD, DWORD); 5722typedef BOOL (WINAPI* Module32First_Fn)(HANDLE, LPMODULEENTRY32); 5723typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE, LPMODULEENTRY32); 5724typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO); 5725 5726SwitchToThread_Fn os::Kernel32Dll::_SwitchToThread = NULL; 5727CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL; 5728Module32First_Fn os::Kernel32Dll::_Module32First = NULL; 5729Module32Next_Fn os::Kernel32Dll::_Module32Next = NULL; 5730GetNativeSystemInfo_Fn os::Kernel32Dll::_GetNativeSystemInfo = NULL; 5731 5732void os::Kernel32Dll::initialize() { 5733 if (!initialized) { 5734 HMODULE handle = ::GetModuleHandle("Kernel32.dll"); 5735 assert(handle != NULL, "Just check"); 5736 5737 _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread"); 5738 _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn) 5739 ::GetProcAddress(handle, "CreateToolhelp32Snapshot"); 5740 _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First"); 5741 _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next"); 5742 _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo"); 5743 initializeCommon(); // resolve the functions that always need resolving 5744 5745 initialized = TRUE; 5746 } 5747} 5748 5749BOOL os::Kernel32Dll::SwitchToThread() { 5750 assert(initialized && _SwitchToThread != NULL, 5751 "SwitchToThreadAvailable() not yet called"); 5752 return _SwitchToThread(); 5753} 5754 5755 5756BOOL os::Kernel32Dll::SwitchToThreadAvailable() { 5757 if (!initialized) { 5758 initialize(); 5759 } 5760 return _SwitchToThread != NULL; 5761} 5762 5763// Help tools 5764BOOL os::Kernel32Dll::HelpToolsAvailable() { 5765 if (!initialized) { 5766 initialize(); 5767 } 5768 return _CreateToolhelp32Snapshot != NULL && 5769 _Module32First != NULL && 5770 _Module32Next != NULL; 5771} 5772 5773HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags, 5774 DWORD th32ProcessId) { 5775 assert(initialized && _CreateToolhelp32Snapshot != NULL, 5776 "HelpToolsAvailable() not yet called"); 5777 5778 return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId); 5779} 5780 5781BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) { 5782 assert(initialized && _Module32First != NULL, 5783 "HelpToolsAvailable() not yet called"); 5784 5785 return _Module32First(hSnapshot, lpme); 5786} 5787 5788inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot, 5789 LPMODULEENTRY32 lpme) { 5790 assert(initialized && _Module32Next != NULL, 5791 "HelpToolsAvailable() not yet called"); 5792 5793 return _Module32Next(hSnapshot, lpme); 5794} 5795 5796 5797BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() { 5798 if (!initialized) { 5799 initialize(); 5800 } 5801 return _GetNativeSystemInfo != NULL; 5802} 5803 5804void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) { 5805 assert(initialized && _GetNativeSystemInfo != NULL, 5806 "GetNativeSystemInfoAvailable() not yet called"); 5807 5808 _GetNativeSystemInfo(lpSystemInfo); 5809} 5810 5811// PSAPI API 5812 5813 5814typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD); 5815typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD); 5816typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD); 5817 5818EnumProcessModules_Fn os::PSApiDll::_EnumProcessModules = NULL; 5819GetModuleFileNameEx_Fn os::PSApiDll::_GetModuleFileNameEx = NULL; 5820GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL; 5821BOOL os::PSApiDll::initialized = FALSE; 5822 5823void os::PSApiDll::initialize() { 5824 if (!initialized) { 5825 HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0); 5826 if (handle != NULL) { 5827 _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle, 5828 "EnumProcessModules"); 5829 _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle, 5830 "GetModuleFileNameExA"); 5831 _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle, 5832 "GetModuleInformation"); 5833 } 5834 initialized = TRUE; 5835 } 5836} 5837 5838 5839 5840BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, 5841 DWORD cb, LPDWORD lpcbNeeded) { 5842 assert(initialized && _EnumProcessModules != NULL, 5843 "PSApiAvailable() not yet called"); 5844 return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded); 5845} 5846 5847DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, 5848 LPTSTR lpFilename, DWORD nSize) { 5849 assert(initialized && _GetModuleFileNameEx != NULL, 5850 "PSApiAvailable() not yet called"); 5851 return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize); 5852} 5853 5854BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, 5855 LPMODULEINFO lpmodinfo, DWORD cb) { 5856 assert(initialized && _GetModuleInformation != NULL, 5857 "PSApiAvailable() not yet called"); 5858 return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb); 5859} 5860 5861BOOL os::PSApiDll::PSApiAvailable() { 5862 if (!initialized) { 5863 initialize(); 5864 } 5865 return _EnumProcessModules != NULL && 5866 _GetModuleFileNameEx != NULL && 5867 _GetModuleInformation != NULL; 5868} 5869 5870 5871// WinSock2 API 5872typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA); 5873typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...); 5874 5875WSAStartup_Fn os::WinSock2Dll::_WSAStartup = NULL; 5876gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL; 5877BOOL os::WinSock2Dll::initialized = FALSE; 5878 5879void os::WinSock2Dll::initialize() { 5880 if (!initialized) { 5881 HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0); 5882 if (handle != NULL) { 5883 _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup"); 5884 _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname"); 5885 } 5886 initialized = TRUE; 5887 } 5888} 5889 5890 5891BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) { 5892 assert(initialized && _WSAStartup != NULL, 5893 "WinSock2Available() not yet called"); 5894 return _WSAStartup(wVersionRequested, lpWSAData); 5895} 5896 5897struct hostent* os::WinSock2Dll::gethostbyname(const char *name) { 5898 assert(initialized && _gethostbyname != NULL, 5899 "WinSock2Available() not yet called"); 5900 return _gethostbyname(name); 5901} 5902 5903BOOL os::WinSock2Dll::WinSock2Available() { 5904 if (!initialized) { 5905 initialize(); 5906 } 5907 return _WSAStartup != NULL && 5908 _gethostbyname != NULL; 5909} 5910 5911typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); 5912typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE); 5913typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID); 5914 5915AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL; 5916OpenProcessToken_Fn os::Advapi32Dll::_OpenProcessToken = NULL; 5917LookupPrivilegeValue_Fn os::Advapi32Dll::_LookupPrivilegeValue = NULL; 5918BOOL os::Advapi32Dll::initialized = FALSE; 5919 5920void os::Advapi32Dll::initialize() { 5921 if (!initialized) { 5922 HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0); 5923 if (handle != NULL) { 5924 _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle, 5925 "AdjustTokenPrivileges"); 5926 _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle, 5927 "OpenProcessToken"); 5928 _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle, 5929 "LookupPrivilegeValueA"); 5930 } 5931 initialized = TRUE; 5932 } 5933} 5934 5935BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle, 5936 BOOL DisableAllPrivileges, 5937 PTOKEN_PRIVILEGES NewState, 5938 DWORD BufferLength, 5939 PTOKEN_PRIVILEGES PreviousState, 5940 PDWORD ReturnLength) { 5941 assert(initialized && _AdjustTokenPrivileges != NULL, 5942 "AdvapiAvailable() not yet called"); 5943 return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState, 5944 BufferLength, PreviousState, ReturnLength); 5945} 5946 5947BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, 5948 DWORD DesiredAccess, 5949 PHANDLE TokenHandle) { 5950 assert(initialized && _OpenProcessToken != NULL, 5951 "AdvapiAvailable() not yet called"); 5952 return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle); 5953} 5954 5955BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, 5956 LPCTSTR lpName, PLUID lpLuid) { 5957 assert(initialized && _LookupPrivilegeValue != NULL, 5958 "AdvapiAvailable() not yet called"); 5959 return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid); 5960} 5961 5962BOOL os::Advapi32Dll::AdvapiAvailable() { 5963 if (!initialized) { 5964 initialize(); 5965 } 5966 return _AdjustTokenPrivileges != NULL && 5967 _OpenProcessToken != NULL && 5968 _LookupPrivilegeValue != NULL; 5969} 5970 5971#endif 5972 5973#ifndef PRODUCT 5974 5975// test the code path in reserve_memory_special() that tries to allocate memory in a single 5976// contiguous memory block at a particular address. 5977// The test first tries to find a good approximate address to allocate at by using the same 5978// method to allocate some memory at any address. The test then tries to allocate memory in 5979// the vicinity (not directly after it to avoid possible by-chance use of that location) 5980// This is of course only some dodgy assumption, there is no guarantee that the vicinity of 5981// the previously allocated memory is available for allocation. The only actual failure 5982// that is reported is when the test tries to allocate at a particular location but gets a 5983// different valid one. A NULL return value at this point is not considered an error but may 5984// be legitimate. 5985// If -XX:+VerboseInternalVMTests is enabled, print some explanatory messages. 5986void TestReserveMemorySpecial_test() { 5987 if (!UseLargePages) { 5988 if (VerboseInternalVMTests) { 5989 gclog_or_tty->print("Skipping test because large pages are disabled"); 5990 } 5991 return; 5992 } 5993 // save current value of globals 5994 bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation; 5995 bool old_use_numa_interleaving = UseNUMAInterleaving; 5996 5997 // set globals to make sure we hit the correct code path 5998 UseLargePagesIndividualAllocation = UseNUMAInterleaving = false; 5999 6000 // do an allocation at an address selected by the OS to get a good one. 6001 const size_t large_allocation_size = os::large_page_size() * 4; 6002 char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false); 6003 if (result == NULL) { 6004 if (VerboseInternalVMTests) { 6005 gclog_or_tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.", 6006 large_allocation_size); 6007 } 6008 } else { 6009 os::release_memory_special(result, large_allocation_size); 6010 6011 // allocate another page within the recently allocated memory area which seems to be a good location. At least 6012 // we managed to get it once. 6013 const size_t expected_allocation_size = os::large_page_size(); 6014 char* expected_location = result + os::large_page_size(); 6015 char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false); 6016 if (actual_location == NULL) { 6017 if (VerboseInternalVMTests) { 6018 gclog_or_tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.", 6019 expected_location, large_allocation_size); 6020 } 6021 } else { 6022 // release memory 6023 os::release_memory_special(actual_location, expected_allocation_size); 6024 // only now check, after releasing any memory to avoid any leaks. 6025 assert(actual_location == expected_location, 6026 "Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead", 6027 expected_location, expected_allocation_size, actual_location); 6028 } 6029 } 6030 6031 // restore globals 6032 UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation; 6033 UseNUMAInterleaving = old_use_numa_interleaving; 6034} 6035#endif // PRODUCT 6036 6037/* 6038 All the defined signal names for Windows. 6039 6040 NOTE that not all of these names are accepted by FindSignal! 6041 6042 For various reasons some of these may be rejected at runtime. 6043 6044 Here are the names currently accepted by a user of sun.misc.Signal with 6045 1.4.1 (ignoring potential interaction with use of chaining, etc): 6046 6047 (LIST TBD) 6048 6049*/ 6050int os::get_signal_number(const char* name) { 6051 static const struct { 6052 char* name; 6053 int number; 6054 } siglabels [] = 6055 // derived from version 6.0 VC98/include/signal.h 6056 {"ABRT", SIGABRT, // abnormal termination triggered by abort cl 6057 "FPE", SIGFPE, // floating point exception 6058 "SEGV", SIGSEGV, // segment violation 6059 "INT", SIGINT, // interrupt 6060 "TERM", SIGTERM, // software term signal from kill 6061 "BREAK", SIGBREAK, // Ctrl-Break sequence 6062 "ILL", SIGILL}; // illegal instruction 6063 for(int i=0;i<sizeof(siglabels)/sizeof(struct siglabel);i++) 6064 if(!strcmp(name, siglabels[i].name)) 6065 return siglabels[i].number; 6066 return -1; 6067} 6068 6069