os_windows.cpp revision 1929:2d4762ec74af
1/* 2 * Copyright (c) 1997, 2010, 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#ifdef _WIN64 26// Must be at least Windows 2000 or XP to use VectoredExceptions 27#define _WIN32_WINNT 0x500 28#endif 29 30// no precompiled headers 31#include "classfile/classLoader.hpp" 32#include "classfile/systemDictionary.hpp" 33#include "classfile/vmSymbols.hpp" 34#include "code/icBuffer.hpp" 35#include "code/vtableStubs.hpp" 36#include "compiler/compileBroker.hpp" 37#include "interpreter/interpreter.hpp" 38#include "jvm_windows.h" 39#include "memory/allocation.inline.hpp" 40#include "memory/filemap.hpp" 41#include "mutex_windows.inline.hpp" 42#include "oops/oop.inline.hpp" 43#include "os_share_windows.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/extendedPC.hpp" 49#include "runtime/globals.hpp" 50#include "runtime/hpi.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/osThread.hpp" 57#include "runtime/perfMemory.hpp" 58#include "runtime/sharedRuntime.hpp" 59#include "runtime/statSampler.hpp" 60#include "runtime/stubRoutines.hpp" 61#include "runtime/threadCritical.hpp" 62#include "runtime/timer.hpp" 63#include "services/attachListener.hpp" 64#include "services/runtimeService.hpp" 65#include "thread_windows.inline.hpp" 66#include "utilities/decoder.hpp" 67#include "utilities/defaultStream.hpp" 68#include "utilities/events.hpp" 69#include "utilities/growableArray.hpp" 70#include "utilities/vmError.hpp" 71#ifdef TARGET_ARCH_x86 72# include "assembler_x86.inline.hpp" 73# include "nativeInst_x86.hpp" 74#endif 75#ifdef COMPILER1 76#include "c1/c1_Runtime1.hpp" 77#endif 78#ifdef COMPILER2 79#include "opto/runtime.hpp" 80#endif 81 82#ifdef _DEBUG 83#include <crtdbg.h> 84#endif 85 86 87#include <windows.h> 88#include <sys/types.h> 89#include <sys/stat.h> 90#include <sys/timeb.h> 91#include <objidl.h> 92#include <shlobj.h> 93 94#include <malloc.h> 95#include <signal.h> 96#include <direct.h> 97#include <errno.h> 98#include <fcntl.h> 99#include <io.h> 100#include <process.h> // For _beginthreadex(), _endthreadex() 101#include <imagehlp.h> // For os::dll_address_to_function_name 102 103/* for enumerating dll libraries */ 104#include <tlhelp32.h> 105#include <vdmdbg.h> 106 107// for timer info max values which include all bits 108#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF) 109 110// For DLL loading/load error detection 111// Values of PE COFF 112#define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c 113#define IMAGE_FILE_SIGNATURE_LENGTH 4 114 115static HANDLE main_process; 116static HANDLE main_thread; 117static int main_thread_id; 118 119static FILETIME process_creation_time; 120static FILETIME process_exit_time; 121static FILETIME process_user_time; 122static FILETIME process_kernel_time; 123 124#ifdef _WIN64 125PVOID topLevelVectoredExceptionHandler = NULL; 126#endif 127 128#ifdef _M_IA64 129#define __CPU__ ia64 130#elif _M_AMD64 131#define __CPU__ amd64 132#else 133#define __CPU__ i486 134#endif 135 136// save DLL module handle, used by GetModuleFileName 137 138HINSTANCE vm_lib_handle; 139static int getLastErrorString(char *buf, size_t len); 140 141BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) { 142 switch (reason) { 143 case DLL_PROCESS_ATTACH: 144 vm_lib_handle = hinst; 145 if(ForceTimeHighResolution) 146 timeBeginPeriod(1L); 147 break; 148 case DLL_PROCESS_DETACH: 149 if(ForceTimeHighResolution) 150 timeEndPeriod(1L); 151#ifdef _WIN64 152 if (topLevelVectoredExceptionHandler != NULL) { 153 RemoveVectoredExceptionHandler(topLevelVectoredExceptionHandler); 154 topLevelVectoredExceptionHandler = NULL; 155 } 156#endif 157 break; 158 default: 159 break; 160 } 161 return true; 162} 163 164static inline double fileTimeAsDouble(FILETIME* time) { 165 const double high = (double) ((unsigned int) ~0); 166 const double split = 10000000.0; 167 double result = (time->dwLowDateTime / split) + 168 time->dwHighDateTime * (high/split); 169 return result; 170} 171 172// Implementation of os 173 174bool os::getenv(const char* name, char* buffer, int len) { 175 int result = GetEnvironmentVariable(name, buffer, len); 176 return result > 0 && result < len; 177} 178 179 180// No setuid programs under Windows. 181bool os::have_special_privileges() { 182 return false; 183} 184 185 186// This method is a periodic task to check for misbehaving JNI applications 187// under CheckJNI, we can add any periodic checks here. 188// For Windows at the moment does nothing 189void os::run_periodic_checks() { 190 return; 191} 192 193#ifndef _WIN64 194// previous UnhandledExceptionFilter, if there is one 195static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL; 196 197LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo); 198#endif 199void os::init_system_properties_values() { 200 /* sysclasspath, java_home, dll_dir */ 201 { 202 char *home_path; 203 char *dll_path; 204 char *pslash; 205 char *bin = "\\bin"; 206 char home_dir[MAX_PATH]; 207 208 if (!getenv("_ALT_JAVA_HOME_DIR", home_dir, MAX_PATH)) { 209 os::jvm_path(home_dir, sizeof(home_dir)); 210 // Found the full path to jvm[_g].dll. 211 // Now cut the path to <java_home>/jre if we can. 212 *(strrchr(home_dir, '\\')) = '\0'; /* get rid of \jvm.dll */ 213 pslash = strrchr(home_dir, '\\'); 214 if (pslash != NULL) { 215 *pslash = '\0'; /* get rid of \{client|server} */ 216 pslash = strrchr(home_dir, '\\'); 217 if (pslash != NULL) 218 *pslash = '\0'; /* get rid of \bin */ 219 } 220 } 221 222 home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1); 223 if (home_path == NULL) 224 return; 225 strcpy(home_path, home_dir); 226 Arguments::set_java_home(home_path); 227 228 dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1); 229 if (dll_path == NULL) 230 return; 231 strcpy(dll_path, home_dir); 232 strcat(dll_path, bin); 233 Arguments::set_dll_dir(dll_path); 234 235 if (!set_boot_path('\\', ';')) 236 return; 237 } 238 239 /* library_path */ 240 #define EXT_DIR "\\lib\\ext" 241 #define BIN_DIR "\\bin" 242 #define PACKAGE_DIR "\\Sun\\Java" 243 { 244 /* Win32 library search order (See the documentation for LoadLibrary): 245 * 246 * 1. The directory from which application is loaded. 247 * 2. The current directory 248 * 3. The system wide Java Extensions directory (Java only) 249 * 4. System directory (GetSystemDirectory) 250 * 5. Windows directory (GetWindowsDirectory) 251 * 6. The PATH environment variable 252 */ 253 254 char *library_path; 255 char tmp[MAX_PATH]; 256 char *path_str = ::getenv("PATH"); 257 258 library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) + 259 sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10); 260 261 library_path[0] = '\0'; 262 263 GetModuleFileName(NULL, tmp, sizeof(tmp)); 264 *(strrchr(tmp, '\\')) = '\0'; 265 strcat(library_path, tmp); 266 267 strcat(library_path, ";."); 268 269 GetWindowsDirectory(tmp, sizeof(tmp)); 270 strcat(library_path, ";"); 271 strcat(library_path, tmp); 272 strcat(library_path, PACKAGE_DIR BIN_DIR); 273 274 GetSystemDirectory(tmp, sizeof(tmp)); 275 strcat(library_path, ";"); 276 strcat(library_path, tmp); 277 278 GetWindowsDirectory(tmp, sizeof(tmp)); 279 strcat(library_path, ";"); 280 strcat(library_path, tmp); 281 282 if (path_str) { 283 strcat(library_path, ";"); 284 strcat(library_path, path_str); 285 } 286 287 Arguments::set_library_path(library_path); 288 FREE_C_HEAP_ARRAY(char, library_path); 289 } 290 291 /* Default extensions directory */ 292 { 293 char path[MAX_PATH]; 294 char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1]; 295 GetWindowsDirectory(path, MAX_PATH); 296 sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR, 297 path, PACKAGE_DIR, EXT_DIR); 298 Arguments::set_ext_dirs(buf); 299 } 300 #undef EXT_DIR 301 #undef BIN_DIR 302 #undef PACKAGE_DIR 303 304 /* Default endorsed standards directory. */ 305 { 306 #define ENDORSED_DIR "\\lib\\endorsed" 307 size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR); 308 char * buf = NEW_C_HEAP_ARRAY(char, len); 309 sprintf(buf, "%s%s", Arguments::get_java_home(), ENDORSED_DIR); 310 Arguments::set_endorsed_dirs(buf); 311 #undef ENDORSED_DIR 312 } 313 314#ifndef _WIN64 315 // set our UnhandledExceptionFilter and save any previous one 316 prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception); 317#endif 318 319 // Done 320 return; 321} 322 323void os::breakpoint() { 324 DebugBreak(); 325} 326 327// Invoked from the BREAKPOINT Macro 328extern "C" void breakpoint() { 329 os::breakpoint(); 330} 331 332// Returns an estimate of the current stack pointer. Result must be guaranteed 333// to point into the calling threads stack, and be no lower than the current 334// stack pointer. 335 336address os::current_stack_pointer() { 337 int dummy; 338 address sp = (address)&dummy; 339 return sp; 340} 341 342// os::current_stack_base() 343// 344// Returns the base of the stack, which is the stack's 345// starting address. This function must be called 346// while running on the stack of the thread being queried. 347 348address os::current_stack_base() { 349 MEMORY_BASIC_INFORMATION minfo; 350 address stack_bottom; 351 size_t stack_size; 352 353 VirtualQuery(&minfo, &minfo, sizeof(minfo)); 354 stack_bottom = (address)minfo.AllocationBase; 355 stack_size = minfo.RegionSize; 356 357 // Add up the sizes of all the regions with the same 358 // AllocationBase. 359 while( 1 ) 360 { 361 VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo)); 362 if ( stack_bottom == (address)minfo.AllocationBase ) 363 stack_size += minfo.RegionSize; 364 else 365 break; 366 } 367 368#ifdef _M_IA64 369 // IA64 has memory and register stacks 370 stack_size = stack_size / 2; 371#endif 372 return stack_bottom + stack_size; 373} 374 375size_t os::current_stack_size() { 376 size_t sz; 377 MEMORY_BASIC_INFORMATION minfo; 378 VirtualQuery(&minfo, &minfo, sizeof(minfo)); 379 sz = (size_t)os::current_stack_base() - (size_t)minfo.AllocationBase; 380 return sz; 381} 382 383struct tm* os::localtime_pd(const time_t* clock, struct tm* res) { 384 const struct tm* time_struct_ptr = localtime(clock); 385 if (time_struct_ptr != NULL) { 386 *res = *time_struct_ptr; 387 return res; 388 } 389 return NULL; 390} 391 392LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo); 393 394// Thread start routine for all new Java threads 395static unsigned __stdcall java_start(Thread* thread) { 396 // Try to randomize the cache line index of hot stack frames. 397 // This helps when threads of the same stack traces evict each other's 398 // cache lines. The threads can be either from the same JVM instance, or 399 // from different JVM instances. The benefit is especially true for 400 // processors with hyperthreading technology. 401 static int counter = 0; 402 int pid = os::current_process_id(); 403 _alloca(((pid ^ counter++) & 7) * 128); 404 405 OSThread* osthr = thread->osthread(); 406 assert(osthr->get_state() == RUNNABLE, "invalid os thread state"); 407 408 if (UseNUMA) { 409 int lgrp_id = os::numa_get_group_id(); 410 if (lgrp_id != -1) { 411 thread->set_lgrp_id(lgrp_id); 412 } 413 } 414 415 416 if (UseVectoredExceptions) { 417 // If we are using vectored exception we don't need to set a SEH 418 thread->run(); 419 } 420 else { 421 // Install a win32 structured exception handler around every thread created 422 // by VM, so VM can genrate error dump when an exception occurred in non- 423 // Java thread (e.g. VM thread). 424 __try { 425 thread->run(); 426 } __except(topLevelExceptionFilter( 427 (_EXCEPTION_POINTERS*)_exception_info())) { 428 // Nothing to do. 429 } 430 } 431 432 // One less thread is executing 433 // When the VMThread gets here, the main thread may have already exited 434 // which frees the CodeHeap containing the Atomic::add code 435 if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) { 436 Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count); 437 } 438 439 return 0; 440} 441 442static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle, int thread_id) { 443 // Allocate the OSThread object 444 OSThread* osthread = new OSThread(NULL, NULL); 445 if (osthread == NULL) return NULL; 446 447 // Initialize support for Java interrupts 448 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL); 449 if (interrupt_event == NULL) { 450 delete osthread; 451 return NULL; 452 } 453 osthread->set_interrupt_event(interrupt_event); 454 455 // Store info on the Win32 thread into the OSThread 456 osthread->set_thread_handle(thread_handle); 457 osthread->set_thread_id(thread_id); 458 459 if (UseNUMA) { 460 int lgrp_id = os::numa_get_group_id(); 461 if (lgrp_id != -1) { 462 thread->set_lgrp_id(lgrp_id); 463 } 464 } 465 466 // Initial thread state is INITIALIZED, not SUSPENDED 467 osthread->set_state(INITIALIZED); 468 469 return osthread; 470} 471 472 473bool os::create_attached_thread(JavaThread* thread) { 474#ifdef ASSERT 475 thread->verify_not_published(); 476#endif 477 HANDLE thread_h; 478 if (!DuplicateHandle(main_process, GetCurrentThread(), GetCurrentProcess(), 479 &thread_h, THREAD_ALL_ACCESS, false, 0)) { 480 fatal("DuplicateHandle failed\n"); 481 } 482 OSThread* osthread = create_os_thread(thread, thread_h, 483 (int)current_thread_id()); 484 if (osthread == NULL) { 485 return false; 486 } 487 488 // Initial thread state is RUNNABLE 489 osthread->set_state(RUNNABLE); 490 491 thread->set_osthread(osthread); 492 return true; 493} 494 495bool os::create_main_thread(JavaThread* thread) { 496#ifdef ASSERT 497 thread->verify_not_published(); 498#endif 499 if (_starting_thread == NULL) { 500 _starting_thread = create_os_thread(thread, main_thread, main_thread_id); 501 if (_starting_thread == NULL) { 502 return false; 503 } 504 } 505 506 // The primordial thread is runnable from the start) 507 _starting_thread->set_state(RUNNABLE); 508 509 thread->set_osthread(_starting_thread); 510 return true; 511} 512 513// Allocate and initialize a new OSThread 514bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) { 515 unsigned thread_id; 516 517 // Allocate the OSThread object 518 OSThread* osthread = new OSThread(NULL, NULL); 519 if (osthread == NULL) { 520 return false; 521 } 522 523 // Initialize support for Java interrupts 524 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL); 525 if (interrupt_event == NULL) { 526 delete osthread; 527 return NULL; 528 } 529 osthread->set_interrupt_event(interrupt_event); 530 osthread->set_interrupted(false); 531 532 thread->set_osthread(osthread); 533 534 if (stack_size == 0) { 535 switch (thr_type) { 536 case os::java_thread: 537 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss 538 if (JavaThread::stack_size_at_create() > 0) 539 stack_size = JavaThread::stack_size_at_create(); 540 break; 541 case os::compiler_thread: 542 if (CompilerThreadStackSize > 0) { 543 stack_size = (size_t)(CompilerThreadStackSize * K); 544 break; 545 } // else fall through: 546 // use VMThreadStackSize if CompilerThreadStackSize is not defined 547 case os::vm_thread: 548 case os::pgc_thread: 549 case os::cgc_thread: 550 case os::watcher_thread: 551 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K); 552 break; 553 } 554 } 555 556 // Create the Win32 thread 557 // 558 // Contrary to what MSDN document says, "stack_size" in _beginthreadex() 559 // does not specify stack size. Instead, it specifies the size of 560 // initially committed space. The stack size is determined by 561 // PE header in the executable. If the committed "stack_size" is larger 562 // than default value in the PE header, the stack is rounded up to the 563 // nearest multiple of 1MB. For example if the launcher has default 564 // stack size of 320k, specifying any size less than 320k does not 565 // affect the actual stack size at all, it only affects the initial 566 // commitment. On the other hand, specifying 'stack_size' larger than 567 // default value may cause significant increase in memory usage, because 568 // not only the stack space will be rounded up to MB, but also the 569 // entire space is committed upfront. 570 // 571 // Finally Windows XP added a new flag 'STACK_SIZE_PARAM_IS_A_RESERVATION' 572 // for CreateThread() that can treat 'stack_size' as stack size. However we 573 // are not supposed to call CreateThread() directly according to MSDN 574 // document because JVM uses C runtime library. The good news is that the 575 // flag appears to work with _beginthredex() as well. 576 577#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION 578#define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000) 579#endif 580 581 HANDLE thread_handle = 582 (HANDLE)_beginthreadex(NULL, 583 (unsigned)stack_size, 584 (unsigned (__stdcall *)(void*)) java_start, 585 thread, 586 CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION, 587 &thread_id); 588 if (thread_handle == NULL) { 589 // perhaps STACK_SIZE_PARAM_IS_A_RESERVATION is not supported, try again 590 // without the flag. 591 thread_handle = 592 (HANDLE)_beginthreadex(NULL, 593 (unsigned)stack_size, 594 (unsigned (__stdcall *)(void*)) java_start, 595 thread, 596 CREATE_SUSPENDED, 597 &thread_id); 598 } 599 if (thread_handle == NULL) { 600 // Need to clean up stuff we've allocated so far 601 CloseHandle(osthread->interrupt_event()); 602 thread->set_osthread(NULL); 603 delete osthread; 604 return NULL; 605 } 606 607 Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count); 608 609 // Store info on the Win32 thread into the OSThread 610 osthread->set_thread_handle(thread_handle); 611 osthread->set_thread_id(thread_id); 612 613 // Initial thread state is INITIALIZED, not SUSPENDED 614 osthread->set_state(INITIALIZED); 615 616 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain 617 return true; 618} 619 620 621// Free Win32 resources related to the OSThread 622void os::free_thread(OSThread* osthread) { 623 assert(osthread != NULL, "osthread not set"); 624 CloseHandle(osthread->thread_handle()); 625 CloseHandle(osthread->interrupt_event()); 626 delete osthread; 627} 628 629 630static int has_performance_count = 0; 631static jlong first_filetime; 632static jlong initial_performance_count; 633static jlong performance_frequency; 634 635 636jlong as_long(LARGE_INTEGER x) { 637 jlong result = 0; // initialization to avoid warning 638 set_high(&result, x.HighPart); 639 set_low(&result, x.LowPart); 640 return result; 641} 642 643 644jlong os::elapsed_counter() { 645 LARGE_INTEGER count; 646 if (has_performance_count) { 647 QueryPerformanceCounter(&count); 648 return as_long(count) - initial_performance_count; 649 } else { 650 FILETIME wt; 651 GetSystemTimeAsFileTime(&wt); 652 return (jlong_from(wt.dwHighDateTime, wt.dwLowDateTime) - first_filetime); 653 } 654} 655 656 657jlong os::elapsed_frequency() { 658 if (has_performance_count) { 659 return performance_frequency; 660 } else { 661 // the FILETIME time is the number of 100-nanosecond intervals since January 1,1601. 662 return 10000000; 663 } 664} 665 666 667julong os::available_memory() { 668 return win32::available_memory(); 669} 670 671julong os::win32::available_memory() { 672 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect 673 // value if total memory is larger than 4GB 674 MEMORYSTATUSEX ms; 675 ms.dwLength = sizeof(ms); 676 GlobalMemoryStatusEx(&ms); 677 678 return (julong)ms.ullAvailPhys; 679} 680 681julong os::physical_memory() { 682 return win32::physical_memory(); 683} 684 685julong os::allocatable_physical_memory(julong size) { 686#ifdef _LP64 687 return size; 688#else 689 // Limit to 1400m because of the 2gb address space wall 690 return MIN2(size, (julong)1400*M); 691#endif 692} 693 694// VC6 lacks DWORD_PTR 695#if _MSC_VER < 1300 696typedef UINT_PTR DWORD_PTR; 697#endif 698 699int os::active_processor_count() { 700 DWORD_PTR lpProcessAffinityMask = 0; 701 DWORD_PTR lpSystemAffinityMask = 0; 702 int proc_count = processor_count(); 703 if (proc_count <= sizeof(UINT_PTR) * BitsPerByte && 704 GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) { 705 // Nof active processors is number of bits in process affinity mask 706 int bitcount = 0; 707 while (lpProcessAffinityMask != 0) { 708 lpProcessAffinityMask = lpProcessAffinityMask & (lpProcessAffinityMask-1); 709 bitcount++; 710 } 711 return bitcount; 712 } else { 713 return proc_count; 714 } 715} 716 717bool os::distribute_processes(uint length, uint* distribution) { 718 // Not yet implemented. 719 return false; 720} 721 722bool os::bind_to_processor(uint processor_id) { 723 // Not yet implemented. 724 return false; 725} 726 727static void initialize_performance_counter() { 728 LARGE_INTEGER count; 729 if (QueryPerformanceFrequency(&count)) { 730 has_performance_count = 1; 731 performance_frequency = as_long(count); 732 QueryPerformanceCounter(&count); 733 initial_performance_count = as_long(count); 734 } else { 735 has_performance_count = 0; 736 FILETIME wt; 737 GetSystemTimeAsFileTime(&wt); 738 first_filetime = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime); 739 } 740} 741 742 743double os::elapsedTime() { 744 return (double) elapsed_counter() / (double) elapsed_frequency(); 745} 746 747 748// Windows format: 749// The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601. 750// Java format: 751// Java standards require the number of milliseconds since 1/1/1970 752 753// Constant offset - calculated using offset() 754static jlong _offset = 116444736000000000; 755// Fake time counter for reproducible results when debugging 756static jlong fake_time = 0; 757 758#ifdef ASSERT 759// Just to be safe, recalculate the offset in debug mode 760static jlong _calculated_offset = 0; 761static int _has_calculated_offset = 0; 762 763jlong offset() { 764 if (_has_calculated_offset) return _calculated_offset; 765 SYSTEMTIME java_origin; 766 java_origin.wYear = 1970; 767 java_origin.wMonth = 1; 768 java_origin.wDayOfWeek = 0; // ignored 769 java_origin.wDay = 1; 770 java_origin.wHour = 0; 771 java_origin.wMinute = 0; 772 java_origin.wSecond = 0; 773 java_origin.wMilliseconds = 0; 774 FILETIME jot; 775 if (!SystemTimeToFileTime(&java_origin, &jot)) { 776 fatal(err_msg("Error = %d\nWindows error", GetLastError())); 777 } 778 _calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime); 779 _has_calculated_offset = 1; 780 assert(_calculated_offset == _offset, "Calculated and constant time offsets must be equal"); 781 return _calculated_offset; 782} 783#else 784jlong offset() { 785 return _offset; 786} 787#endif 788 789jlong windows_to_java_time(FILETIME wt) { 790 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime); 791 return (a - offset()) / 10000; 792} 793 794FILETIME java_to_windows_time(jlong l) { 795 jlong a = (l * 10000) + offset(); 796 FILETIME result; 797 result.dwHighDateTime = high(a); 798 result.dwLowDateTime = low(a); 799 return result; 800} 801 802// For now, we say that Windows does not support vtime. I have no idea 803// whether it can actually be made to (DLD, 9/13/05). 804 805bool os::supports_vtime() { return false; } 806bool os::enable_vtime() { return false; } 807bool os::vtime_enabled() { return false; } 808double os::elapsedVTime() { 809 // better than nothing, but not much 810 return elapsedTime(); 811} 812 813jlong os::javaTimeMillis() { 814 if (UseFakeTimers) { 815 return fake_time++; 816 } else { 817 FILETIME wt; 818 GetSystemTimeAsFileTime(&wt); 819 return windows_to_java_time(wt); 820 } 821} 822 823#define NANOS_PER_SEC CONST64(1000000000) 824#define NANOS_PER_MILLISEC 1000000 825jlong os::javaTimeNanos() { 826 if (!has_performance_count) { 827 return javaTimeMillis() * NANOS_PER_MILLISEC; // the best we can do. 828 } else { 829 LARGE_INTEGER current_count; 830 QueryPerformanceCounter(¤t_count); 831 double current = as_long(current_count); 832 double freq = performance_frequency; 833 jlong time = (jlong)((current/freq) * NANOS_PER_SEC); 834 return time; 835 } 836} 837 838void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) { 839 if (!has_performance_count) { 840 // javaTimeMillis() doesn't have much percision, 841 // but it is not going to wrap -- so all 64 bits 842 info_ptr->max_value = ALL_64_BITS; 843 844 // this is a wall clock timer, so may skip 845 info_ptr->may_skip_backward = true; 846 info_ptr->may_skip_forward = true; 847 } else { 848 jlong freq = performance_frequency; 849 if (freq < NANOS_PER_SEC) { 850 // the performance counter is 64 bits and we will 851 // be multiplying it -- so no wrap in 64 bits 852 info_ptr->max_value = ALL_64_BITS; 853 } else if (freq > NANOS_PER_SEC) { 854 // use the max value the counter can reach to 855 // determine the max value which could be returned 856 julong max_counter = (julong)ALL_64_BITS; 857 info_ptr->max_value = (jlong)(max_counter / (freq / NANOS_PER_SEC)); 858 } else { 859 // the performance counter is 64 bits and we will 860 // be using it directly -- so no wrap in 64 bits 861 info_ptr->max_value = ALL_64_BITS; 862 } 863 864 // using a counter, so no skipping 865 info_ptr->may_skip_backward = false; 866 info_ptr->may_skip_forward = false; 867 } 868 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time 869} 870 871char* os::local_time_string(char *buf, size_t buflen) { 872 SYSTEMTIME st; 873 GetLocalTime(&st); 874 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d", 875 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); 876 return buf; 877} 878 879bool os::getTimesSecs(double* process_real_time, 880 double* process_user_time, 881 double* process_system_time) { 882 HANDLE h_process = GetCurrentProcess(); 883 FILETIME create_time, exit_time, kernel_time, user_time; 884 BOOL result = GetProcessTimes(h_process, 885 &create_time, 886 &exit_time, 887 &kernel_time, 888 &user_time); 889 if (result != 0) { 890 FILETIME wt; 891 GetSystemTimeAsFileTime(&wt); 892 jlong rtc_millis = windows_to_java_time(wt); 893 jlong user_millis = windows_to_java_time(user_time); 894 jlong system_millis = windows_to_java_time(kernel_time); 895 *process_real_time = ((double) rtc_millis) / ((double) MILLIUNITS); 896 *process_user_time = ((double) user_millis) / ((double) MILLIUNITS); 897 *process_system_time = ((double) system_millis) / ((double) MILLIUNITS); 898 return true; 899 } else { 900 return false; 901 } 902} 903 904void os::shutdown() { 905 906 // allow PerfMemory to attempt cleanup of any persistent resources 907 perfMemory_exit(); 908 909 // flush buffered output, finish log files 910 ostream_abort(); 911 912 // Check for abort hook 913 abort_hook_t abort_hook = Arguments::abort_hook(); 914 if (abort_hook != NULL) { 915 abort_hook(); 916 } 917} 918 919void os::abort(bool dump_core) 920{ 921 os::shutdown(); 922 // no core dump on Windows 923 ::exit(1); 924} 925 926// Die immediately, no exit hook, no abort hook, no cleanup. 927void os::die() { 928 _exit(-1); 929} 930 931// Directory routines copied from src/win32/native/java/io/dirent_md.c 932// * dirent_md.c 1.15 00/02/02 933// 934// The declarations for DIR and struct dirent are in jvm_win32.h. 935 936/* Caller must have already run dirname through JVM_NativePath, which removes 937 duplicate slashes and converts all instances of '/' into '\\'. */ 938 939DIR * 940os::opendir(const char *dirname) 941{ 942 assert(dirname != NULL, "just checking"); // hotspot change 943 DIR *dirp = (DIR *)malloc(sizeof(DIR)); 944 DWORD fattr; // hotspot change 945 char alt_dirname[4] = { 0, 0, 0, 0 }; 946 947 if (dirp == 0) { 948 errno = ENOMEM; 949 return 0; 950 } 951 952 /* 953 * Win32 accepts "\" in its POSIX stat(), but refuses to treat it 954 * as a directory in FindFirstFile(). We detect this case here and 955 * prepend the current drive name. 956 */ 957 if (dirname[1] == '\0' && dirname[0] == '\\') { 958 alt_dirname[0] = _getdrive() + 'A' - 1; 959 alt_dirname[1] = ':'; 960 alt_dirname[2] = '\\'; 961 alt_dirname[3] = '\0'; 962 dirname = alt_dirname; 963 } 964 965 dirp->path = (char *)malloc(strlen(dirname) + 5); 966 if (dirp->path == 0) { 967 free(dirp); 968 errno = ENOMEM; 969 return 0; 970 } 971 strcpy(dirp->path, dirname); 972 973 fattr = GetFileAttributes(dirp->path); 974 if (fattr == 0xffffffff) { 975 free(dirp->path); 976 free(dirp); 977 errno = ENOENT; 978 return 0; 979 } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) { 980 free(dirp->path); 981 free(dirp); 982 errno = ENOTDIR; 983 return 0; 984 } 985 986 /* Append "*.*", or possibly "\\*.*", to path */ 987 if (dirp->path[1] == ':' 988 && (dirp->path[2] == '\0' 989 || (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) { 990 /* No '\\' needed for cases like "Z:" or "Z:\" */ 991 strcat(dirp->path, "*.*"); 992 } else { 993 strcat(dirp->path, "\\*.*"); 994 } 995 996 dirp->handle = FindFirstFile(dirp->path, &dirp->find_data); 997 if (dirp->handle == INVALID_HANDLE_VALUE) { 998 if (GetLastError() != ERROR_FILE_NOT_FOUND) { 999 free(dirp->path); 1000 free(dirp); 1001 errno = EACCES; 1002 return 0; 1003 } 1004 } 1005 return dirp; 1006} 1007 1008/* parameter dbuf unused on Windows */ 1009 1010struct dirent * 1011os::readdir(DIR *dirp, dirent *dbuf) 1012{ 1013 assert(dirp != NULL, "just checking"); // hotspot change 1014 if (dirp->handle == INVALID_HANDLE_VALUE) { 1015 return 0; 1016 } 1017 1018 strcpy(dirp->dirent.d_name, dirp->find_data.cFileName); 1019 1020 if (!FindNextFile(dirp->handle, &dirp->find_data)) { 1021 if (GetLastError() == ERROR_INVALID_HANDLE) { 1022 errno = EBADF; 1023 return 0; 1024 } 1025 FindClose(dirp->handle); 1026 dirp->handle = INVALID_HANDLE_VALUE; 1027 } 1028 1029 return &dirp->dirent; 1030} 1031 1032int 1033os::closedir(DIR *dirp) 1034{ 1035 assert(dirp != NULL, "just checking"); // hotspot change 1036 if (dirp->handle != INVALID_HANDLE_VALUE) { 1037 if (!FindClose(dirp->handle)) { 1038 errno = EBADF; 1039 return -1; 1040 } 1041 dirp->handle = INVALID_HANDLE_VALUE; 1042 } 1043 free(dirp->path); 1044 free(dirp); 1045 return 0; 1046} 1047 1048const char* os::dll_file_extension() { return ".dll"; } 1049 1050const char* os::get_temp_directory() { 1051 const char *prop = Arguments::get_property("java.io.tmpdir"); 1052 if (prop != 0) return prop; 1053 static char path_buf[MAX_PATH]; 1054 if (GetTempPath(MAX_PATH, path_buf)>0) 1055 return path_buf; 1056 else{ 1057 path_buf[0]='\0'; 1058 return path_buf; 1059 } 1060} 1061 1062static bool file_exists(const char* filename) { 1063 if (filename == NULL || strlen(filename) == 0) { 1064 return false; 1065 } 1066 return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES; 1067} 1068 1069void os::dll_build_name(char *buffer, size_t buflen, 1070 const char* pname, const char* fname) { 1071 // Copied from libhpi 1072 const size_t pnamelen = pname ? strlen(pname) : 0; 1073 const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0; 1074 1075 // Quietly truncates on buffer overflow. Should be an error. 1076 if (pnamelen + strlen(fname) + 10 > buflen) { 1077 *buffer = '\0'; 1078 return; 1079 } 1080 1081 if (pnamelen == 0) { 1082 jio_snprintf(buffer, buflen, "%s.dll", fname); 1083 } else if (c == ':' || c == '\\') { 1084 jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname); 1085 } else if (strchr(pname, *os::path_separator()) != NULL) { 1086 int n; 1087 char** pelements = split_path(pname, &n); 1088 for (int i = 0 ; i < n ; i++) { 1089 char* path = pelements[i]; 1090 // Really shouldn't be NULL, but check can't hurt 1091 size_t plen = (path == NULL) ? 0 : strlen(path); 1092 if (plen == 0) { 1093 continue; // skip the empty path values 1094 } 1095 const char lastchar = path[plen - 1]; 1096 if (lastchar == ':' || lastchar == '\\') { 1097 jio_snprintf(buffer, buflen, "%s%s.dll", path, fname); 1098 } else { 1099 jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname); 1100 } 1101 if (file_exists(buffer)) { 1102 break; 1103 } 1104 } 1105 // release the storage 1106 for (int i = 0 ; i < n ; i++) { 1107 if (pelements[i] != NULL) { 1108 FREE_C_HEAP_ARRAY(char, pelements[i]); 1109 } 1110 } 1111 if (pelements != NULL) { 1112 FREE_C_HEAP_ARRAY(char*, pelements); 1113 } 1114 } else { 1115 jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname); 1116 } 1117} 1118 1119// Needs to be in os specific directory because windows requires another 1120// header file <direct.h> 1121const char* os::get_current_directory(char *buf, int buflen) { 1122 return _getcwd(buf, buflen); 1123} 1124 1125//----------------------------------------------------------- 1126// Helper functions for fatal error handler 1127 1128// The following library functions are resolved dynamically at runtime: 1129 1130// PSAPI functions, for Windows NT, 2000, XP 1131 1132// psapi.h doesn't come with Visual Studio 6; it can be downloaded as Platform 1133// SDK from Microsoft. Here are the definitions copied from psapi.h 1134typedef struct _MODULEINFO { 1135 LPVOID lpBaseOfDll; 1136 DWORD SizeOfImage; 1137 LPVOID EntryPoint; 1138} MODULEINFO, *LPMODULEINFO; 1139 1140static BOOL (WINAPI *_EnumProcessModules) ( HANDLE, HMODULE *, DWORD, LPDWORD ); 1141static DWORD (WINAPI *_GetModuleFileNameEx) ( HANDLE, HMODULE, LPTSTR, DWORD ); 1142static BOOL (WINAPI *_GetModuleInformation)( HANDLE, HMODULE, LPMODULEINFO, DWORD ); 1143 1144// ToolHelp Functions, for Windows 95, 98 and ME 1145 1146static HANDLE(WINAPI *_CreateToolhelp32Snapshot)(DWORD,DWORD) ; 1147static BOOL (WINAPI *_Module32First) (HANDLE,LPMODULEENTRY32) ; 1148static BOOL (WINAPI *_Module32Next) (HANDLE,LPMODULEENTRY32) ; 1149 1150bool _has_psapi; 1151bool _psapi_init = false; 1152bool _has_toolhelp; 1153 1154static bool _init_psapi() { 1155 HINSTANCE psapi = LoadLibrary( "PSAPI.DLL" ) ; 1156 if( psapi == NULL ) return false ; 1157 1158 _EnumProcessModules = CAST_TO_FN_PTR( 1159 BOOL(WINAPI *)(HANDLE, HMODULE *, DWORD, LPDWORD), 1160 GetProcAddress(psapi, "EnumProcessModules")) ; 1161 _GetModuleFileNameEx = CAST_TO_FN_PTR( 1162 DWORD (WINAPI *)(HANDLE, HMODULE, LPTSTR, DWORD), 1163 GetProcAddress(psapi, "GetModuleFileNameExA")); 1164 _GetModuleInformation = CAST_TO_FN_PTR( 1165 BOOL (WINAPI *)(HANDLE, HMODULE, LPMODULEINFO, DWORD), 1166 GetProcAddress(psapi, "GetModuleInformation")); 1167 1168 _has_psapi = (_EnumProcessModules && _GetModuleFileNameEx && _GetModuleInformation); 1169 _psapi_init = true; 1170 return _has_psapi; 1171} 1172 1173static bool _init_toolhelp() { 1174 HINSTANCE kernel32 = LoadLibrary("Kernel32.DLL") ; 1175 if (kernel32 == NULL) return false ; 1176 1177 _CreateToolhelp32Snapshot = CAST_TO_FN_PTR( 1178 HANDLE(WINAPI *)(DWORD,DWORD), 1179 GetProcAddress(kernel32, "CreateToolhelp32Snapshot")); 1180 _Module32First = CAST_TO_FN_PTR( 1181 BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32), 1182 GetProcAddress(kernel32, "Module32First" )); 1183 _Module32Next = CAST_TO_FN_PTR( 1184 BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32), 1185 GetProcAddress(kernel32, "Module32Next" )); 1186 1187 _has_toolhelp = (_CreateToolhelp32Snapshot && _Module32First && _Module32Next); 1188 return _has_toolhelp; 1189} 1190 1191#ifdef _WIN64 1192// Helper routine which returns true if address in 1193// within the NTDLL address space. 1194// 1195static bool _addr_in_ntdll( address addr ) 1196{ 1197 HMODULE hmod; 1198 MODULEINFO minfo; 1199 1200 hmod = GetModuleHandle("NTDLL.DLL"); 1201 if ( hmod == NULL ) return false; 1202 if ( !_GetModuleInformation( GetCurrentProcess(), hmod, 1203 &minfo, sizeof(MODULEINFO)) ) 1204 return false; 1205 1206 if ( (addr >= minfo.lpBaseOfDll) && 1207 (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage))) 1208 return true; 1209 else 1210 return false; 1211} 1212#endif 1213 1214 1215// Enumerate all modules for a given process ID 1216// 1217// Notice that Windows 95/98/Me and Windows NT/2000/XP have 1218// different API for doing this. We use PSAPI.DLL on NT based 1219// Windows and ToolHelp on 95/98/Me. 1220 1221// Callback function that is called by enumerate_modules() on 1222// every DLL module. 1223// Input parameters: 1224// int pid, 1225// char* module_file_name, 1226// address module_base_addr, 1227// unsigned module_size, 1228// void* param 1229typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *); 1230 1231// enumerate_modules for Windows NT, using PSAPI 1232static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param) 1233{ 1234 HANDLE hProcess ; 1235 1236# define MAX_NUM_MODULES 128 1237 HMODULE modules[MAX_NUM_MODULES]; 1238 static char filename[ MAX_PATH ]; 1239 int result = 0; 1240 1241 if (!_has_psapi && (_psapi_init || !_init_psapi())) return 0; 1242 1243 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 1244 FALSE, pid ) ; 1245 if (hProcess == NULL) return 0; 1246 1247 DWORD size_needed; 1248 if (!_EnumProcessModules(hProcess, modules, 1249 sizeof(modules), &size_needed)) { 1250 CloseHandle( hProcess ); 1251 return 0; 1252 } 1253 1254 // number of modules that are currently loaded 1255 int num_modules = size_needed / sizeof(HMODULE); 1256 1257 for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) { 1258 // Get Full pathname: 1259 if(!_GetModuleFileNameEx(hProcess, modules[i], 1260 filename, sizeof(filename))) { 1261 filename[0] = '\0'; 1262 } 1263 1264 MODULEINFO modinfo; 1265 if (!_GetModuleInformation(hProcess, modules[i], 1266 &modinfo, sizeof(modinfo))) { 1267 modinfo.lpBaseOfDll = NULL; 1268 modinfo.SizeOfImage = 0; 1269 } 1270 1271 // Invoke callback function 1272 result = func(pid, filename, (address)modinfo.lpBaseOfDll, 1273 modinfo.SizeOfImage, param); 1274 if (result) break; 1275 } 1276 1277 CloseHandle( hProcess ) ; 1278 return result; 1279} 1280 1281 1282// enumerate_modules for Windows 95/98/ME, using TOOLHELP 1283static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param) 1284{ 1285 HANDLE hSnapShot ; 1286 static MODULEENTRY32 modentry ; 1287 int result = 0; 1288 1289 if (!_has_toolhelp) return 0; 1290 1291 // Get a handle to a Toolhelp snapshot of the system 1292 hSnapShot = _CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid ) ; 1293 if( hSnapShot == INVALID_HANDLE_VALUE ) { 1294 return FALSE ; 1295 } 1296 1297 // iterate through all modules 1298 modentry.dwSize = sizeof(MODULEENTRY32) ; 1299 bool not_done = _Module32First( hSnapShot, &modentry ) != 0; 1300 1301 while( not_done ) { 1302 // invoke the callback 1303 result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr, 1304 modentry.modBaseSize, param); 1305 if (result) break; 1306 1307 modentry.dwSize = sizeof(MODULEENTRY32) ; 1308 not_done = _Module32Next( hSnapShot, &modentry ) != 0; 1309 } 1310 1311 CloseHandle(hSnapShot); 1312 return result; 1313} 1314 1315int enumerate_modules( int pid, EnumModulesCallbackFunc func, void * param ) 1316{ 1317 // Get current process ID if caller doesn't provide it. 1318 if (!pid) pid = os::current_process_id(); 1319 1320 if (os::win32::is_nt()) return _enumerate_modules_winnt (pid, func, param); 1321 else return _enumerate_modules_windows(pid, func, param); 1322} 1323 1324struct _modinfo { 1325 address addr; 1326 char* full_path; // point to a char buffer 1327 int buflen; // size of the buffer 1328 address base_addr; 1329}; 1330 1331static int _locate_module_by_addr(int pid, char * mod_fname, address base_addr, 1332 unsigned size, void * param) { 1333 struct _modinfo *pmod = (struct _modinfo *)param; 1334 if (!pmod) return -1; 1335 1336 if (base_addr <= pmod->addr && 1337 base_addr+size > pmod->addr) { 1338 // if a buffer is provided, copy path name to the buffer 1339 if (pmod->full_path) { 1340 jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname); 1341 } 1342 pmod->base_addr = base_addr; 1343 return 1; 1344 } 1345 return 0; 1346} 1347 1348bool os::dll_address_to_library_name(address addr, char* buf, 1349 int buflen, int* offset) { 1350// NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always 1351// return the full path to the DLL file, sometimes it returns path 1352// to the corresponding PDB file (debug info); sometimes it only 1353// returns partial path, which makes life painful. 1354 1355 struct _modinfo mi; 1356 mi.addr = addr; 1357 mi.full_path = buf; 1358 mi.buflen = buflen; 1359 int pid = os::current_process_id(); 1360 if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) { 1361 // buf already contains path name 1362 if (offset) *offset = addr - mi.base_addr; 1363 return true; 1364 } else { 1365 if (buf) buf[0] = '\0'; 1366 if (offset) *offset = -1; 1367 return false; 1368 } 1369} 1370 1371bool os::dll_address_to_function_name(address addr, char *buf, 1372 int buflen, int *offset) { 1373 if (Decoder::decode(addr, buf, buflen, offset) == Decoder::no_error) { 1374 return true; 1375 } 1376 if (offset != NULL) *offset = -1; 1377 if (buf != NULL) buf[0] = '\0'; 1378 return false; 1379} 1380 1381void* os::dll_lookup(void* handle, const char* name) { 1382 return GetProcAddress((HMODULE)handle, name); 1383} 1384 1385// save the start and end address of jvm.dll into param[0] and param[1] 1386static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr, 1387 unsigned size, void * param) { 1388 if (!param) return -1; 1389 1390 if (base_addr <= (address)_locate_jvm_dll && 1391 base_addr+size > (address)_locate_jvm_dll) { 1392 ((address*)param)[0] = base_addr; 1393 ((address*)param)[1] = base_addr + size; 1394 return 1; 1395 } 1396 return 0; 1397} 1398 1399address vm_lib_location[2]; // start and end address of jvm.dll 1400 1401// check if addr is inside jvm.dll 1402bool os::address_is_in_vm(address addr) { 1403 if (!vm_lib_location[0] || !vm_lib_location[1]) { 1404 int pid = os::current_process_id(); 1405 if (!enumerate_modules(pid, _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(int pid, char* fname, address base, 1416 unsigned size, void* param) { 1417 if (!param) return -1; 1418 1419 outputStream* st = (outputStream*)param; 1420 1421 address end_addr = base + size; 1422 st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base, end_addr, fname); 1423 return 0; 1424} 1425 1426// Loads .dll/.so and 1427// in case of error it checks if .dll/.so was built for the 1428// same architecture as Hotspot is running on 1429void * os::dll_load(const char *name, char *ebuf, int ebuflen) 1430{ 1431 void * result = LoadLibrary(name); 1432 if (result != NULL) 1433 { 1434 return result; 1435 } 1436 1437 long errcode = GetLastError(); 1438 if (errcode == ERROR_MOD_NOT_FOUND) { 1439 strncpy(ebuf, "Can't find dependent libraries", ebuflen-1); 1440 ebuf[ebuflen-1]='\0'; 1441 return NULL; 1442 } 1443 1444 // Parsing dll below 1445 // If we can read dll-info and find that dll was built 1446 // for an architecture other than Hotspot is running in 1447 // - then print to buffer "DLL was built for a different architecture" 1448 // else call getLastErrorString to obtain system error message 1449 1450 // Read system error message into ebuf 1451 // It may or may not be overwritten below (in the for loop and just above) 1452 getLastErrorString(ebuf, (size_t) ebuflen); 1453 ebuf[ebuflen-1]='\0'; 1454 int file_descriptor=::open(name, O_RDONLY | O_BINARY, 0); 1455 if (file_descriptor<0) 1456 { 1457 return NULL; 1458 } 1459 1460 uint32_t signature_offset; 1461 uint16_t lib_arch=0; 1462 bool failed_to_get_lib_arch= 1463 ( 1464 //Go to position 3c in the dll 1465 (os::seek_to_file_offset(file_descriptor,IMAGE_FILE_PTR_TO_SIGNATURE)<0) 1466 || 1467 // Read loacation of signature 1468 (sizeof(signature_offset)!= 1469 (os::read(file_descriptor, (void*)&signature_offset,sizeof(signature_offset)))) 1470 || 1471 //Go to COFF File Header in dll 1472 //that is located after"signature" (4 bytes long) 1473 (os::seek_to_file_offset(file_descriptor, 1474 signature_offset+IMAGE_FILE_SIGNATURE_LENGTH)<0) 1475 || 1476 //Read field that contains code of architecture 1477 // that dll was build for 1478 (sizeof(lib_arch)!= 1479 (os::read(file_descriptor, (void*)&lib_arch,sizeof(lib_arch)))) 1480 ); 1481 1482 ::close(file_descriptor); 1483 if (failed_to_get_lib_arch) 1484 { 1485 // file i/o error - report getLastErrorString(...) msg 1486 return NULL; 1487 } 1488 1489 typedef struct 1490 { 1491 uint16_t arch_code; 1492 char* arch_name; 1493 } arch_t; 1494 1495 static const arch_t arch_array[]={ 1496 {IMAGE_FILE_MACHINE_I386, (char*)"IA 32"}, 1497 {IMAGE_FILE_MACHINE_AMD64, (char*)"AMD 64"}, 1498 {IMAGE_FILE_MACHINE_IA64, (char*)"IA 64"} 1499 }; 1500 #if (defined _M_IA64) 1501 static const uint16_t running_arch=IMAGE_FILE_MACHINE_IA64; 1502 #elif (defined _M_AMD64) 1503 static const uint16_t running_arch=IMAGE_FILE_MACHINE_AMD64; 1504 #elif (defined _M_IX86) 1505 static const uint16_t running_arch=IMAGE_FILE_MACHINE_I386; 1506 #else 1507 #error Method os::dll_load requires that one of following \ 1508 is defined :_M_IA64,_M_AMD64 or _M_IX86 1509 #endif 1510 1511 1512 // Obtain a string for printf operation 1513 // lib_arch_str shall contain string what platform this .dll was built for 1514 // running_arch_str shall string contain what platform Hotspot was built for 1515 char *running_arch_str=NULL,*lib_arch_str=NULL; 1516 for (unsigned int i=0;i<ARRAY_SIZE(arch_array);i++) 1517 { 1518 if (lib_arch==arch_array[i].arch_code) 1519 lib_arch_str=arch_array[i].arch_name; 1520 if (running_arch==arch_array[i].arch_code) 1521 running_arch_str=arch_array[i].arch_name; 1522 } 1523 1524 assert(running_arch_str, 1525 "Didn't find runing architecture code in arch_array"); 1526 1527 // If the architure is right 1528 // but some other error took place - report getLastErrorString(...) msg 1529 if (lib_arch == running_arch) 1530 { 1531 return NULL; 1532 } 1533 1534 if (lib_arch_str!=NULL) 1535 { 1536 ::_snprintf(ebuf, ebuflen-1, 1537 "Can't load %s-bit .dll on a %s-bit platform", 1538 lib_arch_str,running_arch_str); 1539 } 1540 else 1541 { 1542 // don't know what architecture this dll was build for 1543 ::_snprintf(ebuf, ebuflen-1, 1544 "Can't load this .dll (machine code=0x%x) on a %s-bit platform", 1545 lib_arch,running_arch_str); 1546 } 1547 1548 return NULL; 1549} 1550 1551 1552void os::print_dll_info(outputStream *st) { 1553 int pid = os::current_process_id(); 1554 st->print_cr("Dynamic libraries:"); 1555 enumerate_modules(pid, _print_module, (void *)st); 1556} 1557 1558// function pointer to Windows API "GetNativeSystemInfo". 1559typedef void (WINAPI *GetNativeSystemInfo_func_type)(LPSYSTEM_INFO); 1560static GetNativeSystemInfo_func_type _GetNativeSystemInfo; 1561 1562void os::print_os_info(outputStream* st) { 1563 st->print("OS:"); 1564 1565 OSVERSIONINFOEX osvi; 1566 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); 1567 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 1568 1569 if (!GetVersionEx((OSVERSIONINFO *)&osvi)) { 1570 st->print_cr("N/A"); 1571 return; 1572 } 1573 1574 int os_vers = osvi.dwMajorVersion * 1000 + osvi.dwMinorVersion; 1575 if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) { 1576 switch (os_vers) { 1577 case 3051: st->print(" Windows NT 3.51"); break; 1578 case 4000: st->print(" Windows NT 4.0"); break; 1579 case 5000: st->print(" Windows 2000"); break; 1580 case 5001: st->print(" Windows XP"); break; 1581 case 5002: 1582 case 6000: 1583 case 6001: { 1584 // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could 1585 // find out whether we are running on 64 bit processor or not. 1586 SYSTEM_INFO si; 1587 ZeroMemory(&si, sizeof(SYSTEM_INFO)); 1588 // Check to see if _GetNativeSystemInfo has been initialized. 1589 if (_GetNativeSystemInfo == NULL) { 1590 HMODULE hKernel32 = GetModuleHandle(TEXT("kernel32.dll")); 1591 _GetNativeSystemInfo = 1592 CAST_TO_FN_PTR(GetNativeSystemInfo_func_type, 1593 GetProcAddress(hKernel32, 1594 "GetNativeSystemInfo")); 1595 if (_GetNativeSystemInfo == NULL) 1596 GetSystemInfo(&si); 1597 } else { 1598 _GetNativeSystemInfo(&si); 1599 } 1600 if (os_vers == 5002) { 1601 if (osvi.wProductType == VER_NT_WORKSTATION && 1602 si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) 1603 st->print(" Windows XP x64 Edition"); 1604 else 1605 st->print(" Windows Server 2003 family"); 1606 } else if (os_vers == 6000) { 1607 if (osvi.wProductType == VER_NT_WORKSTATION) 1608 st->print(" Windows Vista"); 1609 else 1610 st->print(" Windows Server 2008"); 1611 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) 1612 st->print(" , 64 bit"); 1613 } else if (os_vers == 6001) { 1614 if (osvi.wProductType == VER_NT_WORKSTATION) { 1615 st->print(" Windows 7"); 1616 } else { 1617 // Unrecognized windows, print out its major and minor versions 1618 st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); 1619 } 1620 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) 1621 st->print(" , 64 bit"); 1622 } else { // future os 1623 // Unrecognized windows, print out its major and minor versions 1624 st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); 1625 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) 1626 st->print(" , 64 bit"); 1627 } 1628 break; 1629 } 1630 default: // future windows, print out its major and minor versions 1631 st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); 1632 } 1633 } else { 1634 switch (os_vers) { 1635 case 4000: st->print(" Windows 95"); break; 1636 case 4010: st->print(" Windows 98"); break; 1637 case 4090: st->print(" Windows Me"); break; 1638 default: // future windows, print out its major and minor versions 1639 st->print(" Windows %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion); 1640 } 1641 } 1642 st->print(" Build %d", osvi.dwBuildNumber); 1643 st->print(" %s", osvi.szCSDVersion); // service pack 1644 st->cr(); 1645} 1646 1647void os::print_memory_info(outputStream* st) { 1648 st->print("Memory:"); 1649 st->print(" %dk page", os::vm_page_size()>>10); 1650 1651 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect 1652 // value if total memory is larger than 4GB 1653 MEMORYSTATUSEX ms; 1654 ms.dwLength = sizeof(ms); 1655 GlobalMemoryStatusEx(&ms); 1656 1657 st->print(", physical %uk", os::physical_memory() >> 10); 1658 st->print("(%uk free)", os::available_memory() >> 10); 1659 1660 st->print(", swap %uk", ms.ullTotalPageFile >> 10); 1661 st->print("(%uk free)", ms.ullAvailPageFile >> 10); 1662 st->cr(); 1663} 1664 1665void os::print_siginfo(outputStream *st, void *siginfo) { 1666 EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo; 1667 st->print("siginfo:"); 1668 st->print(" ExceptionCode=0x%x", er->ExceptionCode); 1669 1670 if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 1671 er->NumberParameters >= 2) { 1672 switch (er->ExceptionInformation[0]) { 1673 case 0: st->print(", reading address"); break; 1674 case 1: st->print(", writing address"); break; 1675 default: st->print(", ExceptionInformation=" INTPTR_FORMAT, 1676 er->ExceptionInformation[0]); 1677 } 1678 st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]); 1679 } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR && 1680 er->NumberParameters >= 2 && UseSharedSpaces) { 1681 FileMapInfo* mapinfo = FileMapInfo::current_info(); 1682 if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) { 1683 st->print("\n\nError accessing class data sharing archive." \ 1684 " Mapped file inaccessible during execution, " \ 1685 " possible disk/network problem."); 1686 } 1687 } else { 1688 int num = er->NumberParameters; 1689 if (num > 0) { 1690 st->print(", ExceptionInformation="); 1691 for (int i = 0; i < num; i++) { 1692 st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]); 1693 } 1694 } 1695 } 1696 st->cr(); 1697} 1698 1699void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 1700 // do nothing 1701} 1702 1703static char saved_jvm_path[MAX_PATH] = {0}; 1704 1705// Find the full path to the current module, jvm.dll or jvm_g.dll 1706void os::jvm_path(char *buf, jint buflen) { 1707 // Error checking. 1708 if (buflen < MAX_PATH) { 1709 assert(false, "must use a large-enough buffer"); 1710 buf[0] = '\0'; 1711 return; 1712 } 1713 // Lazy resolve the path to current module. 1714 if (saved_jvm_path[0] != 0) { 1715 strcpy(buf, saved_jvm_path); 1716 return; 1717 } 1718 1719 GetModuleFileName(vm_lib_handle, buf, buflen); 1720 strcpy(saved_jvm_path, buf); 1721} 1722 1723 1724void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 1725#ifndef _WIN64 1726 st->print("_"); 1727#endif 1728} 1729 1730 1731void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 1732#ifndef _WIN64 1733 st->print("@%d", args_size * sizeof(int)); 1734#endif 1735} 1736 1737// sun.misc.Signal 1738// NOTE that this is a workaround for an apparent kernel bug where if 1739// a signal handler for SIGBREAK is installed then that signal handler 1740// takes priority over the console control handler for CTRL_CLOSE_EVENT. 1741// See bug 4416763. 1742static void (*sigbreakHandler)(int) = NULL; 1743 1744static void UserHandler(int sig, void *siginfo, void *context) { 1745 os::signal_notify(sig); 1746 // We need to reinstate the signal handler each time... 1747 os::signal(sig, (void*)UserHandler); 1748} 1749 1750void* os::user_handler() { 1751 return (void*) UserHandler; 1752} 1753 1754void* os::signal(int signal_number, void* handler) { 1755 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) { 1756 void (*oldHandler)(int) = sigbreakHandler; 1757 sigbreakHandler = (void (*)(int)) handler; 1758 return (void*) oldHandler; 1759 } else { 1760 return (void*)::signal(signal_number, (void (*)(int))handler); 1761 } 1762} 1763 1764void os::signal_raise(int signal_number) { 1765 raise(signal_number); 1766} 1767 1768// The Win32 C runtime library maps all console control events other than ^C 1769// into SIGBREAK, which makes it impossible to distinguish ^BREAK from close, 1770// logoff, and shutdown events. We therefore install our own console handler 1771// that raises SIGTERM for the latter cases. 1772// 1773static BOOL WINAPI consoleHandler(DWORD event) { 1774 switch(event) { 1775 case CTRL_C_EVENT: 1776 if (is_error_reported()) { 1777 // Ctrl-C is pressed during error reporting, likely because the error 1778 // handler fails to abort. Let VM die immediately. 1779 os::die(); 1780 } 1781 1782 os::signal_raise(SIGINT); 1783 return TRUE; 1784 break; 1785 case CTRL_BREAK_EVENT: 1786 if (sigbreakHandler != NULL) { 1787 (*sigbreakHandler)(SIGBREAK); 1788 } 1789 return TRUE; 1790 break; 1791 case CTRL_CLOSE_EVENT: 1792 case CTRL_LOGOFF_EVENT: 1793 case CTRL_SHUTDOWN_EVENT: 1794 os::signal_raise(SIGTERM); 1795 return TRUE; 1796 break; 1797 default: 1798 break; 1799 } 1800 return FALSE; 1801} 1802 1803/* 1804 * The following code is moved from os.cpp for making this 1805 * code platform specific, which it is by its very nature. 1806 */ 1807 1808// Return maximum OS signal used + 1 for internal use only 1809// Used as exit signal for signal_thread 1810int os::sigexitnum_pd(){ 1811 return NSIG; 1812} 1813 1814// a counter for each possible signal value, including signal_thread exit signal 1815static volatile jint pending_signals[NSIG+1] = { 0 }; 1816static HANDLE sig_sem; 1817 1818void os::signal_init_pd() { 1819 // Initialize signal structures 1820 memset((void*)pending_signals, 0, sizeof(pending_signals)); 1821 1822 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL); 1823 1824 // Programs embedding the VM do not want it to attempt to receive 1825 // events like CTRL_LOGOFF_EVENT, which are used to implement the 1826 // shutdown hooks mechanism introduced in 1.3. For example, when 1827 // the VM is run as part of a Windows NT service (i.e., a servlet 1828 // engine in a web server), the correct behavior is for any console 1829 // control handler to return FALSE, not TRUE, because the OS's 1830 // "final" handler for such events allows the process to continue if 1831 // it is a service (while terminating it if it is not a service). 1832 // To make this behavior uniform and the mechanism simpler, we 1833 // completely disable the VM's usage of these console events if -Xrs 1834 // (=ReduceSignalUsage) is specified. This means, for example, that 1835 // the CTRL-BREAK thread dump mechanism is also disabled in this 1836 // case. See bugs 4323062, 4345157, and related bugs. 1837 1838 if (!ReduceSignalUsage) { 1839 // Add a CTRL-C handler 1840 SetConsoleCtrlHandler(consoleHandler, TRUE); 1841 } 1842} 1843 1844void os::signal_notify(int signal_number) { 1845 BOOL ret; 1846 1847 Atomic::inc(&pending_signals[signal_number]); 1848 ret = ::ReleaseSemaphore(sig_sem, 1, NULL); 1849 assert(ret != 0, "ReleaseSemaphore() failed"); 1850} 1851 1852static int check_pending_signals(bool wait_for_signal) { 1853 DWORD ret; 1854 while (true) { 1855 for (int i = 0; i < NSIG + 1; i++) { 1856 jint n = pending_signals[i]; 1857 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 1858 return i; 1859 } 1860 } 1861 if (!wait_for_signal) { 1862 return -1; 1863 } 1864 1865 JavaThread *thread = JavaThread::current(); 1866 1867 ThreadBlockInVM tbivm(thread); 1868 1869 bool threadIsSuspended; 1870 do { 1871 thread->set_suspend_equivalent(); 1872 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 1873 ret = ::WaitForSingleObject(sig_sem, INFINITE); 1874 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed"); 1875 1876 // were we externally suspended while we were waiting? 1877 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 1878 if (threadIsSuspended) { 1879 // 1880 // The semaphore has been incremented, but while we were waiting 1881 // another thread suspended us. We don't want to continue running 1882 // while suspended because that would surprise the thread that 1883 // suspended us. 1884 // 1885 ret = ::ReleaseSemaphore(sig_sem, 1, NULL); 1886 assert(ret != 0, "ReleaseSemaphore() failed"); 1887 1888 thread->java_suspend_self(); 1889 } 1890 } while (threadIsSuspended); 1891 } 1892} 1893 1894int os::signal_lookup() { 1895 return check_pending_signals(false); 1896} 1897 1898int os::signal_wait() { 1899 return check_pending_signals(true); 1900} 1901 1902// Implicit OS exception handling 1903 1904LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) { 1905 JavaThread* thread = JavaThread::current(); 1906 // Save pc in thread 1907#ifdef _M_IA64 1908 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP); 1909 // Set pc to handler 1910 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler; 1911#elif _M_AMD64 1912 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip); 1913 // Set pc to handler 1914 exceptionInfo->ContextRecord->Rip = (DWORD64)handler; 1915#else 1916 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip); 1917 // Set pc to handler 1918 exceptionInfo->ContextRecord->Eip = (LONG)handler; 1919#endif 1920 1921 // Continue the execution 1922 return EXCEPTION_CONTINUE_EXECUTION; 1923} 1924 1925 1926// Used for PostMortemDump 1927extern "C" void safepoints(); 1928extern "C" void find(int x); 1929extern "C" void events(); 1930 1931// According to Windows API documentation, an illegal instruction sequence should generate 1932// the 0xC000001C exception code. However, real world experience shows that occasionnaly 1933// the execution of an illegal instruction can generate the exception code 0xC000001E. This 1934// seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems). 1935 1936#define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E 1937 1938// From "Execution Protection in the Windows Operating System" draft 0.35 1939// Once a system header becomes available, the "real" define should be 1940// included or copied here. 1941#define EXCEPTION_INFO_EXEC_VIOLATION 0x08 1942 1943#define def_excpt(val) #val, val 1944 1945struct siglabel { 1946 char *name; 1947 int number; 1948}; 1949 1950struct siglabel exceptlabels[] = { 1951 def_excpt(EXCEPTION_ACCESS_VIOLATION), 1952 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT), 1953 def_excpt(EXCEPTION_BREAKPOINT), 1954 def_excpt(EXCEPTION_SINGLE_STEP), 1955 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED), 1956 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND), 1957 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO), 1958 def_excpt(EXCEPTION_FLT_INEXACT_RESULT), 1959 def_excpt(EXCEPTION_FLT_INVALID_OPERATION), 1960 def_excpt(EXCEPTION_FLT_OVERFLOW), 1961 def_excpt(EXCEPTION_FLT_STACK_CHECK), 1962 def_excpt(EXCEPTION_FLT_UNDERFLOW), 1963 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO), 1964 def_excpt(EXCEPTION_INT_OVERFLOW), 1965 def_excpt(EXCEPTION_PRIV_INSTRUCTION), 1966 def_excpt(EXCEPTION_IN_PAGE_ERROR), 1967 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION), 1968 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2), 1969 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION), 1970 def_excpt(EXCEPTION_STACK_OVERFLOW), 1971 def_excpt(EXCEPTION_INVALID_DISPOSITION), 1972 def_excpt(EXCEPTION_GUARD_PAGE), 1973 def_excpt(EXCEPTION_INVALID_HANDLE), 1974 NULL, 0 1975}; 1976 1977const char* os::exception_name(int exception_code, char *buf, size_t size) { 1978 for (int i = 0; exceptlabels[i].name != NULL; i++) { 1979 if (exceptlabels[i].number == exception_code) { 1980 jio_snprintf(buf, size, "%s", exceptlabels[i].name); 1981 return buf; 1982 } 1983 } 1984 1985 return NULL; 1986} 1987 1988//----------------------------------------------------------------------------- 1989LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { 1990 // handle exception caused by idiv; should only happen for -MinInt/-1 1991 // (division by zero is handled explicitly) 1992#ifdef _M_IA64 1993 assert(0, "Fix Handle_IDiv_Exception"); 1994#elif _M_AMD64 1995 PCONTEXT ctx = exceptionInfo->ContextRecord; 1996 address pc = (address)ctx->Rip; 1997 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc)); 1998 assert(pc[0] == 0xF7, "not an idiv opcode"); 1999 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands"); 2000 assert(ctx->Rax == min_jint, "unexpected idiv exception"); 2001 // set correct result values and continue after idiv instruction 2002 ctx->Rip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes 2003 ctx->Rax = (DWORD)min_jint; // result 2004 ctx->Rdx = (DWORD)0; // remainder 2005 // Continue the execution 2006#else 2007 PCONTEXT ctx = exceptionInfo->ContextRecord; 2008 address pc = (address)ctx->Eip; 2009 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc)); 2010 assert(pc[0] == 0xF7, "not an idiv opcode"); 2011 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands"); 2012 assert(ctx->Eax == min_jint, "unexpected idiv exception"); 2013 // set correct result values and continue after idiv instruction 2014 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes 2015 ctx->Eax = (DWORD)min_jint; // result 2016 ctx->Edx = (DWORD)0; // remainder 2017 // Continue the execution 2018#endif 2019 return EXCEPTION_CONTINUE_EXECUTION; 2020} 2021 2022#ifndef _WIN64 2023//----------------------------------------------------------------------------- 2024LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { 2025 // handle exception caused by native method modifying control word 2026 PCONTEXT ctx = exceptionInfo->ContextRecord; 2027 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2028 2029 switch (exception_code) { 2030 case EXCEPTION_FLT_DENORMAL_OPERAND: 2031 case EXCEPTION_FLT_DIVIDE_BY_ZERO: 2032 case EXCEPTION_FLT_INEXACT_RESULT: 2033 case EXCEPTION_FLT_INVALID_OPERATION: 2034 case EXCEPTION_FLT_OVERFLOW: 2035 case EXCEPTION_FLT_STACK_CHECK: 2036 case EXCEPTION_FLT_UNDERFLOW: 2037 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std()); 2038 if (fp_control_word != ctx->FloatSave.ControlWord) { 2039 // Restore FPCW and mask out FLT exceptions 2040 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0; 2041 // Mask out pending FLT exceptions 2042 ctx->FloatSave.StatusWord &= 0xffffff00; 2043 return EXCEPTION_CONTINUE_EXECUTION; 2044 } 2045 } 2046 2047 if (prev_uef_handler != NULL) { 2048 // We didn't handle this exception so pass it to the previous 2049 // UnhandledExceptionFilter. 2050 return (prev_uef_handler)(exceptionInfo); 2051 } 2052 2053 return EXCEPTION_CONTINUE_SEARCH; 2054} 2055#else //_WIN64 2056/* 2057 On Windows, the mxcsr control bits are non-volatile across calls 2058 See also CR 6192333 2059 If EXCEPTION_FLT_* happened after some native method modified 2060 mxcsr - it is not a jvm fault. 2061 However should we decide to restore of mxcsr after a faulty 2062 native method we can uncomment following code 2063 jint MxCsr = INITIAL_MXCSR; 2064 // we can't use StubRoutines::addr_mxcsr_std() 2065 // because in Win64 mxcsr is not saved there 2066 if (MxCsr != ctx->MxCsr) { 2067 ctx->MxCsr = MxCsr; 2068 return EXCEPTION_CONTINUE_EXECUTION; 2069 } 2070 2071*/ 2072#endif //_WIN64 2073 2074 2075// Fatal error reporting is single threaded so we can make this a 2076// static and preallocated. If it's more than MAX_PATH silently ignore 2077// it. 2078static char saved_error_file[MAX_PATH] = {0}; 2079 2080void os::set_error_file(const char *logfile) { 2081 if (strlen(logfile) <= MAX_PATH) { 2082 strncpy(saved_error_file, logfile, MAX_PATH); 2083 } 2084} 2085 2086static inline void report_error(Thread* t, DWORD exception_code, 2087 address addr, void* siginfo, void* context) { 2088 VMError err(t, exception_code, addr, siginfo, context); 2089 err.report_and_die(); 2090 2091 // If UseOsErrorReporting, this will return here and save the error file 2092 // somewhere where we can find it in the minidump. 2093} 2094 2095//----------------------------------------------------------------------------- 2096LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) { 2097 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH; 2098 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2099#ifdef _M_IA64 2100 address pc = (address) exceptionInfo->ContextRecord->StIIP; 2101#elif _M_AMD64 2102 address pc = (address) exceptionInfo->ContextRecord->Rip; 2103#else 2104 address pc = (address) exceptionInfo->ContextRecord->Eip; 2105#endif 2106 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady 2107 2108#ifndef _WIN64 2109 // Execution protection violation - win32 running on AMD64 only 2110 // Handled first to avoid misdiagnosis as a "normal" access violation; 2111 // This is safe to do because we have a new/unique ExceptionInformation 2112 // code for this condition. 2113 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2114 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2115 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0]; 2116 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2117 2118 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) { 2119 int page_size = os::vm_page_size(); 2120 2121 // Make sure the pc and the faulting address are sane. 2122 // 2123 // If an instruction spans a page boundary, and the page containing 2124 // the beginning of the instruction is executable but the following 2125 // page is not, the pc and the faulting address might be slightly 2126 // different - we still want to unguard the 2nd page in this case. 2127 // 2128 // 15 bytes seems to be a (very) safe value for max instruction size. 2129 bool pc_is_near_addr = 2130 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15); 2131 bool instr_spans_page_boundary = 2132 (align_size_down((intptr_t) pc ^ (intptr_t) addr, 2133 (intptr_t) page_size) > 0); 2134 2135 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) { 2136 static volatile address last_addr = 2137 (address) os::non_memory_address_word(); 2138 2139 // In conservative mode, don't unguard unless the address is in the VM 2140 if (UnguardOnExecutionViolation > 0 && addr != last_addr && 2141 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) { 2142 2143 // Set memory to RWX and retry 2144 address page_start = 2145 (address) align_size_down((intptr_t) addr, (intptr_t) page_size); 2146 bool res = os::protect_memory((char*) page_start, page_size, 2147 os::MEM_PROT_RWX); 2148 2149 if (PrintMiscellaneous && Verbose) { 2150 char buf[256]; 2151 jio_snprintf(buf, sizeof(buf), "Execution protection violation " 2152 "at " INTPTR_FORMAT 2153 ", unguarding " INTPTR_FORMAT ": %s", addr, 2154 page_start, (res ? "success" : strerror(errno))); 2155 tty->print_raw_cr(buf); 2156 } 2157 2158 // Set last_addr so if we fault again at the same address, we don't 2159 // end up in an endless loop. 2160 // 2161 // There are two potential complications here. Two threads trapping 2162 // at the same address at the same time could cause one of the 2163 // threads to think it already unguarded, and abort the VM. Likely 2164 // very rare. 2165 // 2166 // The other race involves two threads alternately trapping at 2167 // different addresses and failing to unguard the page, resulting in 2168 // an endless loop. This condition is probably even more unlikely 2169 // than the first. 2170 // 2171 // Although both cases could be avoided by using locks or thread 2172 // local last_addr, these solutions are unnecessary complication: 2173 // this handler is a best-effort safety net, not a complete solution. 2174 // It is disabled by default and should only be used as a workaround 2175 // in case we missed any no-execute-unsafe VM code. 2176 2177 last_addr = addr; 2178 2179 return EXCEPTION_CONTINUE_EXECUTION; 2180 } 2181 } 2182 2183 // Last unguard failed or not unguarding 2184 tty->print_raw_cr("Execution protection violation"); 2185 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord, 2186 exceptionInfo->ContextRecord); 2187 return EXCEPTION_CONTINUE_SEARCH; 2188 } 2189 } 2190#endif // _WIN64 2191 2192 // Check to see if we caught the safepoint code in the 2193 // process of write protecting the memory serialization page. 2194 // It write enables the page immediately after protecting it 2195 // so just return. 2196 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) { 2197 JavaThread* thread = (JavaThread*) t; 2198 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2199 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2200 if ( os::is_memory_serialize_page(thread, addr) ) { 2201 // Block current thread until the memory serialize page permission restored. 2202 os::block_on_serialize_page_trap(); 2203 return EXCEPTION_CONTINUE_EXECUTION; 2204 } 2205 } 2206 2207 2208 if (t != NULL && t->is_Java_thread()) { 2209 JavaThread* thread = (JavaThread*) t; 2210 bool in_java = thread->thread_state() == _thread_in_Java; 2211 2212 // Handle potential stack overflows up front. 2213 if (exception_code == EXCEPTION_STACK_OVERFLOW) { 2214 if (os::uses_stack_guard_pages()) { 2215#ifdef _M_IA64 2216 // 2217 // If it's a legal stack address continue, Windows will map it in. 2218 // 2219 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2220 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2221 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) 2222 return EXCEPTION_CONTINUE_EXECUTION; 2223 2224 // The register save area is the same size as the memory stack 2225 // and starts at the page just above the start of the memory stack. 2226 // If we get a fault in this area, we've run out of register 2227 // stack. If we are in java, try throwing a stack overflow exception. 2228 if (addr > thread->stack_base() && 2229 addr <= (thread->stack_base()+thread->stack_size()) ) { 2230 char buf[256]; 2231 jio_snprintf(buf, sizeof(buf), 2232 "Register stack overflow, addr:%p, stack_base:%p\n", 2233 addr, thread->stack_base() ); 2234 tty->print_raw_cr(buf); 2235 // If not in java code, return and hope for the best. 2236 return in_java ? Handle_Exception(exceptionInfo, 2237 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)) 2238 : EXCEPTION_CONTINUE_EXECUTION; 2239 } 2240#endif 2241 if (thread->stack_yellow_zone_enabled()) { 2242 // Yellow zone violation. The o/s has unprotected the first yellow 2243 // zone page for us. Note: must call disable_stack_yellow_zone to 2244 // update the enabled status, even if the zone contains only one page. 2245 thread->disable_stack_yellow_zone(); 2246 // If not in java code, return and hope for the best. 2247 return in_java ? Handle_Exception(exceptionInfo, 2248 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)) 2249 : EXCEPTION_CONTINUE_EXECUTION; 2250 } else { 2251 // Fatal red zone violation. 2252 thread->disable_stack_red_zone(); 2253 tty->print_raw_cr("An unrecoverable stack overflow has occurred."); 2254 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2255 exceptionInfo->ContextRecord); 2256 return EXCEPTION_CONTINUE_SEARCH; 2257 } 2258 } else if (in_java) { 2259 // JVM-managed guard pages cannot be used on win95/98. The o/s provides 2260 // a one-time-only guard page, which it has released to us. The next 2261 // stack overflow on this thread will result in an ACCESS_VIOLATION. 2262 return Handle_Exception(exceptionInfo, 2263 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2264 } else { 2265 // Can only return and hope for the best. Further stack growth will 2266 // result in an ACCESS_VIOLATION. 2267 return EXCEPTION_CONTINUE_EXECUTION; 2268 } 2269 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2270 // Either stack overflow or null pointer exception. 2271 if (in_java) { 2272 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2273 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2274 address stack_end = thread->stack_base() - thread->stack_size(); 2275 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) { 2276 // Stack overflow. 2277 assert(!os::uses_stack_guard_pages(), 2278 "should be caught by red zone code above."); 2279 return Handle_Exception(exceptionInfo, 2280 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2281 } 2282 // 2283 // Check for safepoint polling and implicit null 2284 // We only expect null pointers in the stubs (vtable) 2285 // the rest are checked explicitly now. 2286 // 2287 CodeBlob* cb = CodeCache::find_blob(pc); 2288 if (cb != NULL) { 2289 if (os::is_poll_address(addr)) { 2290 address stub = SharedRuntime::get_poll_stub(pc); 2291 return Handle_Exception(exceptionInfo, stub); 2292 } 2293 } 2294 { 2295#ifdef _WIN64 2296 // 2297 // If it's a legal stack address map the entire region in 2298 // 2299 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2300 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2301 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) { 2302 addr = (address)((uintptr_t)addr & 2303 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1))); 2304 os::commit_memory((char *)addr, thread->stack_base() - addr, 2305 false ); 2306 return EXCEPTION_CONTINUE_EXECUTION; 2307 } 2308 else 2309#endif 2310 { 2311 // Null pointer exception. 2312#ifdef _M_IA64 2313 // We catch register stack overflows in compiled code by doing 2314 // an explicit compare and executing a st8(G0, G0) if the 2315 // BSP enters into our guard area. We test for the overflow 2316 // condition and fall into the normal null pointer exception 2317 // code if BSP hasn't overflowed. 2318 if ( in_java ) { 2319 if(thread->register_stack_overflow()) { 2320 assert((address)exceptionInfo->ContextRecord->IntS3 == 2321 thread->register_stack_limit(), 2322 "GR7 doesn't contain register_stack_limit"); 2323 // Disable the yellow zone which sets the state that 2324 // we've got a stack overflow problem. 2325 if (thread->stack_yellow_zone_enabled()) { 2326 thread->disable_stack_yellow_zone(); 2327 } 2328 // Give us some room to process the exception 2329 thread->disable_register_stack_guard(); 2330 // Update GR7 with the new limit so we can continue running 2331 // compiled code. 2332 exceptionInfo->ContextRecord->IntS3 = 2333 (ULONGLONG)thread->register_stack_limit(); 2334 return Handle_Exception(exceptionInfo, 2335 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2336 } else { 2337 // 2338 // Check for implicit null 2339 // We only expect null pointers in the stubs (vtable) 2340 // the rest are checked explicitly now. 2341 // 2342 if (((uintptr_t)addr) < os::vm_page_size() ) { 2343 // an access to the first page of VM--assume it is a null pointer 2344 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); 2345 if (stub != NULL) return Handle_Exception(exceptionInfo, stub); 2346 } 2347 } 2348 } // in_java 2349 2350 // IA64 doesn't use implicit null checking yet. So we shouldn't 2351 // get here. 2352 tty->print_raw_cr("Access violation, possible null pointer exception"); 2353 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2354 exceptionInfo->ContextRecord); 2355 return EXCEPTION_CONTINUE_SEARCH; 2356#else /* !IA64 */ 2357 2358 // Windows 98 reports faulting addresses incorrectly 2359 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) || 2360 !os::win32::is_nt()) { 2361 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); 2362 if (stub != NULL) return Handle_Exception(exceptionInfo, stub); 2363 } 2364 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2365 exceptionInfo->ContextRecord); 2366 return EXCEPTION_CONTINUE_SEARCH; 2367#endif 2368 } 2369 } 2370 } 2371 2372#ifdef _WIN64 2373 // Special care for fast JNI field accessors. 2374 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks 2375 // in and the heap gets shrunk before the field access. 2376 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2377 address addr = JNI_FastGetField::find_slowcase_pc(pc); 2378 if (addr != (address)-1) { 2379 return Handle_Exception(exceptionInfo, addr); 2380 } 2381 } 2382#endif 2383 2384#ifdef _WIN64 2385 // Windows will sometimes generate an access violation 2386 // when we call malloc. Since we use VectoredExceptions 2387 // on 64 bit platforms, we see this exception. We must 2388 // pass this exception on so Windows can recover. 2389 // We check to see if the pc of the fault is in NTDLL.DLL 2390 // if so, we pass control on to Windows for handling. 2391 if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH; 2392#endif 2393 2394 // Stack overflow or null pointer exception in native code. 2395 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2396 exceptionInfo->ContextRecord); 2397 return EXCEPTION_CONTINUE_SEARCH; 2398 } 2399 2400 if (in_java) { 2401 switch (exception_code) { 2402 case EXCEPTION_INT_DIVIDE_BY_ZERO: 2403 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO)); 2404 2405 case EXCEPTION_INT_OVERFLOW: 2406 return Handle_IDiv_Exception(exceptionInfo); 2407 2408 } // switch 2409 } 2410#ifndef _WIN64 2411 if ((thread->thread_state() == _thread_in_Java) || 2412 (thread->thread_state() == _thread_in_native) ) 2413 { 2414 LONG result=Handle_FLT_Exception(exceptionInfo); 2415 if (result==EXCEPTION_CONTINUE_EXECUTION) return result; 2416 } 2417#endif //_WIN64 2418 } 2419 2420 if (exception_code != EXCEPTION_BREAKPOINT) { 2421#ifndef _WIN64 2422 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2423 exceptionInfo->ContextRecord); 2424#else 2425 // Itanium Windows uses a VectoredExceptionHandler 2426 // Which means that C++ programatic exception handlers (try/except) 2427 // will get here. Continue the search for the right except block if 2428 // the exception code is not a fatal code. 2429 switch ( exception_code ) { 2430 case EXCEPTION_ACCESS_VIOLATION: 2431 case EXCEPTION_STACK_OVERFLOW: 2432 case EXCEPTION_ILLEGAL_INSTRUCTION: 2433 case EXCEPTION_ILLEGAL_INSTRUCTION_2: 2434 case EXCEPTION_INT_OVERFLOW: 2435 case EXCEPTION_INT_DIVIDE_BY_ZERO: 2436 { report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2437 exceptionInfo->ContextRecord); 2438 } 2439 break; 2440 default: 2441 break; 2442 } 2443#endif 2444 } 2445 return EXCEPTION_CONTINUE_SEARCH; 2446} 2447 2448#ifndef _WIN64 2449// Special care for fast JNI accessors. 2450// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and 2451// the heap gets shrunk before the field access. 2452// Need to install our own structured exception handler since native code may 2453// install its own. 2454LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) { 2455 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2456 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2457 address pc = (address) exceptionInfo->ContextRecord->Eip; 2458 address addr = JNI_FastGetField::find_slowcase_pc(pc); 2459 if (addr != (address)-1) { 2460 return Handle_Exception(exceptionInfo, addr); 2461 } 2462 } 2463 return EXCEPTION_CONTINUE_SEARCH; 2464} 2465 2466#define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \ 2467Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \ 2468 __try { \ 2469 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \ 2470 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \ 2471 } \ 2472 return 0; \ 2473} 2474 2475DEFINE_FAST_GETFIELD(jboolean, bool, Boolean) 2476DEFINE_FAST_GETFIELD(jbyte, byte, Byte) 2477DEFINE_FAST_GETFIELD(jchar, char, Char) 2478DEFINE_FAST_GETFIELD(jshort, short, Short) 2479DEFINE_FAST_GETFIELD(jint, int, Int) 2480DEFINE_FAST_GETFIELD(jlong, long, Long) 2481DEFINE_FAST_GETFIELD(jfloat, float, Float) 2482DEFINE_FAST_GETFIELD(jdouble, double, Double) 2483 2484address os::win32::fast_jni_accessor_wrapper(BasicType type) { 2485 switch (type) { 2486 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper; 2487 case T_BYTE: return (address)jni_fast_GetByteField_wrapper; 2488 case T_CHAR: return (address)jni_fast_GetCharField_wrapper; 2489 case T_SHORT: return (address)jni_fast_GetShortField_wrapper; 2490 case T_INT: return (address)jni_fast_GetIntField_wrapper; 2491 case T_LONG: return (address)jni_fast_GetLongField_wrapper; 2492 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper; 2493 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper; 2494 default: ShouldNotReachHere(); 2495 } 2496 return (address)-1; 2497} 2498#endif 2499 2500// Virtual Memory 2501 2502int os::vm_page_size() { return os::win32::vm_page_size(); } 2503int os::vm_allocation_granularity() { 2504 return os::win32::vm_allocation_granularity(); 2505} 2506 2507// Windows large page support is available on Windows 2003. In order to use 2508// large page memory, the administrator must first assign additional privilege 2509// to the user: 2510// + select Control Panel -> Administrative Tools -> Local Security Policy 2511// + select Local Policies -> User Rights Assignment 2512// + double click "Lock pages in memory", add users and/or groups 2513// + reboot 2514// Note the above steps are needed for administrator as well, as administrators 2515// by default do not have the privilege to lock pages in memory. 2516// 2517// Note about Windows 2003: although the API supports committing large page 2518// memory on a page-by-page basis and VirtualAlloc() returns success under this 2519// scenario, I found through experiment it only uses large page if the entire 2520// memory region is reserved and committed in a single VirtualAlloc() call. 2521// This makes Windows large page support more or less like Solaris ISM, in 2522// that the entire heap must be committed upfront. This probably will change 2523// in the future, if so the code below needs to be revisited. 2524 2525#ifndef MEM_LARGE_PAGES 2526#define MEM_LARGE_PAGES 0x20000000 2527#endif 2528 2529// GetLargePageMinimum is only available on Windows 2003. The other functions 2530// are available on NT but not on Windows 98/Me. We have to resolve them at 2531// runtime. 2532typedef SIZE_T (WINAPI *GetLargePageMinimum_func_type) (void); 2533typedef BOOL (WINAPI *AdjustTokenPrivileges_func_type) 2534 (HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); 2535typedef BOOL (WINAPI *OpenProcessToken_func_type) (HANDLE, DWORD, PHANDLE); 2536typedef BOOL (WINAPI *LookupPrivilegeValue_func_type) (LPCTSTR, LPCTSTR, PLUID); 2537 2538static GetLargePageMinimum_func_type _GetLargePageMinimum; 2539static AdjustTokenPrivileges_func_type _AdjustTokenPrivileges; 2540static OpenProcessToken_func_type _OpenProcessToken; 2541static LookupPrivilegeValue_func_type _LookupPrivilegeValue; 2542 2543static HINSTANCE _kernel32; 2544static HINSTANCE _advapi32; 2545static HANDLE _hProcess; 2546static HANDLE _hToken; 2547 2548static size_t _large_page_size = 0; 2549 2550static bool resolve_functions_for_large_page_init() { 2551 _kernel32 = LoadLibrary("kernel32.dll"); 2552 if (_kernel32 == NULL) return false; 2553 2554 _GetLargePageMinimum = CAST_TO_FN_PTR(GetLargePageMinimum_func_type, 2555 GetProcAddress(_kernel32, "GetLargePageMinimum")); 2556 if (_GetLargePageMinimum == NULL) return false; 2557 2558 _advapi32 = LoadLibrary("advapi32.dll"); 2559 if (_advapi32 == NULL) return false; 2560 2561 _AdjustTokenPrivileges = CAST_TO_FN_PTR(AdjustTokenPrivileges_func_type, 2562 GetProcAddress(_advapi32, "AdjustTokenPrivileges")); 2563 _OpenProcessToken = CAST_TO_FN_PTR(OpenProcessToken_func_type, 2564 GetProcAddress(_advapi32, "OpenProcessToken")); 2565 _LookupPrivilegeValue = CAST_TO_FN_PTR(LookupPrivilegeValue_func_type, 2566 GetProcAddress(_advapi32, "LookupPrivilegeValueA")); 2567 return _AdjustTokenPrivileges != NULL && 2568 _OpenProcessToken != NULL && 2569 _LookupPrivilegeValue != NULL; 2570} 2571 2572static bool request_lock_memory_privilege() { 2573 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, 2574 os::current_process_id()); 2575 2576 LUID luid; 2577 if (_hProcess != NULL && 2578 _OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) && 2579 _LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) { 2580 2581 TOKEN_PRIVILEGES tp; 2582 tp.PrivilegeCount = 1; 2583 tp.Privileges[0].Luid = luid; 2584 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 2585 2586 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the 2587 // privilege. Check GetLastError() too. See MSDN document. 2588 if (_AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) && 2589 (GetLastError() == ERROR_SUCCESS)) { 2590 return true; 2591 } 2592 } 2593 2594 return false; 2595} 2596 2597static void cleanup_after_large_page_init() { 2598 _GetLargePageMinimum = NULL; 2599 _AdjustTokenPrivileges = NULL; 2600 _OpenProcessToken = NULL; 2601 _LookupPrivilegeValue = NULL; 2602 if (_kernel32) FreeLibrary(_kernel32); 2603 _kernel32 = NULL; 2604 if (_advapi32) FreeLibrary(_advapi32); 2605 _advapi32 = NULL; 2606 if (_hProcess) CloseHandle(_hProcess); 2607 _hProcess = NULL; 2608 if (_hToken) CloseHandle(_hToken); 2609 _hToken = NULL; 2610} 2611 2612bool os::large_page_init() { 2613 if (!UseLargePages) return false; 2614 2615 // print a warning if any large page related flag is specified on command line 2616 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || 2617 !FLAG_IS_DEFAULT(LargePageSizeInBytes); 2618 bool success = false; 2619 2620# define WARN(msg) if (warn_on_failure) { warning(msg); } 2621 if (resolve_functions_for_large_page_init()) { 2622 if (request_lock_memory_privilege()) { 2623 size_t s = _GetLargePageMinimum(); 2624 if (s) { 2625#if defined(IA32) || defined(AMD64) 2626 if (s > 4*M || LargePageSizeInBytes > 4*M) { 2627 WARN("JVM cannot use large pages bigger than 4mb."); 2628 } else { 2629#endif 2630 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) { 2631 _large_page_size = LargePageSizeInBytes; 2632 } else { 2633 _large_page_size = s; 2634 } 2635 success = true; 2636#if defined(IA32) || defined(AMD64) 2637 } 2638#endif 2639 } else { 2640 WARN("Large page is not supported by the processor."); 2641 } 2642 } else { 2643 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory."); 2644 } 2645 } else { 2646 WARN("Large page is not supported by the operating system."); 2647 } 2648#undef WARN 2649 2650 const size_t default_page_size = (size_t) vm_page_size(); 2651 if (success && _large_page_size > default_page_size) { 2652 _page_sizes[0] = _large_page_size; 2653 _page_sizes[1] = default_page_size; 2654 _page_sizes[2] = 0; 2655 } 2656 2657 cleanup_after_large_page_init(); 2658 return success; 2659} 2660 2661// On win32, one cannot release just a part of reserved memory, it's an 2662// all or nothing deal. When we split a reservation, we must break the 2663// reservation into two reservations. 2664void os::split_reserved_memory(char *base, size_t size, size_t split, 2665 bool realloc) { 2666 if (size > 0) { 2667 release_memory(base, size); 2668 if (realloc) { 2669 reserve_memory(split, base); 2670 } 2671 if (size != split) { 2672 reserve_memory(size - split, base + split); 2673 } 2674 } 2675} 2676 2677char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 2678 assert((size_t)addr % os::vm_allocation_granularity() == 0, 2679 "reserve alignment"); 2680 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size"); 2681 char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE); 2682 assert(res == NULL || addr == NULL || addr == res, 2683 "Unexpected address from reserve."); 2684 return res; 2685} 2686 2687// Reserve memory at an arbitrary address, only if that area is 2688// available (and not reserved for something else). 2689char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2690 // Windows os::reserve_memory() fails of the requested address range is 2691 // not avilable. 2692 return reserve_memory(bytes, requested_addr); 2693} 2694 2695size_t os::large_page_size() { 2696 return _large_page_size; 2697} 2698 2699bool os::can_commit_large_page_memory() { 2700 // Windows only uses large page memory when the entire region is reserved 2701 // and committed in a single VirtualAlloc() call. This may change in the 2702 // future, but with Windows 2003 it's not possible to commit on demand. 2703 return false; 2704} 2705 2706bool os::can_execute_large_page_memory() { 2707 return true; 2708} 2709 2710char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) { 2711 2712 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 2713 2714 if (UseLargePagesIndividualAllocation) { 2715 if (TracePageSizes && Verbose) { 2716 tty->print_cr("Reserving large pages individually."); 2717 } 2718 char * p_buf; 2719 // first reserve enough address space in advance since we want to be 2720 // able to break a single contiguous virtual address range into multiple 2721 // large page commits but WS2003 does not allow reserving large page space 2722 // so we just use 4K pages for reserve, this gives us a legal contiguous 2723 // address space. then we will deallocate that reservation, and re alloc 2724 // using large pages 2725 const size_t size_of_reserve = bytes + _large_page_size; 2726 if (bytes > size_of_reserve) { 2727 // Overflowed. 2728 warning("Individually allocated large pages failed, " 2729 "use -XX:-UseLargePagesIndividualAllocation to turn off"); 2730 return NULL; 2731 } 2732 p_buf = (char *) VirtualAlloc(addr, 2733 size_of_reserve, // size of Reserve 2734 MEM_RESERVE, 2735 PAGE_READWRITE); 2736 // If reservation failed, return NULL 2737 if (p_buf == NULL) return NULL; 2738 2739 release_memory(p_buf, bytes + _large_page_size); 2740 // round up to page boundary. If the size_of_reserve did not 2741 // overflow and the reservation did not fail, this align up 2742 // should not overflow. 2743 p_buf = (char *) align_size_up((size_t)p_buf, _large_page_size); 2744 2745 // now go through and allocate one page at a time until all bytes are 2746 // allocated 2747 size_t bytes_remaining = align_size_up(bytes, _large_page_size); 2748 // An overflow of align_size_up() would have been caught above 2749 // in the calculation of size_of_reserve. 2750 char * next_alloc_addr = p_buf; 2751 2752#ifdef ASSERT 2753 // Variable for the failure injection 2754 long ran_num = os::random(); 2755 size_t fail_after = ran_num % bytes; 2756#endif 2757 2758 while (bytes_remaining) { 2759 size_t bytes_to_rq = MIN2(bytes_remaining, _large_page_size); 2760 // Note allocate and commit 2761 char * p_new; 2762 2763#ifdef ASSERT 2764 bool inject_error = LargePagesIndividualAllocationInjectError && 2765 (bytes_remaining <= fail_after); 2766#else 2767 const bool inject_error = false; 2768#endif 2769 2770 if (inject_error) { 2771 p_new = NULL; 2772 } else { 2773 p_new = (char *) VirtualAlloc(next_alloc_addr, 2774 bytes_to_rq, 2775 MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES, 2776 prot); 2777 } 2778 2779 if (p_new == NULL) { 2780 // Free any allocated pages 2781 if (next_alloc_addr > p_buf) { 2782 // Some memory was committed so release it. 2783 size_t bytes_to_release = bytes - bytes_remaining; 2784 release_memory(p_buf, bytes_to_release); 2785 } 2786#ifdef ASSERT 2787 if (UseLargePagesIndividualAllocation && 2788 LargePagesIndividualAllocationInjectError) { 2789 if (TracePageSizes && Verbose) { 2790 tty->print_cr("Reserving large pages individually failed."); 2791 } 2792 } 2793#endif 2794 return NULL; 2795 } 2796 bytes_remaining -= bytes_to_rq; 2797 next_alloc_addr += bytes_to_rq; 2798 } 2799 2800 return p_buf; 2801 2802 } else { 2803 // normal policy just allocate it all at once 2804 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES; 2805 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot); 2806 return res; 2807 } 2808} 2809 2810bool os::release_memory_special(char* base, size_t bytes) { 2811 return release_memory(base, bytes); 2812} 2813 2814void os::print_statistics() { 2815} 2816 2817bool os::commit_memory(char* addr, size_t bytes, bool exec) { 2818 if (bytes == 0) { 2819 // Don't bother the OS with noops. 2820 return true; 2821 } 2822 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries"); 2823 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks"); 2824 // Don't attempt to print anything if the OS call fails. We're 2825 // probably low on resources, so the print itself may cause crashes. 2826 bool result = VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) != 0; 2827 if (result != NULL && exec) { 2828 DWORD oldprot; 2829 // Windows doc says to use VirtualProtect to get execute permissions 2830 return VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot) != 0; 2831 } else { 2832 return result; 2833 } 2834} 2835 2836bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, 2837 bool exec) { 2838 return commit_memory(addr, size, exec); 2839} 2840 2841bool os::uncommit_memory(char* addr, size_t bytes) { 2842 if (bytes == 0) { 2843 // Don't bother the OS with noops. 2844 return true; 2845 } 2846 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries"); 2847 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks"); 2848 return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0; 2849} 2850 2851bool os::release_memory(char* addr, size_t bytes) { 2852 return VirtualFree(addr, 0, MEM_RELEASE) != 0; 2853} 2854 2855bool os::create_stack_guard_pages(char* addr, size_t size) { 2856 return os::commit_memory(addr, size); 2857} 2858 2859bool os::remove_stack_guard_pages(char* addr, size_t size) { 2860 return os::uncommit_memory(addr, size); 2861} 2862 2863// Set protections specified 2864bool os::protect_memory(char* addr, size_t bytes, ProtType prot, 2865 bool is_committed) { 2866 unsigned int p = 0; 2867 switch (prot) { 2868 case MEM_PROT_NONE: p = PAGE_NOACCESS; break; 2869 case MEM_PROT_READ: p = PAGE_READONLY; break; 2870 case MEM_PROT_RW: p = PAGE_READWRITE; break; 2871 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break; 2872 default: 2873 ShouldNotReachHere(); 2874 } 2875 2876 DWORD old_status; 2877 2878 // Strange enough, but on Win32 one can change protection only for committed 2879 // memory, not a big deal anyway, as bytes less or equal than 64K 2880 if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) { 2881 fatal("cannot commit protection page"); 2882 } 2883 // One cannot use os::guard_memory() here, as on Win32 guard page 2884 // have different (one-shot) semantics, from MSDN on PAGE_GUARD: 2885 // 2886 // Pages in the region become guard pages. Any attempt to access a guard page 2887 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off 2888 // the guard page status. Guard pages thus act as a one-time access alarm. 2889 return VirtualProtect(addr, bytes, p, &old_status) != 0; 2890} 2891 2892bool os::guard_memory(char* addr, size_t bytes) { 2893 DWORD old_status; 2894 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0; 2895} 2896 2897bool os::unguard_memory(char* addr, size_t bytes) { 2898 DWORD old_status; 2899 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0; 2900} 2901 2902void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } 2903void os::free_memory(char *addr, size_t bytes) { } 2904void os::numa_make_global(char *addr, size_t bytes) { } 2905void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { } 2906bool os::numa_topology_changed() { return false; } 2907size_t os::numa_get_groups_num() { return 1; } 2908int os::numa_get_group_id() { return 0; } 2909size_t os::numa_get_leaf_groups(int *ids, size_t size) { 2910 if (size > 0) { 2911 ids[0] = 0; 2912 return 1; 2913 } 2914 return 0; 2915} 2916 2917bool os::get_page_info(char *start, page_info* info) { 2918 return false; 2919} 2920 2921char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 2922 return end; 2923} 2924 2925char* os::non_memory_address_word() { 2926 // Must never look like an address returned by reserve_memory, 2927 // even in its subfields (as defined by the CPU immediate fields, 2928 // if the CPU splits constants across multiple instructions). 2929 return (char*)-1; 2930} 2931 2932#define MAX_ERROR_COUNT 100 2933#define SYS_THREAD_ERROR 0xffffffffUL 2934 2935void os::pd_start_thread(Thread* thread) { 2936 DWORD ret = ResumeThread(thread->osthread()->thread_handle()); 2937 // Returns previous suspend state: 2938 // 0: Thread was not suspended 2939 // 1: Thread is running now 2940 // >1: Thread is still suspended. 2941 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back 2942} 2943 2944size_t os::read(int fd, void *buf, unsigned int nBytes) { 2945 return ::read(fd, buf, nBytes); 2946} 2947 2948class HighResolutionInterval { 2949 // The default timer resolution seems to be 10 milliseconds. 2950 // (Where is this written down?) 2951 // If someone wants to sleep for only a fraction of the default, 2952 // then we set the timer resolution down to 1 millisecond for 2953 // the duration of their interval. 2954 // We carefully set the resolution back, since otherwise we 2955 // seem to incur an overhead (3%?) that we don't need. 2956 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time. 2957 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod(). 2958 // Alternatively, we could compute the relative error (503/500 = .6%) and only use 2959 // timeBeginPeriod() if the relative error exceeded some threshold. 2960 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and 2961 // to decreased efficiency related to increased timer "tick" rates. We want to minimize 2962 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high 2963 // resolution timers running. 2964private: 2965 jlong resolution; 2966public: 2967 HighResolutionInterval(jlong ms) { 2968 resolution = ms % 10L; 2969 if (resolution != 0) { 2970 MMRESULT result = timeBeginPeriod(1L); 2971 } 2972 } 2973 ~HighResolutionInterval() { 2974 if (resolution != 0) { 2975 MMRESULT result = timeEndPeriod(1L); 2976 } 2977 resolution = 0L; 2978 } 2979}; 2980 2981int os::sleep(Thread* thread, jlong ms, bool interruptable) { 2982 jlong limit = (jlong) MAXDWORD; 2983 2984 while(ms > limit) { 2985 int res; 2986 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) 2987 return res; 2988 ms -= limit; 2989 } 2990 2991 assert(thread == Thread::current(), "thread consistency check"); 2992 OSThread* osthread = thread->osthread(); 2993 OSThreadWaitState osts(osthread, false /* not Object.wait() */); 2994 int result; 2995 if (interruptable) { 2996 assert(thread->is_Java_thread(), "must be java thread"); 2997 JavaThread *jt = (JavaThread *) thread; 2998 ThreadBlockInVM tbivm(jt); 2999 3000 jt->set_suspend_equivalent(); 3001 // cleared by handle_special_suspend_equivalent_condition() or 3002 // java_suspend_self() via check_and_wait_while_suspended() 3003 3004 HANDLE events[1]; 3005 events[0] = osthread->interrupt_event(); 3006 HighResolutionInterval *phri=NULL; 3007 if(!ForceTimeHighResolution) 3008 phri = new HighResolutionInterval( ms ); 3009 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) { 3010 result = OS_TIMEOUT; 3011 } else { 3012 ResetEvent(osthread->interrupt_event()); 3013 osthread->set_interrupted(false); 3014 result = OS_INTRPT; 3015 } 3016 delete phri; //if it is NULL, harmless 3017 3018 // were we externally suspended while we were waiting? 3019 jt->check_and_wait_while_suspended(); 3020 } else { 3021 assert(!thread->is_Java_thread(), "must not be java thread"); 3022 Sleep((long) ms); 3023 result = OS_TIMEOUT; 3024 } 3025 return result; 3026} 3027 3028// Sleep forever; naked call to OS-specific sleep; use with CAUTION 3029void os::infinite_sleep() { 3030 while (true) { // sleep forever ... 3031 Sleep(100000); // ... 100 seconds at a time 3032 } 3033} 3034 3035typedef BOOL (WINAPI * STTSignature)(void) ; 3036 3037os::YieldResult os::NakedYield() { 3038 // Use either SwitchToThread() or Sleep(0) 3039 // Consider passing back the return value from SwitchToThread(). 3040 // We use GetProcAddress() as ancient Win9X versions of windows doen't support SwitchToThread. 3041 // In that case we revert to Sleep(0). 3042 static volatile STTSignature stt = (STTSignature) 1 ; 3043 3044 if (stt == ((STTSignature) 1)) { 3045 stt = (STTSignature) ::GetProcAddress (LoadLibrary ("Kernel32.dll"), "SwitchToThread") ; 3046 // It's OK if threads race during initialization as the operation above is idempotent. 3047 } 3048 if (stt != NULL) { 3049 return (*stt)() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ; 3050 } else { 3051 Sleep (0) ; 3052 } 3053 return os::YIELD_UNKNOWN ; 3054} 3055 3056void os::yield() { os::NakedYield(); } 3057 3058void os::yield_all(int attempts) { 3059 // Yields to all threads, including threads with lower priorities 3060 Sleep(1); 3061} 3062 3063// Win32 only gives you access to seven real priorities at a time, 3064// so we compress Java's ten down to seven. It would be better 3065// if we dynamically adjusted relative priorities. 3066 3067int os::java_to_os_priority[MaxPriority + 1] = { 3068 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3069 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3070 THREAD_PRIORITY_LOWEST, // 2 3071 THREAD_PRIORITY_BELOW_NORMAL, // 3 3072 THREAD_PRIORITY_BELOW_NORMAL, // 4 3073 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3074 THREAD_PRIORITY_NORMAL, // 6 3075 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3076 THREAD_PRIORITY_ABOVE_NORMAL, // 8 3077 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3078 THREAD_PRIORITY_HIGHEST // 10 MaxPriority 3079}; 3080 3081int prio_policy1[MaxPriority + 1] = { 3082 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3083 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3084 THREAD_PRIORITY_LOWEST, // 2 3085 THREAD_PRIORITY_BELOW_NORMAL, // 3 3086 THREAD_PRIORITY_BELOW_NORMAL, // 4 3087 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3088 THREAD_PRIORITY_ABOVE_NORMAL, // 6 3089 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3090 THREAD_PRIORITY_HIGHEST, // 8 3091 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3092 THREAD_PRIORITY_TIME_CRITICAL // 10 MaxPriority 3093}; 3094 3095static int prio_init() { 3096 // If ThreadPriorityPolicy is 1, switch tables 3097 if (ThreadPriorityPolicy == 1) { 3098 int i; 3099 for (i = 0; i < MaxPriority + 1; i++) { 3100 os::java_to_os_priority[i] = prio_policy1[i]; 3101 } 3102 } 3103 return 0; 3104} 3105 3106OSReturn os::set_native_priority(Thread* thread, int priority) { 3107 if (!UseThreadPriorities) return OS_OK; 3108 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0; 3109 return ret ? OS_OK : OS_ERR; 3110} 3111 3112OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) { 3113 if ( !UseThreadPriorities ) { 3114 *priority_ptr = java_to_os_priority[NormPriority]; 3115 return OS_OK; 3116 } 3117 int os_prio = GetThreadPriority(thread->osthread()->thread_handle()); 3118 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) { 3119 assert(false, "GetThreadPriority failed"); 3120 return OS_ERR; 3121 } 3122 *priority_ptr = os_prio; 3123 return OS_OK; 3124} 3125 3126 3127// Hint to the underlying OS that a task switch would not be good. 3128// Void return because it's a hint and can fail. 3129void os::hint_no_preempt() {} 3130 3131void os::interrupt(Thread* thread) { 3132 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3133 "possibility of dangling Thread pointer"); 3134 3135 OSThread* osthread = thread->osthread(); 3136 osthread->set_interrupted(true); 3137 // More than one thread can get here with the same value of osthread, 3138 // resulting in multiple notifications. We do, however, want the store 3139 // to interrupted() to be visible to other threads before we post 3140 // the interrupt event. 3141 OrderAccess::release(); 3142 SetEvent(osthread->interrupt_event()); 3143 // For JSR166: unpark after setting status 3144 if (thread->is_Java_thread()) 3145 ((JavaThread*)thread)->parker()->unpark(); 3146 3147 ParkEvent * ev = thread->_ParkEvent ; 3148 if (ev != NULL) ev->unpark() ; 3149 3150} 3151 3152 3153bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 3154 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3155 "possibility of dangling Thread pointer"); 3156 3157 OSThread* osthread = thread->osthread(); 3158 bool interrupted; 3159 interrupted = osthread->interrupted(); 3160 if (clear_interrupted == true) { 3161 osthread->set_interrupted(false); 3162 ResetEvent(osthread->interrupt_event()); 3163 } // Otherwise leave the interrupted state alone 3164 3165 return interrupted; 3166} 3167 3168// Get's a pc (hint) for a running thread. Currently used only for profiling. 3169ExtendedPC os::get_thread_pc(Thread* thread) { 3170 CONTEXT context; 3171 context.ContextFlags = CONTEXT_CONTROL; 3172 HANDLE handle = thread->osthread()->thread_handle(); 3173#ifdef _M_IA64 3174 assert(0, "Fix get_thread_pc"); 3175 return ExtendedPC(NULL); 3176#else 3177 if (GetThreadContext(handle, &context)) { 3178#ifdef _M_AMD64 3179 return ExtendedPC((address) context.Rip); 3180#else 3181 return ExtendedPC((address) context.Eip); 3182#endif 3183 } else { 3184 return ExtendedPC(NULL); 3185 } 3186#endif 3187} 3188 3189// GetCurrentThreadId() returns DWORD 3190intx os::current_thread_id() { return GetCurrentThreadId(); } 3191 3192static int _initial_pid = 0; 3193 3194int os::current_process_id() 3195{ 3196 return (_initial_pid ? _initial_pid : _getpid()); 3197} 3198 3199int os::win32::_vm_page_size = 0; 3200int os::win32::_vm_allocation_granularity = 0; 3201int os::win32::_processor_type = 0; 3202// Processor level is not available on non-NT systems, use vm_version instead 3203int os::win32::_processor_level = 0; 3204julong os::win32::_physical_memory = 0; 3205size_t os::win32::_default_stack_size = 0; 3206 3207 intx os::win32::_os_thread_limit = 0; 3208volatile intx os::win32::_os_thread_count = 0; 3209 3210bool os::win32::_is_nt = false; 3211bool os::win32::_is_windows_2003 = false; 3212 3213 3214void os::win32::initialize_system_info() { 3215 SYSTEM_INFO si; 3216 GetSystemInfo(&si); 3217 _vm_page_size = si.dwPageSize; 3218 _vm_allocation_granularity = si.dwAllocationGranularity; 3219 _processor_type = si.dwProcessorType; 3220 _processor_level = si.wProcessorLevel; 3221 set_processor_count(si.dwNumberOfProcessors); 3222 3223 MEMORYSTATUSEX ms; 3224 ms.dwLength = sizeof(ms); 3225 3226 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual, 3227 // dwMemoryLoad (% of memory in use) 3228 GlobalMemoryStatusEx(&ms); 3229 _physical_memory = ms.ullTotalPhys; 3230 3231 OSVERSIONINFO oi; 3232 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); 3233 GetVersionEx(&oi); 3234 switch(oi.dwPlatformId) { 3235 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break; 3236 case VER_PLATFORM_WIN32_NT: 3237 _is_nt = true; 3238 { 3239 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion; 3240 if (os_vers == 5002) { 3241 _is_windows_2003 = true; 3242 } 3243 } 3244 break; 3245 default: fatal("Unknown platform"); 3246 } 3247 3248 _default_stack_size = os::current_stack_size(); 3249 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size"); 3250 assert((_default_stack_size & (_vm_page_size - 1)) == 0, 3251 "stack size not a multiple of page size"); 3252 3253 initialize_performance_counter(); 3254 3255 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is 3256 // known to deadlock the system, if the VM issues to thread operations with 3257 // a too high frequency, e.g., such as changing the priorities. 3258 // The 6000 seems to work well - no deadlocks has been notices on the test 3259 // programs that we have seen experience this problem. 3260 if (!os::win32::is_nt()) { 3261 StarvationMonitorInterval = 6000; 3262 } 3263} 3264 3265 3266void os::win32::setmode_streams() { 3267 _setmode(_fileno(stdin), _O_BINARY); 3268 _setmode(_fileno(stdout), _O_BINARY); 3269 _setmode(_fileno(stderr), _O_BINARY); 3270} 3271 3272 3273int os::message_box(const char* title, const char* message) { 3274 int result = MessageBox(NULL, message, title, 3275 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY); 3276 return result == IDYES; 3277} 3278 3279int os::allocate_thread_local_storage() { 3280 return TlsAlloc(); 3281} 3282 3283 3284void os::free_thread_local_storage(int index) { 3285 TlsFree(index); 3286} 3287 3288 3289void os::thread_local_storage_at_put(int index, void* value) { 3290 TlsSetValue(index, value); 3291 assert(thread_local_storage_at(index) == value, "Just checking"); 3292} 3293 3294 3295void* os::thread_local_storage_at(int index) { 3296 return TlsGetValue(index); 3297} 3298 3299 3300#ifndef PRODUCT 3301#ifndef _WIN64 3302// Helpers to check whether NX protection is enabled 3303int nx_exception_filter(_EXCEPTION_POINTERS *pex) { 3304 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 3305 pex->ExceptionRecord->NumberParameters > 0 && 3306 pex->ExceptionRecord->ExceptionInformation[0] == 3307 EXCEPTION_INFO_EXEC_VIOLATION) { 3308 return EXCEPTION_EXECUTE_HANDLER; 3309 } 3310 return EXCEPTION_CONTINUE_SEARCH; 3311} 3312 3313void nx_check_protection() { 3314 // If NX is enabled we'll get an exception calling into code on the stack 3315 char code[] = { (char)0xC3 }; // ret 3316 void *code_ptr = (void *)code; 3317 __try { 3318 __asm call code_ptr 3319 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) { 3320 tty->print_raw_cr("NX protection detected."); 3321 } 3322} 3323#endif // _WIN64 3324#endif // PRODUCT 3325 3326// this is called _before_ the global arguments have been parsed 3327void os::init(void) { 3328 _initial_pid = _getpid(); 3329 3330 init_random(1234567); 3331 3332 win32::initialize_system_info(); 3333 win32::setmode_streams(); 3334 init_page_sizes((size_t) win32::vm_page_size()); 3335 3336 // For better scalability on MP systems (must be called after initialize_system_info) 3337#ifndef PRODUCT 3338 if (is_MP()) { 3339 NoYieldsInMicrolock = true; 3340 } 3341#endif 3342 // This may be overridden later when argument processing is done. 3343 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation, 3344 os::win32::is_windows_2003()); 3345 3346 // Initialize main_process and main_thread 3347 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle 3348 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process, 3349 &main_thread, THREAD_ALL_ACCESS, false, 0)) { 3350 fatal("DuplicateHandle failed\n"); 3351 } 3352 main_thread_id = (int) GetCurrentThreadId(); 3353} 3354 3355// To install functions for atexit processing 3356extern "C" { 3357 static void perfMemory_exit_helper() { 3358 perfMemory_exit(); 3359 } 3360} 3361 3362// this is called _after_ the global arguments have been parsed 3363jint os::init_2(void) { 3364 // Allocate a single page and mark it as readable for safepoint polling 3365 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY); 3366 guarantee( polling_page != NULL, "Reserve Failed for polling page"); 3367 3368 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY); 3369 guarantee( return_page != NULL, "Commit Failed for polling page"); 3370 3371 os::set_polling_page( polling_page ); 3372 3373#ifndef PRODUCT 3374 if( Verbose && PrintMiscellaneous ) 3375 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page); 3376#endif 3377 3378 if (!UseMembar) { 3379 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE); 3380 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page"); 3381 3382 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE); 3383 guarantee( return_page != NULL, "Commit Failed for memory serialize page"); 3384 3385 os::set_memory_serialize_page( mem_serialize_page ); 3386 3387#ifndef PRODUCT 3388 if(Verbose && PrintMiscellaneous) 3389 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page); 3390#endif 3391} 3392 3393 FLAG_SET_DEFAULT(UseLargePages, os::large_page_init()); 3394 3395 // Setup Windows Exceptions 3396 3397 // On Itanium systems, Structured Exception Handling does not 3398 // work since stack frames must be walkable by the OS. Since 3399 // much of our code is dynamically generated, and we do not have 3400 // proper unwind .xdata sections, the system simply exits 3401 // rather than delivering the exception. To work around 3402 // this we use VectorExceptions instead. 3403#ifdef _WIN64 3404 if (UseVectoredExceptions) { 3405 topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter); 3406 } 3407#endif 3408 3409 // for debugging float code generation bugs 3410 if (ForceFloatExceptions) { 3411#ifndef _WIN64 3412 static long fp_control_word = 0; 3413 __asm { fstcw fp_control_word } 3414 // see Intel PPro Manual, Vol. 2, p 7-16 3415 const long precision = 0x20; 3416 const long underflow = 0x10; 3417 const long overflow = 0x08; 3418 const long zero_div = 0x04; 3419 const long denorm = 0x02; 3420 const long invalid = 0x01; 3421 fp_control_word |= invalid; 3422 __asm { fldcw fp_control_word } 3423#endif 3424 } 3425 3426 // Initialize HPI. 3427 jint hpi_result = hpi::initialize(); 3428 if (hpi_result != JNI_OK) { return hpi_result; } 3429 3430 // If stack_commit_size is 0, windows will reserve the default size, 3431 // but only commit a small portion of it. 3432 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size()); 3433 size_t default_reserve_size = os::win32::default_stack_size(); 3434 size_t actual_reserve_size = stack_commit_size; 3435 if (stack_commit_size < default_reserve_size) { 3436 // If stack_commit_size == 0, we want this too 3437 actual_reserve_size = default_reserve_size; 3438 } 3439 3440 // Check minimum allowable stack size for thread creation and to initialize 3441 // the java system classes, including StackOverflowError - depends on page 3442 // size. Add a page for compiler2 recursion in main thread. 3443 // Add in 2*BytesPerWord times page size to account for VM stack during 3444 // class initialization depending on 32 or 64 bit VM. 3445 size_t min_stack_allowed = 3446 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ 3447 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size(); 3448 if (actual_reserve_size < min_stack_allowed) { 3449 tty->print_cr("\nThe stack size specified is too small, " 3450 "Specify at least %dk", 3451 min_stack_allowed / K); 3452 return JNI_ERR; 3453 } 3454 3455 JavaThread::set_stack_size_at_create(stack_commit_size); 3456 3457 // Calculate theoretical max. size of Threads to guard gainst artifical 3458 // out-of-memory situations, where all available address-space has been 3459 // reserved by thread stacks. 3460 assert(actual_reserve_size != 0, "Must have a stack"); 3461 3462 // Calculate the thread limit when we should start doing Virtual Memory 3463 // banging. Currently when the threads will have used all but 200Mb of space. 3464 // 3465 // TODO: consider performing a similar calculation for commit size instead 3466 // as reserve size, since on a 64-bit platform we'll run into that more 3467 // often than running out of virtual memory space. We can use the 3468 // lower value of the two calculations as the os_thread_limit. 3469 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K); 3470 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size); 3471 3472 // at exit methods are called in the reverse order of their registration. 3473 // there is no limit to the number of functions registered. atexit does 3474 // not set errno. 3475 3476 if (PerfAllowAtExitRegistration) { 3477 // only register atexit functions if PerfAllowAtExitRegistration is set. 3478 // atexit functions can be delayed until process exit time, which 3479 // can be problematic for embedded VM situations. Embedded VMs should 3480 // call DestroyJavaVM() to assure that VM resources are released. 3481 3482 // note: perfMemory_exit_helper atexit function may be removed in 3483 // the future if the appropriate cleanup code can be added to the 3484 // VM_Exit VMOperation's doit method. 3485 if (atexit(perfMemory_exit_helper) != 0) { 3486 warning("os::init_2 atexit(perfMemory_exit_helper) failed"); 3487 } 3488 } 3489 3490 // initialize PSAPI or ToolHelp for fatal error handler 3491 if (win32::is_nt()) _init_psapi(); 3492 else _init_toolhelp(); 3493 3494#ifndef _WIN64 3495 // Print something if NX is enabled (win32 on AMD64) 3496 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection()); 3497#endif 3498 3499 // initialize thread priority policy 3500 prio_init(); 3501 3502 if (UseNUMA && !ForceNUMA) { 3503 UseNUMA = false; // Currently unsupported. 3504 } 3505 3506 return JNI_OK; 3507} 3508 3509void os::init_3(void) { 3510 return; 3511} 3512 3513// Mark the polling page as unreadable 3514void os::make_polling_page_unreadable(void) { 3515 DWORD old_status; 3516 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) ) 3517 fatal("Could not disable polling page"); 3518}; 3519 3520// Mark the polling page as readable 3521void os::make_polling_page_readable(void) { 3522 DWORD old_status; 3523 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) ) 3524 fatal("Could not enable polling page"); 3525}; 3526 3527 3528int os::stat(const char *path, struct stat *sbuf) { 3529 char pathbuf[MAX_PATH]; 3530 if (strlen(path) > MAX_PATH - 1) { 3531 errno = ENAMETOOLONG; 3532 return -1; 3533 } 3534 hpi::native_path(strcpy(pathbuf, path)); 3535 int ret = ::stat(pathbuf, sbuf); 3536 if (sbuf != NULL && UseUTCFileTimestamp) { 3537 // Fix for 6539723. st_mtime returned from stat() is dependent on 3538 // the system timezone and so can return different values for the 3539 // same file if/when daylight savings time changes. This adjustment 3540 // makes sure the same timestamp is returned regardless of the TZ. 3541 // 3542 // See: 3543 // http://msdn.microsoft.com/library/ 3544 // default.asp?url=/library/en-us/sysinfo/base/ 3545 // time_zone_information_str.asp 3546 // and 3547 // http://msdn.microsoft.com/library/default.asp?url= 3548 // /library/en-us/sysinfo/base/settimezoneinformation.asp 3549 // 3550 // NOTE: there is a insidious bug here: If the timezone is changed 3551 // after the call to stat() but before 'GetTimeZoneInformation()', then 3552 // the adjustment we do here will be wrong and we'll return the wrong 3553 // value (which will likely end up creating an invalid class data 3554 // archive). Absent a better API for this, or some time zone locking 3555 // mechanism, we'll have to live with this risk. 3556 TIME_ZONE_INFORMATION tz; 3557 DWORD tzid = GetTimeZoneInformation(&tz); 3558 int daylightBias = 3559 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias; 3560 sbuf->st_mtime += (tz.Bias + daylightBias) * 60; 3561 } 3562 return ret; 3563} 3564 3565 3566#define FT2INT64(ft) \ 3567 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime)) 3568 3569 3570// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 3571// are used by JVM M&M and JVMTI to get user+sys or user CPU time 3572// of a thread. 3573// 3574// current_thread_cpu_time() and thread_cpu_time(Thread*) returns 3575// the fast estimate available on the platform. 3576 3577// current_thread_cpu_time() is not optimized for Windows yet 3578jlong os::current_thread_cpu_time() { 3579 // return user + sys since the cost is the same 3580 return os::thread_cpu_time(Thread::current(), true /* user+sys */); 3581} 3582 3583jlong os::thread_cpu_time(Thread* thread) { 3584 // consistent with what current_thread_cpu_time() returns. 3585 return os::thread_cpu_time(thread, true /* user+sys */); 3586} 3587 3588jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 3589 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 3590} 3591 3592jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) { 3593 // This code is copy from clasic VM -> hpi::sysThreadCPUTime 3594 // If this function changes, os::is_thread_cpu_time_supported() should too 3595 if (os::win32::is_nt()) { 3596 FILETIME CreationTime; 3597 FILETIME ExitTime; 3598 FILETIME KernelTime; 3599 FILETIME UserTime; 3600 3601 if ( GetThreadTimes(thread->osthread()->thread_handle(), 3602 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0) 3603 return -1; 3604 else 3605 if (user_sys_cpu_time) { 3606 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100; 3607 } else { 3608 return FT2INT64(UserTime) * 100; 3609 } 3610 } else { 3611 return (jlong) timeGetTime() * 1000000; 3612 } 3613} 3614 3615void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 3616 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 3617 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 3618 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 3619 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 3620} 3621 3622void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 3623 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 3624 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 3625 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 3626 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 3627} 3628 3629bool os::is_thread_cpu_time_supported() { 3630 // see os::thread_cpu_time 3631 if (os::win32::is_nt()) { 3632 FILETIME CreationTime; 3633 FILETIME ExitTime; 3634 FILETIME KernelTime; 3635 FILETIME UserTime; 3636 3637 if ( GetThreadTimes(GetCurrentThread(), 3638 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0) 3639 return false; 3640 else 3641 return true; 3642 } else { 3643 return false; 3644 } 3645} 3646 3647// Windows does't provide a loadavg primitive so this is stubbed out for now. 3648// It does have primitives (PDH API) to get CPU usage and run queue length. 3649// "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length" 3650// If we wanted to implement loadavg on Windows, we have a few options: 3651// 3652// a) Query CPU usage and run queue length and "fake" an answer by 3653// returning the CPU usage if it's under 100%, and the run queue 3654// length otherwise. It turns out that querying is pretty slow 3655// on Windows, on the order of 200 microseconds on a fast machine. 3656// Note that on the Windows the CPU usage value is the % usage 3657// since the last time the API was called (and the first call 3658// returns 100%), so we'd have to deal with that as well. 3659// 3660// b) Sample the "fake" answer using a sampling thread and store 3661// the answer in a global variable. The call to loadavg would 3662// just return the value of the global, avoiding the slow query. 3663// 3664// c) Sample a better answer using exponential decay to smooth the 3665// value. This is basically the algorithm used by UNIX kernels. 3666// 3667// Note that sampling thread starvation could affect both (b) and (c). 3668int os::loadavg(double loadavg[], int nelem) { 3669 return -1; 3670} 3671 3672 3673// DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield() 3674bool os::dont_yield() { 3675 return DontYieldALot; 3676} 3677 3678// Is a (classpath) directory empty? 3679bool os::dir_is_empty(const char* path) { 3680 WIN32_FIND_DATA fd; 3681 HANDLE f = FindFirstFile(path, &fd); 3682 if (f == INVALID_HANDLE_VALUE) { 3683 return true; 3684 } 3685 FindClose(f); 3686 return false; 3687} 3688 3689// create binary file, rewriting existing file if required 3690int os::create_binary_file(const char* path, bool rewrite_existing) { 3691 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY; 3692 if (!rewrite_existing) { 3693 oflags |= _O_EXCL; 3694 } 3695 return ::open(path, oflags, _S_IREAD | _S_IWRITE); 3696} 3697 3698// return current position of file pointer 3699jlong os::current_file_offset(int fd) { 3700 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR); 3701} 3702 3703// move file pointer to the specified offset 3704jlong os::seek_to_file_offset(int fd, jlong offset) { 3705 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET); 3706} 3707 3708 3709// Map a block of memory. 3710char* os::map_memory(int fd, const char* file_name, size_t file_offset, 3711 char *addr, size_t bytes, bool read_only, 3712 bool allow_exec) { 3713 HANDLE hFile; 3714 char* base; 3715 3716 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, 3717 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 3718 if (hFile == NULL) { 3719 if (PrintMiscellaneous && Verbose) { 3720 DWORD err = GetLastError(); 3721 tty->print_cr("CreateFile() failed: GetLastError->%ld."); 3722 } 3723 return NULL; 3724 } 3725 3726 if (allow_exec) { 3727 // CreateFileMapping/MapViewOfFileEx can't map executable memory 3728 // unless it comes from a PE image (which the shared archive is not.) 3729 // Even VirtualProtect refuses to give execute access to mapped memory 3730 // that was not previously executable. 3731 // 3732 // Instead, stick the executable region in anonymous memory. Yuck. 3733 // Penalty is that ~4 pages will not be shareable - in the future 3734 // we might consider DLLizing the shared archive with a proper PE 3735 // header so that mapping executable + sharing is possible. 3736 3737 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE, 3738 PAGE_READWRITE); 3739 if (base == NULL) { 3740 if (PrintMiscellaneous && Verbose) { 3741 DWORD err = GetLastError(); 3742 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err); 3743 } 3744 CloseHandle(hFile); 3745 return NULL; 3746 } 3747 3748 DWORD bytes_read; 3749 OVERLAPPED overlapped; 3750 overlapped.Offset = (DWORD)file_offset; 3751 overlapped.OffsetHigh = 0; 3752 overlapped.hEvent = NULL; 3753 // ReadFile guarantees that if the return value is true, the requested 3754 // number of bytes were read before returning. 3755 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0; 3756 if (!res) { 3757 if (PrintMiscellaneous && Verbose) { 3758 DWORD err = GetLastError(); 3759 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err); 3760 } 3761 release_memory(base, bytes); 3762 CloseHandle(hFile); 3763 return NULL; 3764 } 3765 } else { 3766 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0, 3767 NULL /*file_name*/); 3768 if (hMap == NULL) { 3769 if (PrintMiscellaneous && Verbose) { 3770 DWORD err = GetLastError(); 3771 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld."); 3772 } 3773 CloseHandle(hFile); 3774 return NULL; 3775 } 3776 3777 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY; 3778 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset, 3779 (DWORD)bytes, addr); 3780 if (base == NULL) { 3781 if (PrintMiscellaneous && Verbose) { 3782 DWORD err = GetLastError(); 3783 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err); 3784 } 3785 CloseHandle(hMap); 3786 CloseHandle(hFile); 3787 return NULL; 3788 } 3789 3790 if (CloseHandle(hMap) == 0) { 3791 if (PrintMiscellaneous && Verbose) { 3792 DWORD err = GetLastError(); 3793 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err); 3794 } 3795 CloseHandle(hFile); 3796 return base; 3797 } 3798 } 3799 3800 if (allow_exec) { 3801 DWORD old_protect; 3802 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE; 3803 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0; 3804 3805 if (!res) { 3806 if (PrintMiscellaneous && Verbose) { 3807 DWORD err = GetLastError(); 3808 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err); 3809 } 3810 // Don't consider this a hard error, on IA32 even if the 3811 // VirtualProtect fails, we should still be able to execute 3812 CloseHandle(hFile); 3813 return base; 3814 } 3815 } 3816 3817 if (CloseHandle(hFile) == 0) { 3818 if (PrintMiscellaneous && Verbose) { 3819 DWORD err = GetLastError(); 3820 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err); 3821 } 3822 return base; 3823 } 3824 3825 return base; 3826} 3827 3828 3829// Remap a block of memory. 3830char* os::remap_memory(int fd, const char* file_name, size_t file_offset, 3831 char *addr, size_t bytes, bool read_only, 3832 bool allow_exec) { 3833 // This OS does not allow existing memory maps to be remapped so we 3834 // have to unmap the memory before we remap it. 3835 if (!os::unmap_memory(addr, bytes)) { 3836 return NULL; 3837 } 3838 3839 // There is a very small theoretical window between the unmap_memory() 3840 // call above and the map_memory() call below where a thread in native 3841 // code may be able to access an address that is no longer mapped. 3842 3843 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 3844 allow_exec); 3845} 3846 3847 3848// Unmap a block of memory. 3849// Returns true=success, otherwise false. 3850 3851bool os::unmap_memory(char* addr, size_t bytes) { 3852 BOOL result = UnmapViewOfFile(addr); 3853 if (result == 0) { 3854 if (PrintMiscellaneous && Verbose) { 3855 DWORD err = GetLastError(); 3856 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err); 3857 } 3858 return false; 3859 } 3860 return true; 3861} 3862 3863void os::pause() { 3864 char filename[MAX_PATH]; 3865 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 3866 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 3867 } else { 3868 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 3869 } 3870 3871 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 3872 if (fd != -1) { 3873 struct stat buf; 3874 close(fd); 3875 while (::stat(filename, &buf) == 0) { 3876 Sleep(100); 3877 } 3878 } else { 3879 jio_fprintf(stderr, 3880 "Could not open pause file '%s', continuing immediately.\n", filename); 3881 } 3882} 3883 3884// An Event wraps a win32 "CreateEvent" kernel handle. 3885// 3886// We have a number of choices regarding "CreateEvent" win32 handle leakage: 3887// 3888// 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle 3889// field, and call CloseHandle() on the win32 event handle. Unpark() would 3890// need to be modified to tolerate finding a NULL (invalid) win32 event handle. 3891// In addition, an unpark() operation might fetch the handle field, but the 3892// event could recycle between the fetch and the SetEvent() operation. 3893// SetEvent() would either fail because the handle was invalid, or inadvertently work, 3894// as the win32 handle value had been recycled. In an ideal world calling SetEvent() 3895// on an stale but recycled handle would be harmless, but in practice this might 3896// confuse other non-Sun code, so it's not a viable approach. 3897// 3898// 2: Once a win32 event handle is associated with an Event, it remains associated 3899// with the Event. The event handle is never closed. This could be construed 3900// as handle leakage, but only up to the maximum # of threads that have been extant 3901// at any one time. This shouldn't be an issue, as windows platforms typically 3902// permit a process to have hundreds of thousands of open handles. 3903// 3904// 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList 3905// and release unused handles. 3906// 3907// 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle. 3908// It's not clear, however, that we wouldn't be trading one type of leak for another. 3909// 3910// 5. Use an RCU-like mechanism (Read-Copy Update). 3911// Or perhaps something similar to Maged Michael's "Hazard pointers". 3912// 3913// We use (2). 3914// 3915// TODO-FIXME: 3916// 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation. 3917// 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks 3918// to recover from (or at least detect) the dreaded Windows 841176 bug. 3919// 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent 3920// into a single win32 CreateEvent() handle. 3921// 3922// _Event transitions in park() 3923// -1 => -1 : illegal 3924// 1 => 0 : pass - return immediately 3925// 0 => -1 : block 3926// 3927// _Event serves as a restricted-range semaphore : 3928// -1 : thread is blocked 3929// 0 : neutral - thread is running or ready 3930// 1 : signaled - thread is running or ready 3931// 3932// Another possible encoding of _Event would be 3933// with explicit "PARKED" and "SIGNALED" bits. 3934 3935int os::PlatformEvent::park (jlong Millis) { 3936 guarantee (_ParkHandle != NULL , "Invariant") ; 3937 guarantee (Millis > 0 , "Invariant") ; 3938 int v ; 3939 3940 // CONSIDER: defer assigning a CreateEvent() handle to the Event until 3941 // the initial park() operation. 3942 3943 for (;;) { 3944 v = _Event ; 3945 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 3946 } 3947 guarantee ((v == 0) || (v == 1), "invariant") ; 3948 if (v != 0) return OS_OK ; 3949 3950 // Do this the hard way by blocking ... 3951 // TODO: consider a brief spin here, gated on the success of recent 3952 // spin attempts by this thread. 3953 // 3954 // We decompose long timeouts into series of shorter timed waits. 3955 // Evidently large timo values passed in WaitForSingleObject() are problematic on some 3956 // versions of Windows. See EventWait() for details. This may be superstition. Or not. 3957 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time 3958 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from 3959 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend 3960 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv == 3961 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate 3962 // for the already waited time. This policy does not admit any new outcomes. 3963 // In the future, however, we might want to track the accumulated wait time and 3964 // adjust Millis accordingly if we encounter a spurious wakeup. 3965 3966 const int MAXTIMEOUT = 0x10000000 ; 3967 DWORD rv = WAIT_TIMEOUT ; 3968 while (_Event < 0 && Millis > 0) { 3969 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT) 3970 if (Millis > MAXTIMEOUT) { 3971 prd = MAXTIMEOUT ; 3972 } 3973 rv = ::WaitForSingleObject (_ParkHandle, prd) ; 3974 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ; 3975 if (rv == WAIT_TIMEOUT) { 3976 Millis -= prd ; 3977 } 3978 } 3979 v = _Event ; 3980 _Event = 0 ; 3981 OrderAccess::fence() ; 3982 // If we encounter a nearly simultanous timeout expiry and unpark() 3983 // we return OS_OK indicating we awoke via unpark(). 3984 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however. 3985 return (v >= 0) ? OS_OK : OS_TIMEOUT ; 3986} 3987 3988void os::PlatformEvent::park () { 3989 guarantee (_ParkHandle != NULL, "Invariant") ; 3990 // Invariant: Only the thread associated with the Event/PlatformEvent 3991 // may call park(). 3992 int v ; 3993 for (;;) { 3994 v = _Event ; 3995 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 3996 } 3997 guarantee ((v == 0) || (v == 1), "invariant") ; 3998 if (v != 0) return ; 3999 4000 // Do this the hard way by blocking ... 4001 // TODO: consider a brief spin here, gated on the success of recent 4002 // spin attempts by this thread. 4003 while (_Event < 0) { 4004 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ; 4005 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ; 4006 } 4007 4008 // Usually we'll find _Event == 0 at this point, but as 4009 // an optional optimization we clear it, just in case can 4010 // multiple unpark() operations drove _Event up to 1. 4011 _Event = 0 ; 4012 OrderAccess::fence() ; 4013 guarantee (_Event >= 0, "invariant") ; 4014} 4015 4016void os::PlatformEvent::unpark() { 4017 guarantee (_ParkHandle != NULL, "Invariant") ; 4018 int v ; 4019 for (;;) { 4020 v = _Event ; // Increment _Event if it's < 1. 4021 if (v > 0) { 4022 // If it's already signaled just return. 4023 // The LD of _Event could have reordered or be satisfied 4024 // by a read-aside from this processor's write buffer. 4025 // To avoid problems execute a barrier and then 4026 // ratify the value. A degenerate CAS() would also work. 4027 // Viz., CAS (v+0, &_Event, v) == v). 4028 OrderAccess::fence() ; 4029 if (_Event == v) return ; 4030 continue ; 4031 } 4032 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ; 4033 } 4034 if (v < 0) { 4035 ::SetEvent (_ParkHandle) ; 4036 } 4037} 4038 4039 4040// JSR166 4041// ------------------------------------------------------- 4042 4043/* 4044 * The Windows implementation of Park is very straightforward: Basic 4045 * operations on Win32 Events turn out to have the right semantics to 4046 * use them directly. We opportunistically resuse the event inherited 4047 * from Monitor. 4048 */ 4049 4050 4051void Parker::park(bool isAbsolute, jlong time) { 4052 guarantee (_ParkEvent != NULL, "invariant") ; 4053 // First, demultiplex/decode time arguments 4054 if (time < 0) { // don't wait 4055 return; 4056 } 4057 else if (time == 0 && !isAbsolute) { 4058 time = INFINITE; 4059 } 4060 else if (isAbsolute) { 4061 time -= os::javaTimeMillis(); // convert to relative time 4062 if (time <= 0) // already elapsed 4063 return; 4064 } 4065 else { // relative 4066 time /= 1000000; // Must coarsen from nanos to millis 4067 if (time == 0) // Wait for the minimal time unit if zero 4068 time = 1; 4069 } 4070 4071 JavaThread* thread = (JavaThread*)(Thread::current()); 4072 assert(thread->is_Java_thread(), "Must be JavaThread"); 4073 JavaThread *jt = (JavaThread *)thread; 4074 4075 // Don't wait if interrupted or already triggered 4076 if (Thread::is_interrupted(thread, false) || 4077 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) { 4078 ResetEvent(_ParkEvent); 4079 return; 4080 } 4081 else { 4082 ThreadBlockInVM tbivm(jt); 4083 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 4084 jt->set_suspend_equivalent(); 4085 4086 WaitForSingleObject(_ParkEvent, time); 4087 ResetEvent(_ParkEvent); 4088 4089 // If externally suspended while waiting, re-suspend 4090 if (jt->handle_special_suspend_equivalent_condition()) { 4091 jt->java_suspend_self(); 4092 } 4093 } 4094} 4095 4096void Parker::unpark() { 4097 guarantee (_ParkEvent != NULL, "invariant") ; 4098 SetEvent(_ParkEvent); 4099} 4100 4101// Run the specified command in a separate process. Return its exit value, 4102// or -1 on failure (e.g. can't create a new process). 4103int os::fork_and_exec(char* cmd) { 4104 STARTUPINFO si; 4105 PROCESS_INFORMATION pi; 4106 4107 memset(&si, 0, sizeof(si)); 4108 si.cb = sizeof(si); 4109 memset(&pi, 0, sizeof(pi)); 4110 BOOL rslt = CreateProcess(NULL, // executable name - use command line 4111 cmd, // command line 4112 NULL, // process security attribute 4113 NULL, // thread security attribute 4114 TRUE, // inherits system handles 4115 0, // no creation flags 4116 NULL, // use parent's environment block 4117 NULL, // use parent's starting directory 4118 &si, // (in) startup information 4119 &pi); // (out) process information 4120 4121 if (rslt) { 4122 // Wait until child process exits. 4123 WaitForSingleObject(pi.hProcess, INFINITE); 4124 4125 DWORD exit_code; 4126 GetExitCodeProcess(pi.hProcess, &exit_code); 4127 4128 // Close process and thread handles. 4129 CloseHandle(pi.hProcess); 4130 CloseHandle(pi.hThread); 4131 4132 return (int)exit_code; 4133 } else { 4134 return -1; 4135 } 4136} 4137 4138//-------------------------------------------------------------------------------------------------- 4139// Non-product code 4140 4141static int mallocDebugIntervalCounter = 0; 4142static int mallocDebugCounter = 0; 4143bool os::check_heap(bool force) { 4144 if (++mallocDebugCounter < MallocVerifyStart && !force) return true; 4145 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) { 4146 // Note: HeapValidate executes two hardware breakpoints when it finds something 4147 // wrong; at these points, eax contains the address of the offending block (I think). 4148 // To get to the exlicit error message(s) below, just continue twice. 4149 HANDLE heap = GetProcessHeap(); 4150 { HeapLock(heap); 4151 PROCESS_HEAP_ENTRY phe; 4152 phe.lpData = NULL; 4153 while (HeapWalk(heap, &phe) != 0) { 4154 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) && 4155 !HeapValidate(heap, 0, phe.lpData)) { 4156 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter); 4157 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData); 4158 fatal("corrupted C heap"); 4159 } 4160 } 4161 int err = GetLastError(); 4162 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) { 4163 fatal(err_msg("heap walk aborted with error %d", err)); 4164 } 4165 HeapUnlock(heap); 4166 } 4167 mallocDebugIntervalCounter = 0; 4168 } 4169 return true; 4170} 4171 4172 4173bool os::find(address addr, outputStream* st) { 4174 // Nothing yet 4175 return false; 4176} 4177 4178LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) { 4179 DWORD exception_code = e->ExceptionRecord->ExceptionCode; 4180 4181 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) { 4182 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow(); 4183 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord; 4184 address addr = (address) exceptionRecord->ExceptionInformation[1]; 4185 4186 if (os::is_memory_serialize_page(thread, addr)) 4187 return EXCEPTION_CONTINUE_EXECUTION; 4188 } 4189 4190 return EXCEPTION_CONTINUE_SEARCH; 4191} 4192 4193static int getLastErrorString(char *buf, size_t len) 4194{ 4195 long errval; 4196 4197 if ((errval = GetLastError()) != 0) 4198 { 4199 /* DOS error */ 4200 size_t n = (size_t)FormatMessage( 4201 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 4202 NULL, 4203 errval, 4204 0, 4205 buf, 4206 (DWORD)len, 4207 NULL); 4208 if (n > 3) { 4209 /* Drop final '.', CR, LF */ 4210 if (buf[n - 1] == '\n') n--; 4211 if (buf[n - 1] == '\r') n--; 4212 if (buf[n - 1] == '.') n--; 4213 buf[n] = '\0'; 4214 } 4215 return (int)n; 4216 } 4217 4218 if (errno != 0) 4219 { 4220 /* C runtime error that has no corresponding DOS error code */ 4221 const char *s = strerror(errno); 4222 size_t n = strlen(s); 4223 if (n >= len) n = len - 1; 4224 strncpy(buf, s, n); 4225 buf[n] = '\0'; 4226 return (int)n; 4227 } 4228 return 0; 4229} 4230 4231 4232// We don't build a headless jre for Windows 4233bool os::is_headless_jre() { return false; } 4234 4235