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