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