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