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