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