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