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