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